Go: validações, testes e páginas HTML

Instalando e criando a primeira rota com Gin - Apresentação

Olá, meu nome é Guilherme Lima. Boas-vindas a esse treinamento de Gin. Neste curso vamos aprender a fazer coisas muito legais e úteis para o nosso dia a dia como desenvolvedores. O que vamos fazer?

Vamos aprender a criar uma forma de validar os nossos campos, os nossos alunos. Você tem uma struct, você precisará validar determinados campos, precisa ter X caracteres, não podem ser caracteres letras, só números, ou pode ser só números, não podem ser letras... Vamos aprender a fazer tudo isso neste curso e vai ser muito legal.

Além disso, vamos focar grande parte deste treinamento escrevendo testes para configurar as nossas rotas, garantindo o comportamento que esperamos. Teremos rotas de teste, vamos criar alunos mocks, vamos testar os principais endpoints dessa aplicação, que vamos utilizar como base. Para finalizar com chave de ouro, o que vamos aprender?

Renderizar páginas com o Gin. O Gin também é capaz de renderizar arquivos HTML utilizando estilização de CSS. Nós não vamos criar HTML e CSS na mão, vamos ver como estilizar isso e como fazer coisas incríveis, como alterar a nossa página 404 para que ela seja toda configurada e exiba a mensagem que esperamos.

Este treinamento está incrível, realmente está muito legal. Espero que você goste do curso, que você aprenda bastante e te convido para começar esse desafio já. Vamos lá?

Instalando e criando a primeira rota com Gin - Carregando o projeto inicial

Vamos iniciar os nossos estudos com o Gin? Neste curso nós não vamos criar um projeto do zero, nós vamos utilizar um projeto base e vamos desenvolver essa aplicação. Eu estou com esse projeto, já fiz o download dele aqui, já abri no Visual Studio Code. Toda a descrição do passo a passo de como você faz para baixar o projeto, subir o projeto no Docker, está na atividade “Preparando o Ambiente”.

Então o que temos neste curso? Temos um banco de dados rodando no Docker e uma API Rest feita com Gin. Vou mostrar aqui alguns endpoints e vou subir essa aplicação para vermos. É um CRUD de alunos e temos algumas funcionalidades como: buscar um ID por aluno, buscar um aluno por CPF, isso ficou bem legal.

O que eu quero fazer agora é desenvolver essa aplicação e realizar alguns testes junto com vocês, algumas validações. Para subirmos essa aplicação, eu vou rodar o comando do Docker, docker-compose build. Quando der um "Enter", se você estiver rodando a primeira vez, ele vai começar a criar toda a imagem do Docker.

Lembrando que o meu Docker já está rodando aqui, então deixe o Docker rodar e faça esse comando docker-compose build. Depois que o build da imagem for finalizado, é só você rodar o comando docker-compose up e ele vai carregar a base de dados que temos para esse treinamento.

Ele está carregando aqui a base de dados. Feito isso, nós precisamos deixar o Docker habilitado durante todo o nosso treinamento, mesmo utilizando o banco de dados no Docker, esse banco de dados é o banco de dados de desenvolvimento, não é o banco de dados de produção. Ele está carregando aqui, já subiu. Eu vou clicar no símbolo de mais (+) do menu do terminal para abrir mais um terminal.

Eu vou carregar agora, vou subir o meu servidor do Go, go run main.go, quando pressionar "Enter" ele carrega aqui o servidor. Eu posso já dar uma requisição - lembrando que eu estou na porta 8080.

Então no Postman, por exemplo, se eu passo um nome, vou passar aqui http://localhost:8080/gui, quando eu der um "Send", ele tem uma mensagem da API, que estávamos aprendendo como colocar, a pegar essa informação da requisição e colocar em uma mensagem.

Então a API dá uma mensagem: "E aí, Gui, Tudo beleza?". Se eu coloco http://localhost:8080/alunos e dou um "Get", ele vai trazer a lista de todos os alunos para mim.

O resto já temos normal, o get, o post para eu criar um novo aluno, delete para eu deletar, patch para eu editar, e assim por diante. Mas uma coisa interessante que eu quero mostrar para vocês é isso aqui, olha só, se eu faço um "Post" para um aluno - o post, eu quero criar um novo aluno na minha base de dados.

Só que o nome eu vou deixar em branco, o CPF eu vou deixar em branco, o RG eu vou deixar em branco e o CPF eu vou deixar em branco. Eu dou um "Send", olha que interessante, ele criou um novo aluno com todos esses campos em branco.

Não é o comportamento que eu quero. Eu quero que o nome nunca fique em branco, eu quero que o RG tenha no mínimo a quantidade de caracteres que tem um RG - no Brasil são 9 - e um CPF que tenha 11 dígitos. É isso o que vamos atacar no próximo vídeo.

Instalando e criando a primeira rota com Gin - Criando as validações

Vamos descobrir, neste vídeo, como fazemos para conseguir validar alguns campos na nossa aplicação, porque nome, RG e CPF em branco não fazem sentido. Vou pesquisar no Google um pacote específico para realizar validações: "validator V2 golang".

Nesse primeiro link, "Package validator", eu vou clicar nele. Aqui embaixo eu tenho para instalarmos, para trazermos esse pacote, colocarmos ele no nosso projeto, é só rodar esse comando go get gopkg.in/validator.v2.

Eu já vou fazer isso agora. Parei o meu servidor do Go, vou rodar aqui, "Ctrl + V", go get gopkg.in/validator.v2. Ele já foi adicionado na nossa aplicação. O que vamos fazer? Precisamos importar esse pacote onde vamos utilizar. Onde queremos utilizar esse pacote? Queremos utilizar ele no nosso modelo. Por quê?

É no nosso modelo que descrevemos: teremos o nome, RG e o CPF e eu quero que esses campos sejam validados. O que eu vou fazer? Eu vou copiar essa linha do import da validação "gopkg.in/validator.v2" e vou colocar ele aqui no import de "alunos.go".

Ele vai reclamar porque não estamos usando, mas já vamos utilizá-lo. Então fiz o import do modelo e instalei já o pacote. Agora vamos ver como fazemos para conseguirmos de fato validar.

Ele tem uma estrutura, nós conseguimos validar de algumas formas. Nós podemos falar: o name não pode ser em branco, esse nonzero. Quando vamos na descrição dele, para falar o que o acontece com esse nonzero, ele fala alguns pontos interessantes, olha só.

Para inteiro, o 0 será considerado nonzero, então ele vai mostrar um erro. Se a string estiver em branco também vai ativar um erro e, se o ponteiro for nil, ele vai falar que esse campo aqui não pode ser em branco. Se for um ponteiro não pode ser nil, se for string não pode ser vazia e se for um inteiro não pode ser 0.

Então essa é a ideia. Vou até passar o mouse só para lermos o que ele fala. Para int é 0, para string é isso - isso ele considera um valor vazio, um nonzero. Então o que eu vou fazer? Eu vou copiar essa linha `"validate:"nonzero"` .

Vamos no nosso código. No nome aqui, tem o nome, vou dar um espaço, porque esse acento agudo está fechando o nome do JSON, e vou dar um "Ctrl + V": `json:"nome" "validate:"nonzero"`. Vamos ver outras coisas que podemos fazer para validar também os nossos campos.

O RG e o CPF, o que eu tinha falado no vídeo anterior? Eu não vou fazer a validação a fundo para saber se o RG é um valor válido. Não, eu quero saber se todos os campos que são inseridos, eles possuem a quantidade mínima de valores. Eu não posso registrar um RG com 123, por exemplo, igual eu fazia nos meus testes, nos primeiros testes que estávamos realizando.

Então o que eu vou fazer? Eu vou ver aqui, na documentação, como podemos validar. Nós podemos utilizar expressão regular, o regexp.

Tem uma outra forma também, que é esse primeiro, o builtin validators. Ou seja, esse pacote já vem com algumas validações para ele, que é o len. Ele fala: para tipos numéricos, vamos verificar se é igual ao valor que foi passado como parâmetro.

Aqui eu falo, por exemplo, len é igual a um determinado valor e ele vai falar para mim: esse campo não está válido, porque ele precisa deste valor aqui. Então o que eu vou fazer? Eu vou colocar um len para RG igual a 9 e um len para o CPF igual a 11. Vamos para o nosso código para fazermos isso também.

Vamos utilizar a mesma propriedade, o validate, validate:, eu vou passar agora, entre aspas duplas, validate:"len=9" para o RG. E vou fazer a mesma coisa para o CPF, só que, no lugar de 9, eu vou passar 11, validate:"len=11".

Só isso já vai validar? Não, nós colocamos nos nossos campos, mas precisamos de uma função que vai, de fato, verificar se esse conteúdo que nós passamos é válido ou não. Então, o que eu vou fazer? Eu vou criar uma função, um método que eu vou chamar de func ValidaDadosDeAluno(), no singular. Vou passar aqui o nosso aluno, (aluno *Aluno), apontando para o nosso aluno.

O A maiúsculo aqui, porque estamos apontando para essa nossa estrutura. E vou retornar uma mensagem de erro, vou retornar um erro. Vamos supor: se o nosso aluno tiver algum campo que está incorreto - o nome é inválido, o RG e CPF não contém a quantidade exata de caracteres - o que eu quero fazer? Eu quero retornar essa mensagem de erro, error.

Eu vou falar assim: error { if err :=, se o erro do validator - aqui um ponto muito importante, pessoal. Reparem que aparece aqui, validator está o meu "gopkg.in/validator.v2".

Não é o validator do playground, é o validator do V2. Deixa eu até tirar aqui para ver se ele mostra o validator do playground. Não, não mostra. Sempre é esse aqui, o "gopkg.in/validator.v2". Vou clicar nesse validator, que é ele que nós importamos, ponto, eu quero que ele valide, validate, o meu aluno, o aluno, a instância que estamos utilizando naquele momento.

Eu vou verificar, se o erro for diferente de nil, if err := validator.Validate(aluno); err != nill {}, eu quero retornar um erro, return err, temos de fato um erro em algum desses campos, retorne um erro que nós temos. Agora, se não tivermos nenhum erro, não vamos retornar nada, vamos retornar um return nil.

Vou salvar esse código, vamos ver se está tudo certo aqui. Return, faltou o "R" aqui. Agora sim, return, agora está tudo certo. Nós já temos esses campos aqui, aqui depois de (aluno) é um ponto e vírgula, if err := validator.Validate(aluno); err != nill. Agora sim.

Agora, aqui, nós temos o nosso modelo com essa validação. O que vamos fazer na sequência? Vamos aplicar essas validações, tanto quando vamos criar um aluno como quando vamos editar um aluno.

Sobre o curso Go: validações, testes e páginas HTML

O curso Go: validações, testes e páginas HTML possui 109 minutos de vídeos, em um total de 43 atividades. Gostou? Conheça nossos outros cursos de GoLang em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Instalando e criando a primeira rota com Gin
• Testes
• Testando os endpoints
• Aprofundando em testes
• Deletando, editando e buscando alunos