Testes unitários para salvar sua vida - Parte 3

· 824 words · 4 minute read

Sumário 🔗

  1. Como mockar?
  2. Geradores de mock
  3. Manual
  4. Dicas finais

Se você está lendo isso, provavelmente já leu a primeira e a segunda parte deste post. Se não, recomendo que leia a parte 2 antes de continuar.

Como mockar? 🔗

“Accept interface, return struct” é quase que um mantra em Go e pensar dessa forma vai te ajudar na criação de mocks e testes mais flexíveis. Mas afinal o que isso significa?

Vamos imaginar que a função que você precisa testar aceita parâmetros de entrada, como por exemplo uma use case que aceite uma struct de um repositório. Ao tentar criar um teste para essa função você não consegue alterar o comportamento daquele repositório, já que você vai precisar simular operações em banco de dados. Isso se dá ao fato que tipos concretos não podem ser alterados, e para deixar essa função testável, basta você criar uma interface que implemente as funções dessa struct do lado do chamador. Isso significa que você só precisa criar essa interface de acordo com os métodos que você utiliza nessa função, e não precisa se preocupar com todos os métodos da struct original e passar ela como parâmetro para a função que você quer testar. Logo em Go percebemos que não é possível criar mocks diretamente de structs, mas você pode criar mocks de interfaces.

Geradores de mock 🔗

Existem algumas bibliotecas que te ajudam a gerar mocks de uma forma mais automatizada, como por exemplo:

1
2
3
4
5
6
7

// Exemplo utilizando Mockery

//go:generate mockery --name TwitchClient --structname MockTwitchClient --inpackage --case snake
type TwitchClient interface {
  Authenticate(ctx context.Context) (string, error)
  ClientID() string
}

1
2

# Para gerar o mock, execute o comando:
$ go generate ./...

O comando acima irá gerar um arquivo chamado mock_twitch_client.go no mesmo pacote, contendo a implementação do mock da interface TwitchClient. Você pode então usar esse mock nos seus testes.

Manual 🔗

Para criar um mock manualmente, você deve criar uma struct que implemente a interface que você quer mockar e implementar os métodos dessa interface. Eu gosto de criar uma struct que aceite uma função e tenha um contador por função para posteriormente fazer asserts em cima do número de vezes que ela foi chamada. Vale salientar que essa struct deve ficar dentro do seu arquivo de testes e não de forma exportada em algum pacote que não seja de testes, veja este exemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

type (
  // TwitchClient é a interface que define os métodos que o cliente Twitch deve implementar.
  TwitchClient interface {
    Authenticate(ctx context.Context) (string, error)
    ClientID() string
  }

 // mockTwitchClient é uma implementação de TwitchClient para testes.
  mockTwitchClient struct {
    AuthenticateFn      func(ctx context.Context) (string, error)
    AuthenticateFnCount int
    ClientIDFn          func() string
    ClientIDFnCount     int
  }
)

// Authenticate implementa o método Authenticate da interface TwitchClient.
func (m *mockTwitchClient) Authenticate(ctx context.Context) (string, error) {
  m.AuthenticateFnCount++
  return m.AuthenticateFn(ctx)
}

// ClientID implementa o método ClientID da interface TwitchClient.
func (m *mockTwitchClient) ClientID() string {
  m.ClientIDFnCount++
  return m.ClientIDFn()
}

// NewMockTwitchClient cria um novo mock de TwitchClient
// com funções padrão que podem ser sobrescritas para testes específicos.
func NewMockTwitchClient() *mockTwitchClient {
  return &mockTwitchClient{
    AuthenticateFn: func(_ context.Context) (string, error) {
      return "access-token", nil // Retorne o que for necessário para o teste
    },
    ClientIDFn: func() string {
      return "client-id"
    },
  }
}

// TestClient_Games é um exemplo de teste que utiliza o mockTwitchClient.
func TestClient_Games(t *testing.T) {
  mockTwitchClient := &mockTwitchClient{
    AuthenticateFn: func(_ context.Context) (string, error) {
      return "access-token", nil
    },
    ClientIDFn: func() string {
      return "client-id"
    },
  },

  c := igdb.NewClient(igdb.Config{
    TwitchClient: mockTwitchClient,
  })

  games, err := c.Games(context.Background(), "Mario")
  require.NoError(t, err)

  assert.Len(t, games, 10)
  assert.Equal(t, 1, mockTwitchClient.AuthenticateFnCount)
  assert.Equal(t, 1, mockTwitchClient.ClientIDFnCount)
}

Dicas finais 🔗

Como última dica, vale ressaltar que as interfaces devem ser pequenas e específicas, evitando criar interfaces muito genéricas que podem dificultar a compreensão do código e a criação de mocks. Além disso, evite criar mocks de interfaces que não são utilizadas diretamente no seu código, pois isso pode levar a testes desnecessários e complexos.

Por exemplo, se você tem uma interface que define métodos para manipulação de arquivos, mas você só precisa de um método específico para o seu teste, crie uma interface menor que contenha apenas esse método.

Rob Pike já dizia: “The bigger the interface, the weaker the abstraction.”.

“Don’t design your interfaces in advance, discover them as you go.” Não crie interfaces antes dos tipos concretos, descubra-as conforme você vai escrevendo o código. Isso ajuda a manter as interfaces pequenas e específicas, facilitando a criação de mocks e testes mais flexíveis.

golang teste test