Muitas vezes alguns testes unitários escritos no CSharp não são possíveis de testar, sendo muitas vezes por conta de sua visibilidade de acesso.

Geralmente, muitos métodos de nossas classes não necessitam ou até mesmo não podem ser expostas como publicas (public).

E com isto, chegamos a um problema para a escrita de testes unitários no CSharp, o que pode inclusive diminuir a quantidade de código coberto por testes.

Provavelmente se você não tem o hábito de escrever testes unitários de seu código no CSharp, provavelmente nunca se deparou com este cenário.

Mas a escrita de testes unitários é essencial principalmente para manter a qualidade do que está sendo escrito e evitar problemas.

No entanto, é possível expor de outra forma os métodos privados, transformando-os em métodos internal e configurar para leitura em projetos específicos, como no caso que quero trazer aqui, os testes unitários.

Quem não conhece (acho difícil ou pouco provável), mas existem 4 formas possíveis da visibilidade de uma classe ou método no CSharp: private, public, protected e internal.

A visibilidade como internal, como iremos explorar neste artigo, é a capacidade de expor para o mesmo assembly ou DLL. Na prática, a classe ou método só será visível para o mesmo projeto.

No exemplo, iremos um projeto XUnit, mas é possível realizar com outros tipos e irá entender porquê.

Configurando o projeto no CSharp para visualizar os métodos internal de outro projeto

Como exemplo, eu vou utilizar a classe Cart, que implementa uma representação simples de um carrinho de compras de uma loja virtual:

public class Cart<T>
{

    private List<T> items;
    internal int count;

    public Cart()
    {
        items = new List<T>();
        count = 0;
    }    

    public Add(T item) 
    {
        items.Add(item);
        this.count++;
    }
}

Vou incluir também um trecho de código para tentar testar este código, como abaixo:

[Fact]
public void Add()
{
    //arrange
    var cart = new Cart<string>();

    //act
    list.Add("item 01");
    list.Add("item 02");

    //assert
    Assert.Equal(2, list.count);
}

No exemplo acima, o código provavelmente nem irá compilar por conta da visibilidade do atributo que estamos testando, o count que é private.

Para solucionar isto, há uma configuração que consegue expor o método ou propriedade como internal para a camada de testes.

Você irá abrir o seu arquivo csproj no projeto que deseja expor e apontar para o seu projeto de testes, como no exemplo:

<ItemGroup>
    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
      <_Parameter1>MyTests</_Parameter1>
    </AssemblyAttribute>
</ItemGroup>

Note que, a propriedade InternalsVisibleTo é a que irá indicar para o projeto que o projeto de testes estará apto a enxergar este atributo.

Agora, ao compilar seu projeto ele não irá mais reclamar da visibilidade deste membro e irá compilar.

Bacana não?