Integration and Interoperability Facilities Framework: Client Libraries Management Model

Testing of client libraries

Unit Testing using My-Container

When

When needing to exercise the functional features of a CL against the targeted service, the most convenient way to do it is through in-container testing, using my-container. My-container can be used as a convenience for running the tests through Maven or in Eclipse against a small distribution and for simple interactions, not requiring contacting the outside world.

How

To test your CL calls to the targeted web service through my container you need to add the relevant dependencies to its POM, declaring their scope as test. Assuming our web service is marked by the artifact id 'sample-service-multi-core', the declarations are:

<dependency>
    <groupId>org.gcube.tools</groupId>
    <artifactId>my-container</artifactId>
    <version>1.0.0</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.gcube.samples</groupId>
    <artifactId>sample-service-multi-core</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <type>gar</type>
    <scope>test</scope>
</dependency>

Then you need to instruct Maven to install my-container and to deploy the service GAR in my-container for the service to be up and running. In the POM of the CL, instruct Maven to take it and place it in src/test/resources before the tests are ran:

<build>
<plugins>
	<plugin>
		<groupId>org.apache.maven.plugins</groupId>
		<artifactId>maven-dependency-plugin</artifactId>
		<version>2.3</version>
		<executions>
			<execution>
				<id>install-service</id>
				<phase>generate-test-resources</phase>
				<goals>
					<goal>copy-dependencies</goal>
				</goals>
				<configuration>
					<includeArtifactIds>sample-service-multi-core</includeArtifactIds>
					<overWriteSnapshots>true</overWriteSnapshots>
					<includeTypes>gar</includeTypes>
					<excludeTransitive>true</excludeTransitive>
					<outputDirectory>src/test/resources</outputDirectory>
					<stripVersion>true</stripVersion>
				</configuration>
			</execution>		
			<execution>
				<id>install-my-container</id>
				<phase>generate-test-resources</phase>
				<configuration>
					<artifactItems>
						<artifactItem>
							<groupId>org.gcube.tools</groupId>
							<artifactId>my-container</artifactId>
							<version>1.0.0</version>
							<type>tar.gz</type>
							<classifier>distro</classifier>
							<overWrite>false</overWrite>
							<outputDirectory>${project.basedir}</outputDirectory>
						</artifactItem>
					</artifactItems>
					<markersDirectory>${project.basedir}</markersDirectory>
				</configuration>
				<goals>
					<goal>unpack</goal>
				</goals>
			</execution>
		</executions>
	</plugin>
 
</plugins>
</build>

Note that when running the tests from the IDE, Eclipse does not go through all phases of a maven build, so either go to the shell and do:

> mvn generate-test-resources

so as to stage the resources necessary for testing, or do the same from within the IDE (simply running them as JUnit test won't do it).

JUnit Embedding

The testing code could be placed in the main() method of a test client, but the recommended approach is to embed it in a more suitable testing framework, such as JUnit. By doing so, we get a clear structure, proper integration with IDE and build tools, and a host of testing facilities which are standards de facto. We can simply annotate the test-suite as follows:

@RunWith(MyContainerTestRunner.class)
public class MyTestSuite {...}

MyContainerTestRunner is a JUnit 4 test runner which replaces the default one to:

• create, configure, and start an instance of MyContainer before any other code in the test suite is executed by JUnit
• inject into the test-suite any port-type implementation or enpoint reference which we may need
• clearly name the output of any test with the name of the test itself
• stop the underlying instance of MyContainer after any other code in the test suite is executed by JUnit

Of course, we need to provide our Gar/s to the underlying MyContainer. We do that indirectly, by exposing static fields appropriately typed and annotated. The test runner will recognise these fields and pass the information they provide on to the instance of MyContainer that the runner handles, e.g.:

@RunWith(MyContainerTestRunner.class)
public class MyTestSuite {
    @Deployment
    static Gar myGar = new Gar(new File("src/test/resources/sample-service-multi-core.gar"));
 
    @Test
    public void someTest() throws Exception {...}
 
    @Test
    public void anotherTest() throws Exception {...}
    ...