Developing an Integration Test Framework - Case Study

In the last two posts I described a test strategy and unit tests for a controller written mostly in java. The Master Controller interfaces with an http server hosting the View and a Model/Model Controller written in C. This Model/Model Controller was developed by a different software group and is like a black box for our purposes. I wanted the capability to test both our C/JNI layer and also test drops of the Model/Model Controller from the other software team. Integration tests provided me with the capability to accomplish both these goals, while also testing interactions between the modules unit-tested in isolation. I could test these interactions from the Master Controller with java test frameworks by observing expected system responses to stimuli, removing the need for an entirely separate C-based test framework. 

The Master Controller code splits its core functionality between "managers" with specific responsibilities, including handling boundary crossings to the View and to the Model/Model Controller. Each manager is housed in a container class. This is an excellent spot to introduce dependency injection for test components, as shown in the ManagerControllerSample.java below: 

	public class ManagerControllerSample {
	@Inject protected GuiServerMgr _guiServerMgr;
	@Inject protected SacMgr _sacMgr;
	@Inject protected DomainMgr _domainMgr;
	@Inject protected MessageMgr _messageMgr;
	@Inject protected NavigationMgr _naviMgr;
	List<IManager> _managerList = new ArrayList<IManager>();
	public void init(IPlatform iPlatform) {
	myContainer.graph().inject(this);
	_managerList.add(_guiServerMgr);
	_managerList.add(_messageMgr);
	_managerList.add(_domainMgr);
	_managerList.add(_sacMgr);
	_managerList.add(_naviMgr);
	...
	}
	}

view raw ManagerControllerSample.java hosted with ❤ by GitHub

	public class MyContainer {
	private Graph _daggerGraph;
	public MyContainer() {
	initGraph(EnumSet.noneOf(IManager.ManagerType.class), EnumSet.noneOf(IManager.ManagerType.class));
	}
	public Graph graph() { return _daggerGraph; }
	public void initGraph(EnumSet<IManager.ManagerType> mockedManagers, EnumSet<IManager.ManagerType> spiedManagers) {
	_daggerGraph = Graph.Initializer.init(mockedManagers, spiedManagers);
	}
	}

view raw MyContainer.java hosted with ❤ by GitHub

I created a test framework that allowed for each integration test to determine for each manager whether it would be implemented as a mock, using the standard implementation, or using a spied version of the standard implementation. With Dagger2, I was able to inject the appropriate component (test or production) at run-time. In Graph.java we see the dagger graph. IntegrationTestBase.java  specifies the list of managers to mock and spy as seen in the call to initGraph(), and ManagerTestDataModule injects the appropriate manager type (standard, mock, or spy):

	@Singleton
	@Component(modules = {ManagerTestDataModule.class})
	public interface Graph {
	void inject(ManagerController managerController);
	public final static class Initializer {
	public static Graph init(EnumSet<IManager.ManagerType> mockedManagers, EnumSet<IManager.ManagerType> spiedManagers) {
	return DaggerGraph.builder()
	.managerTestDataModule(new ManagerTestDataModule(mockedManagers, spiedManagers))
	.build();
	}
	}
	}

view raw Graph.java hosted with ❤ by GitHub

	public class IntegrationTestBase {
	@Inject protected GuiServerMgr _guiServerMgr;
	@Inject protected SacMgr _sacMgr;
	@Inject protected DomainMgr _domainMgr;
	@Inject protected MessageMgr _messageMgr;
	private MyContainer _container;
	@Before
	public void setup() {
	MockitoAnnotations.initMocks(this);
	_container = new MyContainer();
	_container.initGraph(getMockedManagers(), getSpiedManagers());
	_container.graph().inject(this);
	//...
	}
	//override in tests to setup mocks
	protected EnumSet<IManager.ManagerType> getMockedManagers() {
	return EnumSet.noneOf(IManager.ManagerType.class);
	}
	//override in tests to setup spies
	protected EnumSet<IManager.ManagerType> getSpiedManagers() {
	return EnumSet.noneOf(IManager.ManagerType.class);
	}
	}

view raw IntegrationTestBase.java hosted with ❤ by GitHub

	@Module
	public final class ManagerTestDataModule {
	private final EnumSet<IManager.ManagerType> _mockedManagers;
	private final EnumSet<IManager.ManagerType> _spiedManagers;
	public ManagerTestDataModule(EnumSet<IManager.ManagerType> mockedManagers, EnumSet<IManager.ManagerType>spiedManagers) {
	_mockedManagers = mockedManagers;
	_spiedManagers = spiedManagers;
	}
	@Provides @Singleton
	GuiServerMgr provideServerMgr() {
	if (_mockedManagers.contains(IManager.ManagerType.Server)) {
	return mock(GuiServerMgr.class);
	} else if (_spiedManagers.contains(IManager.ManagerType.Server)) {
	return spy(new GuiServerMgr());
	}
	return new GuiServerMgr();
	}
	//...
	}

view raw ManagerTestDataModule.java hosted with ❤ by GitHub

In the next post I will discuss an integration test that used this framework and a technique for synchronizing callbacks spanning thread boundaries.