Comment tester efficacement les résolveurs GraphQL dans Golang avec moquerie ?

Tests unitaires GraphQL dans Golang

Introduction

Les tests unitaires sont un aspect crucial de l'écriture de logiciels robustes et fiables. Lorsque vous travaillez avec GraphQL dans Golang, il est essentiel de tester à la fois les résolveurs de requêtes et de mutations pour vous assurer qu'ils se comportent comme prévu.

Services moqueurs

L'un des principaux défis liés au test des résolveurs GraphQL est qu'ils s'appuient souvent sur des services externes, tels que des bases de données ou des API. Pour éviter que ces dépendances n'interfèrent avec nos tests, nous pouvons utiliser le mocking. La moquerie nous permet de créer de faux objets qui imitent le comportement des services réels.

Exemple

Prenons un exemple dans lequel nous voulons tester les résolveurs User et ValidateAccessToken. Nous définissons une interface UserService qui représente le service réel, puis nous implémentons une implémentation fictive à des fins de test.

<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>

Configuration du test

Ensuite, nous configurons nos tests en créant un nouveau Résolveur avec le service simulé :

<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>

Test du résolveur ValidateAccessToken

Nous utilisons le package gqlgen/client pour exécuter des requêtes et des mutations GraphQL sur notre service simulé.

<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>

Test du résolveur utilisateur

De même, nous pouvons tester le résolveur utilisateur :

<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

Les tests unitaires des résolveurs GraphQL dans Golang impliquent l'utilisation de la simulation pour isoler vos résolveurs des dépendances externes, vous permettant de vous concentrer sur le test de leurs fonctionnalités. En suivant les étapes décrites dans ce guide, vous pouvez vous assurer que vos résolveurs se comportent comme prévu et fournissent une API GraphQL cohérente et fiable.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!