O teste de software é um processo que avalia as métricas de programas usando ferramentas, scripts ou manualmente.
O teste é parte integrante do ciclo de desenvolvimento de software. Testes abrangentes fornecem informações detalhadas sobre a integridade de seu aplicativo.
Você pode prevenir e corrigir bugs escrevendo testes, avaliando o desempenho do programa e automatizando fluxos de trabalho.
Introdução ao teste em Go
A biblioteca padrão Go fornece uma testando pacote. o testando O pacote tem benchmarking, fuzzing, skipping, sub-testing, sub-benchmarking e outras funcionalidades.
Testar com este pacote é fácil. Aqui está uma estrutura de teste simples que servirá como modelo para o teste:
modelo Casos estrutura {
// a saída esperada do teste
esperado int//saída da função
real int
// o valor que você está passando para a função
argumento corda
}
Aqui está uma função simples que converte strings em inteiros. Seu teste testará esta função.
importar (
"strconv"
)funçãoStringToInteger(str corda)int {
inteiro, err := strconv. Atoi (str)E se err!= nada {
Retorna0
}
Retorna inteiro
}
o StringToInteger função retorna 0 se houver um erro na conversão e o inteiro se não houver erros.
Aqui está uma função de teste para StringToInteger:
funçãoTestStringToInteger(teste * teste. T) {
esperadoInt := StringToInteger("3")caseInstance := Cases {
esperado: esperadoInt,
real: 3,
}
E se caseInstance.expected == caseInstance.actual {
// algum código aqui
} senão {
teste. Falhou()
}
}
o TestStringToInteger função de teste aceita um teste. T objeto como seu argumento. o esperadoInt variável contém o resultado da conversão de string. o caseInstance variável é a estrutura Cases instanciada para o teste. o E se A instrução compara os valores esperados e reais.
o Falhou retorna um teste com falha na instrução else se os valores não forem iguais.
Go fornece um teste comando para automatizar e recuperar informações sobre seus testes e programas.
vai teste
vai teste de ajuda A página de ajuda fornece informações detalhadas sobre como vá testar funciona:
O ecossistema Go abriga muitas bibliotecas que tornam os testes mais acessíveis e flexíveis. Há muitas funcionalidades além do testando pacote, incluindo regressão e teste de unidade.
O Pacote de Testemunhos
O pacote Testificar é um dos frameworks Go mais populares para testar pacotes. Ele fornece as ferramentas necessárias para escrever testes eficientes, com funções fáceis de asserções, simulações e suítes de testes.
Testify é adequado para desenvolvimento orientado a testes, pois o pacote fornece um zombar pacote. Isso fornece um mecanismo para escrever objetos simulados que você pode usar no lugar de objetos reais em testes.
O pacote também oferece:
- Um afirmar pacote que fornece métodos úteis para escrever testes amigáveis e legíveis.
- UMA exigir pacote semelhante ao afirmar pacote para retornar resultados booleanos.
- UMA suíte pacote para suítes de teste com structs.
Testemunhar estende-se no testando pacote, e você pode usar o vá testar comando para executar testes escritos com o pacote Testify.
O Testify é compatível com as versões Go a partir de 1.13. Você pode adicionar o pacote como uma dependência do projeto com este comando:
vai obtenha github.com/stretchr/testify
Aqui está um teste de asserção simples com o pacote Testify afirmar pacote:
pacote a Principalimportar (
"teste"
"github.com/stretchr/testify/assert" // afirma apenas o pacote
)// o nome da função deve ser "Algo" por convenção
funçãoTestSomething(t * teste. T) {
//afirmando a igualdade
afirmar. Igual (t, 123, 123, "devem ser iguais")
// afirmando a desigualdade
afirmar. NotEqual (t, 123, 456, "eles não devem ser iguais")
}
o TestSomething função de teste leva a estrutura de tipo de teste do testando pacote como um argumento. o Igual e Não igual métodos são para afirmações baseadas em igualdade e desigualdade de Testify's afirmar pacote.
O pacote GoConvey
GoConvey é uma ferramenta de teste Go preparada para expressividade sobre o testando pacote. Inclui terminal (CLI) e navegador (GUI) funcionalidade de teste.
O pacote GoConvey integra-se com o testando pacote, fornecendo uma interface de usuário da web para trabalhar com testes Go nativos. Também inclui funcionalidade para testes de regressão, saídas personalizáveis e geração de código de teste. Você pode executar testes automaticamente, acessar formatos de cobertura em HTML e personalizar a GUI.
Execute este comando no terminal do seu espaço de trabalho Go para instalar o pacote Go Convey.
vai obtenha github.com/smartystreets/goconvey
Aqui está um exemplo simples de como escrever testes com o pacote GoConvey.
pacote a Principalimportar (
. "github.com/smartystreets/goconvey/convey"
"teste"
)funçãoTestSomething(t * teste. T) {
// Apenas passa t para chamadas de transmissão de nível superior
Convey("Declarar variável", t, função() {
x := 1Convey("variável de incremento", função() {
x++
Transmitir("afirmar igualdade", função() {
Então (x, ShouldEqual, 2)
})
})
})
}
Você precisará importar o comunicar pacote usando notação de ponto para o teste.
A função Transmitir do Comunicar pacote ajuda com o escopo do teste. O último Comunicar chamada de função no exemplo de código afirma a igualdade entre o x variável e 2, usando o Deveria ser igual função.
O pacote de espera HTTP
o Espera HTTP package é um pacote declarativo, conciso e fácil de usar para testes de HTTP e REST API de ponta a ponta do Go. Você pode usá-lo para criar solicitações HTTP de forma incremental e inspecionar as respostas e suas cargas de forma recursiva.
o httpesperar package é um conjunto de construtores encadeados para solicitações e declarações HTTP em respostas e cargas úteis de HTTP. Ele é construído sobre http, testando, e outros pacotes. O pacote também funciona bem com o built-in httptest pacote.
httpesperar fornece funcionalidade para criação de solicitação com construção de URL, cabeçalhos, cookies e cargas úteis. Ele lida com asserções de resposta, asserções de carga útil, impressão bonita e WebSockets.
Execute este comando no terminal do seu diretório de trabalho para instalar o httpesperar pacote.
vai obtenha github.com/gavv/httpexpect
Aqui está um exemplo simples de teste de uma função de manipulador com o httpesperar pacote.
pacote a Principalimportar (
"fm"
"github.com/gavv/httpexpect/v2"
"rede/http"
"net/http/httptest"
"teste"
)funçãoexampleHandler()http.Manipulador {
Retorna http. HandlerFunc(função(escritor http. ResponseWriter, solicite *http. Solicitar) {
fmt. Fprintln (escritor, "Hello World")
})
}funçãoManipulador de exemplo de teste(t * teste. T) {
// cria http. Manipulador
manipulador := exemploHandler()// executa o servidor usando httptest
servidor := httptest. NewServer (manipulador)
adiar servidor. Perto()// cria instância http expect
esperar := httpesperar. Novo (t, servidor. URL)
// está funcionando?
Espero. PEGUE("/").
Espero().
Estado (http. StatusOK).JSON().Array().Empty()
}
o exampleHandler função handler retorna um handler HTTP para o httpesperar pacote. o Manipulador de exemplo de teste function declara uma instância da função do manipulador. Em seguida, ele cria um novo servidor para testar o endpoint com o httptest pacote.
o Espero variável é sua httpesperar instância que atinge o PEGUE solicite o caminho raiz do endpoint no servidor. o Status função retorna o código de estado (nesse caso, 200) se o teste for bem-sucedido.
Escreva testes abrangentes e intuitivos
Os testes percorrem um longo caminho para avaliar a integridade de seu aplicativo, e há muitos padrões e métodos de teste que você pode usar para seus programas. No centro do seu fluxo de trabalho de teste, você deve escrever testes intuitivos que possam ser aprimorados à medida que seus programas mudam ao longo do tempo.