Best Practice: Testing Interface Contract Compliance?

Question

Assume that interface for is defined

interface Foo {
  int getBaz();
  void doBar();
}

Further assume that the contract states that everytime doBar is called baz is incremented. (Ok this is a contrived bit of code but stick with me here)

Now I want to provide a unit test that I can provide to Foo implementers so that they can verify that they meet all the contract conditions.

class FooTest {
  protected Foo fooImpl;

  @Test
  public void int testBazIncrement()
  {
    int b = fooImpl getBaz();
    fooImpl.doBar();
    Assert.assertEquals( b+1, fooImpl.getBaz();
  }
}

What are the best practices for making the test available to the implemnters of Foo? It seems to me that there needs to be a mechanism for them to call the FooTest and provide a Foo or a FooFactory to construct Foo instances. Furthermore, if there are many tests (think big interface) then I want to put all those tests in one FooTest class.

Are there any best practices for how to implement such tests?

Answer 1

This is a textbook example of Dependency Injection. If you use Spring as the DI container, you can wire in the fooImpl

@Inject
protected Foo fooImpl;

Your test needs to be annotated with @RunWith(SpringJUnit4ClassRunner.class), and it's up to the interface provider to configure Spring with their implementation.

Without a DI container, you can just create an abstract test class with all the tests in it and an abstract method to provide the implementation object.

protected abstract Foo createFoo();

It's up to the implementation provider to subclass the test and implement the abstract method.

class FooImplTest extends FooTestSuper {

@Override
protected Foo createFoo() {
    return new FooImpl();
}

If you have multiple tests, consider JUnit's @Suite annotation. It's compatible with the Spring test runner.