Note that the 'getEmployeeInfo' method internally calls 'getConnectionFactory' method to get a reference to the actual connection factory. The 'getConnectionFactory' is a protected method, as shown below, and helps in making the bean testable.

protected ConnectionFactory getConnectionFactory() throws Exception {
     Context context = new InitialContext();
     return (ConnectionFactory) context.lookup
   (connectionFactoryJNDIName);
}

Running JUnit Tests Using Maven
We'll create a JUnit test case for 'GetEmployeeInfoBeanTest' under the 'src/test/java' directory with one 'testGetEmployeeInfo' test method as shown below:

public class GetEmployeeInfoBeanTest extends TestCase {
   public void testGetEmployeeInfo() throws Exception {
     String employeeId = "1000";
     GetEmployeeInfoBean employeeInfoBean = new GetEmployeeInfoBean() {
       protected ConnectionFactory getConnectionFactory() throws Exception {
     EmployeeInfoSPIManagedConnectionFactory managedConnectionFactory = new
     EmployeeInfoSPIManagedConnectionFactory();
       return (ConnectionFactory)managedConnectionFactory.createConnectionFactory();
     }
       };
     Employee employee = employeeInfoBean.getEmployeeInfo(employeeId);
     assertNotNull( employee );
     assertTrue( employee.getId().equals(employeeId) );
   }
}

To run the test cases using Maven, right-click on the module's POM file in Eclipse and then in 'Run As' options, select 'Maven2 test.' Maven will compile the Java files found in 'src/test/java' and execute JUnit test cases. The result of test case execution can be found in the console.

Skipping Maven Test Execution
Maven will execute test cases whenever a 'test' phase or any other phase that occurs after a 'test' phase in the Maven lifecycle management is invoked. For example, Maven will execute test cases when a Maven 'package' or 'install' phase is invoked. Maven does this by triggering 'maven-surefire-plugin' mojo at the time of the 'test' phase. This plug-in is responsible for executing the JUnit test cases found in the 'test-classes' directory in the project target build directory.

Test case execution can be explicitly skipped for compelling reasons. There are a couple of ways to make Maven skip test execution. One way is to explicitly include 'maven-surefire-plugin' in the POM file and set the value of the 'skip' configuration element to 'true' as shown here:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <configuration>
       <skip>true</skip>
    </configuration>
       </plugin>

If Maven is executed at the command line, test case execution can be skipped by setting the 'maven.test.skip' system property to 'true' as shown below:

mvn -Dmaven.test.skip=true install

Test cases can also be selectively skipped. This can be done by including 'maven-surefire-plugin' in the POM and explicitly specifying test classes using wildcard patterns in the 'excludes' configuration element as shown in the following snippet:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <configuration>
       <excludes>
          <exclude>**/*FunctionTest.java</exclude>
       </excludes>
    </configuration>
</plugin>

For more information on 'maven-surefire-plugin,' see the plug-in documentation at http://maven.apache.org/plugins/maven-surefire-plugin/index.html.

Reporting Source Code Test Coverage Using Maven
Code coverage is a measure of how thoroughly test cases exercise the main application source code. This is an indirect way of measuring the quality of the tests. Code coverage is a type of white-box testing as logical test assertions are made against the internals of our classes and not against other subsystems or components the current application may interact with. Code coverage helps to isolate logical paths in the source code that aren't exercised under the test.

There are many tools to measure code coverage. Cobertura is an open source tool that can be used to measure test coverage. Cobertura instruments the code base and tracks lines of code that are being executed and lines that aren't being executed as the test suite runs. Besides identifying untested code, Cobertura can also optimize code by flagging dead and unreachable code. Cobertura has a Maven plug-in that can be configured in the POM. The plug-in has a set of goals that can be invoked separately. For more information on Cobertura Maven plug-ins, refer to plug-in documentation at http://maven-plugins.sourceforge.net/maven-cobertura-plugin/. We'll add the following plug-in configuration to the 'ejb' module POM.

<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>cobertura-maven-plugin</artifactId>
    <version>2.0</version>
    <executions>
       <execution>
          <goals>
             <goal>cobertura</goal>
          </goals>
       </execution>
    </executions>
       </plugin>

• An Introduction to Maven - Part I
• An Introduction to Maven - Part II
• An Introduction to Maven - Part III