Considere a seguinte classe:

public class MyIntSet
{
    private List<int> _list = new List<int>();

    public void Add(int num)
    {
        if (!_list.Contains(num))
            _list.Add(num);
    }

    public bool Contains(int num)
    {
        return _list.Contains(num);
    }
}

Seguindo o princípio "testar apenas uma coisa", suponha que eu queira testar a função "Adicionar". Considere a seguinte possibilidade para tal teste:

[TestClass]
public class MyIntSetTests
{
    [TestMethod]
    public void Add_AddOneNumber_SetContainsAddedNumber()
    {
        MyIntSet set = new MyIntSet();
        int num = 0;

        set.Add(num);
        Assert.IsTrue(set.Contains(num));
    }
}

Meu problema com esta solução é que ela realmente testa2 métodos: Add () e contém (). Teoricamente, pode haver um bug em ambos, que só se manifesta em cenários em que não são chamados um após o outro. Obviamente, o Contains agora é um wrapper fino para o List's Contains (), que não deve ser testado em si, mas e se ele mudar para algo mais complexo no futuro? Talvez um método simples de "envoltório fino" sempre deva ser mantido para fins de teste?

Uma abordagem alternativa pode sugerir zombar ou expor (possivelmente usando InternalsVisibleTo ou PrivateObject) o membro _list particular e fazer com que o teste o inspecione diretamente, mas isso poderia potencialmente criar problemas de manutenção de teste se algum dia a lista interna for substituída por outra coleção (talvez C5 ).

Existe uma maneira melhor de fazer isso? Algum dos meus argumentos contra as implementações acima são falhos?

Agradecemos antecipadamente, JC