Golang afirmam

Existem três componentes principais no ciclo de vida de um desenvolvedor: código de gravação, código de teste, conserte o código, repita. Embora seja uma simplificação excessiva extrema, ilustra um conceito que todos os desenvolvedores encontram.

Neste artigo, focaremos em uma única entidade do ciclo de vida de um desenvolvedor: testes. O código de teste é um recurso muito útil para qualquer desenvolvedor. Ele permite encontrar e consertar bugs antes de implantar o código para a produção. Embora existam várias maneiras e recursos para implementar o teste de código, este artigo se concentrará no pacote de Go Assert.

Introdução aos testes

Antes de mergulhar em como trabalhar com o pacote de testemunho, vamos aprender a começar com os testes Go Go.

O primeiro passo é saber o que você deseja testar. Esta pode ser uma função simples para uma coleção de métodos.

Vamos fazer um programa de exemplo simples que apenas multiplique sua entrada por 10.

Comece criando um diretório para armazenar seu código.

Teste de Mkidr

Navegue até o diretório e crie um arquivo GO contendo seu programa. Por simplicidade, chamaremos esse arquivo principal.ir

Teste de CD
Toque em Main.ir

Edite o arquivo com seu editor de texto e crie seu programa. Para acompanhar este tutorial, você pode adicionar o código como mostrado abaixo:

Pacote principal
importação (
"FMT"
)
funcmultiply (x int) (resultado int)
resultado = x * 10
resultado de retorno

funcmain ()
fmt.Println ("Começar com testes")

No programa de exemplo, temos uma função que pega uma entrada inteira e retorna o número inteiro multiplicado por 10.

Salve e feche o arquivo.

O próximo passo é criar teste para o programa acima. Para fazer isso, precisamos criar um arquivo no mesmo diretório com o sufixo _test. Isso informa ao módulo de teste Go que este arquivo contém um conjunto de testes para o programa no diretório.

Já que queremos criar um teste para o principal.GO Programa, chamaremos o arquivo de teste como:

toque em main_test.ir

No arquivo de teste, podemos criar instruções de teste para o nosso programa.

Como queremos usar o pacote de uso, precisamos importar os testes e o pacote de assert.

Você pode incluir as importações como:

pacote
importação (
"Teste"
"Github.com/stretchr/testify/assert "
)

Em seguida, crie uma função de teste para testar o programa principal. Podemos criar instruções de teste como mostrado:

Pacote principal
importação (
"Teste"
"Github.com/stretchr/testify/assert "
)
functestmultiply (T *testes.T)
afirmar.Igual (t, multiplique (10), 100)

No programa acima, criamos uma função de teste que leva um teste.T objeto. A estrutura de teste permite que a função grava falha no local apropriado, desde que este objeto.

Dentro da função, usamos o pacote assert para verificar se a função retorna um resultado igual aos parâmetros fornecidos. Se a função multiplique levar o número inteiro 10 e retornar um valor igual a 100, ele passa no teste.

Salve o arquivo de teste e execute o teste usando o comando:

vá testar

O comando acima deve pegar o arquivo de teste e executar os testes configurados.

Um exemplo de saída é como mostrado:

=== Execute testmultiply
--- Pass: testmultiply (0.00s)
PASSAR
ok linuxhint/go-assert
> Execução de teste terminada em 31/01/2022, 13:38:17 <

Como você notará na saída acima, a função passa no teste.

Vamos alterar o valor da função para ilustrar uma instrução de falha. Por exemplo, altere o terceiro parâmetro da função de teste para um valor incorreto. Por exemplo:

functestmultiply (T *testes.T)
afirmar.Igual (t, multiplique (10), 10)

Neste exemplo, estamos dizendo ao programa que, se a função não retornar 10, a função falhar.

NOTA: Lembre -se de que a função de teste está incorreta.

Se executarmos o teste, devemos ter uma falha como:

=== Execute testmultiply
assert \ main_test.GO: 10:
Rastreio de erro:
Erro: não é igual:
esperado: 100
Real: 10
Teste: Testmultiply
--- Falha: testmultiply (0.00s)
FALHAR
Fail Linuxhint/Go-Anssert 0.040S
> Execução de teste terminada em 31/01/2022, 13:40:59 <

A saída acima ilustra um teste falhado.

Golang afirmam

Agora que temos o básico de testar fora do caminho, vamos mudar nosso foco para o pacote assert. Em nosso exemplo anterior, usamos o método igual para verificar se a função retorna o valor esperado. No entanto, o pacote assert fornece uma infinidade de ferramentas e métodos de teste para facilitar o teste de código.

Vamos explorar mais alguns exemplos para ilustrar a funcionalidade do pacote assert.

Desigualdade do teste de Golang

Podemos usar o pacote assert para verificar a desigualdade usando o método notequal (). A sintaxe da função é como mostrado:

Func notequal (T Testingt, esperado, interface real , msgandargs… interface ) bool

A função leva um T.Objeto de teste, o valor esperado e o valor real e uma mensagem de impressão. Ele verifica se o valor esperado e real não são iguais. Se for verdade, o teste passa, caso contrário, falha.

Um exemplo é como mostrado:

functestnotequal (T *testes.T)
afirmar.Notiqual (T, 100, 10, "valores não devem ser iguais")

O código acima verifica se os valores não são iguais. Um exemplo de saída é como mostrado:

=== Execute testnotequal
--- Pass: Testnotequal (0.00s)
PASSAR
ok linuxhint/go-assert 0.037S

Código de status HTTP do teste de Golang

Podemos usar o método httpstatuscode () para verificar se um manipulador retorna o código de status especificado.

Vamos supor que temos um servidor HTTP, que se fizermos uma solicitação para retornar o código de status de 200. Não vamos mergulhar profundamente em como criar um servidor HTTP em Go. Confira nosso tutorial sobre o assunto para saber mais.

Um exemplo de servidor http é como mostrado:

Pacote principal
importação (
"io"
"net/http"
)
VAR MUX MAP [String] func (http.ResponseWriter, *http.Solicitar)
funcmain ()
servidor: = http.Servidor
Addr: ": 8080",
Manipulador: & MyHandler ,

mux = make (map [string] func (http.ResponseWriter, *http.Solicitar))
Mux ["/"] = Sayhello
servidor.ListenandServe ()

TypeMyHandlerStruct
func (*MyHandler) servhttp (w http.ResponseWriter, r *http.Solicitar)
Se h, ok: = mux [r.Url.Corda()]; OK
H (W, R)
retornar

io.Writestring (W, "Servidor em execução:"+R.Url.Corda())

funcsayhello (w http.ResponseWriter, r *http.Solicitar)
io.Escrito (W, "oi!")

Podemos criar um teste para verificar se a função HTTP Handler retorna o código de status especificado. No nosso caso, a função HTTP Handler é o método Sayhello. A função de teste é como mostrado:

func testStatuscode (T *testes.T)
afirmar.Httpstatuscode (t, sayhello, "get", "/", nil, 200)

No exemplo acima, criamos uma função de teste para verificar o envio de uma solicitação para o servidor com a função HTTP Handler Sayhello, retorna o código de status de 200.

O código retorna:

=== Execute testStatuscode
--- Pass: TestStatuscode (0.00s)
PASSAR
ok linuxhint/go-assert 0.034S
> Execução de teste terminada em 31/01/2022, 14:44:39 <

Golang Test Panic

Outro teste que podemos executar é verificar se uma função específica entra em pânico. Podemos usar a afirmação.Método Panicks () como mostrado:

functestpanic (T *testes.T)
afirmar.Pânico (t, func ()
pânico ("eu definitivamente pânico!")
, "Deve entrar em pânico")

No exemplo acima, verificamos se a função se ela entrar em pânico.

Golang verifique se o diretório existe

Se você deseja testar se existe um diretório específico dentro de um caminho especificado, você pode usar o método Direxists ().

Por exemplo:

functestdir (T *testes.T)
afirmar.Direxistas (T, "... /Assert")

Conclusão

Este foi um guia abrangente sobre como começar com os testes na linguagem de programação Go. Os testes são fortemente usados ​​em projetos de vários desenvolvedores. Portanto, aprender a realizar testes é excepcional.

Há muito mais fornecido pelo pacote assert do que o mostrado neste tutorial. A documentação se expande sobre isso.

https: // pkg.ir.Dev/Github.com/stretchr/testify/assert