JAX-RS resources are configured through the resource path, which suffixes the application path. Here is the constitution of the URL.

http://<hostname>:<port>/<web_context>/<application_path>/<resource_path>

The <hostname> is the host name of the server. The <port> refers to the port number, which is optional and the default port is 80. The <web_context> is the Servlet context, which is the context for the deployed web application. The <application_path> is the configuration URI pattern as specified in the web deployment descriptor @ApplicationPath or the Servlet configuration of Application type. The <resource_path> is the resource path to REST style resource.

The final fragment <resource_path> defines the URL pattern that maps a REST style resource. The resource path is configured by annotation javax.ws.rs.Path.

Let us write a unit test to verify the simplest JAX-RS service. It follows a REST style resource around a list of books. There are only four books in this endpoint and the only thing the user/client can do at the start is to access the list of books by author and title. The client invokes the REST style endpoint, otherwise known as a resource with an HTTP GET request.

The following is the code for the class RestfulBookService:

package je7hb.jaxrs.basic;
import javax.annotation.*;
import javax.ws.rs.*;
import java.util.*;

@Path("/books")
public class RestfulBookService {
  private List<Book> products = Arrays.asList(new Book("Sir Arthur Dolan Coyle","Sherlock Holmes and the Hounds of the Baskervilles"),
    new Book("Dan Brown", "Da Vinci Code"),
    new Book("Charles Dickens", "Great Expectations"),
    new Book("Robert Louis Stevenson", "Treasure Island"));

  @GET
  @Produces("text/plain")
  public String getList() {
    StringBuffer buf = new StringBuffer();
    for (Book b: products) { 
      buf.append(b.title); buf.append('
'), }
    return buf.toString();
  }

@PostConstruct
public void acquireResource() { /* ... */ }
@PreDestroy
public void releaseResource() { /* ... */ }

static class Book {
  public final String author;
  public final String title;
  Book(String author, String title) {
    this.author = author;
    this.title = title;
    }
  }
}

The annotation @javax.ws.rs.Path declares the class as a REST style end-point for a resource. The @Path annotation is assigned to the class itself. The path argument defines the relative URL pattern for this resource, namely/books.

The method getList() is the interesting one. It is annotated with both @javax.ws.rs.GET and @javax.ws.rs.Produces.

The @GET is one of the six annotations that conform to the HTTP web request methods. It indicates that the method is associated with HTTP GET protocol request.

The @Produces annotation indicates the MIME content that this resource will generate. In this example, the MIME content is text/plain.

The other methods on the resource bring CDI into the picture. In the example, we are injecting post construction and pre destruction methods into the bean.

This is the only class that we require for a simple REST style application from the server side. With an invoking of the web resource with a HTTP GET Request like http://localhost:8080/mywebapp/rest/books we should get a plain text output with list of titles like the following:

Sherlock Holmes and the Hounds of the Baskervilles
Da Vinci Code
Great Expectations
Treasure Island

So do we test this REST style interface then? We could use Arquillian Framework directly, but this means our tests have to be built specifically in a project and it complicates the build process. Arquillian uses another open source project in the JBoss repository called ShrinkWrap . The framework allows the construction of various types of virtual Java archives in a programmatic fashion. We use ShrinkWrap just to build a Web Archive, and the code is really quite straightforward, because we have already seen it in previous chapters.

Let's look at the unit test class RestfulBookServiceTest in the following code:

package je7hb.jaxrs.basic;
// import omitted

public class RestfulBookServiceTest {
  @Test
  public void shouldAssembleAndRetrieveBookList() 
  throws Exception {
    WebArchive webArchive = ShrinkWrap.create(WebArchive.class, "test.war")
      .addClasses(RestfulBookService.class)
      .setWebXML(new File("src/main/webapp/WEB-INF/web.xml"))
      .addAsWebInfResource(EmptyAsset.INSTANCE, "beans.xml");
    File warFile = new File(webArchive.getName());
    new ZipExporterImpl(webArchive)
      .exportTo(warFile, true);
    SimpleEmbeddedRunner runner =SimpleEmbeddedRunner.launchDeployWarFile(warFile, "mywebapp", 8080);
    try {
      URL url = new URL("http://localhost:8080/mywebapp/rest/books");
      InputStream inputStream = url.openStream();
      BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
      List<String> lines = new ArrayList<>();
      String text = null;
      int count=0;
      while ( ( text = reader.readLine()) != null ) {
        lines.add(text);
        ++count;
        System.out.printf("**** OUTPUT **** text[%d] = %s
", count, text );
      }
        assertFalse( lines.isEmpty() );
        assertEquals("Sherlock Holmes and the Hounds of the Baskervilles", lines.get(0));
        assertEquals("Da Vinci Code", lines.get(1));
        assertEquals("Great Expectations", lines.get(2));
        assertEquals( "Treasure Island", lines.get(3) );
    }
    finally {
      runner.stop();
    }
  }
}

In the unit test method, shouldAssembleAndRetrieveBookList(), we first assemble a virtual web archive with an explicit name test.war. The WAR file contains the RestfulBookService services, the Web deployment descriptor file web.xml and an empty beans.xml file, which if you remember is only there to trigger the CDI container into life for this web application.

With the virtual web archive, we export the WAR as a physical file with the utility ZipExporterImpl class from ShinkWrap library, which creates the file test.war in the project root folder.

Next, we fire up the SimpleEmbeddedRunner utility that is part of the book's appendix. It deploys the web archive to an embedded GlassFish container. Essentially, this is the boilerplate to get to deliver a test result.

We, then, get to the heart of the test itself; we construct a URL to invoke the REST style endpoint, which is http://localhost:8080/mywebapp/rest/books. We read the output from the service endpoint with Java standard I/O line by line into a list collection of Strings. Once we have a list of collections, then we assert each line against the expected output from the rest style service.

Because we acquired an expensive resource, like an embedded Glassfish container, we are careful to release it, which is the reason, why we surround critical code with a try-finally block statement. When the execution comes to end of test method, we ensure the embedded GlassFish container is shut down.