public static LoggedRequest createFrom(Request request) { return new LoggedRequest(request.getUrl(), request.getAbsoluteUrl(), request.getMethod(), request.getClientIp(), copyOf(request.getHeaders()), ImmutableMap.copyOf(request.getCookies()), request.isBrowserProxyRequest(), new Date(), request.getBody(), request.getParts() ); }
protected String formatRequest(Request request) { StringBuilder sb = new StringBuilder(); sb.append(request.getClientIp()) .append(" - ") .append(request.getMethod()) .append(" ") .append(request.getUrl()); if (request.isBrowserProxyRequest()) { sb.append(" (via browser proxy request)"); } sb.append("\n\n"); sb.append(request.getHeaders()); if (request.getBody() != null) { sb.append(request.getBodyAsString()).append("\n"); } return sb.toString(); }
@Override public boolean authenticate(Request request) { List<String> headerValues = FluentIterable.from(credentials).transform(new Function<BasicCredentials, String>() { @Override public String apply(BasicCredentials input) { return input.asAuthorizationHeaderValue(); } }).toList(); return request.containsHeader(AUTHORIZATION) && headerValues.contains(request.header(AUTHORIZATION).firstValue()); } }
public static RequestLine fromRequest(final Request request) { URI url = URI.create(request.getUrl()); Map<String, QueryParameter> rawQuery = Urls.splitQuery(url); Map<String, ListOrSingle<String>> adaptedQuery = Maps.transformValues(rawQuery, TO_TEMPLATE_MODEL); return new RequestLine(request.getMethod(), request.getScheme(), request.getHost(), request.getPort(), request.getUrl(), adaptedQuery); }
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(); }
public List<DiffLine<?>> getLines(Map<String, RequestMatcherExtension> customMatcherExtensions) { ImmutableList.Builder<DiffLine<?>> builder = ImmutableList.builder(); DiffLine<RequestMethod> methodSection = new DiffLine<>("HTTP method", requestPattern.getMethod(), request.getMethod(), requestPattern.getMethod().getName()); builder.add(methodSection); request.getUrl(), urlPattern.getExpected()); builder.add(urlSection); addHeaderSection(requestPattern.combineBasicAuthAndOtherHeaders(), request.getHeaders(), builder); Map<String, QueryParameter> requestQueryParams = Urls.splitQuery(URI.create(request.getUrl())); Map<String, Cookie> cookies = firstNonNull(request.getCookies(), Collections.<String, Cookie>emptyMap()); for (Map.Entry<String, StringValuePattern> entry: requestPattern.getCookies().entrySet()) { String key = entry.getKey(); addBodySection(bodyPatterns, new Body(request.getBody()), builder); if (!request.isMultipart()) { builder.add(new SectionDelimiter("[Multipart request body]", "")); } else if (!pattern.match(request).isExactMatch()) { for (Request.Part part: request.getParts()) { builder.add(SPACER); String patternPartName = pattern.getName() == null ? "" : ": " + pattern.getName();
/** * Builds a {@link Request} for the OpenAPI validator out of the * original {@link com.github.tomakehurst.wiremock.http.Request}. * * @param originalRequest the original {@link com.github.tomakehurst.wiremock.http.Request} */ @Nonnull public static Request of(@Nonnull final com.github.tomakehurst.wiremock.http.Request originalRequest) { requireNonNull(originalRequest, "An original request is required"); final URI uri = URI.create(originalRequest.getUrl()); final Map<String, QueryParameter> queryParameterMap = Urls.splitQuery(uri); final SimpleRequest.Builder builder = new SimpleRequest.Builder(originalRequest.getMethod().getName(), uri.getPath()) .withBody(originalRequest.getBodyAsString()); originalRequest.getHeaders().all().forEach(header -> builder.withHeader(header.key(), header.values())); queryParameterMap.forEach((key, value) -> builder.withQueryParam(key, value.values())); return builder.build(); } }
@Override public String getUrl() { return target.getUrl(); }
/** * Returns a RequestPatternBuilder matching a given Request */ @Override public RequestPatternBuilder apply(Request request) { final RequestPatternBuilder builder = new RequestPatternBuilder(request.getMethod(), urlEqualTo(request.getUrl())); if (headers != null && !headers.isEmpty()) { for (Map.Entry<String, CaptureHeadersSpec> header : headers.entrySet()) { String headerName = header.getKey(); if (request.containsHeader(headerName)) { CaptureHeadersSpec spec = header.getValue(); StringValuePattern headerMatcher = new EqualToPattern(request.getHeader(headerName), spec.getCaseInsensitive()); builder.withHeader(headerName, headerMatcher); } } } byte[] body = request.getBody(); if (bodyPatternFactory != null && body != null && body.length > 0) { builder.withRequestBody(bodyPatternFactory.forRequest(request)); } return builder; } }
@Override public String getBodyAsString() { return target.getBodyAsString(); }
@Override public ServeEvent handleRequest(Request request) { if (requireHttps && !URI.create(request.getAbsoluteUrl()).getScheme().equals("https")) { notifier().info("HTTPS is required for admin requests, sending upgrade redirect"); return ServeEvent.of( notifier().info("Authentication failed for " + request.getMethod() + " " + request.getUrl()); return ServeEvent.of( LoggedRequest.createFrom(request), String path = URI.create(withoutAdminRoot(request.getUrl())).getPath(); AdminTask adminTask = adminRoutes.taskFor(request.getMethod(), path);
@Override public MatchResult match(Request request) { List<WeightedMatchResult> matchResults = new ArrayList<>(asList( weight(RequestPattern.this.url.match(request.getUrl()), 10.0), weight(RequestPattern.this.method.match(request.getMethod()), 3.0), weight(allHeadersMatchResult(request)), weight(allQueryParamsMatch(request)), weight(allCookiesMatch(request)), weight(allBodyPatternsMatch(request)), weight(allMultipartPatternsMatch(request)) )); if (hasInlineCustomMatcher) { matchResults.add(weight(customMatcher.match(request))); } return MatchResult.aggregateWeighted(matchResults); }
/** * If request body was JSON or XML, use "equalToJson" or "equalToXml" (respectively) in the RequestPattern so it's * easier to read. Otherwise, just use "equalTo" */ @Override public ContentPattern<?> forRequest(Request request) { final String mimeType = request.getHeaders().getContentTypeHeader().mimeTypePart(); if (mimeType != null) { if (mimeType.contains("json")) { return new EqualToJsonPattern(request.getBodyAsString(), ignoreArrayOrder, ignoreExtraElements); } else if (mimeType.contains("xml")) { return new EqualToXmlPattern(request.getBodyAsString()); } else if (mimeType.equals("multipart/form-data")) { // TODO: Need to add a matcher that can handle multipart data properly. For now, just always match return new AnythingPattern(); } else if (!determineIsTextFromMimeType(mimeType)) { return new BinaryEqualToPattern(request.getBody()); } } return new EqualToPattern(request.getBodyAsString(), caseInsensitive); } }
private static HttpEntity buildEntityFrom(Request originalRequest) { ContentTypeHeader contentTypeHeader = originalRequest.contentTypeHeader().or("text/plain"); ContentType contentType = ContentType.create(contentTypeHeader.mimeTypePart(), contentTypeHeader.encodingPart().or("utf-8")); if (originalRequest.containsHeader(TRANSFER_ENCODING) && originalRequest.header(TRANSFER_ENCODING).firstValue().equals("chunked")) { return applyGzipWrapperIfRequired( originalRequest, new InputStreamEntity(new ByteArrayInputStream(originalRequest.getBody()), -1, contentType) ); } return applyGzipWrapperIfRequired( originalRequest, new ByteArrayEntity(originalRequest.getBody()) ); }
public static RequestTemplateModel from(final Request request) { RequestLine requestLine = RequestLine.fromRequest(request); Map<String, ListOrSingle<String>> adaptedHeaders = Maps.toMap(request.getAllHeaderKeys(), new Function<String, ListOrSingle<String>>() { @Override public ListOrSingle<String> apply(String input) { return ListOrSingle.of(request.header(input).values()); } }); Map<String, ListOrSingle<String>> adaptedCookies = Maps.transformValues(request.getCookies(), new Function<Cookie, ListOrSingle<String>>() { @Override public ListOrSingle<String> apply(Cookie cookie) { return ListOrSingle.of(cookie.getValues()); } }); return new RequestTemplateModel( requestLine, adaptedHeaders, adaptedCookies, request.getBodyAsString() ); }
@Override public RequestMethod getMethod() { return target.getMethod(); }
private StringValuePattern valuePatternForContentType(Request request) { String contentType = request.getHeader("Content-Type"); if (contentType != null) { if (contentType.contains("json")) { return equalToJson(request.getBodyAsString(), true, true); } else if (contentType.contains("xml")) { return equalToXml(request.getBodyAsString()); } } return equalTo(request.getBodyAsString()); }
@Override public ResponseDefinition execute(Admin admin, Request request, PathParams pathParams) { RecordSpec recordSpec = request.getBody().length == 0 ? RecordSpec.DEFAULTS : Json.read(request.getBodyAsString(), RecordSpec.class); SnapshotRecordResult result = admin.snapshotRecord(recordSpec); return jsonResponse(result, HTTP_OK); } }
@Override public HttpHeaders getHeaders() { return target.getHeaders(); }
@Override public String getAbsoluteUrl() { return target.getAbsoluteUrl(); }