org.springframework.http.HttpStatus.getReasonPhrase()

@Override
public String getStatusText() throws IOException {
    return status.getReasonPhrase();
}

@Override
public String getStatusText() throws IOException {
    return httpStatus.getReasonPhrase();
}

protected String formatResponseRecord(long count, String prefix, Object response, HttpLogging annotation, long executionTime) throws Exception {
    boolean binaryBody = false;
    StringBuilder record = new StringBuilder();
    record.append(prefix).append(" (").append(count).append(')').append(" - Response ");
    if (annotation.logExecutionTime()) {
        record.append(" (").append(executionTime).append(" ms)");
    }
    if (response instanceof ResponseEnreplacedy) {
        HttpStatus status = ((ResponseEnreplacedy) response).getStatusCode();
        record.append(NEWLINE).append(' ').append(status).append(" - ").append(status.getReasonPhrase());
        if (annotation.logHeaders()) {
            HttpHeaders headers = ((ResponseEnreplacedy) response).getHeaders();
            for (String name : headers.keySet()) {
                record.append(NEWLINE).append(' ').append(name).append(':');
                boolean comma = false;
                for (String value : headers.get(name)) {
                    if (HttpHeaders.CONTENT_TYPE.equals(name) && !readableContent(value)) {
                        binaryBody = true;
                    }
                    if (comma) {
                        record.append(',');
                    } else {
                        comma = true;
                    }
                    record.append(' ').append(value);
                }
            }
        }
        if (annotation.logResponseBody()) {
            record.append(NEWLINE).append(' ').append(BODY_DENOMINATOR);
            if (binaryBody) {
                record.append(NEWLINE).append(' ').append('"').append(BODY_BINARY_MARK).append('"');
            } else {
                try {
                    record.append(NEWLINE).append(' ').append(objectMapper.writeValuereplacedtring(((ResponseEnreplacedy<?>) response).getBody()));
                } catch (JsonProcessingException ex) {
                    record.append(NEWLINE).append(' ').append(((ResponseEnreplacedy<String>) response).getBody());
                }
            }
        }
    } else {
        if (annotation.logResponseBody()) {
            record.append(NEWLINE).append(' ').append("Status").append(" - ").append("OK (method return)");
            record.append(NEWLINE).append(' ').append(BODY_DENOMINATOR);
            try {
                record.append(NEWLINE).append(' ').append(objectMapper.writeValuereplacedtring(response));
            } catch (JsonProcessingException ex) {
            // ignore
            }
        }
    }
    return record.toString();
}

public static <T> Result<T> defaultFallbackResult() {
    return Result.failure().code(DEFAULT_FALLBACK_STATUS.value()).message(String.format("请求失败: %s", DEFAULT_FALLBACK_STATUS.getReasonPhrase())).build();
}

public static <T> PageResult<T> defaultFallbackPageResult() {
    return PageResult.failure().code(DEFAULT_FALLBACK_STATUS.value()).message(String.format("请求失败: %s", DEFAULT_FALLBACK_STATUS.getReasonPhrase())).build();
}

public String getError() {
    return httpStatus.getReasonPhrase();
}

/**
 * Gets httpDesc: 'No Content' (string) - description of HTTP status.
 */
public String getHttpDesc() {
    return status.getReasonPhrase();
}

private static void replacedertNoHttp20xInside(HttpStatus... expectedStatusCodes) {
    for (HttpStatus expectedStatusCode : expectedStatusCodes) {
        if (expectedStatusCode.is2xxSuccessful()) {
            StringBuilder sb = new StringBuilder();
            sb.append("Wrong implemented unit test!\n");
            sb.append("You defined an expected status code inside your test which belongs to 2xxSuccesful familiy:\n");
            sb.append(expectedStatusCode.getReasonPhrase());
            sb.append("\n");
            sb.append("This status is never a failure - so your test is wrong implemented !");
            throw new IllegalArgumentException(sb.toString());
        }
    }
}

protected void validateErrorBody(WebTestClient.BodyContentSpec body, HttpStatus status, String path, String message) {
    body.jsonPath("status").isEqualTo(status.value()).jsonPath("error").isEqualTo(status.getReasonPhrase()).jsonPath("path").isEqualTo(path).jsonPath("message").isEqualTo(message);
}

private void mockResponseStatus(HttpStatus responseStatus) throws Exception {
    given(request.execute()).willReturn(response);
    given(errorHandler.hasError(response)).willReturn(responseStatus.isError());
    given(response.getStatusCode()).willReturn(responseStatus);
    given(response.getRawStatusCode()).willReturn(responseStatus.value());
    given(response.getStatusText()).willReturn(responseStatus.getReasonPhrase());
}

/**
 * Sets description.
 *
 * @param httpCode the http code
 * @param apiResponse the api response
 */
public static void setDescription(String httpCode, ApiResponse apiResponse) {
    try {
        HttpStatus httpStatus = HttpStatus.valueOf(Integer.parseInt(httpCode));
        apiResponse.setDescription(httpStatus.getReasonPhrase());
    } catch (IllegalArgumentException e) {
        apiResponse.setDescription(DEFAULT_DESCRIPTION);
    }
}

@SuppressWarnings("unchecked")
protected StatusInfo getStatusInfoFromStatus(HttpStatus httpStatus, Map<String, ?> body) {
    if (httpStatus.is2xxSuccessful()) {
        return StatusInfo.ofUp();
    }
    Map<String, Object> details = new LinkedHashMap<>();
    details.put("status", httpStatus.value());
    details.put("error", httpStatus.getReasonPhrase());
    if (body.get("details") instanceof Map) {
        details.putAll((Map<? extends String, ?>) body.get("details"));
    } else {
        details.putAll(body);
    }
    return StatusInfo.ofDown(details);
}

@ExceptionHandler(ConstraintViolationsException.clreplaced)
public ResponseEnreplacedy<Object> handleConstraintViolationsException(ConstraintViolationsException e) {
    final List<ViolationDetail> details = e.violations().details();
    return ResponseEnreplacedy.badRequest().body(Map.of("status", httpStatus.value(), "error", httpStatus.getReasonPhrase(), "message", e.getMessage(), "timestamp", new Date(), "details", details));
}

public static DefaultErrorResult failure(ResultCode resultCode, Throwable e, HttpStatus httpStatus) {
    DefaultErrorResult result = new DefaultErrorResult();
    result.setCode(resultCode.code());
    result.setMessage(resultCode.message());
    result.setStatus(httpStatus.value());
    result.setError(httpStatus.getReasonPhrase());
    result.setException(e.getClreplaced().getName());
    result.setPath(RequestContextHolderUtil.getRequest().getRequestURI());
    result.setTimestamp(new Date());
    return result;
}

@Test
public void putNull() throws Exception {
    given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.PUT)).willReturn(request);
    HttpHeaders requestHeaders = new HttpHeaders();
    given(request.getHeaders()).willReturn(requestHeaders);
    given(request.execute()).willReturn(response);
    given(errorHandler.hasError(response)).willReturn(false);
    HttpStatus status = HttpStatus.OK;
    given(response.getStatusCode()).willReturn(status);
    given(response.getStatusText()).willReturn(status.getReasonPhrase());
    template.put("http://example.com", null);
    replacedertEquals("Invalid content length", 0, requestHeaders.getContentLength());
    verify(response).close();
}

@Test
public void headForHeaders() throws Exception {
    given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.HEAD)).willReturn(request);
    given(request.execute()).willReturn(response);
    given(errorHandler.hasError(response)).willReturn(false);
    HttpHeaders responseHeaders = new HttpHeaders();
    given(response.getHeaders()).willReturn(responseHeaders);
    HttpStatus status = HttpStatus.OK;
    given(response.getStatusCode()).willReturn(status);
    given(response.getStatusText()).willReturn(status.getReasonPhrase());
    HttpHeaders result = template.headForHeaders("http://example.com");
    replacedertSame("Invalid headers returned", responseHeaders, result);
    verify(response).close();
}

@Test
public void delete() throws Exception {
    given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.DELETE)).willReturn(request);
    given(request.execute()).willReturn(response);
    given(errorHandler.hasError(response)).willReturn(false);
    HttpStatus status = HttpStatus.OK;
    given(response.getStatusCode()).willReturn(status);
    given(response.getStatusText()).willReturn(status.getReasonPhrase());
    template.delete("http://example.com");
    verify(response).close();
}

@Test
public void postForLocationNull() throws Exception {
    given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).willReturn(request);
    HttpHeaders requestHeaders = new HttpHeaders();
    given(request.getHeaders()).willReturn(requestHeaders);
    given(request.execute()).willReturn(response);
    given(errorHandler.hasError(response)).willReturn(false);
    HttpHeaders responseHeaders = new HttpHeaders();
    given(response.getHeaders()).willReturn(responseHeaders);
    HttpStatus status = HttpStatus.OK;
    given(response.getStatusCode()).willReturn(status);
    given(response.getStatusText()).willReturn(status.getReasonPhrase());
    template.postForLocation("http://example.com", null);
    replacedertEquals("Invalid content length", 0, requestHeaders.getContentLength());
    verify(response).close();
}

public static <T> BaseResponse<T> result(HttpStatus httpStatus, String message, T data) {
    boolean success = false;
    if (httpStatus.value() == HttpStatus.OK.value()) {
        success = true;
    }
    if (StringUtils.isBlank(message)) {
        String apiMessage = httpStatus.getReasonPhrase();
        message = apiMessage;
    }
    return (BaseResponse<T>) BaseResponse.builder().code(httpStatus.value()).message(message).data(data).success(success).time(LocalDateTime.now()).build();
}

private String getMessageForStatus(HttpStatus status) {
    switch(status) {
        case UNAUTHORIZED:
            return ACCESS_DENIED;
        case BAD_REQUEST:
            return INVALID_REQUEST;
        default:
            return status.getReasonPhrase();
    }
}

@JsonProperty
@JacksonXmlProperty(isAttribute = true)
public String getHttpStatus() {
    return httpStatus.getReasonPhrase();
}

/**
 * 处理非浏览器访问出错
 * 返回带有 message 字段的 JSON 数据
 */
@Override
public ResponseEnreplacedy<Map<String, Object>> error(HttpServletRequest request) {
    HttpStatus status = this.getStatus(request);
    Map<String, Object> body = new HashMap<>();
    body.put("message", status.getReasonPhrase());
    return new ResponseEnreplacedy(body, status);
}

@Override
public ModelAndView resolveErrorView(HttpServletRequest request, HttpStatus status, Map<String, Object> model) {
    Map<String, Object> errorModel = new HashMap<>(model);
    errorModel.put("status", status.value());
    errorModel.put("comment", status.getReasonPhrase());
    errorModel.put("pagereplacedle", replacedleBuilder.build(status.value() + " - " + status.getReasonPhrase()));
    return new ModelAndView("fail", errorModel);
}

@Test
public void varArgsNullTemplateVariable() throws Exception {
    given(requestFactory.createRequest(new URI("http://example.com/-foo"), HttpMethod.GET)).willReturn(request);
    given(request.execute()).willReturn(response);
    given(errorHandler.hasError(response)).willReturn(false);
    HttpStatus status = HttpStatus.OK;
    given(response.getStatusCode()).willReturn(status);
    given(response.getStatusText()).willReturn(status.getReasonPhrase());
    template.execute("http://example.com/{first}-{last}", HttpMethod.GET, null, null, null, "foo");
    verify(response).close();
}

@Test
public void mapNullTemplateVariable() throws Exception {
    given(requestFactory.createRequest(new URI("http://example.com/-foo"), HttpMethod.GET)).willReturn(request);
    given(request.execute()).willReturn(response);
    given(errorHandler.hasError(response)).willReturn(false);
    HttpStatus status = HttpStatus.OK;
    given(response.getStatusCode()).willReturn(status);
    given(response.getStatusText()).willReturn(status.getReasonPhrase());
    Map<String, String> vars = new HashMap<String, String>(2);
    vars.put("first", null);
    vars.put("last", "foo");
    template.execute("http://example.com/{first}-{last}", HttpMethod.GET, null, null, vars);
    verify(response).close();
}

@Test
@SuppressWarnings("rawtypes")
public void exchangeParameterizedType() throws Exception {
    GenericHttpMessageConverter converter = mock(GenericHttpMessageConverter.clreplaced);
    template.setMessageConverters(Collections.<HttpMessageConverter<?>>singletonList(converter));
    ParameterizedTypeReference<List<Integer>> intList = new ParameterizedTypeReference<List<Integer>>() {
    };
    given(converter.canRead(intList.getType(), null, null)).willReturn(true);
    given(converter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.TEXT_PLAIN));
    given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).willReturn(this.request);
    HttpHeaders requestHeaders = new HttpHeaders();
    given(this.request.getHeaders()).willReturn(requestHeaders);
    given(converter.canWrite(String.clreplaced, null)).willReturn(true);
    String requestBody = "Hello World";
    converter.write(requestBody, null, this.request);
    given(this.request.execute()).willReturn(response);
    given(errorHandler.hasError(response)).willReturn(false);
    List<Integer> expected = Collections.singletonList(42);
    HttpHeaders responseHeaders = new HttpHeaders();
    responseHeaders.setContentType(MediaType.TEXT_PLAIN);
    responseHeaders.setContentLength(10);
    given(response.getStatusCode()).willReturn(HttpStatus.OK);
    given(response.getHeaders()).willReturn(responseHeaders);
    given(response.getBody()).willReturn(new ByteArrayInputStream(new Integer(42).toString().getBytes()));
    given(converter.canRead(intList.getType(), null, MediaType.TEXT_PLAIN)).willReturn(true);
    given(converter.read(eq(intList.getType()), eq(null), any(HttpInputMessage.clreplaced))).willReturn(expected);
    given(response.getStatusCode()).willReturn(HttpStatus.OK);
    HttpStatus status = HttpStatus.OK;
    given(response.getStatusCode()).willReturn(status);
    given(response.getStatusText()).willReturn(status.getReasonPhrase());
    HttpHeaders enreplacedyHeaders = new HttpHeaders();
    enreplacedyHeaders.set("MyHeader", "MyValue");
    HttpEnreplacedy<String> requestEnreplacedy = new HttpEnreplacedy<String>(requestBody, enreplacedyHeaders);
    ResponseEnreplacedy<List<Integer>> result = template.exchange("http://example.com", HttpMethod.POST, requestEnreplacedy, intList);
    replacedertEquals("Invalid POST result", expected, result.getBody());
    replacedertEquals("Invalid Content-Type", MediaType.TEXT_PLAIN, result.getHeaders().getContentType());
    replacedertEquals("Invalid Accept header", MediaType.TEXT_PLAIN_VALUE, requestHeaders.getFirst("Accept"));
    replacedertEquals("Invalid custom header", "MyValue", requestHeaders.getFirst("MyHeader"));
    replacedertEquals("Invalid status code", HttpStatus.OK, result.getStatusCode());
    verify(response).close();
}

@Test
public void postForLocationNoLocation() throws Exception {
    given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).willReturn(request);
    String helloWorld = "Hello World";
    given(converter.canWrite(String.clreplaced, null)).willReturn(true);
    converter.write(helloWorld, null, request);
    given(request.execute()).willReturn(response);
    given(errorHandler.hasError(response)).willReturn(false);
    HttpHeaders responseHeaders = new HttpHeaders();
    given(response.getHeaders()).willReturn(responseHeaders);
    HttpStatus status = HttpStatus.OK;
    given(response.getStatusCode()).willReturn(status);
    given(response.getStatusText()).willReturn(status.getReasonPhrase());
    URI result = template.postForLocation("http://example.com", helloWorld);
    replacedertNull("Invalid POST result", result);
    verify(response).close();
}

@Test
public void postForObjectNull() throws Exception {
    MediaType textPlain = new MediaType("text", "plain");
    given(converter.canRead(Integer.clreplaced, null)).willReturn(true);
    given(converter.getSupportedMediaTypes()).willReturn(Collections.singletonList(textPlain));
    given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).willReturn(request);
    HttpHeaders requestHeaders = new HttpHeaders();
    given(request.getHeaders()).willReturn(requestHeaders);
    given(request.execute()).willReturn(response);
    given(errorHandler.hasError(response)).willReturn(false);
    HttpHeaders responseHeaders = new HttpHeaders();
    responseHeaders.setContentType(textPlain);
    responseHeaders.setContentLength(10);
    given(response.getStatusCode()).willReturn(HttpStatus.OK);
    given(response.getHeaders()).willReturn(responseHeaders);
    given(converter.canRead(Integer.clreplaced, textPlain)).willReturn(true);
    given(converter.read(Integer.clreplaced, response)).willReturn(null);
    HttpStatus status = HttpStatus.OK;
    given(response.getStatusCode()).willReturn(status);
    given(response.getStatusText()).willReturn(status.getReasonPhrase());
    Integer result = template.postForObject("http://example.com", null, Integer.clreplaced);
    replacedertNull("Invalid POST result", result);
    replacedertEquals("Invalid content length", 0, requestHeaders.getContentLength());
    verify(response).close();
}

@Test
public void mapTemplateVariables() throws Exception {
    given(requestFactory.createRequest(new URI("http://example.com/hotels/42/bookings/42"), HttpMethod.GET)).willReturn(request);
    given(request.execute()).willReturn(response);
    given(errorHandler.hasError(response)).willReturn(false);
    HttpStatus status = HttpStatus.OK;
    given(response.getStatusCode()).willReturn(status);
    given(response.getStatusText()).willReturn(status.getReasonPhrase());
    Map<String, String> vars = Collections.singletonMap("hotel", "42");
    template.execute("http://example.com/hotels/{hotel}/bookings/{hotel}", HttpMethod.GET, null, null, vars);
    verify(response).close();
}

@Test
public void postForEnreplacedyNull() throws Exception {
    MediaType textPlain = new MediaType("text", "plain");
    given(converter.canRead(Integer.clreplaced, null)).willReturn(true);
    given(converter.getSupportedMediaTypes()).willReturn(Collections.singletonList(textPlain));
    given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).willReturn(request);
    HttpHeaders requestHeaders = new HttpHeaders();
    given(request.getHeaders()).willReturn(requestHeaders);
    given(request.execute()).willReturn(response);
    given(errorHandler.hasError(response)).willReturn(false);
    HttpHeaders responseHeaders = new HttpHeaders();
    responseHeaders.setContentType(textPlain);
    responseHeaders.setContentLength(10);
    given(response.getStatusCode()).willReturn(HttpStatus.OK);
    given(response.getHeaders()).willReturn(responseHeaders);
    given(converter.canRead(Integer.clreplaced, textPlain)).willReturn(true);
    given(converter.read(Integer.clreplaced, response)).willReturn(null);
    given(response.getStatusCode()).willReturn(HttpStatus.OK);
    HttpStatus status = HttpStatus.OK;
    given(response.getStatusCode()).willReturn(status);
    given(response.getStatusText()).willReturn(status.getReasonPhrase());
    ResponseEnreplacedy<Integer> result = template.postForEnreplacedy("http://example.com", null, Integer.clreplaced);
    replacedertFalse("Invalid POST result", result.hasBody());
    replacedertEquals("Invalid Content-Type", textPlain, result.getHeaders().getContentType());
    replacedertEquals("Invalid content length", 0, requestHeaders.getContentLength());
    replacedertEquals("Invalid status code", HttpStatus.OK, result.getStatusCode());
    verify(response).close();
}

@Test
public void varArgsTemplateVariables() throws Exception {
    given(requestFactory.createRequest(new URI("http://example.com/hotels/42/bookings/21"), HttpMethod.GET)).willReturn(request);
    given(request.execute()).willReturn(response);
    given(errorHandler.hasError(response)).willReturn(false);
    HttpStatus status = HttpStatus.OK;
    given(response.getStatusCode()).willReturn(status);
    given(response.getStatusText()).willReturn(status.getReasonPhrase());
    template.execute("http://example.com/hotels/{hotel}/bookings/{booking}", HttpMethod.GET, null, null, "42", "21");
    verify(response).close();
}

@Test
public void optionsForAllow() throws Exception {
    given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.OPTIONS)).willReturn(request);
    given(request.execute()).willReturn(response);
    given(errorHandler.hasError(response)).willReturn(false);
    HttpHeaders responseHeaders = new HttpHeaders();
    EnumSet<HttpMethod> expected = EnumSet.of(HttpMethod.GET, HttpMethod.POST);
    responseHeaders.setAllow(expected);
    given(response.getHeaders()).willReturn(responseHeaders);
    HttpStatus status = HttpStatus.OK;
    given(response.getStatusCode()).willReturn(status);
    given(response.getStatusText()).willReturn(status.getReasonPhrase());
    Set<HttpMethod> result = template.optionsForAllow("http://example.com");
    replacedertEquals("Invalid OPTIONS result", expected, result);
    verify(response).close();
}

@Test
public void postForLocation() throws Exception {
    given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).willReturn(request);
    String helloWorld = "Hello World";
    given(converter.canWrite(String.clreplaced, null)).willReturn(true);
    converter.write(helloWorld, null, request);
    given(request.execute()).willReturn(response);
    given(errorHandler.hasError(response)).willReturn(false);
    HttpHeaders responseHeaders = new HttpHeaders();
    URI expected = new URI("http://example.com/hotels");
    responseHeaders.setLocation(expected);
    given(response.getHeaders()).willReturn(responseHeaders);
    HttpStatus status = HttpStatus.OK;
    given(response.getStatusCode()).willReturn(status);
    given(response.getStatusText()).willReturn(status.getReasonPhrase());
    URI result = template.postForLocation("http://example.com", helloWorld);
    replacedertEquals("Invalid POST result", expected, result);
    verify(response).close();
}

@Test
public void put() throws Exception {
    given(converter.canWrite(String.clreplaced, null)).willReturn(true);
    given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.PUT)).willReturn(request);
    String helloWorld = "Hello World";
    converter.write(helloWorld, null, request);
    given(request.execute()).willReturn(response);
    given(errorHandler.hasError(response)).willReturn(false);
    HttpStatus status = HttpStatus.OK;
    given(response.getStatusCode()).willReturn(status);
    given(response.getStatusText()).willReturn(status.getReasonPhrase());
    template.put("http://example.com", helloWorld);
    verify(response).close();
}

@Test
public void postForLocationEnreplacedyCustomHeader() throws Exception {
    given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).willReturn(request);
    String helloWorld = "Hello World";
    given(converter.canWrite(String.clreplaced, null)).willReturn(true);
    HttpHeaders requestHeaders = new HttpHeaders();
    given(request.getHeaders()).willReturn(requestHeaders);
    converter.write(helloWorld, null, request);
    given(request.execute()).willReturn(response);
    given(errorHandler.hasError(response)).willReturn(false);
    HttpHeaders responseHeaders = new HttpHeaders();
    URI expected = new URI("http://example.com/hotels");
    responseHeaders.setLocation(expected);
    given(response.getHeaders()).willReturn(responseHeaders);
    HttpStatus status = HttpStatus.OK;
    given(response.getStatusCode()).willReturn(status);
    given(response.getStatusText()).willReturn(status.getReasonPhrase());
    HttpHeaders enreplacedyHeaders = new HttpHeaders();
    enreplacedyHeaders.set("MyHeader", "MyValue");
    HttpEnreplacedy<String> enreplacedy = new HttpEnreplacedy<String>(helloWorld, enreplacedyHeaders);
    URI result = template.postForLocation("http://example.com", enreplacedy);
    replacedertEquals("Invalid POST result", expected, result);
    replacedertEquals("No custom header set", "MyValue", requestHeaders.getFirst("MyHeader"));
    verify(response).close();
}

@Test
public void postForLocationEnreplacedyContentType() throws Exception {
    given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).willReturn(request);
    String helloWorld = "Hello World";
    MediaType contentType = MediaType.TEXT_PLAIN;
    given(converter.canWrite(String.clreplaced, contentType)).willReturn(true);
    HttpHeaders requestHeaders = new HttpHeaders();
    given(request.getHeaders()).willReturn(requestHeaders);
    converter.write(helloWorld, contentType, request);
    given(request.execute()).willReturn(response);
    given(errorHandler.hasError(response)).willReturn(false);
    HttpHeaders responseHeaders = new HttpHeaders();
    URI expected = new URI("http://example.com/hotels");
    responseHeaders.setLocation(expected);
    given(response.getHeaders()).willReturn(responseHeaders);
    HttpStatus status = HttpStatus.OK;
    given(response.getStatusCode()).willReturn(status);
    given(response.getStatusText()).willReturn(status.getReasonPhrase());
    HttpHeaders enreplacedyHeaders = new HttpHeaders();
    enreplacedyHeaders.setContentType(contentType);
    HttpEnreplacedy<String> enreplacedy = new HttpEnreplacedy<String>(helloWorld, enreplacedyHeaders);
    URI result = template.postForLocation("http://example.com", enreplacedy);
    replacedertEquals("Invalid POST result", expected, result);
    verify(response).close();
}

@ParameterizedTest
@MethodSource
void testHandleExceptionForCloudOperationExceptionWithAllHttpStatuses(HttpStatus httpStatus) {
    ResponseEnreplacedy<String> response = exceptionMapper.handleException(new CloudOperationException(httpStatus, httpStatus.getReasonPhrase()));
    StringBuilder expectedMessage = new StringBuilder();
    expectedMessage.append(httpStatus.value());
    expectedMessage.append(" ");
    expectedMessage.append(httpStatus.getReasonPhrase());
    RestResponse expectedResponse = new RestResponse(httpStatus.value(), expectedMessage.toString());
    replacedertEquals(expectedResponse.getStatus(), response.getStatusCodeValue());
    replacedertEquals(expectedResponse.getEnreplacedy(), response.getBody());
}

@ExceptionHandler(ApiException.clreplaced)
public final ResponseEnreplacedy<ErrorMessage> handleApiException(ApiException ex, WebRequest request) {
    HttpStatus status = ex.getStatus();
    ErrorMessage errorDetails = ErrorMessage.builder().timestamp(ex.getTimestamp()).status(status.value()).error(status.getReasonPhrase()).message(ex.getMessage()).build();
    if (request instanceof ServletWebRequest) {
        ServletWebRequest servletWebRequest = (ServletWebRequest) request;
        HttpServletRequest servletRequest = servletWebRequest.getNativeRequest(HttpServletRequest.clreplaced);
        errorDetails.setPath(servletRequest.getRequestURI());
    }
    return new ResponseEnreplacedy<>(errorDetails, status);
}

@Override
public Map<String, Object> getErrorAttributes(ServerRequest request, boolean includeStackTrace) {
    Map<String, Object> errorAttributes = new LinkedHashMap<>();
    errorAttributes.put("timestamp", new Date());
    errorAttributes.put("path", request.path());
    Throwable error = getError(request);
    HttpStatus errorStatus = determineHttpStatus(error);
    errorAttributes.put("status", errorStatus.value());
    errorAttributes.put("error", errorStatus.getReasonPhrase());
    errorAttributes.put("message", determineMessage(error));
    handleException(errorAttributes, determineException(error), includeStackTrace);
    return errorAttributes;
}

@Test
public void postForObject() throws Exception {
    MediaType textPlain = new MediaType("text", "plain");
    given(converter.canRead(Integer.clreplaced, null)).willReturn(true);
    given(converter.getSupportedMediaTypes()).willReturn(Collections.singletonList(textPlain));
    given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).willReturn(this.request);
    HttpHeaders requestHeaders = new HttpHeaders();
    given(this.request.getHeaders()).willReturn(requestHeaders);
    String request = "Hello World";
    given(converter.canWrite(String.clreplaced, null)).willReturn(true);
    converter.write(request, null, this.request);
    given(this.request.execute()).willReturn(response);
    given(errorHandler.hasError(response)).willReturn(false);
    Integer expected = 42;
    HttpHeaders responseHeaders = new HttpHeaders();
    responseHeaders.setContentType(textPlain);
    responseHeaders.setContentLength(10);
    given(response.getStatusCode()).willReturn(HttpStatus.OK);
    given(response.getHeaders()).willReturn(responseHeaders);
    given(response.getBody()).willReturn(new ByteArrayInputStream(expected.toString().getBytes()));
    given(converter.canRead(Integer.clreplaced, textPlain)).willReturn(true);
    given(converter.read(eq(Integer.clreplaced), any(HttpInputMessage.clreplaced))).willReturn(expected);
    HttpStatus status = HttpStatus.OK;
    given(response.getStatusCode()).willReturn(status);
    given(response.getStatusText()).willReturn(status.getReasonPhrase());
    Integer result = template.postForObject("http://example.com", request, Integer.clreplaced);
    replacedertEquals("Invalid POST result", expected, result);
    replacedertEquals("Invalid Accept header", textPlain.toString(), requestHeaders.getFirst("Accept"));
    verify(response).close();
}

@Test
public void exchange() throws Exception {
    given(converter.canRead(Integer.clreplaced, null)).willReturn(true);
    given(converter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.TEXT_PLAIN));
    given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).willReturn(this.request);
    HttpHeaders requestHeaders = new HttpHeaders();
    given(this.request.getHeaders()).willReturn(requestHeaders);
    given(converter.canWrite(String.clreplaced, null)).willReturn(true);
    String body = "Hello World";
    converter.write(body, null, this.request);
    given(this.request.execute()).willReturn(response);
    given(errorHandler.hasError(response)).willReturn(false);
    Integer expected = 42;
    HttpHeaders responseHeaders = new HttpHeaders();
    responseHeaders.setContentType(MediaType.TEXT_PLAIN);
    responseHeaders.setContentLength(10);
    given(response.getStatusCode()).willReturn(HttpStatus.OK);
    given(response.getHeaders()).willReturn(responseHeaders);
    given(response.getBody()).willReturn(new ByteArrayInputStream(expected.toString().getBytes()));
    given(converter.canRead(Integer.clreplaced, MediaType.TEXT_PLAIN)).willReturn(true);
    given(converter.read(Integer.clreplaced, response)).willReturn(expected);
    given(converter.read(eq(Integer.clreplaced), any(HttpInputMessage.clreplaced))).willReturn(expected);
    given(response.getStatusCode()).willReturn(HttpStatus.OK);
    HttpStatus status = HttpStatus.OK;
    given(response.getStatusCode()).willReturn(status);
    given(response.getStatusText()).willReturn(status.getReasonPhrase());
    HttpHeaders enreplacedyHeaders = new HttpHeaders();
    enreplacedyHeaders.set("MyHeader", "MyValue");
    HttpEnreplacedy<String> requestEnreplacedy = new HttpEnreplacedy<String>(body, enreplacedyHeaders);
    ResponseEnreplacedy<Integer> result = template.exchange("http://example.com", HttpMethod.POST, requestEnreplacedy, Integer.clreplaced);
    replacedertEquals("Invalid POST result", expected, result.getBody());
    replacedertEquals("Invalid Content-Type", MediaType.TEXT_PLAIN, result.getHeaders().getContentType());
    replacedertEquals("Invalid Accept header", MediaType.TEXT_PLAIN_VALUE, requestHeaders.getFirst("Accept"));
    replacedertEquals("Invalid custom header", "MyValue", requestHeaders.getFirst("MyHeader"));
    replacedertEquals("Invalid status code", HttpStatus.OK, result.getStatusCode());
    verify(response).close();
}

@Test
public void getUnsupportedMediaType() throws Exception {
    given(converter.canRead(String.clreplaced, null)).willReturn(true);
    MediaType supportedMediaType = new MediaType("foo", "bar");
    given(converter.getSupportedMediaTypes()).willReturn(Collections.singletonList(supportedMediaType));
    given(requestFactory.createRequest(new URI("http://example.com/resource"), HttpMethod.GET)).willReturn(request);
    HttpHeaders requestHeaders = new HttpHeaders();
    given(request.getHeaders()).willReturn(requestHeaders);
    given(request.execute()).willReturn(response);
    given(errorHandler.hasError(response)).willReturn(false);
    HttpHeaders responseHeaders = new HttpHeaders();
    MediaType contentType = new MediaType("bar", "baz");
    responseHeaders.setContentType(contentType);
    responseHeaders.setContentLength(10);
    given(response.getStatusCode()).willReturn(HttpStatus.OK);
    given(response.getHeaders()).willReturn(responseHeaders);
    given(response.getBody()).willReturn(new ByteArrayInputStream("Foo".getBytes()));
    given(converter.canRead(String.clreplaced, contentType)).willReturn(false);
    HttpStatus status = HttpStatus.OK;
    given(response.getStatusCode()).willReturn(status);
    given(response.getStatusText()).willReturn(status.getReasonPhrase());
    try {
        template.getForObject("http://example.com/{p}", String.clreplaced, "resource");
        fail("UnsupportedMediaTypeException expected");
    } catch (RestClientException ex) {
    // expected
    }
    verify(response).close();
}

@Test
public void postForEnreplacedy() throws Exception {
    MediaType textPlain = new MediaType("text", "plain");
    given(converter.canRead(Integer.clreplaced, null)).willReturn(true);
    given(converter.getSupportedMediaTypes()).willReturn(Collections.singletonList(textPlain));
    given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).willReturn(this.request);
    HttpHeaders requestHeaders = new HttpHeaders();
    given(this.request.getHeaders()).willReturn(requestHeaders);
    String request = "Hello World";
    given(converter.canWrite(String.clreplaced, null)).willReturn(true);
    converter.write(request, null, this.request);
    given(this.request.execute()).willReturn(response);
    given(errorHandler.hasError(response)).willReturn(false);
    Integer expected = 42;
    HttpHeaders responseHeaders = new HttpHeaders();
    responseHeaders.setContentType(textPlain);
    responseHeaders.setContentLength(10);
    given(response.getStatusCode()).willReturn(HttpStatus.OK);
    given(response.getHeaders()).willReturn(responseHeaders);
    given(response.getBody()).willReturn(new ByteArrayInputStream(expected.toString().getBytes()));
    given(converter.canRead(Integer.clreplaced, textPlain)).willReturn(true);
    given(converter.read(eq(Integer.clreplaced), any(HttpInputMessage.clreplaced))).willReturn(expected);
    given(response.getStatusCode()).willReturn(HttpStatus.OK);
    HttpStatus status = HttpStatus.OK;
    given(response.getStatusCode()).willReturn(status);
    given(response.getStatusText()).willReturn(status.getReasonPhrase());
    ResponseEnreplacedy<Integer> result = template.postForEnreplacedy("http://example.com", request, Integer.clreplaced);
    replacedertEquals("Invalid POST result", expected, result.getBody());
    replacedertEquals("Invalid Content-Type", textPlain, result.getHeaders().getContentType());
    replacedertEquals("Invalid Accept header", textPlain.toString(), requestHeaders.getFirst("Accept"));
    replacedertEquals("Invalid status code", HttpStatus.OK, result.getStatusCode());
    verify(response).close();
}

private static Error buildErrorFromIdenreplacedyProviderError(IdenreplacedyProviderError idenreplacedyProviderError, HttpStatus code) {
    if (StringUtils.hasText(idenreplacedyProviderError.getKey())) {
        switch(idenreplacedyProviderError.getKey()) {
            case INVALID_PreplacedWORD_KEY:
            case PreplacedWORD_MUST_NOT_BE_BLANK:
            case PreplacedWORD_CANNOT_BE_SO_SHORT:
            case PreplacedWORD_CANNOT_BE_SO_LONG:
            case PreplacedWORD_MUST_CONTAIN_AT_LEAST_ONE_LOWER_CASE_LETTER:
            case PreplacedWORD_MUST_CONTAIN_AT_LEAST_ONE_UPPER_CASE_LETTER:
            case PreplacedWORD_MUST_CONTAIN_AT_LEAST_ONE_NUMBER:
                return Error.fieldError(PreplacedWORD_FIELD_KEY, code.getReasonPhrase(), idenreplacedyProviderError.getKey());
            case EMAIL_MUST_BE_VALID:
                return Error.fieldError(EMAIL_FIELD_KEY, code.getReasonPhrase(), idenreplacedyProviderError.getKey());
        }
    }
    return new Error(idenreplacedyProviderError.getKey(), code);
}

@ExceptionHandler(Exception.clreplaced)
@ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
public BaseResponse<?> handleGlobalException(Exception e) {
    BaseResponse<?> baseResponse = handleBaseException(e);
    HttpStatus status = HttpStatus.INTERNAL_SERVER_ERROR;
    baseResponse.setStatus(status.value());
    baseResponse.setMessage(status.getReasonPhrase());
    return baseResponse;
}

@ExceptionHandler(NoHandlerFoundException.clreplaced)
@ResponseStatus(HttpStatus.BAD_GATEWAY)
public BaseResponse<?> handleNoHandlerFoundException(NoHandlerFoundException e) {
    BaseResponse<?> baseResponse = handleBaseException(e);
    HttpStatus status = HttpStatus.BAD_GATEWAY;
    baseResponse.setStatus(status.value());
    baseResponse.setMessage(status.getReasonPhrase());
    return baseResponse;
}

@ExceptionHandler(ApiException.clreplaced)
public final ResponseEnreplacedy<ErrorMessage> handleApiException(ApiException ex, WebRequest request) {
    HttpStatus status = ex.getStatus();
    ErrorMessage errorDetails = new ErrorMessage().timestamp(ex.getTimestamp()).status(status.value()).error(status.getReasonPhrase()).message(ex.getMessage());
    if (request instanceof ServletWebRequest) {
        ServletWebRequest servletWebRequest = (ServletWebRequest) request;
        HttpServletRequest servletRequest = servletWebRequest.getNativeRequest(HttpServletRequest.clreplaced);
        if (servletRequest != null) {
            errorDetails = errorDetails.path(servletRequest.getRequestURI());
        }
    }
    return new ResponseEnreplacedy<>(errorDetails, status);
}

/**
 * Handles http status error.
 *
 * @param request
 * @param model
 * @return
 */
@RequestMapping(value = ERROR_PATH)
public String handleError(HttpServletRequest request, Model model) {
    HttpStatus httpStatus = getStatus(request);
    model.addAttribute("message", httpStatus.getReasonPhrase());
    return getErrorPath();
}

@RequestMapping(value = "/error")
@ResponseBody
public Object error(HttpServletRequest request) {
    Map<String, Object> body = getErrorAttributes(request, isIncludeStackTrace(request, MediaType.ALL));
    HttpStatus status = getStatus(request);
    return new HttpResp(body).setMsg(status.getReasonPhrase());
}

/**
 * 测试通过设置Result.code来设置HTTP响应的状态码
 * @return
 */
@GetMapping(value = "/result", produces = MediaType.APPLICATION_JSON_VALUE)
public Mono<Object> testResults() {
    HttpStatus status = HttpStatus.BAD_REQUEST;
    Result<Object> result = Result.failure().code(status.value()).message(status.getReasonPhrase()).build();
    return Mono.just(result);
}

See More Examples