Comment tester efficacement les requêtes et mutations GraphQL avec Testify et GQLgen dans Golang ?

Tests unitaires de GraphQL dans Golang

Lorsque vous testez des requêtes et des mutations GraphQL dans une application Golang, il est crucial d'avoir une stratégie de tests robuste pour garantir la fonctionnalité et la fiabilité de votre Points de terminaison de l'API.

Niché dans le labyrinthe des frameworks de test Golang, temoignage règne en maître comme choix privilégié pour sa simplicité et son exhaustivité. En combinaison avec le package gqlgen/client, qui fournit une aide précieuse pour tester GraphQL, vous pouvez plonger dans le domaine gratifiant des tests unitaires efficaces.

Lancons-nous dans un exemple pratique pour éclairer le processus de test des requêtes et des mutations GraphQL. :

<code class="go">// graph/resolver/root.resolver_test.go

import (
    "context"
    "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/mocks"
    "github.com/stretchr/testify/mock"
    "github.com/stretchr/testify/require"
)

...

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>

En utilisant ces objets fictifs, nous pouvons procéder à l'élaboration de tests unitaires complets qui valident la fonctionnalité de nos résolveurs GraphQL :

<code class="go">// graph/resolver/root.resolver_test.go

...

// TestMutationResolver_ValidateAccessToken is a test example for the ValidateAccessToken mutation.
func TestMutationResolver_ValidateAccessToken(t *testing.T) {

    t.Run("should validate accesstoken correctly", func(t *testing.T) {
        // Create a mocked user service
        mockedUserService := new(mocks.MockedUserService)

        // Inject the mocked service into our resolver
        resolvers := resolver.Resolver{UserService: mockedUserService}

        // Create a GraphQL client
        c := client.New(handler.NewDefaultServer(generated.NewExecutableSchema(generated.Config{Resolvers: &resolvers})))

        // Set up expected return values from the mock service
        ue := model.UserEntity{ID: "123", User: model.User{Loginname: &loginname, AvatarURL: &avatarURL}}
        mockedUserService.On("ValidateAccessToken", mock.AnythingOfType("string")).Return(&ue)

        // Run the GraphQL mutation query
        var resp struct {
            ValidateAccessToken struct{ ID, Loginname, AvatarUrl string }
        }
        q := `
      mutation { 
        validateAccessToken(accesstoken: "abc") { 
          id, 
          loginname, 
          avatarUrl 
        } 
      }
    `
        c.MustPost(q, &resp)

        // Assert that the mock service was called as expected
        mockedUserService.AssertExpectations(t)

        // Check the response from the GraphQL mutation
        require.Equal(t, "123", resp.ValidateAccessToken.ID)
        require.Equal(t, "mrdulin", resp.ValidateAccessToken.Loginname)
        require.Equal(t, "avatar.jpg", resp.ValidateAccessToken.AvatarUrl)
    })

}
...</code>

En mettant en œuvre cette approche de test, vous pouvez efficacement examinez vos résolveurs GraphQL et équipez votre application d'une base solide de qualité et de fiabilité.

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!