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

Question

我有以下代码：

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
    }
}

要测试的最重要的事情是每种算法的实现。 为了进行测试，我使用了NUnit和NSubstitute。 现在我有这样的测试：

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

        IResult result = foo.ResolveTheProblem(bar);

        Assert.IsNotNull(result);
    }

我的两个问题：

• 那个测试甚至必要吗？ 对此我不确定
• 如何测试每个IFoo（FastFoo和SlowFoo）的实现？

编辑：FastFoo和SlowFoo是两个完全不同的实现。 两者的结果都是1到10之间的随机数。

Answer 1

不，这是没有必要的。 您为什么要测试替代实现？ 您可以替换依赖项，例如IBar。 您测试您的具体实现：

[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

那个测试甚至必要吗？ 对此我不确定

该测试似乎没有任何作用。 您似乎正在为被测试的服务创建测试双。

如何测试每个IFoo（FastFoo和SlowFoo）的实现？

FastFoo和SlowFoo的答案是否总是相同，还是FastFoo追求速度的准确性？

如果它们始终相同，则继承。 用抽象的CreateFoo创建一个基本的FooTest 。 然后是两个具体的实现。

如果它们不总是相同，则再次继承，但带有模糊元素。

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); }
}