public
Created

Arquillian Extension REST - Rest Client Annotations on TestMethods

  • Download Gist
RestClientTestClass.java
Java
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83
/*
* 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());
}
}

Hey Alsak, did you start something on the REST Arquillian extension?
I'll be happy to contribute, but for now, I don't know how works an Arquillian extension and where to start, is there any docs somewhere?

I have the code for the example above if interested, not pushed it to github yet. The idea was to move form the RestEasy Proxies to the JaxRs 2.0 Proxies when they were released. But it seems JaxRS 2.0 won't have Proxy support like RestEasy, but a pure Client API instead, where you're building up the request 'header by header'. Not sure how that will fit in to this picture. There might still be things we can do to simplify REST and JaxRS 2.0 that makes sense from a testing perspective, but personally I don't know enough about it to comment at this point.

If you want to head up a little research project on how to simplify Rest testing with JaxRs 2.0 and Arquillian, I'm more then happy to help you along. :)

The docs on the SPI level it self is a bit low at the moment, but we're working on it.

This gives you atleast a lot of docs on Arq Usage: http://arqpreview-alrubinger.rhcloud.com/guides/

Some Work In Progress Guides:

Container SPI: https://github.com/arquillian/arquillian.github.com/blob/issue-70/guides/adapting_to_new_backends.textile
Over all SPI: https://github.com/aslakknutsen/arquillian.github.com/blob/spi_guide/guides/getting_started_spi.textile

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>        

Please sign in to comment on this gist.

Something went wrong with that request. Please try again.