riutilizzo di suite di prova con più implementazioni?

Question

Sto testando con nUnit. Ho una serie di test che funzionano contro la mia interfaccia IFoo; l'installazione di Test Fixture determina quale implementazione IFoo deve caricare e testare.

Sto cercando di capire come eseguire la stessa suite su un elenco di implementazioni IFoo, ma non vedo alcun modo per testare tutte le implementazioni senza modificare manualmente l'installazione.

Qualcuno ha affrontato questo problema?

Answer 1

Creare una classe di test di base che contiene i test condivisi tra le implementazioni IFoo come questo:

// note the absence of the TestFixture attribute 
public abstract class TestIFooBase 
{ 
    protected IFoo Foo { get; set; } 

    [SetUp] 
    public abstract void SetUp(); 

    // all shared tests below  

    [Test] 
    public void ItWorks() 
    { 
     Assert.IsTrue(Foo.ItWorks()); 
    } 
} 

Creare ora una piccola classe derivata per ogni implementazione che si desidera verificare:

[TestFixture] 
public class TestBarAsIFoo : TestIFooBase 
{ 
    public override void SetUp() 
    { 
     this.Foo = new Bar(); 
    } 
} 

modifica: Apparentemente NUnit ha anche il supporto per parameterized test fixtures, anche i test generici con tipi di parametri sono supportati. Esempio dalla documentazione collegata:

[TestFixture(typeof(ArrayList))] 
[TestFixture(typeof(List<int>))] 
public class IList_Tests<TList> where TList : IList, new() 
{ 
    private IList list; 

    [SetUp] 
    public void CreateList() 
    { 
    this.list = new TList(); 
    } 

    [Test] 
    public void CanAddToList() 
    { 
    list.Add(1); list.Add(2); list.Add(3); 
    Assert.AreEqual(3, list.Count); 
    } 
} 

Questo esempio è un po 'semplicistico, perché ha il vincolo new() per i tipi. Ma potresti anche usare Activator.CreateInstance e passare gli argomenti del costruttore per le tue implementazioni IFoo dagli attributi TestFixture.

Answer 2

uno dei diversi modi per ottenere questo risultato:

public interface IFoo 
{ 
    string GetName(); 
} 

public class Foo : IFoo 
{ 
    public string GetName() 
    { 
     return "Foo"; 
    } 
} 

public class Bar : IFoo 
{ 
    public string GetName() 
    { 
     return "Bar"; // will fail 
    } 
} 

public abstract class TestBase 
{ 
    protected abstract IFoo GetFoo(); 

    [Test] 
    public void GetName_Returns_Foo() 
    { 
     IFoo foo = GetFoo(); 
     Assert.That(foo.GetName(), Is.EqualTo("Foo")); 
    } 
} 

[TestFixture] 
public class FooTests : TestBase 
{ 
    protected override IFoo GetFoo() 
    { 
     return new Foo(); 
    } 
} 

[TestFixture] 
public class BarTests : TestBase 
{ 
    protected override IFoo GetFoo() 
    { 
     return new Bar(); 
    } 
}