fr.gouv.vitam.common.server.application.junit

Class VitamJerseyTest<A>

java.lang.Object

fr.gouv.vitam.common.server.application.junit.VitamJerseyTest<A>

Type Parameters:

A - Application class

What is already implemented:

• A mocked ExpectedResults interface
• The start and stop of the application at each run
• _client containing MockOrRestClient interface that will be closed at each run
• The reservation and free of network port through JunitHelper used to start the application (the port is accessible through getServerPort() method)

You must implement the following:

• _getClient() method that returns the client to use and close at each run
• setup() method (for instance to set your own mock if default one is not enough)
• startVitamApplication(int reservedPort) to create the application and starting it (method application.start()) using the reserved port
• Define your own Application class (to register your own Resource) based on AbstractVitamApplication
• Define your own ApplicationConfiguration (or simply extend DefaultVitamApplicationConfiguration)

You may implement:

• Your own Mock

Example:

 
 public class MyClientTest extends VitamJerseyTest {
  private static final String RESOURCE_PATH = "...";
  // You own factory
  TestVitamClientFactory factory =
    new TestVitamClientFactory(8080, RESOURCE_PATH);
  // Store your own client
  TestClient client;

  // ************************************** //
  // Start of VitamJerseyTest configuration //
  // ************************************** //
  // Override the beforeTest if necessary (not mandatory)
  @Override
  public void beforeTest() throws VitamApplicationServerException {
    // anything before test
  }

  // Override the afterTest if necessary (not mandatory)
  @Override
  public void afterTest() throws VitamApplicationServerException {
   // anything after test
  }

  // This method MUST be created. Assign your own client (keep it) and returns it.
  @Override
  protected MockOrRestClient _getClient() throws VitamApplicationServerException {
    try {
       // Fix your factory
       factory.changeServerPort(getServerPort());
       client = factory.getClient();
       return client;
    } catch (final VitamClientException e) {
       throw new VitamApplicationServerException(e);
    }
  }

  // Setup test to setup anything if necessary (not mandatory)
  @Override
  public void setup() {
    // nothing
  }

  // Define the getApplication to return your Application using the correct Configuration
  @Override
  public StartApplicationResponse startVitamApplication(int reservedPort) {
    // Use your own ApplicationConfiguration if necessary, or just copy the following
    final TestVitamApplicationConfiguration configuration =
      new TestVitamApplicationConfiguration();

    // DEFAULT_XML_CONFIGURATION_FILE could be used as default XML file, but you can specify another
    configuration.setJettyConfig(DEFAULT_XML_CONFIGURATION_FILE);

    // Use your own application or just copy the following
    final AbstractApplication application = new AbstractApplication(configuration);
    // Start the application (mandatory)
    try {
       application.start();
    } catch (final VitamApplicationServerException e) {
       SysErrLogger.FAKE_LOGGER.ignoreLog(e);
       throw new IllegalStateException("Cannot start the application", e);
    }
    // Return the response as follow
    return new StartApplicationResponse()
       .setServerPort(application.getVitamServer().getPort())
       .setApplication(application);
  }

  // Define your Application class (or reuse it), in particular set your own MockResources or just copy the following
  public final class AbstractApplication
    extends AbstractVitamApplication {
    protected AbstractApplication(TestVitamApplicationConfiguration configuration) {
       super(TestVitamApplicationConfiguration.class, configuration);
    }

    @Override
    protected void registerInResourceConfig(ResourceConfig resourceConfig) {
       resourceConfig.registerInstances(new MockResource(mock));
    }
  }

  // Define your Configuration class (or reuse it) or just copy the following
  public static class TestVitamApplicationConfiguration extends DefaultVitamApplicationConfiguration {
    // Empty for this example
  }

  // Define your Resource class
  @Path(RESOURCE_PATH)
  public static class MockResource extends ApplicationStatusResource {
    private final ExpectedResults expectedResponse;

    public MockResource(ExpectedResults expectedResponse) {
       this.expectedResponse = expectedResponse;
    }
    ...
  }
  // ************************************ //
  // End of VitamJerseyTest configuration //
  // ************************************ //

  // Use client to act on AbstractApplication

 }
        

All Implemented Interfaces:

VitamApplicationTestFactory<A>

public abstract class VitamJerseyTest<A>
extends Object
implements VitamApplicationTestFactory<A>

Class to extend for Junit as JerseyTest.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	VitamJerseyTest.ExpectedResults Default ExpectedResults

Nested classes/interfaces inherited from interface fr.gouv.vitam.common.junit.VitamApplicationTestFactory

VitamApplicationTestFactory.StartApplicationResponse<A>

Field Summary

Fields

Modifier and Type	Field and Description
static String	DEFAULT_XML_CONFIGURATION_FILE Default XML Configuration to use (from JunitHelper)
static String	HOSTNAME Localhost
protected VitamJerseyTest.ExpectedResults	mock

Constructor Summary

Constructors

Constructor and Description
VitamJerseyTest(VitamClientFactoryInterface<?> factory) Create the VitamJerseyTest, calling setup first. Note: will call factory.changeServerPort(getServerPort()) automatically before creating the client.

Method Summary

Modifier and Type	Method and Description
void	afterTest() To be extended if necessary (equivalent to @After)
void	beforeTest() To be extended if necessary (equivalent to @Before)
void	endApplication() End the application only
void	endTest() End the Application.
VitamApplicationInterface<?,?>	getApplication()
MockOrRestClient	getClient()
VitamClientFactoryInterface<?>	getFactory()
int	getServerPort()
void	setup() Do anything necessary before starting the application and before getting the server port.
void	startTest() Start the Application.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface fr.gouv.vitam.common.junit.VitamApplicationTestFactory

startVitamApplication

Field Detail

DEFAULT_XML_CONFIGURATION_FILE

public static final String DEFAULT_XML_CONFIGURATION_FILE

Default XML Configuration to use (from JunitHelper)

See Also:

Constant Field Values

HOSTNAME

public static final String HOSTNAME

Localhost

See Also:

Constant Field Values

mock

protected VitamJerseyTest.ExpectedResults mock

Constructor Detail

VitamJerseyTest

public VitamJerseyTest(VitamClientFactoryInterface<?> factory)

Create the VitamJerseyTest, calling setup first.
Note: will call factory.changeServerPort(getServerPort()) automatically before creating the client.

Parameters:

factory - the Client Factory to use

Throws:

VitamApplicationServerException - when starting server exception occurred

IllegalStateException - if the start is incorrect

Method Detail

getFactory

public VitamClientFactoryInterface<?> getFactory()

Returns:

the factory to use

getClient

public MockOrRestClient getClient()

Returns:

the client using the factory

setup

public void setup()

Do anything necessary before starting the application and before getting the server port. Called before startVitamApplication and _getClient()

getServerPort

public final int getServerPort()

Returns:

the current port

getApplication

public final VitamApplicationInterface<?,?> getApplication()

Returns:

the current application

startTest

public final void startTest()
                     throws VitamApplicationServerException

Start the Application.

Throws:

VitamApplicationServerException - when starting server exception occurred

beforeTest

public void beforeTest()
                throws VitamApplicationServerException

To be extended if necessary (equivalent to @Before)

Throws:

VitamApplicationServerException - when starting server exception occurred

endApplication

public final void endApplication()
                          throws VitamApplicationServerException

End the application only

Throws:

VitamApplicationServerException

endTest

public final void endTest()
                   throws VitamApplicationServerException

End the Application.

Throws:

VitamApplicationServerException - stopping server exception occurred

afterTest

public void afterTest()
               throws VitamApplicationServerException

To be extended if necessary (equivalent to @After)

Throws:

VitamApplicationServerException - when stopping server exception occurred