Wie kann man GraphQL-Abfragen und -Mutationen effektiv mit Testify und GQLgen in Golang testen?

Unit-Testing von GraphQL in Golang

Beim Testen von GraphQL-Abfragen und -Mutationen in einer Golang-Anwendung ist es entscheidend, über eine robuste Teststrategie zu verfügen, um die Funktionalität und Zuverlässigkeit Ihrer Anwendung sicherzustellen API-Endpunkte.

Eingebettet in das Labyrinth der Golang-Test-Frameworks gilt testify aufgrund seiner Einfachheit und Vollständigkeit als bevorzugte Wahl. In Kombination mit dem gqlgen/client-Paket, das unschätzbare Hilfe beim Testen von GraphQL bietet, können Sie in die lohnende Welt effektiver Unit-Tests eintauchen.

Lassen Sie uns mit einem praktischen Beispiel beginnen, um den Prozess des Testens von GraphQL-Abfragen und -Mutationen zu veranschaulichen :

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

Mithilfe dieser Scheinobjekte können wir umfassende Komponententests erstellen, die die Funktionalität unserer GraphQL-Resolver validieren:

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

Durch die Implementierung dieses Testansatzes können Sie dies effektiv tun Überprüfen Sie Ihre GraphQL-Resolver und statten Sie Ihre Anwendung mit einer soliden Grundlage für Qualität und Zuverlässigkeit aus.

Das obige ist der detaillierte Inhalt vonWie kann man GraphQL-Abfragen und -Mutationen effektiv mit Testify und GQLgen in Golang testen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!