Java ResponseSpecBuilder.expectBody方法代码示例

import com.jayway.restassured.builder.ResponseSpecBuilder; //导入方法依赖的package包/类
@Test
public void shouldReturnOkOnGetRepositoriesWithResultsUsingOnlyCount() throws Exception {
    String resourcePath = getRepositoriesResourcePath();

    for (int i = 0; i < 30; i++) {
        String json = "{ \"name\" : \"test" + i + "\", \"type\" : \"FILE\"}";
        post(resourcePath, json, "editor", "password", Optional.of("v1"), Optional.empty());
    }

    ResponseSpecBuilder responseSpecBuilder = new ResponseSpecBuilder();
    responseSpecBuilder.expectStatusCode(200);
    responseSpecBuilder.expectBody("page", nullValue());
    responseSpecBuilder.expectBody("per_page", nullValue());
    responseSpecBuilder.expectBody("total_pages", nullValue());
    responseSpecBuilder.expectBody("total_count", equalTo(30));
    responseSpecBuilder.expectBody("data", hasSize(0));
    responseSpecBuilder.expectBody("links", nullValue());
    com.jayway.restassured.response.Response response = get(resourcePath + "?only_count=true", "reader", "password", Optional.of("v1"), Optional.of(responseSpecBuilder.build()));
    // Validate Link Headers
    assertThat(response.header("Link")).isNull();
}
 

import com.jayway.restassured.builder.ResponseSpecBuilder; //导入方法依赖的package包/类
@Test
public void shouldReturnOkOnGetVariantsWithResultsUsingOnlyCount() throws Exception {
    for (int i = 0; i < 30; i++) {
        String json = "{ \"name\" : \"test1\", \"external_ids\" : [\"id1\", \"id2\"]}";
        post(getVariantsResourcePath(baseURL, assetId), json, "editor", "password", Optional.of("v1"), Optional.empty());
    }

    ResponseSpecBuilder responseSpecBuilder = new ResponseSpecBuilder();
    responseSpecBuilder.expectStatusCode(200);
    responseSpecBuilder.expectBody("page", nullValue());
    responseSpecBuilder.expectBody("per_page", nullValue());
    responseSpecBuilder.expectBody("total_pages", nullValue());
    responseSpecBuilder.expectBody("total_count", equalTo(30));
    responseSpecBuilder.expectBody("data", hasSize(0));
    responseSpecBuilder.expectBody("links", nullValue());
    UriBuilder uriBuilder = UriBuilder.fromUri(Throwables.returnableInstance(baseURL::toURI));
    uriBuilder.path("api/assets/{assetId}/variants");
    uriBuilder.queryParam("only_count", true);
    com.jayway.restassured.response.Response response = get(uriBuilder.build(assetId).toString(), "reader", "password", Optional.of("v1"), Optional.of(responseSpecBuilder.build()));
    // Validate Link Headers
    assertThat(response.header("Link")).isNull();
}
 

import com.jayway.restassured.builder.ResponseSpecBuilder; //导入方法依赖的package包/类
@Test
public void shouldReturnOkOnGetWorkersFilteredByNameLike() throws Exception {
    String workerResourcePath = getWorkersResourcePath(baseURL);

    for (int i = 0; i < 5; i++) {
        String json = "{ \"name\" : \"test" + i + "\", \"external_ids\" : [\"id1\", \"id2\"]}";
        post(workerResourcePath, json, "editor", "password", Optional.of("v1"), Optional.empty());
    }

    ResponseSpecBuilder responseSpecBuilder = new ResponseSpecBuilder();
    responseSpecBuilder.expectStatusCode(200);
    responseSpecBuilder.expectBody("data.name", contains("test3"));
    get(workerResourcePath + "?name[like]=3", "reader", "password", Optional.of("v1"), Optional.of(responseSpecBuilder.build()));
}
 

import com.jayway.restassured.builder.ResponseSpecBuilder; //导入方法依赖的package包/类
@Test
public void shouldReturnOkOnGetVariantsFilteredByNameEqual() throws Exception {
    for (int i = 0; i < 5; i++) {
        String json = "{ \"name\" : \"test" + i + "\", \"external_ids\" : [\"id1\", \"id2\"]}";
        post(getVariantsResourcePath(baseURL, assetId), json, "editor", "password", Optional.of("v1"), Optional.empty());
    }

    ResponseSpecBuilder responseSpecBuilder = new ResponseSpecBuilder();
    responseSpecBuilder.expectStatusCode(200);
    responseSpecBuilder.expectBody("data.name", contains("test0"));
    get(getVariantsResourcePath(baseURL, assetId) + "?name[eq]=test0", "reader", "password", Optional.of("v1"), Optional.of(responseSpecBuilder.build()));
}
 

import com.jayway.restassured.builder.ResponseSpecBuilder; //导入方法依赖的package包/类
@Test
public void shouldReturnBadRequestOnGetAssetsFilteredUnsupportedOperator() throws Exception {
    ResponseSpecBuilder responseSpecBuilder = new ResponseSpecBuilder();
    responseSpecBuilder.expectStatusCode(200);
    responseSpecBuilder.expectBody("data.name", contains("test"));
    RestIntegrationTests.get(RestIntegrationTests.getAssetsResourcePath(baseURL) + "?name[ne]=bad", "reader", "password", Optional.of("v1"),
                             Optional.of(RestIntegrationTests.badRequestResponseSpecification(Optional.of("Invalid search condition operator NE for condition attribute name"))));
}
 

import com.jayway.restassured.builder.ResponseSpecBuilder; //导入方法依赖的package包/类
@Test
public void shouldReturnOkOnGetWorkersFilteredByNameWithSpaces() throws Exception {
    String workerResourcePath = getWorkersResourcePath(baseURL);

    for (int i = 0; i < 5; i++) {
        String json = "{ \"name\" : \"test " + i + "\", \"external_ids\" : [\"id1\", \"id2\"]}";
        post(workerResourcePath, json, "editor", "password", Optional.of("v1"), Optional.empty());
    }

    ResponseSpecBuilder responseSpecBuilder = new ResponseSpecBuilder();
    responseSpecBuilder.expectStatusCode(200);
    responseSpecBuilder.expectBody("data.name", contains("test 0"));
    // the RestAssured framework auto escapes the space to %20
    get(workerResourcePath + "?name[eq]=test 0", "reader", "password", Optional.of("v1"), Optional.of(responseSpecBuilder.build()));
}
 

import com.jayway.restassured.builder.ResponseSpecBuilder; //导入方法依赖的package包/类
@Test
public void shouldReturnOkOnGetLocationsFilteredByNameEqual() throws Exception {
    String resourcePath = getLocationResourcePath(baseURL);

    for (int i = 0; i < 5; i++) {
        String json = "{ \"name\" : \"test" + i + "\", \"type\" : \"FILE\"}";
        post(resourcePath, json, "editor", "password", Optional.of("v1"), Optional.empty());
    }

    ResponseSpecBuilder responseSpecBuilder = new ResponseSpecBuilder();
    responseSpecBuilder.expectStatusCode(200);
    responseSpecBuilder.expectBody("data.name", contains("test0"));
    get(resourcePath + "?name[eq]=test0", "reader", "password", Optional.of("v1"), Optional.of(responseSpecBuilder.build()));
}
 

import com.jayway.restassured.builder.ResponseSpecBuilder; //导入方法依赖的package包/类
@Test
public void shouldReturnBadRequestOnGetLocationsFilteredUnsupportedOperator() throws Exception {
    ResponseSpecBuilder responseSpecBuilder = new ResponseSpecBuilder();
    responseSpecBuilder.expectStatusCode(200);
    responseSpecBuilder.expectBody("data.name", contains("test"));
    get(getLocationResourcePath(baseURL) + "?name[ne]=bad", "reader", "password", Optional.of("v1"),
            Optional.of(badRequestResponseSpecification(Optional.of("Invalid search condition operator NE for condition attribute name"))));
}
 

import com.jayway.restassured.builder.ResponseSpecBuilder; //导入方法依赖的package包/类
@Test
public void shouldReturnBadRequestOnGetVariantsFilteredByInvalidDateFormat() throws Exception {
    ResponseSpecBuilder responseSpecBuilder = new ResponseSpecBuilder();
    responseSpecBuilder.expectStatusCode(200);
    responseSpecBuilder.expectBody("data.name", contains("test"));
    get(getVariantsResourcePath(baseURL, assetId) + "?created[eq]=3", "reader", "password", Optional.of("v1"),
            Optional.of(badRequestResponseSpecification(Optional.of("Invalid date format for attribute created"))));
}
 

import com.jayway.restassured.builder.ResponseSpecBuilder; //导入方法依赖的package包/类
public static Response post(String path, String json, RequestSpecification requestSpecification, Optional<ResponseSpecification> responseSpecification) {
    ResponseSpecBuilder defaultSpecBuilder = new ResponseSpecBuilder();
    defaultSpecBuilder.expectStatusCode(201);
    defaultSpecBuilder.expectHeader("Location", startsWith(path));
    defaultSpecBuilder.expectBody("status", equalTo("OK"));

    Response response = given().spec(requestSpecification).content(json).when().post(path);
    response.then().spec(responseSpecification.orElse(defaultSpecBuilder.build()));
    return response;
}
 

import com.jayway.restassured.builder.ResponseSpecBuilder; //导入方法依赖的package包/类
/**
 * Returns a {@link com.jayway.restassured.specification.ResponseSpecification} that can be used to validate paginated results
 *
 * @param page
 *         the expected page
 * @param perPage
 *         the expected results per page
 * @param totalPages
 *         the expected total number of pages
 * @param totalCount
 *         the expected total number of results
 * @param dataSize
 *         the expected number of results returned in the data payload
 * @param resourcePath
 *         the resource path
 * @param first
 *         an Optional containing the expected query parameters for the first link, if empty the result is checked if it is null
 * @param last
 *         an Optional containing the expected query parameters for the last link, if empty the result is checked if it is null
 * @param next
 *         an Optional containing the expected query parameters for the next link, if empty the result is checked if it is null
 * @param prev
 *         an Optional containing the expected query parameters for the prev link, if empty the result is checked if it is null
 * @return a {@link com.jayway.restassured.specification.ResponseSpecification} that can be used to validate paginated results
 */
public static ResponseSpecification paginationResponseSpecification(int page, int perPage, int totalPages, int totalCount, int dataSize, String resourcePath, Optional<String> first,
                                                                    Optional<String> last, Optional<String> next, Optional<String> prev) {
    ResponseSpecBuilder builder = new ResponseSpecBuilder();
    builder.expectStatusCode(200);
    builder.expectBody("page", equalTo(page));
    builder.expectBody("per_page", equalTo(perPage));
    builder.expectBody("total_pages", equalTo(totalPages));
    builder.expectBody("total_count", equalTo(totalCount));
    builder.expectBody("data", hasSize(dataSize));
    if (first.isPresent()) {
        builder.expectBody("links.first.href", equalTo(resourcePath + first.get()));
    } else {
        builder.expectBody("links.first", nullValue());
    }
    if (last.isPresent()) {
        builder.expectBody("links.last.href", equalTo(resourcePath + last.get()));
    } else {
        builder.expectBody("links.last", nullValue());
    }
    if (next.isPresent()) {
        builder.expectBody("links.next.href", equalTo(resourcePath + next.get()));
    } else {
        builder.expectBody("links.next", nullValue());
    }
    if (prev.isPresent()) {
        builder.expectBody("links.prev.href", equalTo(resourcePath + prev.get()));
    } else {
        builder.expectBody("links.prev", nullValue());
    }
    return builder.build();
}
 

import com.jayway.restassured.builder.ResponseSpecBuilder; //导入方法依赖的package包/类
@Test
public void shouldReturnOkOnGetWorkersSortNameAsc() throws Exception {
    String workerResourcePath = getWorkersResourcePath(baseURL);

    for (int i = 0; i < 5; i++) {
        String json = "{ \"name\" : \"test" + i + "\", \"external_ids\" : [\"id1\", \"id2\"]}";
        post(workerResourcePath, json, "editor", "password", Optional.of("v1"), Optional.empty());
    }

    ResponseSpecBuilder responseSpecBuilder = new ResponseSpecBuilder();
    responseSpecBuilder.expectStatusCode(200);
    responseSpecBuilder.expectBody("data.name", contains("test0", "test1", "test2", "test3", "test4"));
    get(workerResourcePath + "?sort=name&order=ASC", "reader", "password", Optional.of("v1"), Optional.of(responseSpecBuilder.build()));
}
 

import com.jayway.restassured.builder.ResponseSpecBuilder; //导入方法依赖的package包/类
@Test
public void shouldReturnOkOnGetVariantsDefaultSort() throws Exception {
    for (int i = 0; i < 5; i++) {
        String json = "{ \"name\" : \"test" + i + "\", \"external_ids\" : [\"id1\", \"id2\"]}";
        post(getVariantsResourcePath(baseURL, assetId), json, "editor", "password", Optional.of("v1"), Optional.empty());
    }

    ResponseSpecBuilder responseSpecBuilder = new ResponseSpecBuilder();
    responseSpecBuilder.expectStatusCode(200);
    responseSpecBuilder.expectBody("data.name", contains("test4", "test3", "test2", "test1", "test0"));
    get(getVariantsResourcePath(baseURL, assetId), "reader", "password", Optional.of("v1"), Optional.of(responseSpecBuilder.build()));
}
 

import com.jayway.restassured.builder.ResponseSpecBuilder; //导入方法依赖的package包/类
@Test
public void shouldReturnBadRequestOnGetVariantsFilteredUnsupportedOperator() throws Exception {
    ResponseSpecBuilder responseSpecBuilder = new ResponseSpecBuilder();
    responseSpecBuilder.expectStatusCode(200);
    responseSpecBuilder.expectBody("data.name", contains("test"));
    get(getVariantsResourcePath(baseURL, assetId) + "?name[ne]=bad", "reader", "password", Optional.of("v1"),
            Optional.of(badRequestResponseSpecification(Optional.of("Invalid search condition operator NE for condition attribute name"))));
}
 

import com.jayway.restassured.builder.ResponseSpecBuilder; //导入方法依赖的package包/类
/**
 * Returns a {@link com.jayway.restassured.specification.ResponseSpecification} that can be used to validate a 400 BAD REQUEST was returned.
 *
 * @param message
 *         an Optional containing the expected error message, if empty the message will be validated to make sure it is not null.
 * @return a {@link com.jayway.restassured.specification.ResponseSpecification} that can be used to validate a 400 BAD REQUEST was returned.
 */
public static ResponseSpecification badRequestResponseSpecification(Optional<String> message) {
    ResponseSpecBuilder builder = new ResponseSpecBuilder();
    builder.expectStatusCode(400);
    builder.expectHeader("Warning", notNullValue(String.class));
    builder.expectBody("status", equalTo("ERROR"));
    if (message.isPresent()) {
        builder.expectBody("message", equalTo(message.get()));
    } else {
        builder.expectBody("message", notNullValue(String.class));
    }
    return builder.build();
}