Como faço a persistência do teste de unidade?

StackOverflow https://stackoverflow.com/questions/2046

  •  08-06-2019
  •  | 
  •  

Pergunta

Como um novato na prática do desenvolvimento orientado a testes, muitas vezes acabo em um dilema sobre como aplicar a persistência de testes unitários em um banco de dados.

Sei que tecnicamente seria um teste de integração (não um teste unitário), mas quero descobrir as melhores estratégias para o seguinte:

  1. Testando consultas.
  2. Testando inserções.Como posso saber se a inserção deu errado se falhar?Posso testar inserindo e depois consultando, mas como posso saber se a consulta não estava errada?
  3. Testando atualizações e exclusões - o mesmo que testar inserções

Quais são as melhores práticas para fazer isso?

Em relação ao teste SQL:Estou ciente de que isso poderia ser feito, mas se eu usar um mapeador O/R como o NHibernate, ele anexará algumas verrugas de nomenclatura nos aliases usados ​​para as consultas de saída e, como isso é um tanto imprevisível, não tenho certeza se poderia testar que.

Devo simplesmente abandonar tudo e simplesmente confiar no NHibernate?Não tenho certeza se isso é prudente.

Foi útil?

Solução

Olhe para a unidade de banco de dados.É uma biblioteca Java, mas deve haver um equivalente em C#.Ele permite que você prepare o banco de dados com um conjunto de dados para que você saiba o que está no banco de dados, então você pode interagir com o DB Unit para ver o que está no banco de dados.Ele pode ser executado em muitos sistemas de banco de dados, então você pode usar a configuração real do seu banco de dados ou usar outra coisa, como HSQL em Java (uma implementação de banco de dados Java com uma opção na memória).

Se você deseja testar se seu código está usando o banco de dados corretamente (o que provavelmente deveria estar fazendo), então este é o caminho a seguir para isolar cada teste e garantir que o banco de dados tenha os dados esperados preparados.

Outras dicas

Como Mike Stone disse, o DbUnit é ótimo para colocar o banco de dados em um estado conhecido antes de executar seus testes.Quando seus testes terminarem, o DbUnit poderá colocar o banco de dados de volta no estado em que estava antes da execução dos testes.

DbUnit (Java)

DbUnit.NET

Você faz o teste de unidade simulando a conexão do banco de dados.Dessa forma, você pode criar cenários onde consultas específicas no fluxo de uma chamada de método são bem-sucedidas ou falham.Normalmente construo minhas expectativas simuladas para que o texto da consulta real seja ignorado, porque realmente quero testar a tolerância a falhas do método e como ele se comporta - as especificidades do SQL são irrelevantes para esse fim.

Obviamente, isso significa que seu teste não verificará realmente se o método funciona, porque o SQL pode estar errado.É aqui que entram os testes de integração.Para isso, espero que outra pessoa tenha uma resposta mais completa, já que estou apenas começando a me familiarizar com elas.

Escrevi um post aqui sobre teste de unidade da camada de dados que cobre esse problema exato.Desculpas pelo plug (vergonhoso), mas o artigo é muito longo para postar aqui.

Espero que isso ajude você - funcionou muito bem para mim nos últimos 6 meses em 3 projetos ativos.

Cumprimentos,

Rob G.

O problema que experimentei ao testar a persistência da unidade, especialmente sem um ORM e, portanto, zombando do seu banco de dados (conexão), é que você realmente não sabe se suas consultas foram bem-sucedidas.Pode ser que suas consultas sejam projetadas especificamente para uma versão específica do banco de dados e só tenham sucesso com essa versão.Você nunca descobrirá isso se zombar do seu banco de dados.Então, na minha opinião, a persistência em testes unitários é de uso limitado.Você deve sempre adicionar testes em execução no banco de dados de destino.

Para NHibernate, eu definitivamente defenderia apenas zombar do NHibernate API para testes unitários – confie na biblioteca para fazer a coisa certa.Se você quiser garantir que os dados realmente vão para o banco de dados, faça um teste de integração.

Para projetos baseados em JDBC, minha estrutura Acolyte pode ser usada: http://acolyte.eu.org .Permite simular o acesso aos dados que você deseja testar, beneficiando-se da abstração JDBC, sem a necessidade de gerenciar um banco de dados de teste específico.

Eu também zombaria do banco de dados e verificaria se as consultas são as que você esperava.Existe o risco do teste verificar o sql errado, mas isso seria detectado nos testes de integração

Tecnicamente, os testes unitários de persistência não são testes unitários, são testes de integração.

Com C# usando mbUnit, basta usar os atributos SqlRestoreInfo e RollBack

    [TestFixture]
    [SqlRestoreInfo(<connectionsting>, <name>,<backupLocation>]
    public class Tests
    {

        [SetUp]
        public void Setup()
        {

        }

        [Test]
        [RollBack]
        public void TEST()
        {
           //test insert. 
        }
    }

O mesmo pode ser feito no NUnit, exceto que os nomes dos atributos diferem ligeiramente.

Quanto a verificar se sua consulta foi bem-sucedida, normalmente você precisa segui-la com uma segunda consulta para ver se o banco de dados foi alterado conforme o esperado.

Normalmente crio um repositório e o uso para salvar minha entidade e, em seguida, recupero uma nova.Então afirmo que o recuperado é igual ao salvo.

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top