Define mock providers in the Spring application context

If an integration test requires usage of plugin providers, then a mock provider can be defined in the Spring application context using the Spring feature classed environment profile.

An environment profile allows for the definition of beans which are only accessible when the test is executed with the profile defined as being active.

To enable it:

• Define an environment profile named integration-test.
• Define mock providers and other test classes to be injected into test classes in the application context within the profile section:

      <!-- 
          definitions used by the integration tests. 
          Only available for test with @ActiveProfiles("integration-test") 
      -->
      <beans profile="integration-test" >
          <bean id="defaultOperation" class="com.alpha.pineapple.plugin.agent.operation.DefaultOperation" />              
          <bean id="coreAdministrationProvider" class="org.easymock.EasyMock" factory-method="createMock" primary="true" >
              <constructor-arg value="com.alpha.pineapple.admin.AdministrationProvider"/>
          </bean>
          <bean id="coreExecutionInfoProvider" class="org.easymock.EasyMock" factory-method="createMock">
              <constructor-arg value="com.alpha.pineapple.execution.ExecutionInfoProvider"/>
          </bean>
          <bean id="coreRuntimeDirectoryProvider" class="org.easymock.EasyMock" factory-method="createMock">
              <constructor-arg value="com.alpha.pineapple.io.file.RuntimeDirectoryProvider"/>
          </bean>                                                 
      </beans>
  

• A test class that need access to the mock providers (or other test classes to be injected) must be annotated with the @ActiveProfiles("integration-test"):

  @ActiveProfiles("integration-test")
  @RunWith(SpringJUnit4ClassRunner.class)
  @TestExecutionListeners({ DirectoryTestExecutionListener.class, DependencyInjectionTestExecutionListener.class })
  @ContextConfiguration(locations = { PLUGIN_APP_CONTEXT })
  public class CloneRepositoryCommandSystemTest {
  

Use the test context configuration to test classes which uses plugin providers

The plugin framework defines two plugin providers which can provide a plugin with useful information at runtime:

• An operation can gain access to a ExecutionInfo object which contains runtime information about the operation
• An operation can gain access to a RuntimeDirectoryProvider object which contains runtime information about which runtime directories Pineapple is using.

The providers are injected into the plugin application context as beans when Pineapple is initialized. During integration test of classes in an plugin project which uses these providers, the provider beans must be present in the plugin application context or the test will fail due to dependency injection errors.

The solution is to use the test context configuration named com.alpha.pineapple.testutils-config.xml which is defined in the the pineapple-test-utils project.

The test context configuration contains bean definitions of the plugin provider whose implementations are uninitialized EasyMock objects:

<!-- definition of MOCK runtime directory provider -->
<bean id="runtimeDirectoryProvider" class="org.easymock.EasyMock" factory-method="createMock">
        <constructor-arg value="com.alpha.pineapple.io.file.RuntimeDirectoryProvider"/>
</bean>

<!-- definition of MOCK execution info provider -->
<bean id="executionInfoProvider" class="org.easymock.EasyMock" factory-method="createMock">
        <constructor-arg value="com.alpha.pineapple.execution.ExecutionInfoProvider"/>
</bean>

To use test context configuration follow these steps:

1. Add a Maven dependency to the pineapple-test-utils project.
2. Add the com.alpha.pineapple.testutils-config.xml to the @ContextConfiguration annotation for the integration test case which required the presence of the provider classes. Example:

   package com.alpha.pineapple.plugin.helloworld.operation;
   
   import ...;
   
   /**
    * Integration test for the <code>TestDeployedConfiguration</code> class.  
    */
   @RunWith( SpringJUnit4ClassRunner.class )
   @ContextConfiguration( locations = { "/com.alpha.pineapple.testutils-config.xml", "/com.alpha.pineapple.plugin.helloworld-config.xml" } )
   public class TestDeployedConfigurationIntegrationTest
   {
           // class content goes here... 
   }               
   

3. Add a field in the test class to inject the provider to able to initialize it. Example:

   public class TestDeployedConfigurationIntegrationTest
   {
   
       /**
        * Mock Runtime directory provider.
        */
       @Resource
       RuntimeDirectoryProvider coreRuntimeDirectoryProvider;
    
   }               
   

4. Initialize the mock providers. The mock providers are now defined and injected into the classes in the plugin application context. But as mocks they are not initialized. They will not return any values when invoked. To complete the initialization add a field to the integration test to get the mock injected into the integration test class and then complete initialization of the mock provider in the setup() method and/or individual test methods. Please notice: the providers should reset between each test method by invoking:

   @Before
   public void setUp() throws Exception {
   
           // reset plugin provider
           EasyMock.reset(coreRuntimeDirectoryProvider);
           
           // more stuff here        
   }