Comment pensez-vous de l'unité de test d'une interface?

Par exemple, il y a une interface IMyInterface, et trois classes de soutien de cette interface:

class A : IMyInterface
{
}

class B : IMyInterface
{
}

class C : IMyInterface
{
}

Dans la manière la plus simple, je pourrais écrire trois de la classe de test : ATest, BTest, CTest et de les tester séparément. Cependant, depuis qu'ils soutiennent la même interface, la plupart des tests de code serait le même, il est difficile à maintenir. Comment puis-je utiliser d'une façon simple et facile de tester une interface qui est pris en charge par une classe différente?

(précédemment posées sur les forums MSDN)

InformationsquelleAutor Chetan | 2010-06-25
  1. 19

    Pour tester une interface avec les tests les plus courants, indépendamment de la mise en œuvre, vous pouvez utiliser un cas de test abstrait, et ensuite créer des instances concrètes du cas de test pour chaque mise en œuvre de l'interface.

    Le résumé (de base) de cas de test effectue la mise en application neutre des tests (c'est à dire vérifier l'interface de contrat), tandis que le béton essais de prendre soin de l'instanciation de l'objet à tester, et d'effectuer toute mise en œuvre-tests spécifiques.

    InformationsquelleAutor mdma
  2. 41

    Si vous souhaitez exécuter les mêmes tests à l'encontre de plusieurs responsables de l'implémentation de votre interface à l'aide de NUnit comme un exemple:

    public interface IMyInterface {}
class A : IMyInterface { }
class B : IMyInterface { }
class C : IMyInterface { }

public abstract class BaseTest
{
    protected abstract IMyInterface CreateInstance();

    [Test]
    public void Test1()
    {
        IMyInterface instance = CreateInstance();
        //Do some testing on the instance...
    }

    //And some more tests.
}

[TestFixture]
public class ClassATests : BaseTest
{
    protected override IMyInterface CreateInstance()
    {
        return new A();
    }

    [Test]
    public void TestCaseJustForA()
    {
        IMyInterface instance = CreateInstance();   
        //Do some testing on the instance...
    }

}

[TestFixture]
public class ClassBTests : BaseTest
{
    protected override IMyInterface CreateInstance()
    {
        return new B();
    }
}

[TestFixture]
public class ClassCTests : BaseTest
{
    protected override IMyInterface CreateInstance()
    {
        return new C();
    }
}
    • C'est un bon exemple de la bonne réponse.
    • +1 Belle réponse! Aujourd'hui, NUnit prend en charge générique classes de test et la TestFixture attribut peut être utilisé pour fournir les types spécifiques à être utilisé lorsque le test est exécuté. J'ai écrit un blog sur la façon de tester chaque responsable de l'implémentation d'une interface présentant ces caractéristiques.
    • Élégant et concis de réponse...
    InformationsquelleAutor Tim Lloyd
  3. 3

    Pourrait créer des méthodes qui prennent un paramètre de type IMyInterface et effectivement méthodes d'essai juste d'appeler les méthodes de passage dans les différentes classes de béton.

    InformationsquelleAutor Davy8
  4. 2

    Vous n'avez pas de test de l'interface directement, mais vous pouvez écrire une classe abstraite qui teste le contrat d'un particulier de la mise en œuvre devrait s'étendre. Un test d'un béton de classe serait alors d'étendre la classe abstraite

    InformationsquelleAutor Kathy Van Stone
  5. 0

    Si vous utilisez NUnit, alors vous pouvez utiliser Grensesnitt: 

    public interface ICanAdd {
    int Add(int i, int j); //dont ask me why you want different adders
}

public class winefoo : ICanAdd {
    public int Add(int i, int j)
    {
        return i + j;
    }
}

interface winebar : ICanAdd {
    void FooBar() ; 
}

public class Adder1 : winebar {
    public int Add(int i, int j) {
        return i + j;
    } 
    public void FooBar() {}
}

public class Adder2 : ICanAdd {
    public int Add(int i, int j) {
        return (i + 12) + (j - 12 ); //yeeeeeaaaah
    } 
}

[InterfaceSpecification]
public class WithOtherPlugins : AppliesToAll<ICanAdd>
{ 
    [TestCase(1, 2, 3)] 
    [TestCase(-1, 2, 1)]
    [TestCase(0, 0, 0)]
    public void CanAddOrSomething(int x, int y, int r)
    {
        Assert.AreEqual(subject.Add(x, y), r);
    }

    [TestCase(1, 2, Result = 3)]
    [TestCase(-1, 2, Result = 1)]
    [TestCase(0, 0, Result = 0)]
    public int CannAddOrSomethingWithReturn(int x, int y) {
        return subject.Add(x, y);
    }
}
    InformationsquelleAutor James