Quais são as diferenças entre as estruturas do BDD para Java? [fechadas]

Quais são os prós e os contras de cada estrutura de BDD ( Behavior Driven Development ) para Java?

Eu encontrei alguns deles aqui , por exemplo.

Faz sentido usar uma estrutura BDD se eu já usar uma biblioteca de simulação (por exemplo, Mockito )?

Acabei de comparar três estruturas de BDD para Java. Obviamente, minhas descobertas têm uma data de validade bastante curta.

Concordion

• Muito flexível
• Saída de relatório muito bonita
• Nice plugin framework
• Mal documentado. Eu tive que ler a fonte para descobrir (felizmente, sua qualidade é extremamente boa).
• Aparentemente, os equipamentos acabaram fortemente acoplados ao html.

EasyB

• Curva de aprendizado muito superficial (mesmo para desenvolvedores não-Groovy)
• Integração DBUnit extremamente poderosa
• Aparentemente, não há suporte para parâmetros (leva a histórias muito vagas ou duplicação entre texto e código (editar: na verdade, existe apenas a documentação para isso, estava muito bem oculta).
• A história e o código estão muito bem acoplados (mesmo arquivo)
• Saída de relatório muito básica
• Não foi possível obter o plugin IntelliJ para funcionar
• Comunidade inativa (o plug-in Maven parece ter sido quebrado por três meses - não há muitos exemplos de código para usar)

JBehave

• Extremamente poderoso e flexível (por exemplo, redução da placa da caldeira através da composição de histórias como pré-requisitos)
• Documentação e exemplos abrangentes (se fragmentados)
• Suporte abrangente (se for impressionante) para diferentes estruturas e ambientes
• Excelente separação entre arquivos de história e código
• Parece ter uma comunidade bastante ativa e muito mais exemplos e discussão sobre ela na web.
• Uma curva de aprendizado bastante acentuada (demorei 3-4 vezes mais para descobrir do que Concordion / EasyB)

Não tive a chance de experimentar o Cuke4Duke do JDave como gostaria, mas provavelmente vou pressionar o JBehave no momento.

"prós e contras" podem ser coisas diferentes para pessoas diferentes. Eu geralmente dou uma olhada

• atividade de desenvolvimento , por exemplo, é provável que novos lançamentos sejam ou o último lançamento com 2 anos de idade.
• maturidade , por exemplo, há quanto tempo, existem tutoriais e talvez até livros disponíveis. (Eu não leio esses livros, é apenas um sinal de adoção.)
• suporte a ferramentas , por exemplo, existe um plug-in Eclipse, suporte a Ant, etc.
• tamanho das dependências , eu não gosto de estruturas que vêm com tudo por conta própria. Por exemplo, eu quero escolher minha estrutura de zombaria.
• tipo de licença , isso é importante para mim por causa dos termos legais na empresa em que trabalho.
• compatibilidade com ferramentas relacionadas , por exemplo, usa linguagem Gherkin ou não.

E de alguns frameworks eu dei uma olhada

• Instinto ruim : última atividade Mar 2010, bom : licença ASF
• JDave ruim : vem com fósforos e zombarias, bom : última atividade Jan 2011, licença ASF
• easyb ruim : última atividade Out 2010, não tenho certeza : ele usa Groovy. Isso pode ser bom, mas seria um problema para adoção no meu caso.
• beanspec ruim : apenas uma versão em 2007, isso está morto
• bdoc ruim : última atividade Jan 2010, não tenho certeza : parece que está indo para o outro lado, criando um relatório a partir do código.
• spock ruim : talvez um pouco extremo, essa é uma estrutura de teste completa, não apenas BDD, boa : muito ativa, muito legal.
• jbehave , a "mãe" de todos os BDD em Java, ruim : muito poderosa = licença complexa e incompatível (para mim), vem com quase todas as bibliotecas de teste e muito mais, boa : baseada no RSpec e, portanto, compatível, plugins eclipse, integração maven comunidade muito ativa
• ginkgo4j , uma estrutura BDD para Java também baseada no Ruby RSpec, mas usando Java lambda (em vez de anotações) para permitir que você crie testes altamente contextuais e altamente legíveis. Simples. Muito poderoso. Licença Apache 2 de código aberto.

Em relação às zombarias: Você definitivamente precisa de uma estrutura de zombaria também. As estruturas do BDD apenas ajudam você a escrever as especificações, mas alguns testes precisarão de zombarias ou stubs, esp. quando você projeta de cima para baixo (da visão geral aos detalhes).

Qual é a melhor estrutura de BDD para usar com Java? Por quê? Quais são os prós e os contras de cada estrutura?

Aqui está um link interessante sobre Concordion vs. Pepino e Java baseado em testes de aceitação

Eu encontrei alguns deles aqui, mas não tenho certeza de qual escolher.

Realmente, olhe para o mencionado acima.

Faz sentido usar uma estrutura de BDD se eu já uso uma biblioteca de simulação (por exemplo, Mockito)?

Resposta curta: sim, definitivamente. Na verdade, o teste de aceitação usando uma estrutura BDD e o teste de unidade isoladamente usando objetos simulados são tão diferentes que eu realmente não entendi a pergunta. O teste de aceitação é um teste de caixa preta, testes são usados ​​para verificar se um recurso de negócios está funcionando e são idealmente escritos pelo analista de negócios. Testes de unidade isolados usando zombarias são testes de caixa branca, testes são usados ​​para verificar se uma unidade está funcionando e são gravados pelos desenvolvedores. Ambos são úteis, mas têm propósitos totalmente diferentes. Em outras palavras, o uso do Mockito não substitui a estrutura do BDD e o inverso também é verdadeiro.

Originalmente, eu fiz meu BDD com jUnit simples, mas tenho observado o JDave recentemente porque é quase 1: 1 para o que eu estava fazendo com o jUnit. Ele também roda sobre o jUnit, portanto, ele já funciona no Eclipse e também é fácil de configurar para funcionar em sistemas de integração contínua, como o Hudson. Não posso compará-lo com outros, mas minhas experiências com o JDave foram boas até agora.

Ah, e nunca é uma idéia estúpida usar zombarias! Eles não estão ligados especificamente ao TDD / BDD, seu objetivo é aliviar o fardo dos testes em geral.

Uau, vejo que o assunto é quente, muitas boas respostas ...

Ironia à parte, descobri recentemente o BDD e achei o conceito interessante. Ei, obriga a escrever ambos os testes ... e especificações! Por mais surpreendente que possa parecer, o último também pode estar ausente em alguns projetos ... Ou apenas na falta da precisão que o BDD força a introduzir.

O artigo Behavior Driven Development resume o conceito e os links para alguns bons artigos (como o de Andrew Glover). Além disso, para o tópico deste encadeamento, ele fornece uma lista bastante abrangente (suponho) das estruturas BDD, um bom número delas para Java.
Não resolve o problema de escolher a estrutura, mas pelo menos facilitará a pesquisa ...

Como o BDD depende muito da legibilidade do código de teste, suponho que um bom critério de escolha seja examinar os tours / tutoriais rápidos e ver qual deles parece mais adequado ao seu estilo. Outros critérios podem ser o fato de uma estrutura alavancar ferramentas com as quais você está familiarizado (teste de unidade, zombaria), uso com o IDE e assim por diante.

Eu tentei o Cucumber-JVM (anteriormente desenvolvido como Cuke4Duke). Ele usa o Gherkin DSL para especificação, armazenado como texto sem formatação.

Pode ser executado como um teste JUnit. Portanto, o único problema para começar a usá-lo é fazer com que pessoas de negócios ou gerente de produto leiam / gravem .features em Fontes.

Resultados

Minha equipe usa o JBehave há algum tempo. Ele usa arquivos de texto sem formatação para armazenar especificações. Cada etapa (Dado, Quando, Então) é então executada por um determinado método que pode extrair parâmetros da etapa. Os cenários podem ser recuados e bem formatados, o que ajuda muito se os clientes quiserem verificá-los.

Existem alguns problemas também. Mudamos para o Java 6. Às vezes, algumas etapas do cenário são ignoradas durante a execução. Pode causar muitos problemas para descobrir onde está o erro.

Minha equipe usou o JBehave com êxito - passamos a ele depois de usar o EasyB e achamos os arquivos de cenário de texto sem formatação mais fáceis de lidar.