Testing RESTful Web Services made easy using the REST-assured Framework

<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.10</version>
  <scope>test</scope>
</dependency>

<dependency>
  <groupId>com.jayway.restassured</groupId>
  <artifactId>rest-assured</artifactId>
  <version>1.4</version>
  <scope>test</scope>
</dependency>

@Test
public void testGetSingleUserAsXml() {
    expect()
      .statusCode(200)
      .body(
        "user.email", equalTo("test@hascode.com"),
        "user.firstName", equalTo("Tim"),
        "user.lastName", equalTo("Testerman"),
        "user.id", equalTo("1"))
    .when()
    .get("/service/single-user/xml");
}

@Test
public void testGetPersons() {
    expect()
      .statusCode(200)
      .body(hasXPath("//*[self::person and self::person[@id='1'] and self::person/email[text()='test@hascode.com'] and self::person/firstName[text()='Tim'] and self::person/lastName[text()='Testerman']]"))
      .body(hasXPath("//*[self::person and self::person[@id='20'] and self::person/email[text()='dev@hascode.com'] and self::person/firstName[text()='Sara'] and self::person/lastName[text()='Stevens']]"))
      .body(hasXPath("//*[self::person and self::person[@id='11'] and self::person/email[text()='devnull@hascode.com'] and self::person/firstName[text()='Mark'] and self::person/lastName[text()='Mustache']]"))
    .when()
    .get("/service/persons/xml");
}

<?xml version="1.0" encoding="UTF-8"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema">
    <element name="user">
        <complexType>
            <sequence>
                <element name="email">
                    <simpleType>
                        <restriction base="string">
                          <pattern value=".+@.+"></pattern>
                        </restriction>
                    </simpleType>
                </element>
                <element name="firstName" type="string"/>
                <element name="id" type="int"/>
                <element name="lastName" type="string"/>
            </sequence>
        </complexType>
    </element>
</schema>

@Test
public void testGetSingleUserAgainstSchema() {
    InputStream xsd = getClass().getResourceAsStream("/user.xsd");
    assertNotNull(xsd);
    expect().
      statusCode(200).
      body(
        matchesXsd(xsd)).
    when().
    get("/service/single-user/xml");
}

@Test
public void testCreateuser() {
    final String email = "test@hascode.com";
    final String firstName = "Tim";
    final String lastName = "Tester";

    given().
        .parameters(
          "email", email,
          "firstName", firstName,
          "lastName", lastName)
        .expect()
        .body("email", equalTo(email)
        .body("firstName", equalTo(firstName))
        .body("lastName", equalTo(lastName))
    .when()
    .get("/service/user/create");
}

@Test
public void testStatusNotFound() {
  expect()
      .statusCode(404)
  .when()
  .get("/service/status/notfound");
}

@Test
public void testAuthenticationWorking() {
    // we're not authenticated, service returns "401 Unauthorized"
    expect()
      .statusCode(401)
    .when()
    .get("/service/secure/person");

    // with authentication it is working
    expect().
      .statusCode(200)
    .when()
    .with()
      .authentication().basic("admin", "admin")
    .get("/service/secure/person");
}

@Test
public void testSetRequestHeaders() {
    expect()
      .body(equalTo("TEST"))
    .when()
    .with()
      .header("myparam", "TEST")
    .get("/service/header/print");

    expect()
      .body(equalTo("foo"))
    .when()
    .with()
      .header("myparam", "foo")
    .get("/service/header/print");
}

@Test
public void testReturnedHeaders() {
    expect()
      .headers(
          "customHeader1", "foo",
          "anotherHeader", "bar"
      )
    .when()
    .get("/service/header/multiple");
}

@Test
public void testAccessSecuredByCookie() {
    expect()
      .statusCode(403)
    .when()
    .get("/service/access/cookie-token-secured");

    given()
      .cookie("authtoken", "abcdef")
    .expect()
      .statusCode(200)
    .when()
    .get("/service/access/cookie-token-secured");
}

@Test
public void testModifyCookie() {
    expect()
      .cookie("userName", equalTo("Ted"))
    .when()
    .with()
      .param("name", "Ted")
    .get("/service/cookie/modify");

    expect().
      .cookie("userName", equalTo("Bill"))
    .when()
    .with()
      .param("name", "Bill")
    .get("/service/cookie/modify");
}

@Test
public void testFileUpload() {
    final File file = new File(getClass()
      .getClassLoader()
      .getResource("test.txt")
    .getFile());

    assertNotNull(file);
    assertTrue(file.canRead());
    given()
      .multiPart(file)
    expect()
      .body(equalTo("This is an uploaded test file."))
    .when()
    .post("/service/file/upload");
}

@Test
public void testRegisterParserForUnknownContentType() {
    RestAssured.registerParser("text/json", Parser.JSON);
    expect()
      .body("test", equalTo(true))
      .when()
    .get("/service/detail/json");
}

@Test
public void testSpecReuse() {
    ResponseSpecBuilder builder = new ResponseSpecBuilder();
    builder.expectStatusCode(200);
    builder.expectBody("email", equalTo("test@hascode.com"));
    builder.expectBody("firstName", equalTo("Tim"));
    builder.expectBody("lastName", equalTo("Testerman"));
    builder.expectBody("id", equalTo("1"));
    ResponseSpecification responseSpec = builder.build();

    // now we're able to use this specification for this test
    expect()
      .spec(responseSpec)
    .when()
    .get("/service/single-user");

    // now re-use for another test that returns similar data .. you may
    // extend the specification with further tests as you wish
    final String email = "test@hascode.com";
    final String firstName = "Tim";
    final String lastName = "Testerman";

    expect()
      .spec(responseSpec)
    .when()
    .with()
      .parameters(
        "email", email,
        "firstName", firstName,
        "lastName",lastName)
    .get("/service/user/create");
}