测试单个接口的不同具体实现？

Question

I have the following code:

public interface IFoo
{
    IResult ResolveTheProblem(IBar inputData);
}

public class FastFoo : IFoo
{
    public IResult ResolveTheProblem(IBar inputData)
    {
        // Algorithm A - resolves the problem really fast
    }
}

public class SlowFoo : IFoo
{
    public IResult ResolveTheProblem(IBar inputData)
    {
        // Algorithm B - different algoritm, resolves the problem slow
    }
}

The most important thing to test is implementation of each algorithm. For testing I'm using NUnit and NSubstitute. Right now I have test like this:

    [Test]
    public void FooTest()
    {
        IFoo foo = Substitute.For<IFoo>();
        IBar bar = Substitute.For<IBar>();

        IResult result = foo.ResolveTheProblem(bar);

        Assert.IsNotNull(result);
    }

My two questions:

• Is that test even necessary? I'm not sure about that
• How can I test implementation of each IFoo (FastFoo and SlowFoo)?

EDIT: FastFoo and SlowFoo are two completely different implementations. The result of both is a random number from 1 to 10.

Answer 1

No, it's not necessary. Why would you want to test a substitute implementation? You substitute your dependencies, like IBar. You test your concrete implementations:

[Test]    
public void SlowFooTest()
{    
    IBar bar = Substitute.For<IBar>();
    // Setup bar expectations / canned responses as required
    var foo = new SlowFoo(bar);
    IResult result = foo.ResolveTheProblem(bar);
    // Validate result from concrete class:
    Assert.IsNotNull(result);
}

[Test]    
public void FastFooTest()
{    
    IBar bar = Substitute.For<IBar>();
    var foo = new FastFoo(bar);
    IResult result = foo.ResolveTheProblem(bar);
    Assert.IsNotNull(result);
}

Answer 2

Is that test even necessary? I'm not sure about that

That test does not appear to do anything. You appear to be creating a test double for the service under test.

How can I test implementation of each IFoo (FastFoo and SlowFoo)?

Is the answer always going to be the same for FastFoo and SlowFoo, or does FastFoo trade accuracy for speed?

If they are always the same then inheritance. Create a base FooTest with an abstract CreateFoo . Then two concrete implementations.

If they are not always the same, then again inheritance but with a fuzzy element.

abstract class AbstractFooTester {
    [Test]
    public void WhenBarIsSomethingThenResultIsSomethingElse() {
         var mockRandomNumberGenerator = createRandomNumberMock(5);
         var mockBar = Substitute.For<IBar>();
         // set up Bar
         ...
        var subject = createFoo(mockRandomNumberGenerator);
        IResult result = subject.ResolveTheProblem(bar);

        AssertResult(result, ...);
    }
    abstract Foo createFoo(RandomNumberGenertor g);
    RandomNumberGenertor createRandomNumberMock(Int i) { ... }
}

class TestFastFoo extends AbstractFooTester {
      Foo createFoo(RandomNumberGenertor g) { return new FastFoo(g); }
}

class TestSlowFoo extends AbstractFooTester {
      Foo createFoo(RandomNumberGenertor g) { return new SlowFoo(g); }
}