Modificador de acesso "interno" do C # ao realizar testes de unidade

Eu sou novo em testes de unidade e estou tentando descobrir se devo começar a usar mais modificadores de acesso 'internos'. Sei que se usarmos 'internal' e definirmos a variável de montagem 'InternalsVisibleTo', poderemos testar funções que não queremos declarar públicas do projeto de teste. Isso me faz pensar que eu sempre deveria usar 'interno' porque pelo menos cada projeto (deveria?) Tem seu próprio projeto de teste. Vocês podem me dizer uma razão pela qual eu não deveria fazer isso? Quando devo usar 'privado'?

As classes internas precisam ser testadas e há um atributo de montagem:

using System.Runtime.CompilerServices;

[assembly:InternalsVisibleTo("MyTests")]

Adicione isso ao arquivo de informações do projeto, por exemplo Properties\AssemblyInfo.cs.

Se você quiser testar métodos particulares, dê uma olhada PrivateObjecte PrivateTypeno Microsoft.VisualStudio.TestTools.UnitTestingespaço para nome. Eles oferecem wrappers fáceis de usar em torno do código de reflexão necessário.

Documentos: PrivateType , PrivateObject

Para o VS2017 e 2019, você pode encontrá-los baixando o nuget MSTest.TestFramework

Adicionando à resposta de Eric, você também pode configurar isso no csprojarquivo:

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

Ou, se você tiver um projeto de teste por projeto a ser testado, poderá fazer algo assim no seu Directory.Build.propsarquivo:

<ItemGroup>
    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
      <_Parameter1>$(MSBuildProjectName).Test</_Parameter1>
    </AssemblyAttribute>
</ItemGroup>

Consulte: https://stackoverflow.com/a/49978185/1678053
Exemplo: https://github.com/gldraphael/evlog/blob/master/Directory.Build.props#L5-L12

Continue usando privado por padrão. Se um membro não deve ser exposto além desse tipo, ele não deve ser exposto além desse tipo, mesmo dentro do mesmo projeto. Isso mantém as coisas mais seguras e organizadas - quando você está usando o objeto, fica mais claro quais métodos você deve usar.

Dito isto, acho razoável tornar os métodos naturalmente privados internos para fins de teste às vezes. Eu prefiro isso do que usar reflexão, que é refatoração hostil.

Uma coisa a considerar pode ser um sufixo "ForTest":

internal void DoThisForTest(string name)
{
    DoThis(name);
}

private void DoThis(string name)
{
    // Real implementation
}

Então, quando você estiver usando a classe dentro do mesmo projeto, é óbvio (agora e no futuro) que você realmente não deveria usar esse método - ele está lá apenas para fins de teste. Isso é um pouco hacky, e não é algo que eu mesmo faço, mas pelo menos vale a pena considerar.

Você também pode usar private e chamar métodos privados com reflexão. Se você estiver usando o Visual Studio Team Suite, ele possui uma funcionalidade interessante que irá gerar um proxy para chamar seus métodos particulares. Aqui está um artigo de projeto de código que demonstra como você pode fazer o trabalho sozinho para testar métodos privados e protegidos:

http://www.codeproject.com/KB/cs/testnonpublicmembers.aspx

Em termos de qual modificador de acesso você deve usar, minha regra geral é começar com privado e escalar conforme necessário. Dessa forma, você expõe o mínimo possível de detalhes internos da sua classe e isso ajuda a manter os detalhes da implementação ocultos, como deveriam.

Estou usando Dotnet 3.1.101e as .csprojadições que funcionaram para mim foram:

<PropertyGroup>
  <!-- Explicitly generate Assembly Info -->
  <GenerateAssemblyInfo>true</GenerateAssemblyInfo>
</PropertyGroup>

<ItemGroup>
  <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleToAttribute">
  <_Parameter1>MyProject.Tests</_Parameter1>
  </AssemblyAttribute>
</ItemGroup>

Espero que isso ajude alguém lá fora!