How to Effectively Unit Test GraphQL Resolvers in Golang with Mocking?

Unit Testing GraphQL in Golang

Introduction

Unit testing is a crucial aspect of writing robust and reliable software. When working with GraphQL in Golang, it's essential to test both the Query and Mutation resolvers to ensure they behave as expected.

Mocking Services

One of the key challenges in testing GraphQL resolvers is that they often rely on external services, such as databases or APIs. To prevent these dependencies from interfering with our tests, we can use mocking. Mocking allows us to create fake objects that mimic the behavior of the real services.

Example

Let's consider an example where we want to test the User and ValidateAccessToken resolvers. We define a UserService interface that represents the real service, and then we implement a mock implementation for testing purposes.

<code class="go">package mocks

import (
    "github.com/mrdulin/gqlgen-cnode/graph/model"
    "github.com/stretchr/testify/mock"
)

type MockedUserService struct {
    mock.Mock
}

func (s *MockedUserService) GetUserByLoginname(loginname string) *model.UserDetail {
    args := s.Called(loginname)
    return args.Get(0).(*model.UserDetail)
}

func (s *MockedUserService) ValidateAccessToken(accesstoken string) *model.UserEntity {
    args := s.Called(accesstoken)
    return args.Get(0).(*model.UserEntity)
}</code>

Test Setup

Next, we set up our tests by creating a new Resolver with the mocked service:

<code class="go">package resolver_test

import (
    "testing"

    "github.com/99designs/gqlgen/client"
    "github.com/99designs/gqlgen/graphql/handler"
    "github.com/mrdulin/gqlgen-cnode/graph/generated"
    "github.com/mrdulin/gqlgen-cnode/graph/model"
    "github.com/mrdulin/gqlgen-cnode/graph/resolver"
    "github.com/mrdulin/gqlgen-cnode/mocks"
    "github.com/stretchr/testify/mock"
    "github.com/stretchr/testify/require"
)</code>

Testing the ValidateAccessToken Resolver

We use the gqlgen/client package to execute GraphQL queries and mutations against our mocked service.

<code class="go">func TestMutationResolver_ValidateAccessToken(t *testing.T) {

    t.Run("should validate accesstoken correctly", func(t *testing.T) {
        testUserService := new(mocks.MockedUserService)
        resolvers := resolver.Resolver{UserService: testUserService}
        c := client.New(handler.NewDefaultServer(generated.NewExecutableSchema(generated.Config{Resolvers: &resolvers})))
        ue := model.UserEntity{ID: "123", User: model.User{Loginname: &loginname, AvatarURL: &avatarURL}}
        testUserService.On("ValidateAccessToken", mock.AnythingOfType("string")).Return(&ue)
        var resp struct {
            ValidateAccessToken struct{ ID, Loginname, AvatarUrl string }
        }
        q := `
      mutation { 
        validateAccessToken(accesstoken: "abc") { 
          id, 
          loginname, 
          avatarUrl 
        } 
      }
    `
        c.MustPost(q, &resp)
        testUserService.AssertExpectations(t)
    })

}</code>

Testing the User Resolver

Similarly, we can test the User resolver:

<code class="go">func TestQueryResolver_User(t *testing.T) {
    t.Run("should query user correctly", func(t *testing.T) {
        testUserService := new(mocks.MockedUserService)
        resolvers := resolver.Resolver{UserService: testUserService}
        c := client.New(handler.NewDefaultServer(generated.NewExecutableSchema(generated.Config{Resolvers: &resolvers})))
        u := model.UserDetail{User: model.User{Loginname: &loginname, AvatarURL: &avatarURL}, Score: &score, CreateAt: &createAt}
        testUserService.On("GetUserByLoginname", mock.AnythingOfType("string")).Return(&u)
        var resp struct {
            User struct {
                Loginname, AvatarURL, CreateAt string
                Score                          int
            }
        }
        q := `
      query GetUser($loginname: String!) { 
        user(loginname: $loginname) { 
          loginname
          avatarUrl 
          createAt 
          score 
        } 
      }
    `
        c.MustPost(q, &resp, client.Var("loginname", "mrdulin"))
        testUserService.AssertCalled(t, "GetUserByLoginname", "mrdulin")
    })
}</code>

Conclusion

Unit testing GraphQL resolvers in Golang involves using mocking to isolate your resolvers from external dependencies, allowing you to focus on testing their functionality. By following the steps outlined in this guide, you can ensure that your resolvers behave as expected and provide a consistent and reliable GraphQL API.

The above is the detailed content of How to Effectively Unit Test GraphQL Resolvers in Golang with Mocking?. For more information, please follow other related articles on the PHP Chinese website!