public boolean receivedMessageWithHeader(String header, String value) { synchronized (receivedRequests) { return receivedRequests.stream().anyMatch(r -> r.header(header).containsValue(value)); } }
public HttpHeaders(Iterable<HttpHeader> headers) { ImmutableMultimap.Builder<CaseInsensitiveKey, String> builder = ImmutableMultimap.builder(); for (HttpHeader header: firstNonNull(headers, Collections.<HttpHeader>emptyList())) { builder.putAll(caseInsensitive(header.key()), header.values()); } this.headers = builder.build(); }
@Override public void serialize(HttpHeaders headers, JsonGenerator jgen, SerializerProvider provider) throws IOException { jgen.writeStartObject(); for (HttpHeader header: headers.all()) { if (header.isSingleValued()) { jgen.writeStringField(header.key(), header.firstValue()); } else { jgen.writeArrayFieldStart(header.key()); for (String value: header.values()) { jgen.writeString(value); } jgen.writeEndArray(); } } jgen.writeEndObject(); } }
@Override public HttpHeader apply(HttpHeader input) { List<String> newValues = Lists.transform(input.values(), new Function<String, String>() { @Override public String apply(String input) { Template template = uncheckedCompileTemplate(input); return uncheckedApplyTemplate(template, model); } }); return new HttpHeader(input.key(), newValues); } });
@Override @JsonIgnore public String getHeader(String key) { HttpHeader header = header(key); if (header.isPresent()) { return header.firstValue(); } return null; }
private MultipartValuePattern valuePatternForPart(Request.Part part) { MultipartValuePatternBuilder builder = new MultipartValuePatternBuilder().withName(part.getName()).matchingType(MultipartValuePattern.MatchingType.ALL); if (!headersToMatch.isEmpty()) { Collection<HttpHeader> all = part.getHeaders().all(); for (HttpHeader httpHeader : all) { if (headersToMatch.contains(httpHeader.caseInsensitiveKey())) { builder.withHeader(httpHeader.key(), equalTo(httpHeader.firstValue())); } } } HttpHeader contentType = part.getHeader("Content-Type"); if (!contentType.isPresent() || contentType.firstValue().contains("text")) { builder.withBody(equalTo(part.getBody().asString())); } else if (contentType.firstValue().contains("json")) { builder.withBody(equalToJson(part.getBody().asString(), true, true)); } else if (contentType.firstValue().contains("xml")) { builder.withBody(equalToXml(part.getBody().asString())); } else { builder.withBody(binaryEqualTo(part.getBody().asBytes())); } return builder.build(); }
private RequestPattern buildRequestPatternFrom(Request request) { RequestPatternBuilder builder = newRequestPattern(request.getMethod(), urlEqualTo(request.getUrl())); if (!headersToMatch.isEmpty()) { for (HttpHeader header: request.getHeaders().all()) { if (headersToMatch.contains(header.caseInsensitiveKey())) { builder.withHeader(header.key(), equalTo(header.firstValue())); } } } if (request.isMultipart()) { for (Request.Part part : request.getParts()) { builder.withRequestBodyPart(valuePatternForPart(part)); } } else { String body = request.getBodyAsString(); if (!body.isEmpty()) { builder.withRequestBody(valuePatternForContentType(request)); } } return builder.build(); }
@Override public boolean authenticate(Request request) { HttpHeader requestHeader = request.header(key); if (requestHeader == null || !requestHeader.isPresent()) { return false; } List<String> headerValues = requestHeader.values(); return request.containsHeader(AUTHORIZATION) && headerValues.contains(value); } }
private void addRequestHeaders(HttpRequest httpRequest, ResponseDefinition response) { Request originalRequest = response.getOriginalRequest(); for (String key: originalRequest.getAllHeaderKeys()) { if (headerShouldBeTransferred(key)) { if (!HOST_HEADER.equalsIgnoreCase(key) || preserveHostHeader) { List<String> values = originalRequest.header(key).values(); for (String value: values) { httpRequest.addHeader(key, value); } } else { if (hostHeaderValue != null) { httpRequest.addHeader(key, hostHeaderValue); } else if (response.getProxyBaseUrl() != null) { httpRequest.addHeader(key, URI.create(response.getProxyBaseUrl()).getAuthority()); } } } } if (response.getAdditionalProxyRequestHeaders() != null) { for (String key: response.getAdditionalProxyRequestHeaders().keys()) { httpRequest.setHeader(key, response.getAdditionalProxyRequestHeaders().getHeader(key).firstValue()); } } }
private void assertHeadersContains(HttpHeaders actual) { contains.entrySet().stream().forEach(e -> { assertEquals(e.getValue(), actual.getHeader(e.getKey()).firstValue()); }); }
public static HttpHeader empty(String key) { return httpHeader(key, ""); }
@Override @SuppressWarnings("unchecked") public HttpHeader header(String key) { List<String> headerNames = list(request.getHeaderNames()); for (String currentKey : headerNames) { if (currentKey.toLowerCase().equals(key.toLowerCase())) { List<String> valueList = list(request.getHeaders(currentKey)); if (valueList.isEmpty()) { return HttpHeader.empty(key); } return new HttpHeader(key, valueList); } } return HttpHeader.absent(key); }
@Override public ListOrSingle<String> apply(String input) { return ListOrSingle.of(request.header(input).values()); } });
@Override public boolean containsHeader(String key) { return header(key).isPresent(); }
private void addHeaderSection(Map<String, MultiValuePattern> headerPatterns, HttpHeaders headers, ImmutableList.Builder<DiffLine<?>> builder) { boolean anyHeaderSections = false; if (headerPatterns != null && !headerPatterns.isEmpty()) { anyHeaderSections = true; for (String key : headerPatterns.keySet()) { HttpHeader header = headers.getHeader(key); MultiValuePattern headerPattern = headerPatterns.get(header.key()); String operator = generateOperatorString(headerPattern.getValuePattern(), ""); String printedPatternValue = header.key() + operator + ": " + headerPattern.getExpected(); DiffLine<MultiValue> section = new DiffLine<>("Header", headerPattern, header, printedPatternValue); builder.add(section); } } if (anyHeaderSections) { builder.add(SPACER); } }
public static HttpHeader httpHeader(String key, String... values) { return new HttpHeader(key, values); }
public HttpHeader getHeader(String key) { if (!headers.containsKey(caseInsensitive(key))) { return HttpHeader.absent(key); } Collection<String> values = headers.get(caseInsensitive(key)); return new HttpHeader(key, values); }
public boolean apply(HttpHeader header) { return !EXCLUDED_HEADERS.contains(header.caseInsensitiveKey()); } }));
@Override public HttpHeader getHeader(String name) { return HttpHeader.absent(name); }
public ContentTypeHeader getContentTypeHeader() { HttpHeader header = getHeader(ContentTypeHeader.KEY); if (header.isPresent()) { return new ContentTypeHeader(header.firstValue()); } return ContentTypeHeader.absent(); }