Go Mocking with testify/mock

Welcome to the exciting world of Go Mocking using the popular testify/mock library! This tutorial will guide you through understanding and implementing Go mocking, perfect for self-learners, students, and developers looking to upskill. Let's dive in! 🎯

What is Go Mocking?

In simple terms, mocking is a technique used in testing where you create fake objects to replace real dependencies during testing. This allows you to isolate and test specific parts of your code without depending on external services or system components. 💡

Why Go Mocking?

Independent Testing: Mocking enables you to write tests that are not dependent on external services or resources, making your tests faster and more reliable.
Isolation: Mocking helps isolate the unit you are testing, reducing the chances of side effects and improving test coverage.
Flexibility: With mocks, you can easily test different scenarios and edge cases without affecting the actual code.

Getting Started with testify/mock

Installation

First, you need to install the testify/mock package. If you haven't already, install it by running:

bash

go get github.com/stretchr/testify/mock

Creating a Mock

To create a mock, you'll first import the mock package and then define a type that implements the interface you want to mock. Here's a simple example:

package main

import (
	"fmt"
	"testing"
	"github.com/stretchr/testify/mock"
)

type Logger interface {
	Log(string)
}

type MockLogger struct {
	mock.Mock
}

func (m *MockLogger) Log(msg string) {
	m.Called(msg)
}

func TestLogging(t *testing.T) {
	logger := new(MockLogger)
	logger.On("Log", "Hello, World!").Once()
	logger.Log("Hello, World!")
}

In this example, we've defined a Logger interface and a MockLogger struct that implements it. We've also defined a Log method on the MockLogger and used mock.Mock to tell Go that this struct will be mocked.

During testing, we create a MockLogger instance and use the On method to specify that when the Log method is called with "Hello, World!", it should be called once. Then, when we call Log on our mock logger, it will behave as expected.

Calling Real Methods on Mocks

You can also call real methods on mocks in your tests. Here's an example:

package main

import (
	"fmt"
	"testing"
	"github.com/stretchr/testify/mock"
)

type Service struct {
	Logger Logger
}

type Logger interface {
	Log(string)
}

type MockLogger struct {
	mock.Mock
}

func (m *MockLogger) Log(msg string) {
	m.Called(msg)
}

func (s *Service) DoSomething() {
	s.Logger.Log("Doing something...")
}

func TestService(t *testing.T) {
	logger := new(MockLogger)
	service := &Service{Logger: logger}
	service.DoSomething()

	logger.AssertExpectations(t)
}

In this example, we've defined a Service struct that takes a Logger as a dependency. We've also defined the DoSomething method that calls the Log method on the logger. During testing, we create a MockLogger, inject it into our Service, and call DoSomething. Finally, we use AssertExpectations to ensure that our mocks were called as expected.

📝 Note:

Remember to call AssertExpectations after you've exercised your mocks in the test.
You can also use ExpectationsWereMet for asserting that the mocks were called.

Quiz

Happy coding! 🤖 Let's continue exploring Go Mocking in our next lesson! 🚀