Golang - Tests

What is the purpose of unit testing in Go?

To ensure that individual components of the code function correctly

Why might a developer choose Go's built-in mocking techniques over third-party solutions?

To gain a deeper understanding of the testing process and maintain closer control

What are higher-order functions in Go's mocking context?

Functions that take other functions as parameters or return them

What is monkey patching in Go?

A technique involving reassignment of package-level variables to mock implementations during testing, allowing control over function behavior without altering the original code. For example:

var fetchData = realFetchData  
fetchData = mockFetchData  

How does interface substitution aid in mocking within Go?

By defining interfaces that represent desired behaviors, allowing the replacement of concrete types with mock implementations that satisfy these interfaces during testing. For example:

type Fetcher interface { Fetch(id int) (string, error) }  
type MockFetcher struct {}  
func (m MockFetcher) Fetch(id int) (string, error) { return "mock data", nil }  

What is the purpose of embedding interfaces in Go's testing?

To extend existing interfaces by embedding them into new ones, facilitating the creation of mock implementations that include additional methods or behaviors. For example:

type BaseFetcher interface { Fetch(id int) (string, error) }  
type AdvancedFetcher interface { BaseFetcher; ExtraFetch(param string) bool }  

How can downstream HTTP calls be mocked in Go?

By using Go's net/http/httptest package to create mock servers that simulate HTTP responses. For example:

server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {  
    w.WriteHeader(http.StatusOK)  
    w.Write([]byte(`{"message":"mock"}`))  
}))  

What caution should be taken when using higher-order functions for mocking in Go?

They can make code harder to read and expand function parameter lists, potentially increasing dependencies for packages that call the function. For example, passing a mockFetch to multiple layers of function calls could make debugging harder.

What are potential drawbacks of monkey patching in Go tests?

It may hinder parallel test execution due to shared variable manipulation and could require making variables public, exposing them to unintended external modifications. For example, patching a fetchData variable can create conflicts if tests run concurrently.

Why is interface substitution considered powerful for mocking in Go?

Because Go's interfaces are implicitly and statically satisfied by implementing types, allowing for flexible and type-safe mock implementations without explicit declarations. For example, any type that has a Fetch(id int) (string, error) method satisfies a Fetcher interface.

What are the different types of mocking techniques in Go?

1. Higher-order functions – Functions that take or return other functions. For example:
   

type FetchFunc func(id int) (string, error)
func MockFetch(id int) (string, error) { return "mock data", nil }

2. Monkey patching – Reassigning package-level variables to mock implementations. For example:

var fetchData = realFetchData
fetchData = mockFetchData

3. Interface substitution – Defining interfaces and replacing concrete types with mocks. For example:

type Fetcher interface { Fetch(id int) (string, error) }
type MockFetcher struct {}
func (m MockFetcher) Fetch(id int) (string, error) { return "mock data", nil }

4. Embedding interfaces – Extending existing interfaces to create advanced mock implementations. For example:

type BaseFetcher interface { Fetch(id int) (string, error) }
type AdvancedFetcher interface { BaseFetcher; ExtraFetch(param string) bool }

5. Mocking HTTP calls – Using httptest to simulate HTTP servers. For example:

server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    w.WriteHeader(http.StatusOK)
    w.Write([]byte(`{"message":"mock"}`))
}))