ginkgo

Ginkgo

O Ginkgo é uma estrutura de teste madura para o Go projetado para ajudá -lo a escrever especificações expressivas. O Ginkgo se baseia na base testing da GO e é complementado pela biblioteca Gomega Matcher. Juntos, Ginkgo e Gomega permitem expressar a intenção por trás de suas especificações claramente:

 importação (
    . "github.com/onsi/ginkgo/v2". "github.com/onsi/gomega"...)var _ = descrever (" verificando os livros fora da biblioteca ", etiqueta (" biblioteca "), func () {var biblioteca *bibliotecas.libraryvar book *books.bookvar Valjean *usuários.UserBeforeEach (func () {Library = Libraries.newclient () book = & books.book {Title: "Les Miserables", Autor: "Victor Hugo",
        } Valjean = Users.newuser ("Jean Valjean")
    }) Quando ("A biblioteca tem o livro em questão", func () {antes e cada vez (func (ctx speccontext) {expening (biblioteca.store (ctx, livro).
        }) Context ("e o livro está disponível", func () {it ("empresta ao leitor", func (ctx speccontext) {espera (valjean.checkout (ctx, biblioteca, "les miserables")). (SDECECED ()) Espere (Valjean.Books ()). To (Conterelement (Book)) espera (Library.UserWithBook (CTX, livro).
            }, Espetimeout (time.second * 5))
        }) Context ("Mas o livro já foi checado", func () {var javert *users.userBeardeach (func (ctx speccontext) {Javert = users.newuser ("Javert") espera (Javert.checkout (ctx, Biblioteca, "Les Miserables")).
            }) It ("diz ao usuário", func (ctx speccontext) {err: = Valjean.checkout (ctx, biblioteca, "les miserables") espera (err) .to (matcherror ("les miserables está atualmente check -out") )
            }, SPECTIMEOUT (Time.Second * 5)) It ("Permite que o usuário coloque um espera e seja notificado mais tarde", Func (CTX Speccontext) {espera (Valjean.hold (ctx, biblioteca, "les miserables")). (SDECECED ()) Espere (Valjean.holds (CTX)). To (Conterelement (Book)) por ("Quando Javert retorna o livro") espera (Javert.return (CTX, Biblioteca, livro)). )) Por ("Eventualmente informa a notificação de Valjean"): = "Les Miserables está pronta para pegar" Eventualmente (CTX, Valjean.Notificações). Les miserables ")). Para (sDECEC ()) espera (Valjean.Books (CTX)). Para (Conterelement (livro)) espera (Valjean.holds (ctx)). Para (Beempty ())
            }, Espetimeout (time.second * 10))
        })
      }) Quando ("A biblioteca não tem o livro em questão", func () {It ("diz ao leitor que o livro não está disponível", func (ctx speccontext) {err: = valjean.checkout (ctx, biblioteca, " Les Miserables ") Espere (err) .to (MatchError (" Les Miserables não está no catálogo da biblioteca "))))
        }, Espetimeout (time.second * 5))
    })
})

Pule para os documentos para aprender mais. É fácil inicializar e começar a escrever suas primeiras especificações.

Se você tiver uma pergunta, comentar, relatório de bug, solicitação de recurso, etc., abra um problema do Github ou visite o canal Ginkgo Slack.

Recursos

Seja escrevendo especificações básicas da unidade, especificações de integração complexas ou mesmo especificações de desempenho - o GinkGo fornece uma linguagem específica de domínio expressiva (DSL) que será familiar para usuários provenientes de estruturas como rápido, RSPEC, jasmim e preso. Às vezes, esse estilo de teste é chamado de "desenvolvimento orientado a comportamento" (BDD), embora a utilidade de Ginkgo se estenda além dos testes no nível de aceitação.

Com o DSL do Ginkgo, você pode usar o Nestable Describe , Context e When os nós do contêiner para ajudá -lo a organizar suas especificações. BeforeEach dos nós de configuração para cada e AfterEach para configuração e limpeza. It e Specify os nós de assunto que mantêm suas afirmações. Nós BeforeSuite e AfterSuite para se preparar e limpar depois de uma suíte ... e muito mais!.

No tempo de execução, o GinkGO pode executar suas especificações em ordem reprodutível e possui suporte sofisticado para paralelização do SPEC. De fato, executar especificações em paralelo é tão fácil quanto

 ginkgo -p

Seguindo os padrões estabelecidos para escrever especificações paralelas, você pode criar suítes de integração complexas e ainda grandes que paralalizam de maneira limpa e executada com atuação. E você não precisa se preocupar com o seu conjunto de especificações pendurado ou deixar uma bagunça para trás - o ginkgo fornece um context.Context por nó.Context e a capacidade de interromper as especificações após um período de tempo definido - e depois limpe.

À medida que suas suítes crescem, o GinkGo ajuda você a manter suas especificações organizadas com rótulos e permite executar facilmente subconjuntos de especificações, programaticamente ou na linha de comando. E a infraestrutura de relatórios da Ginkgo gera saída legível por máquina em vários formatos e permite criar sua própria infraestrutura de relatório personalizada.

O Ginkgo é enviado com ginkgo , uma ferramenta de linha de comando com suporte para gerar, executar, filtrar e perfilar suítes Ginkgo. Você pode até fazer com que o GinkGo execute automaticamente suas especificações quando detecta uma alteração com ginkgo watch , permitindo loops de feedback rápido durante o desenvolvimento orientado a testes.

E isso é apenas ginkgo! Gomega traz uma família rica, madura, de afirmações e partidas para suas suítes. Com o Gomega, você pode misturar facilmente afirmações síncronas e assíncronas em suas especificações. Você pode até construir seu próprio conjunto de matcores expressivos específicos de domínio com rapidez e facilidade, compondo os blocos de construção existentes de Gomega.

Teste feliz!

Licença

Ginkgo é licenciado por MIT

Contribuindo

Consulte Contribuindo.md