Arquillian Extension REST - Rest Client Annotations on TestMethods

RestClientTestClass.java

/*
 * JBoss, Home of Professional Open Source
 * Copyright 2011 Red Hat Inc. and/or its affiliates and other contributors
 * as indicated by the @authors tag. All rights reserved.
 * See the copyright.txt in the distribution for a
 * full listing of individual contributors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * http://www.apache.org/licenses/LICENSE-2.0
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.jboss.arquillian.extension.rest;

import java.util.List;

import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response.Status;

import org.jboss.arquillian.container.test.api.Deployment;
import org.jboss.arquillian.extension.rest.app.CustomerResource;
import org.jboss.arquillian.extension.rest.app.model.Customer;
import org.jboss.arquillian.extension.rest.app.persistence.EntityManagerProducer;
import org.jboss.arquillian.extension.rest.app.rs.JaxRsActivator;
import org.jboss.arquillian.junit.Arquillian;
import org.jboss.resteasy.client.ClientResponse;
import org.jboss.resteasy.util.GenericType;
import org.jboss.shrinkwrap.api.ShrinkWrap;
import org.jboss.shrinkwrap.api.asset.EmptyAsset;
import org.jboss.shrinkwrap.api.spec.WebArchive;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;

/**
 * Arquillian Extension REST API Test Case
 * 
 * Annotate the TestClass's TestMethods with JAX-RS Client annotations.
 * 
 * Executes the REST request in the background for so to inject back the Response into the TestMethods arguments.  
 *
 * @author <a href="mailto:aslak@redhat.com">Aslak Knutsen</a>
 * @version $Revision: $
 */
@RunWith(Arquillian.class)
public class RestClientTestClass
{
   @Deployment(testable = false)
   public static WebArchive create() {
      return ShrinkWrap.create(WebArchive.class)
            .addPackage(Customer.class.getPackage())
            .addClasses(EntityManagerProducer.class, CustomerResource.class, JaxRsActivator.class)
            .addAsResource("import.sql")
            .addAsResource("test-persistence.xml", "META-INF/persistence.xml")
            .addAsWebInfResource(EmptyAsset.INSTANCE, "beans.xml");
   }

   @Test @GET @Path("rest/customer") @Consumes(MediaType.APPLICATION_XML)
   public void shouldBeAbleToListAllCustomers(ClientResponse<List<Customer>> response) 
   {
      Assert.assertEquals(Status.OK.getStatusCode(), response.getStatus());
      
      List<Customer> customers = response.getEntity(new GenericType<List<Customer>>(){});
      Assert.assertEquals(2, customers.size());
   }

   @Test @GET @Path("rest/customer/1") @Consumes(MediaType.APPLICATION_XML)
   public void shouldBeAbleToListACustomer(ClientResponse<Customer> response) 
   {
      Assert.assertEquals(Status.OK.getStatusCode(), response.getStatus());
      
      Customer customers = response.getEntity();
      Assert.assertEquals(1, customers.getId().intValue());
   }
}

I'll keep an eye on the JaxRS 2.0 client API to imagine how can be a REST test using JaxRS annotations and I'll probably create my own. I'll let you know when I'll push on github the first draft. Thx

Hey,

I've created some annotations based on the JaxRS 2.0 client API. What do you think about something like this:

package org.jboss.arquillian.example;

import org.jboss.arquillian.container.test.api.Deployment;
import org.jboss.arquillian.junit.Arquillian;
import org.jboss.arquillian.rest.annotations.*;
import org.jboss.arquillian.rest.annotations.configuration.*;
import org.jboss.shrinkwrap.api.ShrinkWrap;
import org.jboss.shrinkwrap.api.asset.EmptyAsset;
import org.jboss.shrinkwrap.api.spec.WebArchive;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import static org.fest.assertions.Assertions.assertThat;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;

/**
 * Arquillian Extension REST API Test Case
 *
 * Annotate the TestClass's TestMethods with JAX-RS Client annotations.
 *
 * Executes the REST request in the background for so to inject back the Response into the TestMethods arguments.
 *
 * @author <a href="mailto:jeremy.herault@gmail.com">Jeremy Herault</a>
 */
@RunWith(Arquillian.class)
public class RESTExtensionTest {

    @POSTData(id=1)
    public Person data1;

    @Deployment(testable = false)
    public static WebArchive create() {
        return ShrinkWrap.create(WebArchive.class)
                .addPackage(Person.class.getPackage())
                //...
                ;
    }

    @Before
    @Register(provider=PersonProvider.class)
    public void setup(){

        data1 = new Person();
        //init data1 for the post request test
    }

    @Test @GET @Path("/person")
    @QueryParams({@QueryParam(name = "hair", value = "blond"),@QueryParam(name = "eye", value = "blue")})
    @Request({MediaType.APPLICATION_JSON})
    @Cookies({@Cookie(name="connected", value="true")})
    public void test1(Person person){

        /*
         This is equivalent to:

         Client client = ClientFactory.newClient();
         Target target = client.target("http://<host>:<port>/<base-url>/person");
         target.configuration().register(PersonProvider.class);
         Person person = target.queryParam("hair","blond")
               .queryParam("eye","blue")
               .request(MediaType.APPLICATION_JSON)
               .cookie(new NewCookie("connected","true"))
               .get(Person.class);
         */

        assertThat(person.eye).isEqualTo("blue");
        assertThat(person.hair).isEqualTo("blond");
    }

    @Test @POST @Path("/person")
    @POSTDatas({1})
    @HeaderParams({@HeaderParam(name="User-Agent", value="Arquillian REST extension :-)")})
    public void test2(String response){

       assertThat(response).isEqualTo("OK: Received a new person from Arquillian REST extension, really cool");
    }
}

I think the Client object could be injected in particular cases (set Features, set properties...) but in most cases these annotations should be enough.
I'll take a look to the REST extension engine now and make this test possible.

Started a post on the dev forum, we can move the discussion there: https://community.jboss.org/thread/199281 :)

ok. Thx, I'll commit my work today (just a little draft, not working) :)

Do you have an example how to test a REST service today? I'm using the following example code which starts up without issues but the REST URL is not reachable:

@RunWith(Arquillian.class)
public class SampleTest
{
@deployment(testable = false)
public static WebArchive createDeployment()
{
WebArchive webArchive = null;

    webArchive = ShrinkWrap
            .create(WebArchive.class, "sample.war")
            .addClass(sample.class)
            .setWebXML("WEB-INF/web.xml");

    System.out.println("webArchive " + webArchive.getContent().toString());

    return webArchive;
}

@Test
public void testRestService(@ArquillianResource URL baseUrl)
        throws Exception
{
    System.out.println("URL to call: " + baseUrl);

    String result = null;

    try
    {
        result = ClientProxyFactory.create(sample.class,
                baseUrl.toString()).sampleService();

    } catch (Exception e)
    {
        System.out.println(e.getLocalizedMessage());
    }
}

The referenced web.xml contains the following configuration to activate REST:

<listener>
    <listener-class>org.jboss.resteasy.plugins.server.servlet.ResteasyBootstrap</listener-class>
</listener>
<servlet>
    <servlet-name>Resteasy</servlet-name>
    <servlet-class>org.jboss.resteasy.plugins.server.servlet.HttpServletDispatcher</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>Resteasy</servlet-name>
    <url-pattern>/restws/*</url-pattern>
</servlet-mapping>