How to Test Private Functions in Go

Table of Contents

  1. Overview
  2. Prerequisites
  3. Setting Up the Project

  4. Testing Private Functions - Approach 1: Export a Helper Function - Approach 2: Use Reflection

  5. Conclusion

Overview

In Go, it is common to organize code into packages and hide implementation details by using private functions. However, testing private functions can be challenging since they are not directly accessible from outside the package. In this tutorial, we will explore two approaches to test private functions in Go. By the end, you will learn how to write unit tests for private functions and ensure the correctness of your code.

Prerequisites

Before starting this tutorial, you should have a basic understanding of Go programming language, including functions, packages, and testing. You should also have Go installed on your machine.

Setting Up the Project

To demonstrate the testing of private functions, let’s create a simple Go package called “mathutil” that provides some mathematical utilities. Start by creating a new directory for your project and navigate to it in your terminal. Then, create a file named “mathutil.go” with the following code:

package mathutil

// privateAdd is a private function that adds two numbers.
func privateAdd(a, b int) int {
    return a + b
}

Next, create a file named “mathutil_test.go” in the same directory with the following code:

package mathutil

import "testing"

func TestPrivateAdd(t *testing.T) {
    result := privateAdd(2, 3)
    expected := 5
    if result != expected {
        t.Errorf("privateAdd(2, 3) = %d; expected %d", result, expected)
    }
}

In this test file, we import the testing package and define a test function named TestPrivateAdd. Inside the test function, we call the private function privateAdd with some arguments and compare the result with the expected value using t.Errorf if they are not equal.

Now, navigate to the project directory in your terminal and run the tests with the following command:

go test

You should see the following output:

PASS
ok      your/package/dir     0.001s

Congratulations! You have successfully executed the test for a private function.

Testing Private Functions

Approach 1: Export a Helper Function

One approach to test private functions is to create a helper function within the package that exports the private function. This way, we can call the helper function from the test code. Let’s modify our “mathutil” package to demonstrate this approach.

Update the “mathutil.go” file with the following code:

package mathutil

// Add is a helper function that calls the privateAdd function.
func Add(a, b int) int {
    return privateAdd(a, b)
}

// privateAdd is a private function that adds two numbers.
func privateAdd(a, b int) int {
    return a + b
}

Modify the “mathutil_test.go” file as follows:

package mathutil

import "testing"

func TestAdd(t *testing.T) {
    result := Add(2, 3)
    expected := 5
    if result != expected {
        t.Errorf("Add(2, 3) = %d; expected %d", result, expected)
    }
}

Now, when you run the tests with go test, you should see the same passing output as before.

By providing an exported helper function Add, we can indirectly test the private function privateAdd. This approach allows us to write tests that cover the logic within the private function without directly exposing it.

Approach 2: Use Reflection

Another approach to test private functions in Go is to use reflection. Reflection allows us to inspect and call private functions dynamically. While this approach is more advanced and less efficient, it can be useful in certain situations where exporting a helper function is not desirable.

Let’s modify our “mathutil_test.go” file to demonstrate this reflection-based testing approach:

package mathutil

import (
    "reflect"
    "testing"
)

func TestPrivateAddReflection(t *testing.T) {
    privateAddValue := reflect.ValueOf(privateAdd)
    result := privateAddValue.Call([]reflect.Value{reflect.ValueOf(2), reflect.ValueOf(3)})[0].Int()
    expected := 5
    if result != expected {
        t.Errorf("privateAdd(2, 3) = %d; expected %d", result, expected)
    }
}

In this test function, we use the reflect package to get a reflection value of the private function privateAdd. We then call the function dynamically with the desired arguments using Call and extract the result using indexing and type conversion. Finally, we compare the result with the expected value.

When you run the tests again, you should still see the passing output.

Conclusion

In this tutorial, we explored two approaches for testing private functions in Go. By using either an exported helper function or reflection, we can write effective unit tests for our private functions. Remember to find the best approach depending on your specific requirements and project constraints. Writing comprehensive tests helps ensure the correctness and maintainability of your code. Happy testing!

Published:

Related Articles