Testing Constants in Go

In Go, constants are a valuable tool for ensuring code consistency and correctness. However, when it comes to unit testing, using constants can create challenges. This article explores how to redefine constants specifically for testing purposes in Go.

The Challenge with Constants

Constants in Go are immutable values that cannot be modified during program execution. This immutability ensures the integrity of the program's state and prevents accidental changes. However, during testing, it can be necessary to temporarily modify constants to test specific scenarios.

A Testing-Friendly Approach

Consider the following example:

package main

const baseUrl = "http://google.com"

// in main_test.go
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  ...
}))
const baseUrl = ts.URL // Error: const baseUrl already defined

In this example, we want to use a test server instead of calling the remote API for testing. To do this, we need to redefine baseUrl with the test server's URL. However, Go throws an error because the constant baseUrl is already defined.

Solution: Refactor for Testability

To make testing easier, we can slightly refactor the code by introducing an additional function:

const baseUrl_ = "http://google.com"

func MyFunc() string {
    // Call other function passing the const value
    return myFuncImpl(baseUrl_)
}

func myFuncImpl(baseUrl string) string {
    // use baseUrl
    // Same implementation that was in your original MyFunc() function
}

In this refactored code, the original MyFunc function delegates its implementation to myFuncImpl, which takes a baseUrl parameter. This allows us to call myFuncImpl directly from a test function and pass in any desired base URL.

Keeping Production Code Safe

The original MyFunc function remains safe and unaffected by the refactoring. It always passes the constant baseUrl_ to myFuncImpl, ensuring that the production code does not have unexpected behavior due to modified constants.

Conclusion

This technique allows developers to redefine constants for testing purposes while maintaining the integrity and safety of the production code. By introducing an additional function that provides the same functionality as the original, tests can modify constants without affecting the actual code's behavior.