How to use

RequestMethod

in

com.github.tomakehurst.wiremock.http

@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);
  }
}

public boolean matches(RequestMethod method, String path) {
  return (this.method.equals(ANY) || this.method.equals(method)) && uriTemplate.matches(path);
}

  @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);
}

public MatchResult match(RequestMethod method) {
  return MatchResult.of(this.equals(ANY) || this.equals(method));
}

  @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);