Working with Test Doubles in Go

Table of Contents

  1. Introduction
  2. Prerequisites
  3. Setup
  4. Understanding Test Doubles
  5. Types of Test Doubles
  6. Using Test Doubles in Go
  7. Example: Testing a File Writer
  8. Conclusion

Introduction

Welcome to this tutorial on working with Test Doubles in Go! In this tutorial, we will explore the concept of Test Doubles and how they can be used to facilitate testing in your Go applications. By the end of this tutorial, you will have a good understanding of what Test Doubles are and how to use them effectively in your Go projects.

Prerequisites

To follow along with this tutorial, you should have a basic understanding of Go programming language and familiarity with writing tests in Go. It would also be helpful to have Go installed on your local development machine.

Setup

There is no specific setup required for this tutorial. You can use any Go development environment of your choice, such as VS Code, GoLand, or even the command-line tools. Just make sure you have a working Go environment before you proceed.

Understanding Test Doubles

Test Doubles are objects that are used in place of real dependencies in unit tests. They allow us to isolate the code under test by removing its dependencies on external systems or services. By using Test Doubles, we can control the behavior of these dependencies and easily simulate different scenarios during testing.

Test Doubles come in different forms, depending on their purpose and how they interact with the code under test. Let’s explore some of the common types of Test Doubles.

Types of Test Doubles

  1. Dummy objects are usually placeholders that are required by the code under test but are not actually used during the test. For example, if a function requires a parameter to be passed but doesn’t use it, we can pass a dummy object.

  2. Stub objects provide predefined responses to method calls during testing. They are useful when we want to control the behavior of a dependency and ensure specific responses are returned.

  3. Mock objects are similar to stubs but include additional verification capabilities. We can use mock objects to set expectations on method calls and then verify if those expectations were met.

  4. Fake objects are simplified versions of real implementations. They mimic the behavior of the real implementation but usually take shortcuts or simplifications to make testing easier.

    Using Test Doubles appropriately can greatly improve the speed, reliability, and maintainability of your tests. Now let’s see how we can use Test Doubles in Go.

Using Test Doubles in Go

Go provides a built-in testing package, testing, which makes it easy to write test cases. To use Test Doubles effectively, we often create interfaces and implement those interfaces in real and fake implementations of dependencies.

Here are the general steps to use Test Doubles in Go:

  1. Identify the dependencies that need to be replaced with Test Doubles in your code.
  2. Create an interface that represents the functionality of the dependency. This allows us to define a contract that all Test Doubles must adhere to.
  3. Implement the interface in the real dependency and any relevant fake or mock implementations.

  4. In your code, use this interface instead of the concrete implementation of the dependency.

  5. In your tests, create and use Test Doubles (stubs, mocks, or fakes) that implement the same interface to replace the real dependencies.

    Now let’s walk through a practical example to demonstrate how to implement Test Doubles in Go.

Example: Testing a File Writer

Suppose we have a simple file writer package that provides a WriteToFile function to write content to a file. We want to test this package, but we don’t want the tests to depend on the file system.

First, let’s define an interface that represents the file writer functionality:

type FileWriter interface {
    WriteToFile(filename string, content string) error
}

Next, we implement the real file writer that satisfies this interface:

type RealFileWriter struct{}

func (w *RealFileWriter) WriteToFile(filename string, content string) error {
    file, err := os.Create(filename)
    if err != nil {
        return err
    }
    defer file.Close()

    _, err = file.WriteString(content)
    return err
}

Now, let’s write our first test using a Stub:

type StubFileWriter struct{}

func (w *StubFileWriter) WriteToFile(filename string, content string) error {
    return nil // Always return nil (success)
}

func TestWriteToFile_Stub(t *testing.T) {
    writer := &StubFileWriter{}
    err := writer.WriteToFile("test.txt", "Hello, World!")

    if err != nil {
        t.Errorf("Expected no error, but got: %v", err)
    }
}

In this test, we created a StubFileWriter that always returns nil (indicating success) regardless of the inputs. This allows us to test the calling code without worrying about the actual file writing.

Now, let’s write another test using a Mock:

type MockFileWriter struct {
    WriteToFileFn func(filename string, content string) error
}

func (w *MockFileWriter) WriteToFile(filename string, content string) error {
    return w.WriteToFileFn(filename, content)
}

func TestWriteToFile_Mock(t *testing.T) {
    expectedFile := "test.txt"
    expectedContent := "Hello, World!"

    var called bool = false
    writer := &MockFileWriter{
        WriteToFileFn: func(filename string, content string) error {
            called = true

            if filename != expectedFile {
                t.Errorf("Expected filename: %s, got: %s", expectedFile, filename)
            }

            if content != expectedContent {
                t.Errorf("Expected content: %s, got: %s", expectedContent, content)
            }

            return nil
        },
    }

    err := writer.WriteToFile(expectedFile, expectedContent)
    
    if !called {
        t.Error("Expected WriteToFileFn to be called")
    }

    if err != nil {
        t.Errorf("Expected no error, but got: %v", err)
    }
}

In this test, we create a MockFileWriter that allows us to set up expectations on the WriteToFileFn field, which is our substitute for the WriteToFile method. We verify that the function was called with the expected arguments.

These examples showcase the usage of Stub and Mock Test Doubles. You can also create a FakeFileWriter to test the behavior without actually writing files.

Conclusion

In this tutorial, we explored the concept of Test Doubles and how they can be used to facilitate testing in Go applications. We discussed different types of Test Doubles, including Dummies, Stubs, Mocks, and Fakes. We also provided a step-by-step guide on using Test Doubles in Go, along with a practical example of testing a file writer.

By leveraging Test Doubles effectively, you can write more reliable and maintainable tests for your Go projects. I hope this tutorial has provided you with a solid understanding of Test Doubles and their usage in Go testing.

Remember to experiment with different Test Double implementations and adapt them to suit your specific testing needs. Happy coding!

Published:

Related Articles