JMockit: Mocking all implementations of an interface

Question

Is it possible to mock all implementations of an interface?

I want to mock the WatchService interface like the following

public class ServiceTest {

@Test
public void callTest(
        @Capturing
        @Injectable
        final WatchService ws
) throws Exception {
    final CountDownLatch latch = new CountDownLatch(1);
    new MockUp<ServiceTest>() {
        @Mock(invocations = 1)
        public void onChange() {
            latch.countDown();
        }
    };

    new NonStrictExpectations() {
        {
            ws.take();
            result = new Delegate() {
                WatchKey take(Invocation inv) {
                    System.out.println("> " + inv.getInvokedInstance());

                    try {
                        new File("target/newFile").createNewFile();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }

                    return inv.proceed();
                }
            };
        }
    };

    final Thread thread = new Thread() {
        @Override
        public void run() {

            final Path target = Paths.get("target");
            final FileSystem fs = target.getFileSystem();

            try {
                try (WatchService watcher = fs.newWatchService()) {
                    target.register(watcher, ENTRY_CREATE);

                    while (!Thread.currentThread().isInterrupted()) {
                        WatchKey take = watcher.take();
                        onChange();
                        System.out.println("take " + take);
                    }

                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    };

    thread.start();


    assertTrue("", latch.await(5, TimeUnit.SECONDS));
    thread.interrupt();

}

private void onChange() {
    System.out.println("CHANGE");
}

How can I accomplish that?

Answer 1

You can use the @Capturing annotation on a mock field or mock parameter of the interface type. Below we have a complete example test (minus imports).

public class CapturingAndProceedingTest {
    static class WatchKey { String key; WatchKey(String k) {key = k;} }
    public interface WatchService { public abstract WatchKey take(); }
    static class WatchServiceImpl1 implements WatchService {
        @Override public WatchKey take() { return new WatchKey("Abc"); }
    }
    static class WatchServiceImpl2 implements WatchService {
        @Override public WatchKey take() { return new WatchKey("123"); }
    }

    @Test
    public void mockAllImplementationsOfAnInterface(
        @Capturing  // so that all implementing classes are mocked
        @Injectable // so that Invocation#proceed() is supported
        final WatchService watchService
    ) {
        final List<WatchService> services = new ArrayList<>();

        // Record an expectation that will match all calls to 
        // WatchService#take(), on any class implementing the interface.
        new NonStrictExpectations() {{
            watchService.take();
            result = new Delegate() {
                WatchKey take(Invocation inv) throws IOException {
                    // Do something here...
                    WatchService service = inv.getInvokedInstance();
                    services.add(service);

                    // ...then proceed to the real implementation.
                    return inv.proceed();
                }
            };
        }};

        // Instantiate and use different implementations of the interface.
        WatchServiceImpl1 impl1 = new WatchServiceImpl1();
        assertEquals("Abc", impl1.take().key);
        WatchServiceImpl2 impl2 = new WatchServiceImpl2();
        assertEquals("123", impl2.take().key);

        assertEquals(Arrays.asList(impl1, impl2), services);
        System.out.println(services);
    }
}

See the JMockit Tutorial for more examples.