Wie kann man GraphQL-Resolver in Golang mit Mocking effektiv einem Unit-Test unterziehen?

Unit-Testing von GraphQL in Golang

Einführung

Unit-Tests sind ein entscheidender Aspekt beim Schreiben robuster und zuverlässiger Software. Bei der Arbeit mit GraphQL in Golang ist es wichtig, sowohl den Query- als auch den Mutation-Resolver zu testen, um sicherzustellen, dass sie sich wie erwartet verhalten.

Mocking Services

Eine der größten Herausforderungen beim Testen von GraphQL-Resolvern besteht darin, dass sie verlassen sich häufig auf externe Dienste wie Datenbanken oder APIs. Um zu verhindern, dass diese Abhängigkeiten unsere Tests beeinträchtigen, können wir Mocking verwenden. Mocking ermöglicht es uns, gefälschte Objekte zu erstellen, die das Verhalten der echten Dienste nachahmen.

Beispiel

Betrachten wir ein Beispiel, in dem wir die User- und ValidateAccessToken-Resolver testen möchten. Wir definieren eine UserService-Schnittstelle, die den tatsächlichen Dienst darstellt, und implementieren dann eine Scheinimplementierung zu Testzwecken.

<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

Als nächstes richten wir unsere Tests ein, indem wir eine neue erstellen Resolver mit dem simulierten Dienst:

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

Testen des ValidateAccessToken-Resolvers

Wir verwenden das gqlgen/client-Paket, um GraphQL-Abfragen und Mutationen für unseren simulierten Dienst auszuführen.

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

Testen des Benutzer-Resolvers

Ähnlich können wir den Benutzer-Resolver testen:

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

Fazit

Beim Unit-Testen von GraphQL-Resolvern in Golang wird Mocking verwendet, um Ihre Resolver zu isolieren von externen Abhängigkeiten, sodass Sie sich auf das Testen ihrer Funktionalität konzentrieren können. Indem Sie die in diesem Leitfaden beschriebenen Schritte befolgen, können Sie sicherstellen, dass sich Ihre Resolver wie erwartet verhalten und eine konsistente und zuverlässige GraphQL-API bereitstellen.

Das obige ist der detaillierte Inhalt vonWie kann man GraphQL-Resolver in Golang mit Mocking effektiv einem Unit-Test unterziehen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!