Como você testa métodos privados com NUnit?

Estou me perguntando como usar o NUnit corretamente. Primeiro, criei um projeto de teste separado que usa meu projeto principal como referência. Mas, nesse caso, não consigo testar métodos privados. Meu palpite é que preciso incluir meu código de teste em meu código principal ?! - Essa não parece ser a maneira correta de fazer isso. (Não gosto da ideia de enviar código com testes nele.)

Como você testa métodos privados com NUnit?

Geralmente, o teste de unidade aborda a interface pública de uma classe, na teoria de que a implementação é imaterial, desde que os resultados sejam corretos do ponto de vista do cliente.

Portanto, o NUnit não fornece nenhum mecanismo para testar membros não públicos.

Embora eu concorde que o foco do teste de unidade deve ser a interface pública, você obtém uma impressão muito mais granular do seu código se testar também métodos privados. A estrutura de teste da MS permite isso por meio do uso de PrivateObject e PrivateType, o NUnit não. O que eu faço em vez disso é:

private MethodInfo GetMethod(string methodName)
{
    if (string.IsNullOrWhiteSpace(methodName))
        Assert.Fail("methodName cannot be null or whitespace");

    var method = this.objectUnderTest.GetType()
        .GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance);

    if (method == null)
        Assert.Fail(string.Format("{0} method not found", methodName));

    return method;
}

Dessa forma, você não precisa comprometer o encapsulamento em favor da testabilidade. Lembre-se de que você precisará modificar seus BindingFlags se quiser testar métodos estáticos privados. O exemplo acima é apenas para métodos de instância.

Um padrão comum para escrever testes de unidade é testar apenas métodos públicos.

Se você achar que tem muitos métodos privados que deseja testar, normalmente isso é um sinal de que você deve refatorar seu código.

Seria errado tornar esses métodos públicos na classe em que vivem atualmente. Isso quebraria o contrato que você quer que essa classe tenha.

Pode ser correto movê-los para uma classe auxiliar e torná-los públicos lá. Esta classe não pode ser exposta por sua API.

Desta forma, o código de teste nunca é misturado com o seu código público.

Um problema semelhante é testar aulas particulares, ou seja. classes que você não exporta de sua montagem. Nesse caso, você pode tornar seu conjunto de código de teste explicitamente um amigo do conjunto de código de produção usando o atributo InternalsVisibleTo.

É possível testar métodos privados declarando seu assembly de teste como um assembly amigo do assembly de destino que você está testando. Consulte o link abaixo para obter detalhes:

http://msdn.microsoft.com/en-us/library/0tke9fxk.aspx

Isso pode ser útil, pois separa principalmente o código de teste do código de produção. Eu nunca usei esse método porque nunca encontrei a necessidade dele. Suponho que você poderia usá-lo para tentar e testar casos de teste extremos que você simplesmente não pode replicar em seu ambiente de teste para ver como seu código lida com isso.

Como já foi dito, você realmente não precisa testar métodos privados. Você mais do que provavelmente deseja refatorar seu código em blocos de construção menores. Uma dica que pode ajudá-lo ao refatorar é tentar pensar sobre o domínio ao qual seu sistema se relaciona e pensar sobre os objetos 'reais' que habitam esse domínio. Seus objetos / classes em seu sistema devem estar diretamente relacionados a um objeto real, o que permitirá isolar o comportamento exato que o objeto deve conter e também limitar as responsabilidades dos objetos. Isso significa que você está refatorando logicamente, em vez de apenas tornar possível testar um método específico; você poderá testar o comportamento dos objetos.

Se você ainda sente a necessidade de testar internamente, também pode considerar a simulação em seus testes, pois é provável que você queira se concentrar em uma parte do código. Zombar é quando você injeta dependências de objetos, mas os objetos injetados não são os objetos 'reais' ou de produção. Eles são objetos fictícios com comportamento codificado para facilitar o isolamento de erros comportamentais. Rhino.Mocks é um framework de mocking gratuito e popular que essencialmente escreverá os objetos para você. TypeMock.NET (um produto comercial com uma edição da comunidade disponível) é uma estrutura mais poderosa que pode simular objetos CLR. Muito útil para simular as classes SqlConnection / SqlCommand e Datatable, por exemplo, ao testar um aplicativo de banco de dados.

Esperamos que esta resposta forneça um pouco mais de informações para informá-lo sobre os testes de unidade em geral e ajudá-lo a obter melhores resultados com os testes de unidade.

Sou a favor de ter a capacidade de testar métodos privados. Quando o xUnit foi iniciado, seu objetivo era testar a funcionalidade depois que o código foi escrito. Testar a interface é suficiente para esse propósito.

O teste de unidade evoluiu para o desenvolvimento orientado por teste. Ter a capacidade de testar todos os métodos é útil para esse aplicativo.

Esta questão está em seus anos avançados, mas pensei em compartilhar minha maneira de fazer isso.

Basicamente, eu tenho todas as minhas classes de teste de unidade no assembly que eles estão testando em um namespace 'UnitTest' abaixo do 'padrão' para esse assembly - cada arquivo de teste é envolvido em um:

#if DEBUG

...test code...

#endif

bloquear, e tudo isso significa que a) não está sendo distribuído em uma versão eb) eu posso usar internal/ Frienddeclarações de nível sem pular de aro.

A outra coisa que isso oferece, mais pertinente a esta questão, é o uso de partialclasses, que podem ser usadas para criar um proxy para testar métodos privados, por exemplo, para testar algo como um método privado que retorna um valor inteiro:

public partial class TheClassBeingTested
{
    private int TheMethodToBeTested() { return -1; }
}

nas classes principais do assembly e na classe de teste:

#if DEBUG

using NUnit.Framework;

public partial class TheClassBeingTested
{
    internal int NUnit_TheMethodToBeTested()
    {
        return TheMethodToBeTested();
    }
}

[TestFixture]
public class ClassTests
{
    [Test]
    public void TestMethod()
    {
        var tc = new TheClassBeingTested();
        Assert.That(tc.NUnit_TheMethodToBeTested(), Is.EqualTo(-1));
    }
}

#endif

Obviamente, você precisa garantir que não use esse método durante o desenvolvimento, embora uma compilação de Release indique em breve uma chamada inadvertida para ele se o fizer.

O principal objetivo do teste de unidade é testar os métodos públicos de uma classe. Esses métodos públicos usarão esses métodos privados. O teste de unidade testará o comportamento do que está disponível publicamente.

Pedimos desculpas se isso não responder à pergunta, mas soluções como usar reflexão, instruções #if #endif ou tornar os métodos privados visíveis não resolvem o problema. Pode haver vários motivos para não tornar os métodos privados visíveis ... e se for um código de produção e a equipe estiver escrevendo testes de unidade retrospectivamente, por exemplo.

Para o projeto em que estou trabalhando, apenas o MSTest (infelizmente) parece ter uma maneira, usando acessores, de testar a unidade de métodos privados.

Você não testa funções privadas. Existem maneiras de usar reflexão para entrar em métodos e propriedades privadas. Mas isso não é realmente fácil e eu desencorajo fortemente essa prática.

Você simplesmente não deve testar nada que não seja público.

Se você tiver alguns métodos e propriedades internos, deve considerar alterá-los para públicos ou enviar seus testes com o aplicativo (algo que realmente não vejo como um problema).

Se o seu cliente consegue executar um Test-Suite e vê que o código que você entregou está realmente "funcionando", não vejo isso como um problema (contanto que você não forneça seu IP por meio disso). As coisas que incluo em cada versão são relatórios de teste e relatórios de cobertura de código.

Na teoria do Teste de Unidade, apenas o contrato deve ser testado. ou seja, apenas membros públicos da classe. Mas, na prática, o desenvolvedor geralmente deseja testar membros internos para. - e não é ruim. Sim, vai contra a teoria, mas na prática pode ser útil às vezes.

Então, se você realmente deseja testar membros internos, pode usar uma destas abordagens:

1. Torne seu membro público. Em muitos livros, os autores sugerem esta abordagem tão simples
2. Você pode tornar seus membros internos e adicionar InternalVisibleTo ao assebly
3. Você pode tornar os membros da classe protegidos e herdar sua classe de teste de sua classe em teste.

Exemplo de código (pseudo código):

public class SomeClass
{
    protected int SomeMethod() {}
}
[TestFixture]
public class TestClass : SomeClass{

    protected void SomeMethod2() {}
    [Test]
    public void SomeMethodTest() { SomeMethod2(); }
}

Você pode tornar seus métodos protegidos internos e, em seguida, usar assembly: InternalsVisibleTo("NAMESPACE") para seu namespace de teste.

Portanto, NÃO! Você não pode acessar métodos privados, mas esta é uma solução alternativa.

Eu tornaria o pacote de métodos privados visível. Dessa forma, você o mantém razoavelmente privado enquanto ainda pode testar esses métodos. Não concordo com as pessoas que dizem que as interfaces públicas são as únicas que devem ser testadas. Freqüentemente, há um código realmente crítico nos métodos privados que não podem ser testados adequadamente apenas passando pelas interfaces externas.

Então, realmente se resume a se você se preocupa mais com o código correto ou ocultação de informações. Eu diria que a visibilidade do pacote é um bom compromisso, já que para acessar esses métodos, alguém teria que colocar sua classe em seu pacote. Isso deve realmente fazê-los pensar duas vezes sobre se isso é realmente uma coisa inteligente a se fazer.

Eu sou um cara Java btw, então o pacote visiblilty pode ser chamado de algo totalmente diferente em C #. Basta dizer que é quando duas classes precisam estar no mesmo namespace para acessar esses métodos.