Servidor HTTP

Search…

Servidor HTTP

​Você encontra todo o código-fonte para este capítulo aqui​
Você recebeu o desafio de criar um servidor web para que usuários possam acompanhar quantas partidas os jogadores venceram.
GET /jogadores/{nome} deve retornar um número indicando o número total de vitórias
POST /jogadores/{nome} deve registrar uma vitória para este nome de jogador, incrementando a cada nova chamada de submissão de dados (método HTTP POST). 
Vamos seguir com a abordagem do Desenvolvimento Orientado a Testes, criando software que funciona o mais rápido possível, e a cada ciclo fazendo pequenas melhorias até uma solução completa. Com essa abordagem, nós:
Mantemos pequeno o escopo do problema em qualquer momento
Não perdemos o foco por pensar em muito detalhes
Se ficamos emperrados ou perdidos, podemos voltar para uma versão anterior do código sem perder muito trabalho.
Vermelho, verde, refatore
Por todo o livro, enfatizamos o processo Desenvolvimento Orientado a Testes de escrever um teste e ver a falha (vermelho), escrever a menor quantidade de código para fazer o teste passar/funcionar (verde), e então fazemos a reescrita (refatoração).
A disciplina de escrever a menor quantidade de código é importante para garantir a segurança que o Desenvolvimento Orientado a Testes proporciona. Você deve se empenhar em sair do vermelho o quanto antes.
Kent Beck descreve essa prática como:
Faça o teste passar rapidamente, cometendo quaisquer pecados necessários nesse processo.
E você pode cometer estes pecados porque vamos reescrever o código logo depois, com a segurança garantida pelos testes.
E se você não fizer assim?
Quanto mais alterações você fizer enquanto seu código estiver em vermelho, maiores as chances de você adicionar problemas, não cobertos por testes.
A ideia é escrever iterativamente código útil em pequenos passos, guiados pelos testes, para que você não perca foco no objetivo principal.
A galinha e o ovo
Como podemos construir isso de forma incremental? Não podemos obter um jogador (método HTTP GET) sem tê-lo registrado anteriormente, e parece complicado saber se a chamada ao método HTTP POST funcionou sem a chamada ao método HTTP GET já implementado.
E é nesse ponto que o uso de classes com valores predefinidos vai nos ajudar.
(Nota de tradução: No original, é usada a expressão mocking, que significa "zombar", "fazer piada" ou "enganar". Em programação, mocking significa criar algo, como uma classe ou função, que retorna os valores esperados de forma predefinida.)
a implementação que responde ao método HTTP GET precisa de uma coisa ArmazenamentoJogador para obter pontuações de um nome de jogador. Isso deve ser uma interface, para que, ao executar os testes, seja possível criar um código simples de esboço para testar o código sem precisar, neste momento, implementar o código final que será usado para armazenar os dados.
para o método HTTP POST, podemos inspecionar as chamadas feitas a ArmazenamentoJogador para ter certeza de que os dados são armazenados corretamente. Nossa implementação de gravação dos dados não estará vinculada à busca dos dados.
para ver código rodando rapidamente vamos fazer uma implementação simples de armazenamento dos dados na memória, e depois podemos criar uma implementação que dá suporte ao mecanismo de armazenamento de preferência.
Escrevendo o teste primeiro
Podemos escrever um teste e fazer funcionar retornando um valor predeterminado para nos ajudar a começar. Kent Beck se refere a isso como "Fazer de conta". Uma vez que temos um teste funcionando podemos escrever mais testes que nos ajudem a remover este valor predeterminado (constante).
Com este pequeno passo, nós começamos a ter uma estrutura inicial para o projeto funcionando corretamente, sem nos preocuparmos demais com a lógica da aplicação.
Para criar um servidor web (uma aplicação que recebe chamadas via protocolo HTTP) em Go, você vai chamar, usualmente, a função ListenAndServe.
1
func ListenAndServe(endereco string, tratador Handler) error
Copied!
Isso vai iniciar um servidor web escutando em uma porta, criando uma gorotina para cada requisição, e repassando para um Tratador, que é representado pela interface Handler, usada para receber a requisição e avaliar o que fazer com os dados recebidos.
1
type Handler interface {
2
    ServeHTTP(ResponseWriter, *Request)
3
}
Copied!
Esta interface define uma única função que espera dois argumentos, o primeiro que indica onde escrevemos a resposta e o outro com a requisição HTTP que nos foi enviada.
Vamos criar o primeiro arquivo, servidor_test.go e escrever um teste para a função ServidorJogador que recebe estes dois argumentos. A requisição enviada serve para obter a pontuação de um Nome de Jogador, que esperamos que seja "20".
1
func TestObterJogadores(t *testing.T) {
2
    t.Run("retornar resultado de Maria", func(t *testing.T) {
3
        requisicao, _ := http.NewRequest(http.MethodGet, "/jogadores/Maria", nil)
4
        resposta := httptest.NewRecorder()
5
​
6
        ServidorJogador(resposta, requisicao)
7
​
8
        recebido := resposta.Body.String()
9
        esperado := "20"
10
​
11
        if recebido != esperado {
12
            t.Errorf("recebido '%s', esperado '%s'", recebido, esperado)
13
        }
14
    })
15
}
Copied!
Para testar nosso servidor, vamos precisar de uma Requisição (Request) para enviar ao servidor, e então queremos inspecionar o que o nosso Tratador escreve para o ResponseWriter.
Nós usamos o http.NewRequest para criar uma requisição. O primeiro argumento é o método da requisição e o segundo é o caminho da requisição. O valor nil para o segundo argumento corresponde ao corpo (body) da requisição, que não precisamos definir para este teste.
net/http/httptest já tem um inspecionador criado para nós, chamado ResponseRecorder (GravadorDeResposta), então podemos usá-lo. Este possui muitos métodos úteis para inspecionar o que foi escrito como resposta.
Tente rodar o teste
./servidor_test.go:13:2: undefined: ServidorJogador
Escreva a quantidade mínima de código para o que teste passe e verifique a falha indicada na responta do teste
O compilador está aqui para ajudar, ouça o que ele diz.
Crie o arquivo servidor.go, e nele a função ServidorJogador
1
func ServidorJogador() {}
Copied!
Tente novamente
1
./servidor_test.go:13:14: too many arguments in call to ServidorJogador
2
    have (*httptest.ResponseRecorder, *http.Request)
3
    want ()
Copied!
Adicione os argumentos à função:
1
import "net/http"
2
​
3
func ServidorJogador(w http.ResponseWriter, r *http.Request) {
4
​
5
}
Copied!
Agora o código compila, e o teste falha.
1
--- FAIL: TestObterJogadores (0.00s)
2
    --- FAIL: TestObterJogadores/retornar_resultado_de_Maria (0.00s)
3
        servidor_test.go:20: recebido '', esperado '20'
Copied!
Escreva código suficiente para fazer o teste funcionar
Do capítulo sobre injeção de dependências, falamos sobre servidores HTTP com a função Greet. Aprendemos que a função ResponseWriter também implementa a interface Writer do pacote io, então podemos usar fmt.Fprint para enviar strings como respostas HTTP.
1
func ServidorJogador(w http.ResponseWriter, r *http.Request) {
2
    fmt.Fprint(w, "20")
3
}
Copied!
O teste agora deve funcionar.
Complete a estrutura
Nós queremos converter o código acima em uma aplicação. Isso é importante porque
Teremos software funcionando; não queremos escrever testes apenas por escrever, e é bom ver código que funciona.
Conforme refatoramos o código, é provável que mudaremos a estrutura do programa. Nós queremos garantir que isso é refletido em nossa aplicação também, como parte da abordagem incremental.
Crie um novo arquivo main.go para nossa aplicação, com o código abaixo.
1
package main
2
​
3
import (
4
    "log"
5
    "net/http"
6
)
7
​
8
func main() {
9
    tratador := http.HandlerFunc(ServidorJogador)
10
    if err := http.ListenAndServe(":5000", tratador); err != nil {
11
        log.Fatalf("não foi possível escutar na porta 5000 %v", err)
12
    }
13
}
Copied!
Para executar, execute o comando go build -o programa, que vai pegar todos os arquivos terminados em .go neste diretório e construir seu programa. E então você pode executar o programa rodando ./programa.
http.HandlerFunc
Anteriormente, vimos que precisamos implementar a interface Handler para criar um servidor. Normalmente fazemos isso criando um estrutura (struct) e fazendo com que esta implemente a interface. No entanto, mesmo que o comum seja utilizar as estruturas para armazenar dados, nesse momento não armazenamos um estado, então não parece certo criar uma estrutura para isso.
Usar a função HandlerFunc nos ajuda a resolver este problema.
O tipo HandlerFunc é um adaptador que permite usar funções comuns como tratadores (handlers). Se f é uma função com a assinatura adequada, HandlerFunc(f) é um Handler que chama f.
1
type HandlerFunc func(ResponseWriter, *Request)
Copied!
Então usamos essa construção para adaptar a função ServidorJogador, fazendo com que esteja de acordo com a interface Handler.
http.ListenAndServe(":5000"...)
ListenAndServe recebe como parâmetro um número de porta para escutar em um tratador (Handler). Se a porta já estiver sendo usada, será retornado um erro (error) para que, usando um comando if, possamos capturar esse erro e informar o problema para o usuário.
O que vamos fazer agora é escrever outro teste para nos forçar a fazer uma mudança para tentar nos afastar do valor predefinido.
Escreva o teste primeiro
Vamos adicionar outro subteste aos nossos testes, que tenta obter a pontuação de um jogador diferente, o que causará um problema em nossa implementação que usa um código predefinido.
1
t.Run("retornar resultado de Pedro", func(t *testing.T) {
2
    requisicao, _ := http.NewRequest(http.MethodGet, "/jogadores/Pedro", nil)
3
    resposta := httptest.NewRecorder()
4
​
5
    ServidorJogador(resposta, requisicao)
6
​
7
    recebido := resposta.Body.String()
8
    esperado := "10"
9
​
10
    if recebido != esperado {
11
        t.Errorf("recebido '%s', esperado '%s'", recebido, esperado)
12
    }
13
})
Copied!
Você deve estar pensando:
Certamente precisamos de algum tipo de armazenamento para controlar qual jogador recebe qual pontuação. É estranho que os valores sejam predefinidos em nossos testes.
Lembre-se de que estamos apenas tentando dar os menores passos possíveis; e por isso estamos, nesse momento, tentando invalidar o valor da constante.
Tente rodar o próximo teste
1
=== RUN   TestObterJogadores
2
=== RUN   TestObterJogadores/retornar_resultado_de_Maria
3
=== RUN   TestObterJogadores/retornar_resultado_de_Pedro
4
    TestObterJogadores/retornar_resultado_de_Pedro: servidor_test.go:34: recebido '20', esperado '10'
5
--- FAIL: TestObterJogadores (0.00s)
6
    --- PASS: TestObterJogadores/retornar_resultado_de_Maria (0.00s)
7
    --- FAIL: TestObterJogadores/retornar_resultado_de_Pedro (0.00s)
Copied!
Escreva código suficiente para fazer passar
1
func ServidorJogador(w http.ResponseWriter, r *http.Request) {
2
    jogador := r.URL.Path[len("/jogadores/"):]
3
​
4
    if jogador == "Maria" {
5
        fmt.Fprint(w, "20")
6
        return
7
    }
8
​
9
    if jogador == "Pedro" {
10
        fmt.Fprint(w, "10")
11
        return
12
    }
13
}
Copied!
Este teste nos forçou a olhar para a URL da requisição e tomar uma decisão. Embora ainda estamos pensando em como armazenar os dados do jogador e as interfaces, na verdade o próximo passo a ser dado está relacionado ao roteamento (routing).
Se tivéssemos começado com o código de armazenamento dos dados, a quantidade de alterações que precisaríamos fazer seria muito grande. Este é um pequeno passo em relação ao nosso objetivo final e foi guiado pelos testes.
Estamos resistindo, nesse momento, à tentação de usar alguma biblioteca de roteamento, e queremos apenas dar o menor passo para fazer nossos testes funcionarem.
r.URL.Path retorna o caminho da requisição, e então usamos a sintaxe de slice para obter a parte final, depois de /jogadores/. Não é o recomendado por não ser muito robusto, mas resolve o problema por enquanto.
Refatorar
Podemos simplificar a ServidorJogador separando a parte de obtenção da pontuação em uma função.
1
func ServidorJogador(w http.ResponseWriter, r *http.Request) {
2
    jogador := r.URL.Path[len("/jogadores/"):]
3
​
4
    fmt.Fprint(w, ObterPontuacaoJogador(jogador))
5
}
6
​
7
func ObterPontuacaoJogador(nome string) string {
8
    if nome == "Maria" {
9
        return "20"
10
    }
11
​
12
    if nome == "Pedro" {
13
        return "10"
14
    }
15
​
16
    return ""
17
}
Copied!
E podemos eliminar as repetições de parte do código dos testes montando algumas funções auxiliares("helpers"):
1
func TestObterJogadores(t *testing.T) {
2
    t.Run("retornar resultado de Maria", func(t *testing.T) {
3
        requisicao := novaRequisicaoObterPontuacao("Maria")
4
        resposta := httptest.NewRecorder()
5
​
6
        ServidorJogador(resposta, requisicao)
7
​
8
        verificarCorpoRequisicao(t, resposta.Body.String(), "20")
9
    })
10
​
11
    t.Run("returns Pedro's score", func(t *testing.T) {
12
        requisicao := novaRequisicaoObterPontuacao("Pedro")
13
        resposta := httptest.NewRecorder()
14
​
15
        ServidorJogador(resposta, requisicao)
16
​
17
        verificarCorpoRequisicao(t, resposta.Body.String(), "10")
18
    })
19
}
20
​
21
func novaRequisicaoObterPontuacao(nome string) *http.Request {
22
    requisicao, _ := http.NewRequest(http.MethodGet, fmt.Sprintf("/jogadores/%s", nome), nil)
23
    return requisicao
24
}
25
​
26
func verificarCorpoRequisicao(t *testing.T, recebido, esperado string) {
27
    t.Helper()
28
    if recebido != esperado {
29
        t.Errorf("corpo da requisição é inválido, obtive '%s' esperava '%s'", recebido, esperado)
30
    }
31
}
Copied!
Ainda assim, não estamos felizes. Não parece correto que o servidor saiba as pontuações.
Mas nossa refatoração nos mostra claramente o que fazer.
Nós movemos o cálculo de pontuação para fora do código principal que trata a requisição (handler) para uma função ObterPontuacaoJogador. Isso parece ser o lugar correto para isolar as responsabilidades usando interfaces.
Vamos alterar, em servidor.go, a função que refatoramos para ser uma interface:
1
type ArmazenamentoJogador interface {
2
    ObterPontuacaoJogador(nome string) int
3
}
Copied!
Para que o ServidorJogador consiga usar o ArmazenamentoJogador, é necessário ter uma referência a ele. Agora nos parece o momento certo para alterar nossa arquitetura, e nosso ServidorJogador agora se torna uma estrutura (struct).
1
type ServidorJogador struct {
2
    armazenamento ArmazenamentoJogador
3
}
Copied!
E agora, vamos implementar a interface do tratador (Handler) adicionando um método à nossa nova estrutura ServidorJogador e adicionado neste método o código existente.
1
func (s *ServidorJogador) ServeHTTP(w http.ResponseWriter, r *http.Request) {
2
   jogador  := r.URL.Path[len("/jogadores/"):]
3
    fmt.Fprint(w, s.armazenamento.ObterPontuacaoJogador(jogador))
4
}
Copied!
Outra alteração a fazer: agora usamos a armazenamento.ObterPontuacaoJogador para obter a pontuação, ao invés da função local definida anteriormente (e que podemos remover).
Abaixo, a listagem completa do servidor (arquivo servidor.go):
1
type ArmazenamentoJogador interface {
2
    ObterPontuacaoJogador(nome string) int
3
}
4
​
5
type ServidorJogador struct {
6
    armazenamento ArmazenamentoJogador
7
}
8
​
9
func (s *ServidorJogador) ServeHTTP(w http.ResponseWriter, r *http.Request) {
10
    jogador := r.URL.Path[len("/jogadores/"):]
11
    fmt.Fprint(w, s.armazenamento.ObterPontuacaoJogador(jogador))
12
}
Copied!
Ajustar os problemas
Fizemos muitas mudanças, e sabemos que nossos testes não irão funcionar e a compilação deixou de funcionar nesse momento; mas relaxe, e deixe o compilador fazer o trabalho.
./main.go:9:58: type ServidorJogador is not an expression
Precisamos mudar os nossos testes, que agora devem criar uma nova instância de ServidorJogador e então chamar o método ServeHTTP.
1
func TestObterJogadores(t *testing.T) {
2
    servidor := &ServidorJogador{}
3
​
4
    t.Run("retorna a pontuação de Maria", func(t *testing.T) {
5
        requisicao := novaRequisicaoObterPontuacao("Maria")
6
        resposta := httptest.NewRecorder()
7
​
8
        servidor.ServeHTTP(resposta, requisicao)
9
​
10
        verificarCorpoRequisicao(t, resposta.Body.String(), "20")
11
    })
12
​
13
    t.Run("retorna a pontuação de Pedro", func(t *testing.T) {
14
        requisicao := novaRequisicaoObterPontuacao("Pedro")
15
        resposta := httptest.NewRecorder()
16
​
17
        servidor.ServeHTTP(resposta, requisicao)
18
​
19
        verificarCorpoRequisicao(t, resposta.Body.String(), "10")
20
    })
21
}
Copied!
Perceba que ainda não nos preocupamos, por enquanto, com o armazenamento dos dados, nós apenas queremos a compilação funcionando o quanto antes.
Você deve ter o hábito de priorizar, sempre, código que compila antes de ter código que passa nos testes.
Adicionando mais funcionalidades (como códigos de esboço de armazenamento) a um código que não ainda não compila, nos arriscamos a ter, potencialmente, mais problemas de compilação.
Agora main.go não vai compilar pelas mesmas razões.
1
func main() {
2
    servidor := &ServidorJogador{}
3
​
4
    if err := http.ListenAndServe(":5000", servidor); err != nil {
5
        log.Fatalf("não foi possível escutar na porta 5000 %v", err)
6
    }
7
}
Copied!
Agora tudo compila, mas os testes falham.
1
--- FAIL: TestObterJogadores (0.00s)
2
    --- FAIL: TestObterJogadores/retorna_pontucao_de_Maria (0.00s)
3
panic: runtime error: invalid memory address or nil pointer dereference [recovered]
4
        panic: runtime error: invalid memory address or nil pointer dereference
Copied!
Isso porque não passamos um ArmazenamentoJogador em nossos testes. Precisamos fazer, no arquivo servidor_test.go um código de esboço para nos ajudar.
1
type EsbocoArmazenamentoJogador struct {
2
    pontuacoes map[string]int
3
}
4
​
5
func (e *EsbocoArmazenamentoJogador) ObterPontuacaoJogador(nome string) int {
6
    pontuacao := e.pontuacoes[nome]
7
    return pontuacao
8
}
Copied!
Um mapa (map) é um jeito simples e rápido de fazer um armazenamento chave/valor para os nossos testes. Agora vamos criar um desses armazenamentos para os nossos testes e inserir ServidorJogador.
1
func TestObterJogadores(t *testing.T) {
2
    armazenamento := EsbocoArmazenamentoJogador{
3
        map[string]int{
4
            "Maria": 20,
5
            "Pedro": 10,
6
        },
7
    }
8
    servidor := &ServidorJogador{&armazenamento}
9
​
10
    t.Run("retorna pontuacao de Maria", func(t *testing.T) {
11
        requisicao := novaRequisicaoObterPontuacao("Maria")
12
        resposta := httptest.NewRecorder()
13
​
14
        servidor.ServeHTTP(resposta, requisicao)
15
​
16
        verificarCorpoRequisicao(t, resposta.Body.String(), "20")
17
    })
18
​
19
    t.Run("retorna pontuacao de Pedro", func(t *testing.T) {
20
        requisicao := novaRequisicaoObterPontuacao("Pedro")
21
        resposta := httptest.NewRecorder()
22
​
23
        servidor.ServeHTTP(resposta, requisicao)
24
​
25
        verificarCorpoRequisicao(t, resposta.Body.String(), "10")
26
    })
27
}
Copied!
Nossos testes agora passam, e parecem melhores. Agora a intenção do nosso código é clara, por conta da adição do armazenamento. Estamos dizendo a quem lê o código que, por termos este dado em um ArmazenamentoJogador, quando você o usar com um ServidorJogador você deve obter as respostas definidas.
Rodar a aplicação
Agora que nossos testes estão passando, a última coisa que precisamos fazer para completar a refatoração é verificar se a aplicação está funcionando. O programa deve iniciar, mas você vai receber uma mensagem horrível se tentar acessar o servidor em http://localhost:5000/jogadores/Maria.
E a razão pra isso é: não informamos um ArmazenamentoJogador.
Precisamos implementar um. No entanto, isso é difícil no momento, já que não estamos armazenando nenhum dado significativo e por isso vamos usar um valor predefinido, por enquanto. Vamos alterar na main.go:
1
type ArmazenamentoJogadorEmMemoria struct{}
2
​
3
func (a *ArmazenamentoJogadorEmMemoria) ObterPontuacaoJogador(nome string) int {
4
    return 123
5
}
6
​
7
func main() {
8
    server := &ServidorJogador{&ArmazenamentoJogadorEmMemoria{}}
9
​
10
    if err := http.ListenAndServe(":5000", server); err != nil {
11
        log.Fatalf("não foi possível escutar na porta 5000 %v", err)
12
    }
13
}
Copied!
Se você rodar novamente o go build e acessar a mesma URL você deve receber "123". Não é fantástico, mas até armazenarmos os dados, é o melhor que podemos fazer.
Temos algumas opções para decidir o que fazer agora:
Tratar o cenário onde o jogador não existe
Tratar o cenário da chamado ao método HTTP POST em /jogadores/{nome}
Não foi particularmente interessante perceber que nossa aplicação principal iniciou mas não funcionou. Tivemos que testar manualmente para ver o problema
Enquanto o cenário do tratamento ao método HTTP POST nos deixa mais perto do "caminho ideal", eu sinto que vai ser mais fácil atacar o cenário de "jogador não existente" antes, já que estamos neste assunto. Veremos os outros itens posteriormente.
Escreva o teste primeiro
Adicione o cenário de um jogador inexistente aos nossos testes:
1
t.Run("retorna 404 para jogador não encontrado", func(t *testing.T) {
2
    requisicao := novaRequisicaoObterPontuacao("Jorge")
3
    resposta := httptest.NewRecorder()
4
​
5
    server.ServeHTTP(resposta, requisicao)
6
​
7
    recebido := resposta.Code
8
    esperado := http.StatusNotFound
9
​
10
    if recebido != esperado {
11
        t.Errorf("recebido status %d esperado %d", recebido, esperado)
12
    }
13
})
Copied!
Tente rodar o teste
1
--- FAIL: TestObterJogadores (0.00s)
2
    --- FAIL: TestObterJogadores/retorna_404_para_jogador_não_encontrado (0.00s)
3
        servidor_test.go:56: recebido status 200 esperado 404
Copied!
Escreva código necessário para que o teste funcione
1
func (s *ServidorJogador) ServeHTTP(w http.ResponseWriter, r *http.Request) {
2
    jogador := r.URL.Path[len("/jogadores/"):]
3
​
4
    w.WriteHeader(http.StatusNotFound)
5
​
6
    fmt.Fprint(w, s.armazenamento.ObterPontuacaoJogador(jogador))
7
}
Copied!
Às vezes eu me incomodo quando os defensores do Desenvolvimento Orientado a Testes dizem "tenha certeza de você escreveu apenas a mínima quantidade de código para fazer o teste funcionar", porque isso me parece muito pedante.
Mas este cenário ilustra muito bem o que querem dizer. Eu fiz o mínimo (sabendo que não era a implementação correta), que foi retornar um StatusNotFound em todas as respostas, mas todos os nossos testes estão passando!
Implementando o mínimo para que os testes passem vai evidenciar as lacunas nos testes. Em nosso caso, nós não estamos validando que devemos receber um StatusOK quando jogadores existem em nosso armazenamento.
Atualize os outros dois testes para validar o retorno e corrija o código.
Eis os novos testes:
1
func TestObterJogadores(t *testing.T) {
2
    armazenamento := EsbocoArmazenamentoJogador{
3
        map[string]int{
4
            "Maria": 20,
5
            "Pedro": 10,
6
        },
7
    }
8
    servidor := &ServidorJogador{&armazenamento}
9
​
10
    t.Run("retorna pontuacao de Maria", func(t *testing.T) {
11
        requisicao := novaRequisicaoObterPontuacao("Maria")
12
        resposta := httptest.NewRecorder()
13
​
14
        servidor.ServeHTTP(resposta, requisicao)
15
​
16
        verificarRespostaCodigoStatus(t, resposta.Code, http.StatusOK)
17
        verificarCorpoRequisicao(t, resposta.Body.String(), "20")
18
    })
19
​
20
    t.Run("retorna pontuacao de Pedro", func(t *testing.T) {
21
        requisicao := novaRequisicaoObterPontuacao("Pedro")
22
        resposta := httptest.NewRecorder()
23
​
24
        servidor.ServeHTTP(resposta, requisicao)
25
​
26
        verificarRespostaCodigoStatus(t, resposta.Code, http.StatusOK)
27
        verificarCorpoRequisicao(t, resposta.Body.String(), "10")
28
    })
29
​
30
    t.Run("retorna 404 para jogador não encontrado", func(t *testing.T) {
31
        requisicao := novaRequisicaoObterPontuacao("Jorge")
32
        resposta := httptest.NewRecorder()
33
​
34
        servidor.ServeHTTP(resposta, requisicao)
35
​
36
        recebido := resposta.Code
37
        esperado := http.StatusNotFound
38
​
39
        if recebido != esperado {
40
            t.Errorf("recebido status %d esperado %d", recebido, esperado)
41
        }
42
    })
43
}
44
​
45
func novaRequisicaoObterPontuacao(nome string) *http.Request {
46
    req, _ := http.NewRequest(http.MethodGet, fmt.Sprintf("/jogadores/%s", nome), nil)
47
    return req
48
}
49
​
50
func verificarCorpoRequisicao(t *testing.T, recebido, esperado string) {
51
    t.Helper()
52
    if recebido != esperado {
53
        t.Errorf("corpo da requisição é inválido, recebido '%s' esperado '%s'", recebido, esperado)
54
    }
55
}
56
​
57
func verificarRespostaCodigoStatus(t *testing.T, recebido, esperado int) {
58
    t.Helper()
59
    if recebido != esperado {
60
        t.Errorf("não recebeu código de status HTTP esperado, recebido %d, esperado %d", recebido, esperado)
61
    }
62
}
Copied!
Estamos verificando o status (código de retorno HTTP) em todos os nossos testes, por isso existe a função auxiliar verificarRespostaCodigoStatus para ajudar com isso.
Agora os primeiros dois testes falham porque o código de status recebido é 404, ao invés do esperado 200. Então vamos corrigir o ServidorJogador para que retorne não encontrado (HTTP status 404) se a pontuação for 0.
1
func (s *ServidorJogador) ServeHTTP(w http.ResponseWriter, r *http.Request) {
2
    jogador := r.URL.Path[len("/jogadores/"):]
3
​
4
    pontuacao := s.armazenamento.ObterPontuacaoJogador(jogador)
5
​
6
    if pontuacao == 0 {
7
        w.WriteHeader(http.StatusNotFound)
8
    }
9
​
10
    fmt.Fprint(w, pontuacao)
11
}
Copied!
Armazenando pontuações
Agora que podemos obter pontuações de um armazenamento, também podemos armazenar novas pontuações.
Escreva os testes primeiro
1
func TestArmazenamentoVitorias(t *testing.T) {
2
    armazenamento := EsbocoArmazenamentoJogador{
3
        map[string]int{},
4
    }
5
    servidor := &ServidorJogador{&armazenamento}
6
​
7
    t.Run("retorna status 'aceito' para chamadas ao método POST", func(t *testing.T) {
8
        requisicao, _ := http.NewRequest(http.MethodPost, "/jogadores/Maria", nil)
9
        resposta := httptest.NewRecorder()
10
​
11
        servidor.ServeHTTP(resposta, requisicao)
12
​
13
        verificarRespostaCodigoStatus(t, resposta.Code, http.StatusAccepted)
14
    })
15
}
Copied!
Inicialmente vamos verificar se obtemos o código de status HTTP correto ao fazer a requisição em uma rota específica usando o método POST. Isso nos permite preparar o caminho da funcionalidade que aceita um tipo diferente de requisição, e tratar de forma diferente a requisição para GET /jogadores/{nome}. Uma vez que isso funcione como esperado, podemos começar a testar a interação do nosso tratador (handler) com o armazenamento.
Tente rodar o teste
1
--- FAIL: TestArmazenamentoVitorias (0.00s)
2
    --- FAIL: TestArmazenamentoVitorias/retorna_status_'aceito'_para_chamadas_ao_método_POST (0.00s)
3
        servidor_test.go:75: não recebeu código de status HTTP esperado, recebido 404, esperado 202
Copied!
Escreva código suficiente pra fazer passar
Lembre-se que estamos cometendo pecados deliberadamente, então um comando if para identificar o método da requisição vai resolver o problema.
1
func (s *ServidorJogador) ServeHTTP(w http.ResponseWriter, r *http.Request) {
2
​
3
    if r.Method == http.MethodPost {
4
        w.WriteHeader(http.StatusAccepted)
5
        return
6
    }
7
​
8
    jogador := r.URL.Path[len("/jogadores/"):]
9
​
10
    pontuacao := s.armazenamento.ObterPontuacaoJogador(jogador)
11
​
12
    if pontuacao == 0 {
13
        w.WriteHeader(http.StatusNotFound)
14
    }
15
​
16
    fmt.Fprint(w, pontuacao)
17
}
Copied!
Refatorar
O tratador parece um pouco bagunçado agora. Vamos separar o código para ficar simples de entender e isolar as diferentes funcionalidades em novas funções.
1
func (s *ServidorJogador) ServeHTTP(w http.ResponseWriter, r *http.Request) {
2
​
3
    switch r.Method {
4
    case http.MethodPost:
5
        s.registrarVitoria(w)
6
    case http.MethodGet:
7
        s.mostrarPontuacao(w, r)
8
    }
9
}
10
​
11
func (s *ServidorJogador) mostrarPontuacao(w http.ResponseWriter, r *http.Request) {
12
    jogador := r.URL.Path[len("/jogadores/"):]
13
​
14
    pontuacao := s.armazenamento.ObterPontuacaoJogador(jogador)
15
​
16
    if pontuacao == 0 {
17
        w.WriteHeader(http.StatusNotFound)
18
    }
19
​
20
    fmt.Fprint(w, pontuacao)
21
}
22
​
23
func (s *ServidorJogador) registrarVitoria(w http.ResponseWriter) {
24
    w.WriteHeader(http.StatusAccepted)
25
}
Copied!
Isso faz com que a responsabilidade de roteamento do ServeHTTP esteja mais clara; e também permite que, em nossas próximas iterações, o código para armazenamento possa estar dentro de registrarVitoria.
Agora, queremos verificar que, quando fazemos a chamada POST a /jogadores/{nome}, nosso ArmazenamentoJogador registra a vitória.
Escreva primeiro o teste
Vamos implementar isso estendendo o EsbocoArmazenamentoJogador com um novo método GravarVitoria e então inspecionar as chamadas.
1
type EsbocoArmazenamentoJogador struct {
2
    pontuacoes        map[string]int
3
    registrosVitorias []string
4
}
5
​
6
func (e *EsbocoArmazenamentoJogador) ObterPontuacaoJogador(nome string) int {
7
    pontuacao := e.pontuacoes[nome]
8
    return pontuacao
9
}
10
​
11
func (e *EsbocoArmazenamentoJogador) RegistrarVitoria(nome string) {
12
    e.registrosVitorias = append(e.registrosVitorias, nome)
13
}
Copied!
Agora, para começar, estendemos o teste para verificar a quantidade de chamadas:
1
func TestArmazenamentoVitorias(t *testing.T) {
2
    armazenamento := EsbocoArmazenamentoJogador{
3
        map[string]int{},
4
        nil,
5
    }
6
    servidor := &ServidorJogador{&armazenamento}
7
​
8
    t.Run("registra vitorias na chamada ao método HTTP POST", func(t *testing.T) {
9
        requisicao := novaRequisicaoRegistrarVitoriaPost("Maria")
10
        resposta := httptest.NewRecorder()
11
​
12
        servidor.ServeHTTP(resposta, requisicao)
13
​
14
        verificarRespostaCodigoStatus(t, resposta.Code, http.StatusAccepted)
15
​
16
        if len(armazenamento.registrosVitorias) != 1 {
17
            t.Errorf("verifiquei %d chamadas a RegistrarVitoria, esperava %d", len(armazenamento.registrosVitorias), 1)
18
        }
19
    })
20
}
21
​
22
func novaRequisicaoRegistrarVitoriaPost(nome string) *http.Request {
23
    requisicao, _ := http.NewRequest(http.MethodPost, fmt.Sprintf("/jogadores/%s", nome), nil)
24
    return requisicao
25
}
Copied!
Tente rodar o teste
1
./servidor_test.go:26:17: too few values in EsbocoArmazenamentoJogador literal
2
./servidor_test.go:70:17: too few values in EsbocoArmazenamentoJogador literal
Copied!
Escreva a mínima quantidade de código para a execução do teste e verifique a falha indicada no retorno
Como adicionamos um campo, precisamos atualizar o código onde criamos o EsbocoArmazenamentoJogador
1
armazenamento := EsbocoArmazenamentoJogador{
2
    map[string]int{},
3
    nil,
4
}
Copied!
1
--- FAIL: TestArmazenamentoVitorias (0.00s)
2
    --- FAIL: TestArmazenamentoVitorias/#00 (0.00s)
3
        servidor_test.go:85: verifiquei 0 chamadas a RegistrarVitoria, esperava 1
Copied!
Escreva código suficiente para o teste passar
Como estamos apenas verificando o número de chamadas, e não seus valores específicos, nossa iteração inicial é um pouco menor.
Para conseguir invocar a RegistrarVitoria, precisamos atualizar a definição de ArmazenamentoJogador para que o ServidorJogador funcione como esperado.
1
type ArmazenamentoJogador interface {
2
    ObterPontuacaoJogador(nome string) int
3
    RegistrarVitoria(nome string)
4
}
Copied!
E, ao fazer isso, main não compila mais
1
./main.go:15:29: cannot use &ArmazenamentoJogadorEmMemoria literal (type *ArmazenamentoJogadorEmMemoria) as type ArmazenamentoJogador in field value:
2
        *ArmazenamentoJogadorEmMemoria does not implement ArmazenamentoJogador (missing RegistrarVitoria method)
Copied!
O compilador nos informa o que está errado. Vamos alterar ArmazenamentoJogadorEmMemoria, adicionando esse método.
1
type ArmazenamentoJogadorEmMemoria struct{}
2
​
3
func (s *ArmazenamentoJogadorEmMemoria) RegistrarVitoria(nome string) {}
Copied!
Com essa alteração, o código volta a compilar - mas os testes ainda falham.
Agora que ArmazenamentoJogador tem o método GravarVitoria, podemos chamar de dentro do nosso ServidorJogador
1
func (s *ServidorJogador) registrarVitoria(w http.ResponseWriter) {
2
    s.armazenamento.GravarVitoria("Marcela")
3
    w.WriteHeader(http.StatusAccepted)
4
}
Copied!
Rode os testes e devem estar funcionando sem erros! Claro, "Marcela" não é bem o que queremos enviar para RegistrarVitoria, então vamos ajustar os testes.
Escreva os testes primeiro
1
t.Run("registra vitorias na chamada ao método HTTP POST", func(t *testing.T) {
2
    jogador := "Maria"
3
​
4
    requisicao := novaRequisicaoRegistrarVitoriaPost(jogador)
5
    resposta := httptest.NewRecorder()
6
​
7
    servidor.ServeHTTP(resposta, requisicao)
8
​
9
    verificarRespostaCodigoStatus(t, resposta.Code, http.StatusAccepted)
10
​
11
    if len(armazenamento.registrosVitorias) != 1 {
12
        t.Errorf("verifiquei %d chamadas a RegistrarVitoria, esperava %d", len(armazenamento.registrosVitorias), 1)
13
    }
14
​
15
    if armazenamento.registrosVitorias[0] != jogador {
16
        t.Errorf("não registrou o vencedor corretamente, recebi '%s', esperava '%s'", armazenamento.registrosVitorias[0], jogador)
17
    }
18
})
Copied!
Agora sabemos que existe um elemento no slice registrosVitorias, e então podemos acessar, sem erros, o primeiro elemento e verificar se é igual a jogador.
Tente rodar o teste
1
--- FAIL: TestArmazenamentoVitorias (0.00s)
2
    --- FAIL: TestArmazenamentoVitorias/registra_vitorias_na_chamada_ao_método_HTTP_POST (0.00s)
3
        servidor_test.go:91: não registrou o vencedor corretamente, recebi 'Marcela', esperava 'Maria'
Copied!
Escreva código suficiente para o teste passar
1
func (s *ServidorJogador) registrarVitoria(w http.ResponseWriter, r *http.Request) {
2
    jogador := r.URL.Path[len("/jogadores/"):]
3
    s.armazenamento.RegistrarVitoria(jogador)
4
    w.WriteHeader(http.StatusAccepted)
5
}
Copied!
Mudamos registrarVitoria para obter a http.Request, e assim conseguir extrair o nome do jogador da URL. Com o nome, podemos chamar o armazenamento com o valor correto para fazer os testes passarem.
Refatorar
Podemos eliminar repetições no código, porque estamos obtendo o nome do jogador do mesmo jeito em dois lugares diferentes.
1
func (s *ServidorJogador) ServeHTTP(w http.ResponseWriter, r *http.Request) {
2
    jogador := r.URL.Path[len("/jogadores/"):]
3
​
4
    switch r.Method {
5
    case http.MethodPost:
6
        s.registrarVitoria(w, jogador)
7
    case http.MethodGet:
8
        s.mostrarPontuacao(w, jogador)
9
    }
10
}
11
​
12
func (s *ServidorJogador) mostrarPontuacao(w http.ResponseWriter, jogador string) {
13
    pontuacao := s.armazenamento.ObterPontuacaoJogador(jogador)
14
​
15
    if pontuacao == 0 {
16
        w.WriteHeader(http.StatusNotFound)
17
    }
18
​
19
    fmt.Fprint(w, pontuacao)
20
}
21
​
22
func (s *ServidorJogador) registrarVitoria(w http.ResponseWriter, jogador string) {
23
    s.armazenamento.RegistrarVitoria(jogador)
24
    w.WriteHeader(http.StatusAccepted)
25
}
Copied!
Mesmo com os testes passando, não temos código funcionando de forma ideal. Se executar a main e usar o programa como planejado, não vai funcionar porque ainda não nos dedicamos a implementar corretamente ArmazenamentoJogador. Mas isso não é um problema; como focamos no tratamento da requisição, identificamos a interface necessária, ao invés de tentar definir antecipadamente.
Poderíamos começar a escrever alguns testes para a ArmazenamentoJogadorEmMemoria, mas ela é apenas uma solução temporária até a implementação de um modo mais robusto de registrar as pontuações (por exemplo, em um banco de dados).
O que vamos fazer agora é escrever um teste de integração entre ServidorJogador e ArmazenamentoJogadorEmMemoria para terminar a funcionalidade. Isso vai permitir confiar que a aplicação está funcionando, sem ter que testar diretamente ArmazenamentoJogadorEmMemoria. E não apenas isso, mas quando implementarmos ArmazenamentoJogador com um banco de dados, usaremos esse mesmo teste para verificar se a implementação funciona como esperado.
Testes de integração
Testes de integração podem ser úteis para testar partes maiores do sistema, mas saiba que:
São mais difíceis de escrever
Quando falham, é difícil saber o porquê (normalmente é um problema dentro de um componente do teste de integração) e pode ser difícil de corrigir
Às vezes são mais lentos para rodar (porque são usados com componentes "reais", como um banco de dados)
Por isso, é recomendado que pesquise sobre Pirâmide de Testes.
Escreva os testes primeiro
Para ser mais breve, vou te mostrar o teste de integração, já refatorado.
1
func TestRegistrarVitoriasEBuscarEstasVitorias(t *testing.T) {
2
    armazenamento := NovoArmazenamentoJogadorEmMemoria()
3
    servidor := ServidorJogador{armazenamento}
4
    jogador := "Maria"
5
​
6
    servidor.ServeHTTP(httptest.NewRecorder(), novaRequisicaoRegistrarVitoriaPost(jogador))
7
    servidor.ServeHTTP(httptest.NewRecorder(), novaRequisicaoRegistrarVitoriaPost(jogador))
8
    servidor.ServeHTTP(httptest.NewRecorder(), novaRequisicaoRegistrarVitoriaPost(jogador))
9
​
10
    resposta := httptest.NewRecorder()
11
    servidor.ServeHTTP(resposta, novaRequisicaoObterPontuacao(jogador))
12
    verificarRespostaCodigoStatus(t, resposta.Code, http.StatusOK)
13
​
14
    verificarCorpoRequisicao(t, resposta.Body.String(), "3")
15
}
Copied!
Estamos criando os dois componentes que queremos integrar: ArmazenamentoJogadorEmMemoria e ServidorJogador.
Então fazemos 3 requisições para registrar 3 vitórias para jogador. Não nos preocupamos com os códigos de retorno no teste, porque isso não é relevante para verificar se a integração funciona como esperado.
Registramos a próxima resposta (por isso guardamos o valor em resposta) porque vamos obter a pontuação do jogador.
Tente rodar o teste
1
--- FAIL: TestRegistrarVitoriasEBuscarEstasVitorias (0.00s)
2
    servidor_test.go:109: corpo da requisição é inválido, recebido '123' esperado '3'
Copied!
Escreva código suficiente para passar
Abaixo, há mais código do que o esperado para se escrever sem ter os testes correspondentes.
Isso é permitido! Ainda existem testes verificando se as coisas estão funcionando como esperado, mas não focando na parte específica em que estamos trabalhando (ArmazenamentoJogadorEmMemoria).
Se houvesse algum problema para continuarmos, era só reverter as alterações para antes do teste que falhou e então escrever mais testes unitários específicos para ArmazenamentoJogadorEmMemoria, que nos ajudariam a encontrar a solução.
1
func NovoArmazenamentoJogadorEmMemoria() *ArmazenamentoJogadorEmMemoria {
2
    return &ArmazenamentoJogadorEmMemoria{map[string]int{}}
3
}

Vermelho, verde, refatore

E se você não fizer assim?

A galinha e o ovo

Escrevendo o teste primeiro

Tente rodar o teste

Escreva a quantidade mínima de código para o que teste passe e verifique a falha indicada na responta do teste

Escreva código suficiente para fazer o teste funcionar

Complete a estrutura

`http.HandlerFunc`

`http.ListenAndServe(":5000"...)`

Escreva o teste primeiro

Tente rodar o próximo teste

Escreva código suficiente para fazer passar

Refatorar

Ajustar os problemas

Rodar a aplicação

Escreva o teste primeiro

Tente rodar o teste

Escreva código necessário para que o teste funcione

Armazenando pontuações

Escreva os testes primeiro

Tente rodar o teste

Escreva código suficiente pra fazer passar

Refatorar

Escreva primeiro o teste

Tente rodar o teste

Escreva a mínima quantidade de código para a execução do teste e verifique a falha indicada no retorno

Escreva código suficiente para o teste passar

Escreva os testes primeiro

Tente rodar o teste

Escreva código suficiente para o teste passar

Refatorar

Testes de integração

Escreva os testes primeiro

Tente rodar o teste

Escreva código suficiente para passar