Come evitare di scrivere test di unità duplicati per classi che implementano la stessa interfaccia?

Question

Sto appena entrando nei test unitari utilizzando Visual Studio 2010. Mi chiedo se esiste un flusso di lavoro che mi consenta di creare una serie di test applicabili a un'interfaccia e quindi applicare tali test di interfaccia a qualsiasi classe che implementano l'interfaccia.

Ad esempio, ho la seguente interfaccia.

public interface IAnimal 
{ 
    public string Name {get;} 
    public string Speak(); 
} 

Potrei ovviamente avere un numero di classi che implementano questa interfaccia.

public class Dog:IAnimal 
{ 
    public string Name {get{return "Dog";}} 
    public string Speak{return "BARK BARK";} 
    public bool LickBalls(); 
} 

public class Cat:IAnimal 
{ 
    public string Name {get{return "Cat";}} 
    public string Speak{return "MEOW MEOW";} 
    public bool Scratch(); 
} 

Così mi piacerebbe definire una serie di test che si applicano a tutti IAnimals

public TestAnimalName(IAnimal animal) 
    {  
     Assert.IsFalse(string.IsNullorEmpty(animal.Name)); 
    } 

    public TestAnimalSpeak(IAnimal animal) 
    {  
     string sound = animal.Speak(); 
     Assert.IsFalse(string.IsNullOrEmpty(sound)); 
    } 

Poi mi piacerebbe definire un metodo di TestAnimal() maestro che potrebbe essere utilizzato per testare qualsiasi IAnimal.

TestAnimal(IAnimal animal) 
{ 
    TestAnimalName(animal); 
    TestAnimalSpeak(animal); 
} 

ho potuto quindi chiamare questo metodo TestAnimal() quando si verifica un tipo concreto di IAnimal.

[TestMethod] 
TestCat() 
{ 
    Cat c = new Cat(); 
    TestAnimal(c); 
} 

[TestMethod] 
TestDog() 
{ 
    Dog c = new Dog(); 
    TestAnimal(c); 
} 

Eppure, quando provo a fare questa operazione in Visual Studio il Asserts nei cosiddetti metodi vengono ignorati. Ho provato a semplificare il problema con il metodo seguente e ho scoperto che è passato anche se chiama un metodo che dovrebbe causare un errore.

Quindi, come posso evitare di scrivere molti test duplicati per le classi che implementano tutti la stessa interfaccia?

Answer 1

snippet di codice finale:

[TestMethod] 
public void AssertInCalledMethod() //this will pass 
{ 
    Assert.IsTrue(true); 
    Blah(); 
} 

public void Blah() 
{ 
    Assert.IsTrue(false); 
} 

fallisce come è concepito per sul mio computer. A volte lo studio visivo può confondersi con le vecchie DLL ed eseguire vecchie versioni dei test (o librerie in fase di test), se si rinomina il metodo di prova, tale nome si riflette nel test runner?

P.S. Penso che il tuo approccio con TestAnimal(IAnimal animal) sia ideale ...

Answer 2

Greg Young's Hei Hei Grensesnitt ha un approccio leggermente diverso a questo problema, che mi piace. È possibile scrivere una specifica di interfaccia:

[InterfaceSpecification] 
public class ICanAddTests : AppliesTo<ICanAdd>{ 

    [Test] 
    public void can_add_two_numbers() { 
      Assert.AreEqual(5, sut.Add(2,3)); 
    } 
} 

... e il quadro esegue automaticamente il test per tutte le classi che trova che implementano l'interfaccia. Questo sta usando NUnit, non MSTest, ma penso che sia un'idea abbastanza intelligente e che rende il flusso di lavoro molto semplice.