com.github.tomakehurst.wiremock.http.HttpHeaders Java Examples

private static void stubRequest(String method, String endpoint, int status, Collection<Pair> headers, String body) {
	UrlPattern urlPattern = urlEqualTo(endpoint);
	MappingBuilder request = request(method, urlPattern);

	ResponseDefinitionBuilder response = aResponse().withStatus(status);

	HttpHeaders httpHeaders = new HttpHeaders();

	for (Pair header : headers) {
		String name = header.getO1();
		List<String> values = header.getO2();
		HttpHeader h = new HttpHeader(name, values);
		httpHeaders = httpHeaders.plus(h);
	}

	response.withHeaders(httpHeaders);

	if (body != null) {
		response.withBody(body);
	}

	stubFor(request.willReturn(response));
}
 

@Test
public void convertsResponseWithBody() {
    ResponseDefinition response = new ResponseDefinition(HTTP_OK, "{ \"count\" : 0, \"requestJournalDisabled\" : false}");
    response.setHeaders(new HttpHeaders(
            httpHeader("Transfer-Encoding", "chunked"),
            httpHeader("Content-Type", "application/json")));

    HttpResponse styxResponse = toStyxResponse(new BasicResponseRenderer().render(response));

    assertThat(styxResponse.status(), is(OK));
    Map<String, String> actual = headersAsMap(styxResponse);

    assertThat(actual, is(ImmutableMap.of(
            "Transfer-Encoding", "chunked",
            "Content-Type", "application/json")));
    assertThat(styxResponse.bodyAs(UTF_8), is("{ \"count\" : 0, \"requestJournalDisabled\" : false}"));
    assertThat(headerCount(styxResponse.headers()), is(2));
}
 

private MappingBuilder requestHeaders(MappingBuilder request, Operation operation) {
	org.springframework.http.HttpHeaders headers = operation.getRequest()
			.getHeaders();
	// TODO: whitelist headers
	for (String name : headers.keySet()) {
		if (!this.headerBlackList.contains(name.toLowerCase())) {
			if ("content-type".equalsIgnoreCase(name) && this.contentType != null) {
				continue;
			}
			request = request.withHeader(name, equalTo(headers.getFirst(name)));
		}
	}
	if (this.contentType != null) {
		request = request.withHeader("Content-Type",
				matching(Pattern.quote(this.contentType.toString()) + ".*"));
	}
	return request;
}
 

@Override
public Response transform(Request request, Response response, FileSource files, Parameters parameters) {
    // if gzipped, ungzip they body and discard the Content-Encoding header
    if (response.getHeaders().getHeader("Content-Encoding").containsValue("gzip")) {
        Iterable<HttpHeader> headers = Iterables.filter(
            response.getHeaders().all(),
            (HttpHeader header) -> header != null && !header.keyEquals("Content-Encoding") && !header.containsValue("gzip")
        );
        return Response.Builder.like(response)
            .but()
            .body(Gzip.unGzip(response.getBody()))
            .headers(new HttpHeaders(headers))
            .build();
    }
    return response;
}
 

private void addHeadersToContext(final HttpHeaders headers) {
    context.put("headers", headers.all().stream()
        .collect(Collectors.toMap(
            MultiValue::key,
            h -> h.values().size() != 1 ? h.values() : h.values().get(0))
        ));
}
 

@Override
public HttpHeaders getHeaders() {
	List<HttpHeader> headers = new ArrayList<>();
	for (Header header : request.getHeaders()) {
		String value = header.getValue();
		if ("accept".equals(header.getName().toLowerCase()) && "*/*".equals(value)) {
			continue;
		}
		headers.add(new HttpHeader(header.getName(), header.getValue()));
	}
	return new HttpHeaders(headers);
}
 

@JsonCreator
public WebhookDefinition(@JsonProperty("method") RequestMethod method,
                         @JsonProperty("url") URI url,
                         @JsonProperty("headers") HttpHeaders headers,
                         @JsonProperty("body") String body,
                         @JsonProperty("base64Body") String base64Body) {
    this.method = method;
    this.url = url;
    this.headers = newArrayList(headers.all());
    this.body = Body.fromOneOf(null, body, null, base64Body);
}
 

private HttpHeaders responseHeaders(Operation operation) {
	org.springframework.http.HttpHeaders headers = operation.getResponse()
			.getHeaders();
	HttpHeaders result = new HttpHeaders();
	for (String name : headers.keySet()) {
		if (!this.headerBlackList.contains(name.toLowerCase())) {
			result = result.plus(new HttpHeader(name, headers.get(name)));
		}
	}
	return result;
}
 

private void stubWithHeaders(Map<String, List<String>> headers) {

        HttpHeaders httpHeaders = new HttpHeaders(headers.entrySet().stream().map(entry -> new HttpHeader(entry.getKey(),
                                                                                                          entry.getValue()))
                                                         .collect(Collectors.toList()));
        stubFor(post(anyUrl()).willReturn(aResponse()
                                              .withStatus(200)
                                              .withStatusMessage(STATUS_TEXT)
                                              .withHeaders(httpHeaders)
                                              .withBody(JSON_BODY)));
    }
 

@Override
public HttpHeaders getHeaders() {
    List<HttpHeader> list = stream(styxRequest.headers().spliterator(), false)
            .map(styxHeader -> httpHeader(styxHeader.name(), styxHeader.value()))
            .collect(toList());

    return new HttpHeaders(list);
}
 

@Override
public <S> void forEach(String headerName, LoggedRequest loggedRequest, S state, HeaderConsumer<String, S> consumer) {
    HttpHeaders headers = loggedRequest.getHeaders();
    if (headers != null) {
        HttpHeader header = headers.getHeader(headerName);
        if (header != null) {
            List<String> values = header.values();
            for (int i = 0, size = values.size(); i < size; i++) {
                consumer.accept(values.get(i), state);
            }
        }
    }
}
 

@Override
public Response transform(Request request, Response response, FileSource files, Parameters parameters) {
    return Response.Builder.like(response)
                           .headers(HttpHeaders.copyOf(response.getHeaders())
                                               .plus(new HttpHeader("Connection", "Close")))
                           .build();
}
 

private void assertDoesNotContainHeaders(HttpHeaders actual) {
    doesNotContain.forEach(headerName -> {
        assertFalse(String.format("Header '%s' was expected to be absent", headerName),
                    actual.getHeader(headerName).isPresent());
    });
}
 

private void assertHeadersContains(HttpHeaders actual) {
    contains.entrySet().forEach(e -> {
        assertEquals(e.getValue(), actual.getHeader(e.getKey()).firstValue());
    });
}
 

private int headerCount(com.hotels.styx.api.HttpHeaders headers) {
    AtomicInteger count = new AtomicInteger();
    headers.forEach(header -> count.incrementAndGet());
    return count.get();
}
 

public HttpHeaders getHeaders() {
    return new HttpHeaders(headers);
}
 

@Override
public Response transform(Request request, Response response, FileSource files, Parameters parameters) {
	return Response.Builder.like(response)
			.headers(HttpHeaders.copyOf(response.getHeaders()).plus(new HttpHeader("Connection", "Close"))).build();
}