@Override public RequestMethod getMethod() { return RequestMethod.fromString(request.getMethod().toUpperCase()); }
@Override public String getExpected() { return getName(); }
@JsonCreator public static RequestMethod fromString(String value) { return new RequestMethod(value); }
public static HttpUriRequest getHttpRequestFor(RequestMethod method, String url) { notifier().info("Proxying: " + method + " " + url); if (method.equals(GET)) return new HttpGet(url); else if (method.equals(POST)) return new HttpPost(url); else if (method.equals(PUT)) return new HttpPut(url); else if (method.equals(DELETE)) return new HttpDelete(url); else if (method.equals(HEAD)) return new HttpHead(url); else if (method.equals(OPTIONS)) return new HttpOptions(url); else if (method.equals(TRACE)) return new HttpTrace(url); else if (method.equals(PATCH)) return new HttpPatch(url); else return new GenericHttpUriRequest(method.toString(), url); } }
@Override protected void doAssert(LoggedRequest actual) { assertEquals(expectedMethodName.name(), actual.getMethod().value()); } }
@Override public int hashCode() { int result = method.hashCode(); result = 31 * result + uriTemplate.hashCode(); return result; } }
private static void addBodyIfPostPutOrPatch(HttpRequest httpRequest, ResponseDefinition response) throws UnsupportedEncodingException { Request originalRequest = response.getOriginalRequest(); if (originalRequest.getMethod().isOneOf(PUT, POST, PATCH)) { HttpEntityEnclosingRequest requestWithEntity = (HttpEntityEnclosingRequest) httpRequest; requestWithEntity.setEntity(buildEntityFrom(originalRequest)); } }
@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); }
@Override protected void doAssert(LoggedRequest actual) throws Exception { assertEquals(expectedMethodName.name(), actual.getMethod().value()); } }
private void setStub(WireMockServer server, String url, RequestMethod requestMethod, Object body) throws JsonProcessingException { ObjectMapper mapper = new ObjectMapper(); String jsonInString = mapper.writeValueAsString(body); server.addStubMapping( WireMock.request(requestMethod.getName(), WireMock.urlMatching(url)) .willReturn(WireMock.aResponse().withStatus(200).withBody(jsonInString) .withHeader("Content-Type", "text/plain").withHeader("Access-Control-Allow-Origin", "*") ) .build()); }
public static MappingBuilder request(String method, UrlPattern urlPattern) { return new BasicMappingBuilder(RequestMethod.fromString(method), urlPattern); }
@Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; RequestSpec that = (RequestSpec) o; if (!method.equals(that.method)) return false; if (!uriTemplate.equals(that.uriTemplate)) return false; return true; }
/** * 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 RequestMethod getMethod() { return RequestMethod.fromString(styxRequest.method().name()); }
private void respondTo(Request request, Response response) { try { if (response.wasConfigured()) { applyResponse(response, httpServletRequest, httpServletResponse); } else if (request.getMethod().equals(GET) && shouldForwardToFilesContext) { forwardToFilesContext(httpServletRequest, httpServletResponse, request); } else { httpServletResponse.sendError(HTTP_NOT_FOUND); } } catch (Exception e) { throwUnchecked(e); } } }
private <B, R> R executeRequest(RequestSpec requestSpec, PathParams pathParams, B requestBody, Class<R> responseType) { String url = String.format(ADMIN_URL_PREFIX + requestSpec.path(pathParams), scheme, host, port, urlPathPrefix); RequestBuilder requestBuilder = RequestBuilder .create(requestSpec.method().getName()) .setUri(url); if (requestBody != null) { requestBuilder.setEntity(jsonStringEntity(Json.write(requestBody))); } String responseBodyString = safelyExecuteRequest(url, requestBuilder.build()); return responseType == Void.class ? null : Json.read(responseBodyString, responseType); }
private void validateResponse(HttpExecuteResponse response, int returnCode, SdkHttpMethod method) throws IOException { RequestMethod requestMethod = RequestMethod.fromString(method.name()); RequestPatternBuilder patternBuilder = RequestPatternBuilder.newRequestPattern(requestMethod, urlMatching("/")) .withHeader("Host", containing("localhost")) .withHeader("User-Agent", equalTo("hello-world!")); if (method == SdkHttpMethod.HEAD) { patternBuilder.withRequestBody(equalTo("")); } else { patternBuilder.withRequestBody(equalTo("Body")); } verify(1, patternBuilder); if (method == SdkHttpMethod.HEAD) { assertThat(response.responseBody()).isEmpty(); } else { assertThat(IoUtils.toUtf8String(response.responseBody().orElse(null))).isEqualTo("hello"); } assertThat(response.httpResponse().firstMatchingHeader("Some-Header")).contains("With Value"); assertThat(response.httpResponse().statusCode()).isEqualTo(returnCode); mockServer.resetMappings(); }
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);