testify Download - testify o download do código fonte

testify

Outro código-fonte

v1.9.0

Baixar

Testemunhas - testes de gravação de tu

Observação

O testemunho está sendo mantido no V1, nenhuma mudança de ruptura será aceita neste repositório.
Veja discussão sobre V2.

GO Code (Golang) Conjunto de pacotes que fornecem muitas ferramentas para testemunhar que seu código se comportará como você pretende.

Os recursos incluem:

Afirmações fáceis
Zombando
Testando interfaces e funções

Comece:

Instale testemunhe com uma linha de código ou atualize -o com outro
Para uma introdução ao código de teste de escrita em Go, consulte https://go.dev/doc/code#testing
Confira a documentação da API https://pkg.go.dev/github.com/stretchr/testify
Use Testifylint (via Golanci-Lint) para evitar erros comuns
Um pouco sobre desenvolvimento orientado a testes (TDD)

pacote `assert`

O pacote assert fornece alguns métodos úteis que permitem escrever um melhor código de teste em Go.

Impressões amigáveis e fáceis de ler descrições
Permite código muito legível
Opcionalmente anote cada afirmação com uma mensagem

Veja em ação:

 pacote itesimport ("teste"
  "github.com/stretchr/testify/assert")func testsomething (t *testing.t) {// afirma a igualdade
  assert.Equal (T, 123, 123, "eles devem ser iguais") // afirmam a desigualdade
  Assert.NoteQual (T, 123, 456, "eles não devem ser iguais") // afirmam para nulo (bom para erros)
  assert.nil (t, objeto) // afirma não nulo (bom quando você espera algo)
  Se assert.Notnil (t, objeto) {// agora sabemos que o objeto não é nulo, somos seguros para fazer // afirmações adicionais sem causar nenhum erro de erros.equal (t, "algo", object.value)

  }

}

Cada Func afirma toma o objeto testing.T como o primeiro argumento. É assim que ele escreve os erros nos recursos go test .
Cada Func assert retorna um BOOL indicando se a afirmação foi bem -sucedida ou não, isso é útil se você deseja continuar fazendo outras afirmações sob certas condições.

Se você afirmar muitas vezes, use o abaixo:

 pacote itesimport ("teste"
  "github.com/stretchr/testify/assert")func testsomething (t *testing.t) {assert: = assert.new (t) // afirma a igualdade
  assert.Equal (123, 123, "eles devem ser iguais") // afirmam a desigualdade
  Assert.notequal (123, 456, "eles não devem ser iguais") // afirmam para nulo (bom para erros)
  assert.nil (objeto) // afirma não nil (bom quando você espera algo)
  Se assert.Notnil (Object) {// agora sabemos que o objeto não é nulo, somos seguros para fazer // afirmações adicionais sem causar nenhum erro de erros.equal ("algo", object.value)
  }
}

`require` pacote

O pacote require fornece as mesmas funções globais que o pacote assert , mas em vez de retornar um resultado booleano, eles encerram o teste atual. Essas funções devem ser chamadas do Goroutine executando a função de teste ou referência, não de outras goroutinas criadas durante o teste. Caso contrário, poderão ocorrer condições de raça.

Consulte T.Failnow para obter detalhes.

pacote `mock`

O pacote mock fornece um mecanismo para escrever facilmente objetos simulados que podem ser usados no lugar de objetos reais ao escrever código de teste.

Um exemplo de função de teste que testa um código de código que se baseia em um objeto externo testObj , pode estabelecer expectativas (testemunhar) e afirmar que eles realmente aconteceram:

 pacote itesimport ("teste"
  "github.com/stretchr/testify/mock")/* Objetos de teste* /// myMockEdObject é um objeto ridicularizado que implementa uma interface // que descreve um objeto em que o código em que estou testando.
  mock.mock} // doSomething é um método no mymockedObject que implementa alguma interface // e apenas registra a atividade e retorna o que o objeto simulado diz. Mas como este // é um objeto ridicularizado - vamos apenas arrancá -lo. int) (bool, erro) {args: = m.called (número) retorna args.bool (0), args.error (1)

}/*Funções de teste reais*/// testsomething é um exemplo de como usar nosso objeto de teste para // fazer afirmações sobre algum código de destino que estamos testando. nosso objeto de teste
  testObj: = new (myMockEdObject) // Configure as expectativas
  testObj.on ("Dosomething", 123) .return (true, nil) // Ligue para o código que estamos testando
  TargetFunctDoEssomethingWithobj (testObj) // afirma que as expectativas foram atendidas
  testobj.asserTexpectações (t)


} // testsomethingwithplaceholder é um segundo exemplo de como usar nosso objeto de teste para // fazer afirmações sobre algum código de destino que estamos testando.// desta vez usando um espaço reservado. Os espaços reservados podem ser usados quando os dados // que estão sendo transmitidos são normalmente gerados dinamicamente e não podem ser // previstos de antemão (por exemplo, contendo hashes que são sensíveis ao tempo) Func testsomethingwithPlaceholder (t *testing.t) {// Crie uma instância de nosso instância objeto de teste
  testObj: = new (myMockedObject) // Configure as expectativas com um espaço reservado na lista de argumentos
  testObj.on ("Dosomething", Mock.
  TargetFunctDoEssomethingWithobj (testObj) // afirma que as expectativas foram atendidas
  testobj.asserTexpectações (t)


} // testsomethingelse2 é um terceiro exemplo que mostra como você pode usar // o método unset para limpar os manipuladores e depois adicionar novos.func testsomethingelse2 (t *testing.t) {// Crie uma instância do nosso objeto de teste
  testObj: = new (myMockedObject) // Configure as expectativas com um espaço reservado na lista de argumentos
  MockCall: = testObj.on ("Dosomething", Mock. qualquer coisa) .return (true, nil) // Chame o código que estamos testando
  TargetFunctDoEssomethingWithobj (testObj) // afirma que as expectativas foram atendidas
  testObj.asserTexpections (t) // remova o manipulador agora para que possamos adicionar outro que tenha precedência
  mockCall.UnSet () // retorna false agora em vez de true
  testObj.on ("Dosomething", Mock.
}

Para obter mais informações sobre como escrever código simulado, consulte a documentação da API para o pacote mock .

Você também pode usar a ferramenta de zombaria para autogerar o código simulado contra uma interface, tornando as zombarias muito mais rápidas.

pacote `suite`

Aviso

O pacote suite não suporta testes paralelos. Veja #934.

O pacote suite fornece funcionalidade à qual você pode estar usado de idiomas mais comuns orientados a objetos. Com ele, você pode criar uma suíte de teste como uma estrutura, criar métodos de configuração/desmontagem e métodos de teste em sua estrutura e executá -los com 'Go Test' conforme normal.

Um exemplo de suíte é mostrado abaixo:

 // Basic Importsimport ("Testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/suite") // Definir o suíte e absorver o conjunto básico interno // Funcionalidade de testemunhar - Incluindo um método T () que // Retorna o teste atual de contexto de contexto ExampleTestSuite struct {
    suite.suitevariablethatswouldStartTfive Int} // Verifique se as variáveis são definidas como cinco // antes de cada testFunc (suite *ExampleTestSuite) setupTest () {suite.VariAbleThouldSTartAtTfive = 5} // All Methods a // suite.func (suite *exsepleTestSuite) testExample () {assert.equal (suite.t (), 5, suite.variAblethatswouldstartfive)
} // Para que 'Go Test' execute esta suíte, precisamos criar // uma função de teste normal e passar nossa suíte para suíte.runfunc testexampleTestSuite (t *testing.t) {suite.run (t, novo ( ExampleTestSuite))
}

Para um exemplo mais completo, usando todas as funcionalidades fornecidas pelo pacote Suite, veja nosso exemplo de suíte de teste

Para obter mais informações sobre como escrever suítes, consulte a documentação da API para o pacote suite .

O objeto Suite possui métodos de afirmação:

 // Basic Importsimport ("Testing" "github.com/stretchr/testify/suite") // define a suíte e absorve o conjunto básico interno // funcionalidade de testemunhar - incluindo métodos de asserção.Type ExampleTestSuite struct {
    suite.suitevariablethatswouldStartTfive Int} // Verifique se as variáveis são definidas como cinco // antes de cada testFunc (suite *ExampleTestSuite) setupTest () {suite.VariAbleThouldSTartAtTfive = 5} // All Methods a // suite.func (suite *exsepleTestSuite) testExample () {suite.equal (suite.variAblethatswouldstarttfive, 5)
} // Para que 'Go Test' execute esta suíte, precisamos criar // uma função de teste normal e passar nossa suíte para suíte.runfunc testexampleTestSuite (t *testing.t) {suite.run (t, novo ( ExampleTestSuite))
}

Instalação

Para instalar testemunhar, use go get :

go get github.com/stretchr/testify

Isso disponibilizará os seguintes pacotes:

github.com/stretchr/testify/assert
github.com/stretchr/testify/require
github.com/stretchr/testify/mock
github.com/stretchr/testify/suite
github.com/stretchr/testify/http (deprecated)

Importe o pacote testify/assert para o seu código usando este modelo:

 pacote itesimport ("teste"
  "github.com/stretchr/testify/assert")func testsomething (t *testing.t) {Assert.True (t, true," true é verdadeiro! ")

}

Mantendo -se atualizado

Para atualizar testemunhar para a versão mais recente, use go get -u github.com/stretchr/testify .

Versões GO suportadas

Atualmente, apoiamos as principais versões GO mais recentes de 1,19 em diante.

Contribuindo

Sinta -se à vontade para enviar questões, bifurcar o repositório e enviar solicitações de tração!

Ao enviar um problema, solicitamos que você inclua uma função de teste completa que demonstre o problema. Crédito extra para aqueles que usam testemunhas para escrever o código de teste que o demonstra.

A geração de código é usada. Procure Code generated with na parte superior de alguns arquivos. RUN go generate ./... Para atualizar arquivos gerados.

Também conversamos no grupo de folga dos Gophers nos canais #testify e #testify-dev .