May 6, 2016

Custom Restito Sequenced Stub Action

In this post I show how to write custom Restito Action to mock a single REST endpoint to response differently even is subsequent requests are identical.

Restito is lightweight testing framework that provides a Java DSL to:
  • mimic REST server behavior,
  • perform verification against happened calls.
It is based on Grizzly HTTP Server. See developer's guide for more details about all supported features.

Let's say I want to test business login of application that calls following REST API:
  1. Gets list of all open comments (GET /comments),
  2. Archives each comment that is older than a month (DELETE /comments/{id}),
  3. Lists all remaining open comments (GET /comments).

import java.util.List;

import com.xebialabs.restito.builder.ensure.EnsureHttp;
import com.xebialabs.restito.support.junit.StartServer;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;

import static com.xebialabs.restito.builder.stub.StubHttp.whenHttp;
import static com.xebialabs.restito.semantics.Action.contentType;
import static com.xebialabs.restito.semantics.Action.status;
import static com.xebialabs.restito.semantics.Action.stringContent;
import static com.xebialabs.restito.semantics.Condition.delete;
import static com.xebialabs.restito.semantics.Condition.get;
import static org.glassfish.grizzly.http.util.HttpStatus.NO_CONTENT_204;
import static org.glassfish.grizzly.http.util.HttpStatus.OK_200;
import static org.hamcrest.Matchers.hasSize;
import static org.junit.Assert.assertThat;

public class MyAppTest {

    private static final String GET_COMMENTS_BEFORE =
              "{\"comments\":[\n"
            + "    {\"id\" : 1, \"content\" : \"Happy New Year ...\", \"date\" : \"2016-01-01\"},\n"
            + "    {\"id\" : 2, \"content\" : \"Happy Valentine...\", \"date\" : \"2016-02-14\"},\n"
            + "    {\"id\" : 3, \"content\" : \"I like Restito ...\", \"date\" : \"2016-05-06\"}\n"
            + "]}";
    private static final String GET_COMMENTS_AFTER =
              "{\"comments\":[\n"
            + "    {\"id\" : 3, \"content\" : \"I like Restito ...\", \"date\" : \"2016-05-06\"}\n"
            + "]}";

    @Rule
    public StartServer startServer = new StartServer();

    @Test
    public void testArchiveOldComments() {
        // 1. Stub for: Gets list of all open comments (GET /comments):
        whenHttp(startServer.getServer()).
                match(get("/comments")).
                then(status(OK_200),
                     contentType("application/json"),
                     stringContent(GET_COMMENTS_BEFORE)).
                mustHappen();
        // 2. Stub for: Archives each comment that is older than a month (DELETE /comments/{id}):
        whenHttp(startServer.getServer()).
                match(delete("/comments/1")).
                then(status(NO_CONTENT_204)).
                mustHappen();
        whenHttp(startServer.getServer()).
                match(delete("/comments/2")).
                then(status(NO_CONTENT_204)).
                mustHappen();
        // 3. Stub for: Lists all remaining open comments (GET /comments):
        whenHttp(startServer.getServer()).
                match(get("/comments")).
                then(status(OK_200),
                     contentType("application/json"),
                     stringContent(GET_COMMENTS_AFTER)).
                mustHappen();

        // call business logic
        MyApp myApp = new MyApp();
        List<Comment> comments = myApp.archiveOldComments();

        // remaining 1 comment:
        assertThat(comments, hasSize(1));
        // ensure that each stubs has been invoked:
        EnsureHttp.ensureHttp(startServer.getServer()).gotStubsCommitmentsDone();
    }

}

But this test fails because DELETE stubs are not invoked.

MyAppTest > testArchiveOldComments FAILED
    java.lang.AssertionError at MyAppTest.java:72

Expected stub com.xebialabs.restito.semantics.Stub@775449c1 to be called 1 times, called 0 times instead
java.lang.AssertionError: Expected stub com.xebialabs.restito.semantics.Stub@775449c1 to be called 1 times, called 0 times instead

Note: You can see the error output is not comprehensive. It is known issue, see https://github.com/mkotsur/restito/issues/45.

The reason why DELETE methods are not invoked is that the first GET call does not return JSON with 3 comments but just 1 (JSON in GET_COMMENTS_AFTER String). It means that the second GET /comments stub overrides the first one. Or, the first stub that returns JSON with 3 comments (GET_COMMENTS_BEFORE String) is ignored because the match Conditions for both stubs are identical.

Unfortunately Restito does not support directly this use case. Fortunately you can create custom Action or Condition. Described use-case can be solved by custom Action.

import java.util.LinkedList;
import java.util.Queue;

import com.xebialabs.restito.semantics.Action;
import com.xebialabs.restito.semantics.Function;
import org.glassfish.grizzly.http.server.Response;

public class SequencedAction implements Function<Response, Response> {
    private Queue<Action> queue = new LinkedList<>();

    public SequencedAction(Action... actions) {
        for (Action action : actions) {
            this.queue.offer(action);
        }
    }

    @Override
    public Response apply(Response input) {
        Action next = queue.poll();
        if (next != null) {
            input = next.apply(input);
        }
        return input;
    }
}

Custom SequencedAction keeps a queue of not yet processed Actions and polls just one available Action from the queue in apply method. I.e. subsequent SequencedAction.apply invocation behaves differently. If the queue is empty the SequencedAction.apply does nothing like noop action.

So now I can update test method to use custom action.

@Test
public void testArchiveOldComments() {
    // 1. Stub for both: Gets list of all open comments (GET /comments):
    whenHttp(startServer.getServer()).
            match(get("/comments")).
            then(status(OK_200),
                 contentType("application/json"),
                 // use custom action:
                 Action.custom(new SequencedAction(
                         // the first get: returns 3 comments
                         stringContent(GET_COMMENTS_BEFORE),
                         // the second get: returns 1 comment
                         stringContent(GET_COMMENTS_AFTER)
                 ))).
            // 2 actions in sequence:
            mustHappen(2);
    // 2. Stub for: Archives each comment that is older than a month (DELETE /comments/{id}):
    whenHttp(startServer.getServer()).
            match(delete("/comments/1")).
            then(status(NO_CONTENT_204)).
            mustHappen();
    whenHttp(startServer.getServer()).
            match(delete("/comments/2")).
            then(status(NO_CONTENT_204)).
            mustHappen();

    // call business logic
    MyApp myApp = new MyApp();
    List<Comment> comments = myApp.archiveOldComments();

    // remaining 1 comment:
    assertThat(comments, hasSize(1));
    // ensure that each stubs has been invoked:
    EnsureHttp.ensureHttp(startServer.getServer()).gotStubsCommitmentsDone();
}

And the test is fixed.

You are right, it is a little bit too verbose to use custom action. So I have decided to contribute the sequenced action directly to Restito Action, method sequence, see or comment or vote for my GitHub pull request: https://github.com/mkotsur/restito/pull/49. ­čśç

Enjoy,
Libor

March 27, 2016

How to run standalone Java EE MVC application

This project demonstrates how to create standalone Java EE MVC application.

MVC is newly developed Java EE JSR 371: Model-View-Controller (MVC 1.0) Specification.
The MVC API defines an action-oriented Web framework as an alternative to the component-oriented JSF. In an action-oriented framework, developers are responsible for all the controller logic and are given full control of the URI space for their application. 
The MVC API is layered on top of JAX-RS over Servlets and integrates with existing EE technologies like CDI and Bean Validation.
MVC spec is going to be part of next Java EE 8. MVC reference implementation named Ozark is hosted on java.net. MVC depends on Servlets, JAX-RS and CDI. I've chosen to use UndertowJersey and Weld. And DeltaSpike as CDI extension library. Finally, Gradle to build and run the project.

ext {
    undertowVersion = '1.3.18.Final'
    weldVersion = '2.3.3.Final'
    deltaspikeVersion = '1.5.4'
    jerseyVersion = '2.22.2'
    ozarkVersion = '1.0.0-m02'
}
task wrapper(type: Wrapper) {
    gradleVersion = '2.12'
}

Standalone CDI container

Weld contains module to support Java SE applications. Together with Apache DeltaSpike Java SE & Weld module:

dependencies {
    compile "org.jboss.weld.se:weld-se:$weldVersion"
    compile "org.apache.deltaspike.cdictrl:deltaspike-cdictrl-weld:$deltaspikeVersion"

it is easy to bootstrap and shutdown CDI container:

import javax.enterprise.context.ApplicationScoped;
import org.apache.deltaspike.cdise.api.CdiContainer;
import org.apache.deltaspike.cdise.api.CdiContainerLoader;
import org.jboss.weld.servlet.WeldInitialListener;
import org.jboss.weld.servlet.WeldTerminalListener;

public class Main {

    static CdiContainer init() throws ServletException, NoSuchMethodException {
        CdiContainer cdiContainer = CdiContainerLoader.getCdiContainer();

        cdiContainer.boot();
        cdiContainer.getContextControl().startContext(ApplicationScoped.class);

        initServlet();

        return cdiContainer;
    }

    static void destroy(CdiContainer cdiContainer) {
        cdiContainer.getContextControl().stopContext(ApplicationScoped.class);
        cdiContainer.shutdown();
    }

...

You can see we also start and stop CDI ApplicationScoped scope.

Initialize Servlet

Next we need to register Jersey ServletContainer as Undertow servlet:

dependencies {
    compile "io.undertow:undertow-core:$undertowVersion"
    compile "io.undertow:undertow-servlet:$undertowVersion"

    compile "org.glassfish.jersey.core:jersey-server:$jerseyVersion"
    compile "org.glassfish.jersey.containers:jersey-container-servlet-core:$jerseyVersion"
    compile "org.glassfish.jersey.ext.cdi:jersey-cdi1x-servlet:$jerseyVersion"

import javax.servlet.Servlet;
import javax.servlet.ServletException;

import io.undertow.Undertow;
import io.undertow.servlet.Servlets;
import io.undertow.servlet.api.DeploymentInfo;
import io.undertow.servlet.api.DeploymentManager;
import io.undertow.servlet.api.ServletContainer;
import io.undertow.servlet.api.ServletInfo;

import org.jboss.weld.servlet.WeldInitialListener;
import org.jboss.weld.servlet.WeldTerminalListener;

public class Main {

    ...

    private static void initServlet() throws ServletException, NoSuchMethodException {
        DeploymentInfo deploymentInfo = new DeploymentInfo()
                .addListener(Servlets.listener(WeldInitialListener.class))
                .addListener(Servlets.listener(WeldTerminalListener.class))
                .setContextPath("/")
                .setDeploymentName("standalone-javax-mvc-app")
                .addServlets(
                        createServletInfo("/resources/*", "JAX-RS Resources", org.glassfish.jersey.servlet.ServletContainer.class)
                )
                .setClassIntrospecter(CdiClassIntrospecter.INSTANCE)
                .setAllowNonStandardWrappers(true)
                .setClassLoader(ClassLoader.getSystemClassLoader());

        ServletContainer servletContainer = Servlets.defaultContainer();
        DeploymentManager deploymentManager = servletContainer.addDeployment(deploymentInfo);
        deploymentManager.deploy();

        Undertow server = Undertow.builder()
                .addHttpListener(8080, "0.0.0.0")
                .setHandler(deploymentManager.start())
                .build();
        server.start();
    }

    private static ServletInfo createServletInfo(String mapping, String servletName, Class<? extends Servlet> servlet)
            throws NoSuchMethodException {
        ServletInfo servletInfo = Servlets
                .servlet(servletName, servlet)
                .setAsyncSupported(true)
                .setLoadOnStartup(1)
                .addMapping(mapping);
        servletInfo.setInstanceFactory(CdiClassIntrospecter.INSTANCE.createInstanceFactory(servlet));

        return servletInfo;
    }
}

Important part is registering of Weld Servlet listeners: WeldInitialListener and WeldTerminalListener.

The instance of Jersey ServletContainer is provided as ApplicationScoped bean by custom CdiProducer using CdiClassIntrospecter.

import javax.enterprise.inject.Produces;

import org.glassfish.jersey.server.ResourceConfig;
import org.glassfish.jersey.servlet.ServletContainer;

@ApplicationScoped
public class CdiProducer {

    private long helloCounter;

    @Produces
    @ApplicationScoped
    public ServletContainer createServletContainer() {
        final ResourceConfig resourceConfig = new ResourceConfig();
        resourceConfig.register(HelloController.class);
        resourceConfig.property("javax.mvc.engine.ViewEngine.viewFolder", "WEB-INF/views/");

        return new ServletContainer(resourceConfig);
    }

    ...

You can see we need to customize "javax.mvc.engine.ViewEngine.viewFolder" property to support standalone application class-path behaviour.

CdiClassIntrospecter implements Undertow ClassIntrospecter interface and just delegates to CDI.

MVC

Now you can provide MVC @Controller methods:

dependencies {
    compile "org.glassfish.ozark:ozark:$ozarkVersion"
    compile "org.glassfish.ozark.ext:ozark-mustache:$ozarkVersion"

import javax.enterprise.context.ApplicationScoped;
import javax.inject.Inject;
import javax.mvc.Models;
import javax.mvc.annotation.Controller;
import javax.mvc.annotation.View;
import javax.ws.rs.DefaultValue;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;

@Path("hello")
@ApplicationScoped
public class HelloController {

    @Inject
    private Models models;

    @GET
    @Controller
    @Produces("text/html")
    @View("hello.mustache")
    public void hello(@QueryParam("user") @DefaultValue("World") String user) {
        models.put("user", user);
    }

}

You can see I've chosen to use Mustache template engine, see hello.mustache:

<html>
    <head>
        <title>Hello</title>
    </head>
    <body>
        <h1>Hello {{user}}!</h1>
    </body>
</html>

Sources

Complete project sources are available on GitHub, https://github.com/shamoh/standalone-javax-mvc.

The easiest way how to run the project is:


gradlew run

The application is then available on: http://localhost:8080/resources/hello?user=Libor.