How to Use Interfaces for Testing in Go

Table of Contents

  1. Introduction
  2. Prerequisites
  3. Setup
  4. Overview
  5. Step 1: Writing Testable Code
  6. Step 2: Creating the Interface
  7. Step 3: Implementing the Interface
  8. Step 4: Writing Tests
  9. Conclusion

Introduction

In Go (or Golang), interfaces play a crucial role in achieving testability and writing cleaner code. By programming to interfaces instead of concrete implementations, you can easily replace dependencies with fakes or mocks during testing, making your tests more reliable. In this tutorial, you will learn how to use interfaces for testing in Go. By the end, you will have a solid understanding of how to write testable code and how to create and implement interfaces for testing purposes.

Prerequisites

To follow along with this tutorial, you should have a basic understanding of the Go programming language, including how to write functions, structs, and tests. It is also recommended to have Go installed on your machine.

Setup

There is no specific setup required for this tutorial, as we will be writing the code from scratch. However, make sure you have Go installed and properly configured on your system before proceeding.

Overview

In this tutorial, we will go through the following steps:

  1. Writing testable code
  2. Creating the interface

  3. Implementing the interface

  4. Writing tests

    We will use a simple example of a bookstore application. The application has a Book struct, which represents a book with a title and an author. We will write code to fetch book details from a database, but instead of directly interacting with the database, we will use interfaces to decouple the code from the actual database implementation. This not only makes our code more testable but also allows us to switch databases easily in the future without affecting the rest of the application.

    Let’s get started!

Step 1: Writing Testable Code

First, let’s create a file named book.go and define our Book struct. The file structure should look like this:

bookstore/
├── book.go
└── book_test.go

In book.go, add the following code:

package bookstore

type Book struct {
    Title  string
    Author string
}

func (b *Book) FetchDetailsFromDB() error {
    // Code to fetch book details from the database
    return nil
}

Here, we have defined the Book struct with Title and Author fields. We have also added a method FetchDetailsFromDB which will be responsible for fetching book details from the database. This is the code we want to test.

Step 2: Creating the Interface

Now, let’s create an interface that defines the behavior of our database operations. In a new file named database.go, add the following code:

package bookstore

type Database interface {
    FetchBookDetails() ([]Book, error)
}

In this code, we have defined an interface Database with a single method FetchBookDetails. This interface represents the contract for fetching book details from the database. Any type that implements this interface will be considered a valid database implementation.

Step 3: Implementing the Interface

In order to use the database interface, we need to implement it for a specific database. Let’s create a MySQLDatabase type which implements the Database interface. In a new file named mysql_database.go, add the following code:

package bookstore

type MySQLDatabase struct {
    // Database connection details and configurations
}

func (db *MySQLDatabase) FetchBookDetails() ([]Book, error) {
    // Code to fetch book details from a MySQL database
    return []Book{}, nil
}

Here, we have defined a MySQLDatabase struct with fields representing the database connection details. We have also implemented the FetchBookDetails method, where you would normally write the code to interact with the MySQL database and retrieve the book details.

You can create similar implementations for other databases like PostgreSQL or MongoDB by providing their respective struct and implementing the FetchBookDetails method.

Step 4: Writing Tests

Finally, let’s write tests for our code. In the book_test.go file, add the following code:

package bookstore

import "testing"

type mockDatabase struct{}

func (mdb *mockDatabase) FetchBookDetails() ([]Book, error) {
    // Code for mock implementation of FetchBookDetails
    return []Book{
        {Title: "Test Book", Author: "Test Author"},
    }, nil
}

func TestFetchDetailsFromDB(t *testing.T) {
    b := Book{}
    db := &mockDatabase{}
    b.FetchDetailsFromDB(db)

    // Assert statements to validate the result
}

In this code, we have created a mock implementation of the Database interface named mockDatabase. It returns a predefined book when FetchBookDetails is called. We then create an instance of Book and pass our mock database to the FetchDetailsFromDB method.

You can add assertion statements inside the test function to validate the result based on the expected book details returned by the mock database.

Please note that this is a simplified example, and in real-world scenarios, you might use popular mocking libraries like testify/mock for creating mocks.

To run the tests, use the following command:

go test -v ./...

This will execute all the tests in the current directory and subdirectories, printing verbose output.

Conclusion

In this tutorial, you learned how to use interfaces for testing in Go. By using interfaces, you can write testable code and easily replace dependencies with mock implementations during testing. We went through the steps of writing testable code, creating an interface, implementing the interface, and writing tests.

Interfaces are a powerful tool in Go that can improve the testability and maintainability of your codebase. Embracing interfaces and dependency injection can lead to cleaner and more flexible code, making it easier to write robust tests.

Remember, the key is to program to interfaces rather than concrete implementations, which makes it easier to swap dependencies and facilitates the isolation of code for testing purposes.

Happy coding!

Published:

Related Articles