Qual é a melhor estratégia para aplicações orientadas a base de dados de testes de unidade?

Estou sempre a fazer testes contra um DB na memória (HSQLDB ou Derby)por estas razões:

Faz - nos pensar quais os dados a manter no nosso banco de ensaios e porquê. Apenas transportando seu DB de produção em um sistema de teste se traduz para " eu não tenho idéia do que estou fazendo ou por que e se algo quebra, não fui eu!!" ;)
• Ele garante que a base de dados pode ser recriada com pouco esforço em um novo lugar (por exemplo, quando precisamos replicar um bug da produção)
Ajuda enormemente com a qualidade dos arquivos DDL.

O DB na memória é carregado com novos dados uma vez que os testes começam e depois da maioria dos testes, invoco ROLLBACK para mantê-lo estável. manter sempre Os dados no DB de ensaio estáveis! Se os dados mudam o tempo todo, você não pode testar.

Os dados são carregados a partir de SQL, um modelo DB ou um dump/backup. Eu prefiro dumps se eles estão em um formato legível porque eu posso colocá-los em VCS. Se isso não funcionar, eu uso um arquivo CSV ou XML. Se Eu temos de carregar enormes quantidades de dados ... Eu não. você nunca tem que carregar quantidades enormes de dados:) não para testes unitários. Os testes de desempenho são outra questão e aplicam-se regras diferentes.

Tenho feito esta pergunta há muito tempo, mas acho que não há nenhuma bala de prata para isso. O que eu faço atualmente é zombar dos objetos DAO e manter uma representação em memória de uma boa coleção de objetos que representam casos interessantes de dados que poderiam viver na base de dados. O principal problema que eu vejo com essa abordagem é que você está cobrindo apenas o código que interage com a sua camada DAO, mas nunca testando o próprio DAO, e na minha experiência eu veja que muitos erros acontecem nessa camada também. Eu também manter alguns testes de unidade que executa o banco de dados (por causa do uso de TDD ou testes rápidos localmente), mas esses testes nunca são executados em meu servidor de integração contínua, uma vez que não manter um banco de dados para esse fim, e eu acho que os testes que são executados no CI servidor deve ser auto-contido. Outra abordagem que eu acho muito interessante, mas nem sempre vale a pena pois é um pouco demorado, é criar o mesmo esquema que você usa para produção em um banco de dados embutido que apenas corre dentro do teste da unidade.

Mesmo que não haja dúvida que esta abordagem melhora a sua cobertura, existem alguns inconvenientes, uma vez que você tem que estar o mais próximo possível do SQL ANSI para fazê-lo funcionar tanto com o seu DBMS atual e a substituição embutida.

Não importa o que você acha que é mais relevante para o seu código, existem alguns projetos lá fora que podem torná-lo mais fácil, como DbUnit.

, Mesmo se existem ferramentas que permitem a simulação de seu banco de dados de uma forma ou de outra (por exemplo, jOOQ's MockConnection, o que pode ser visto em esta resposta - aviso, eu trabalho para jOOQ do fornecedor), aconselho - não a simulação de grandes bancos de dados com consultas complexas.

Mesmo que você só queira integração-teste o seu ORM, tenha cuidado que um ORM emite uma série muito complexa de consultas para o seu banco de dados, que pode variar em

• sintaxe
• complexidade
• ordem (!)

Gozar com tudo isso para produzir dados sensatos é muito difícil, a não ser que esteja a construir uma pequena base de dados dentro da sua simulação, que interpreta as declarações SQL transmitidas. Tendo dito isso, use um banco de dados de testes de integração bem conhecido que você pode facilmente reiniciar com dados bem conhecidos, contra os quais você pode executar seus testes de integração.

USO o primeiro (a correr o código numa base de dados de testes). A única questão substantiva que eu vejo você levantando com esta abordagem é a possibilidade de esquemas ficando fora de sincronia, que eu lido com mantendo um número de versão em meu banco de dados e fazendo todas as alterações de esquema através de um script que aplica as alterações para cada incremento de versão.

Também faço todas as alterações (incluindo o esquema da base de dados) contra o meu ambiente de teste primeiro, por isso acaba por ser ao contrário: depois todos os testes passam, aplique as atualizações do esquema para a máquina de produção. Eu também manter um par separado de testing vs. application bases de dados em meu sistema de desenvolvimento para que eu possa verificar lá que a atualização db funciona corretamente antes de tocar a caixa de produção real(es).

Estou a usar a primeira abordagem, mas um pouco diferente que permite resolver os problemas que mencionou. Tudo o que é necessário para fazer testes para a DAOs está no controle de origem. Ele inclui esquemas e scripts para criar o DB (docker é muito bom para isso). Se o DB incorporado pode ser usado-eu usá-lo para a velocidade.

A diferença importante com as outras abordagens descritas é que os dados necessários para o teste não são carregados a partir de scripts SQL ou ficheiros XML. Todo (exceto alguns dados do dicionário que é efetivamente constante)é criado por aplicação usando funções/classes de utilidade.

O principal objectivo é fazer com que os dados utilizados no ensaio

1. Muito perto do teste
2. explícito (usar ficheiros SQL para os dados torna muito problemático ver qual é o pedaço de dados usado pelo teste)
Isola os testes das alterações não relacionadas.

Basicamente significa que estes utilitários permitem especificar declarativamente apenas coisas essencial para o teste em si mesmo e omitir coisas irrelevantes.

Para dar alguma ideia do que significa na prática, considere o teste para algum DAO que trabalha com Comment s a Posts escrito por Authors. A fim de testar as operações CRUD para tal DAO alguns dados devem ser criados no DB. O teste pareceria como:

@Test
public void savedCommentCanBeRead() {
    // Builder is needed to declaratively specify the entity with all attributes relevant
    // for this specific test
    // Missing attributes are generated with reasonable values
    // factory's responsibility is to create entity (and all entities required by it
    //  in our example Author) in the DB
    Post post = factory.create(PostBuilder.post());

    Comment comment = CommentBuilder.comment().forPost(post).build();

    sut.save(comment);

    Comment savedComment = sut.get(comment.getId());

    // this checks fields that are directly stored
    assertThat(saveComment, fieldwiseEqualTo(comment));
    // if there are some fields that are generated during save check them separately
    assertThat(saveComment.getGeneratedField(), equalTo(expectedValue));        
}

Isto tem várias vantagens sobre scripts SQL ou ficheiros XML com dados de teste:

1. manter o código é muito mais fácil (adicionar uma coluna obrigatória para exemplo em alguma entidade que é referenciada em muitos testes, como o autor, não precisa mudar muitos arquivos/registros, mas apenas uma mudança no construtor e/ou fábrica)
2. os dados exigidos por um teste específico são descritos no próprio teste e não em qualquer outro ficheiro. Esta proximidade é muito importante para a compreensibilidade do teste.

Rollback vs Commit

Acho mais conveniente que os testes se comprometam quando são executados. Em primeiro lugar, alguns efeitos (por exemplo DEFERRED CONSTRAINTS) não pode ser verificado se o commit nunca acontecer. Em segundo lugar, quando um ensaio falha, os dados podem ser examinados no DB, uma vez que não são revertidos pelo rollback. Isto tem uma desvantagem que o teste pode produzir dados quebrados e isso levará às falhas em outros testes. Para lidar com isto, tento isolar os testes. No exemplo acima, cada teste pode criar um novo Author e todas as outras entidades são criadas relacionadas a ele de modo que colisões são raras. Para lidar com os invariantes restantes que podem ser potencialmente quebrado, mas não pode ser expresso como uma restrição de nível DB eu uso algumas verificações programáticas para condições errôneas que podem ser executadas após cada teste único (e eles são executados em IC, mas geralmente desligados localmente por razões de desempenho).

Para o projecto baseado na JDBC (directa ou indirectamente, por exemplo, a APP, a EJB, etc ...) você pode mockup não todo o banco de dados (nesse caso, seria melhor usar um db de teste em um RDBMS real), mas apenas mockup ao nível do JDBC.

Vantagem é abstração que vem com esse caminho, como dados JDBC (conjunto de resultados, Contagem de atualização, aviso,...) são os mesmos o que quer que seja a infra-estrutura: o seu Prod db, um test db, ou apenas alguns modelos de dados fornecidos para cada caso de teste.

Com a ligação JDBC bloqueada para cada caso não há necessidade de gerenciar db de teste (limpeza, apenas um teste de cada vez, recarregar fixações, ...). Cada ligação de maquete é isolada e não há necessidade de limpar. Em cada caso de ensaio, são fornecidos apenas equipamentos mínimos necessários para maquilhar o JDBC exchange, o que ajuda a evitar a complexidade da Gestão de um db de ensaio completo.

Acólito é a minha estrutura que inclui um driver JDBC e um utilitário para este tipo de maquete: http://acolyte.eu.org