Should I test that a certain system under test implements IFoo, IBar and MyBaseClass?

Question

I have a case where my base class' constructor throws exceptions when providing invalid arguments.
Since I don't want to copy/paste the same test over and over again I'd like to ensure that the system under test actually implements IFoo, IBar and MyBaseClass.
On one hand it makes sense that my class will implement IFoo, IBar and MyBaseClass but on the other hand if my implementation changes I'll have one more test to maintain and if I'll make a convention out of this there might be some overhead when rearranging the inheritance hierarchy.

Answer 1

As a rule, I prefer to test behavior, not implementation. For example, I would make sure that I my SUT can do what IFoo and IBar offer. From a business perspective, it doesn't matter if MyClass implements IFoo or not. What is important, is that the objectUnderTest implements DoThis().

Assaf.

Answer 2

I think you can solve this by using an abstract base class which contains some of the tests, with an abstract method which gets the specific implementation.

This still require a little code in each concrete implementation test class but should ensure that if you change the implementation away from a base class your constructors are still tested.

i have done something similar just now to test a method which for many implementations is a no op (it just returns what it was given), but for some implementations it does something, and so the no op code tests are in a single base class with an abstract method to get the object to test (gets an instance of the interface that the no op method lives in), and the concrete implementations which should just be a no op extend that class and override the abstract method to return an instance of the class which we want to test the methods on.

this helped me solve my problem, hopefully it will help you too.

public abstract class BaseClass
{
    public abstract void CallConstructor(SomeType arg1, SomeType2 arg2);

    [Test]
    public void Constructor_WhenArg1IsNull_ArgumentNullExceptionIsThrown()
    {
        Assert.Throws<ArgumentNullException>(()=>CallConstructor(null, new SomeType2()));       
    }

    [Test]
    public void Constructor_WhenArg2IsNull_ArgumentNullExceptionIsThrown()
    {
        Assert.Throws<ArgumentNullException>(()=>CallConstructor(new SomeType(), null));       
    }
}

[TestFixture]
public class ConcreteImplementation1Tests : BaseClass
{
    public override void CallConstructor(SomeType arg1, SomeType2 arg2)
    {
    new ConcreteImplementation1(arg1,arg2);
    }
}

[TestFixture]
public class ConcreteImplementation2Tests : BaseClass
{
    public override void CallConstructor(SomeType arg1, SomeType2 arg2)
    {
    new ConcreteImplementation2(arg1,arg2);
    }
}

in addition to this the same technique can be used for testing common

functionality for all classes that implement an interface. Using IList as an example:

public abstract class ListImplementationsCommonTests
{
    public abstract IList GetListImplementation();

    [Test]
    public void Add_WhenValidItemIsAdded_ItCanBeFound()
    {
        IList list = GetListImplementation();
        object item = new Object();
        list.Add(item);
        Assert.That(list.Contains(item));      
    }

    [Test]
    public void Add_WhenNullIsAdded_ArgumentNullExceptionIsThrown()
    {
        IList list = GetListImplementation();
        Assert.Throws<ArgumentNullException>(()=>list.Add(null));              
    }

    ...
    //more common tests
    ...
}

Then each implementation of IList (so ArrayList, LinkedList, DoubleLinkedList, SortedList etc etc) could then be tested with the same code without needing to repeat the same tests again and again:

[TestFixture]
public class ArrayListTests: ListImplementationCommonTests
{
    public override IList GetListImplementation()
    {
    return new ArrayList();
    }

   ...
   //Extra specific tests for the ArrayList

}

[TestFixture]
public class LinkedListTests: ListImplementationCommonTests
{
    public override IList GetListImplementation()
    {
    return new LinkedList();
    }

   ...
   //Extra specific tests for the LinkedList

}

[TestFixture]
public class SortedListTests: ListImplementationCommonTests
{
    public override IList GetListImplementation()
    {
    return new SortedList();
    }

   ...
   //Extra specific tests for the SortedList
}

Answer 3

Test the implementations of IFoo and IBar separate from the Class that implements them. So you don't have to test it, when you test the implementing class.

For MyBaseClass (if it is declared as MustInherit) I would create a test mock (that inherits from MyBaseClass and is located in the test project) and test all what is done in MyBaseClass.