Servidor HTTP
Last updated
Was this helpful?
Last updated
Was this helpful?
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.
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.
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.
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.
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.
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"
.
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.
./servidor_test.go:13:2: undefined: ServidorJogador
O compilador está aqui para ajudar, ouça o que ele diz.
Crie o arquivo servidor.go
, e nele a função ServidorJogador
Tente novamente
Adicione os argumentos à função:
Agora o código compila, e o teste falha.
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.
O teste agora deve funcionar.
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.
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.
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.
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.
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.
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.
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.
Podemos simplificar a ServidorJogador
separando a parte de obtenção da pontuação em uma função.
E podemos eliminar as repetições de parte do código dos testes montando algumas funções auxiliares("helpers"):
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:
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
).
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.
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
):
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
.
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.
Agora tudo compila, mas os testes falham.
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.
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
.
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.
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
:
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.
Adicione o cenário de um jogador inexistente aos nossos testes:
À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:
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.
Agora que podemos obter pontuações de um armazenamento, também podemos armazenar novas pontuações.
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.
Lembre-se que estamos cometendo pecados deliberadamente, então um comando if
para identificar o método da requisição vai resolver o problema.
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.
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.
Vamos implementar isso estendendo o EsbocoArmazenamentoJogador
com um novo método GravarVitoria
e então inspecionar as chamadas.
Agora, para começar, estendemos o teste para verificar a quantidade de chamadas:
Como adicionamos um campo, precisamos atualizar o código onde criamos o EsbocoArmazenamentoJogador
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.
E, ao fazer isso, main
não compila mais
O compilador nos informa o que está errado. Vamos alterar ArmazenamentoJogadorEmMemoria
, adicionando esse método.
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
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.
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
.
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.
Podemos eliminar repetições no código, porque estamos obtendo o nome do jogador do mesmo jeito em dois lugares diferentes.
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 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.
Para ser mais breve, vou te mostrar o teste de integração, já refatorado.
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
.
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.
Para armazenar os dados, adicionamos um map[string]int
na struct ArmazenamentoJogadorEmMemoria
Para ajudar nos testes, criamos a NewArmazenamentoJogadorEmMemoria
para inicializar o armazenamento, e o código do teste de integração foi atualizado para usar esta função (armazenamento := NewNovoArmazenamentoJogadorEmMemoria()
).
O resto do código é apenas para fazer o map
funcionar.
Nosso teste de integração passa, e agora só é preciso mudar o main
para usar o NewNovoArmazenamentoJogadorEmMemoria()
Após compilar e rodar, use o curl
para testar.
Execute o comando a seguir algumas vezes, mude o nome do jogador se quiser curl -X POST http://localhost:5000/jogadores/Maria
Verifique a pontuação, rodando curl http://localhost:5000/jogadores/Maria
Ótimo! Criamos um serviço de acordo com os padrões REST! Se quiser continuar, você pode escolher um armazenamento de dados com maior persistência, que não vai perder os dados quando o programa terminar.
Escolher uma tecnologia de armazenamento (Bolt? Mongo? Postgres? Sistema de arquivos?)
Fazer PostgresArmazenamentoJogador
implementar ArmazenamentoJogador
Desenvolver a funcionalidade usando Desenvolvimento Orientado a Testes para ter certeza de que funciona
Conectar nos testes de integração, verificar se tudo funciona
E, finalmente, integrar dentro de main
.
http.Handler
Implemente essa interface para criar servidores web
Use http.HandlerFunc
para transformar funções simples em http.Handler
s
Use httptest.NewRecorder
para informar um ResponseWriter
que permite inspecionar as respostas que a função tratadora envia
Use http.NewRequest
para construir as requisições que você espera que seu sistema receba
Permitem que você construa a sua aplicação de forma iterativa, um pedaço de cada vez
Te permite desenvolver uma funcionalidade de tratamento de requisições que precisa de um armazenamento sem precisar exatamente de uma estrutura de armazenamento
O Desenvolvimento Orientado a Testes nos ajudou a definir as interfaces necessárias
Você precisa tratar falhas na compilação ou nos testes como uma situação urgente, a qual precisa resolver o mais rápido possível
Escreva apenas o código necessário para resolver o problema. Logo depois refatore e faça um código melhor
Ao tentar fazer muitas alterações enquanto o código não está compilando ou os testes estão falhando, corremos o risco de acumular e agravar os problemas
Nos manter fiéis à essa abordagem nos obriga a escrever pequenos testes, o que significa pequenas alterações, o que nos ajuda a continuar trabalhando em sistemas complexos de forma gerenciável
Para criar um servidor web (uma aplicação que recebe chamadas via protocolo HTTP) em Go, você vai chamar, usualmente, a função .
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 , usada para receber a requisição e avaliar o que fazer com os dados recebidos.
Usar a função nos ajuda a resolver este problema.