Java 类org.springframework.http.HttpMethod 实例源码

public void postOrUpdateRightHolder(String eppn) {  
    if(enable) {
        String url = webUrl + "/rightholders/" + eppn;
        HttpHeaders headers = this.getAuthHeaders();    
        HttpEntity entity = new HttpEntity(headers);        
        try {
            ResponseEntity<RightHolder> response = restTemplate.exchange(url, HttpMethod.GET, entity, RightHolder.class);
            log.info("Getting RightHolder for " + eppn +" : " + response.toString());
            RightHolder oldRightHolder = response.getBody();
            RightHolder newRightHolder = this.computeEsupSgcRightHolder(eppn);
            if(!newRightHolder.fieldWoDueDateEquals(oldRightHolder) || mustUpdateDueDateCrous(oldRightHolder, eppn)) {
                updateRightHolder(eppn);
            } 
        } catch(HttpClientErrorException clientEx) {
            if(HttpStatus.NOT_FOUND.equals(clientEx.getStatusCode())) {
                postRightHolder(eppn);
                return ;
            } else {
                throw clientEx;
            }
        }
    }
}

@Test
public void should_return_cases_as_empty_list_if_patient_not_exist() {
    //Given
    long patientId = 123123;

    //When
    ResponseEntity<List<Case>> response = testRestTemplate.
            withBasicAuth("1","1").
            exchange("/v1/cases?patientId="+patientId,
                    HttpMethod.GET,
                    null,
                    new ParameterizedTypeReference<List<Case>>() {
                    });
    List<Case> cases = response.getBody();

    //Then
    assertThat(cases).isNotNull();
    assertThat(cases).isEmpty();
}

@Override
protected void configure(HttpSecurity httpSecurity) throws Exception {
    httpSecurity
            // we don't need CSRF because our token is invulnerable
            .csrf().disable()

            .exceptionHandling().authenticationEntryPoint(jwtAuthenticationEntryPoint).and()

            // no need to create session as JWT auth is stateless and per request
            .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS).and()

            .authorizeRequests()
            .antMatchers("/auth").permitAll()                   // allow anyone to try and authenticate
            .antMatchers(HttpMethod.OPTIONS, "/**").permitAll() // allow CORS pre-flighting
            .anyRequest().authenticated();                      // lock down everything else

    // Add our custom JWT security filter before Spring Security's Username/Password filter
    httpSecurity.addFilterBefore(authenticationTokenFilterBean(), UsernamePasswordAuthenticationFilter.class);

    // Disable page caching in the browser
    httpSecurity.headers().cacheControl().disable();
}

@Test
public void execute_withHeaders() {
    Request request = new MockRequest("http://example.ca", HttpMethod.GET);
    request.headers().add(HttpHeaders.ACCEPT, MediaType.APPLICATION_JSON_VALUE);
    request.headers().add(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_XML_VALUE);

    requestExecutor.execute(request);
    ClientRequest clientRequest = verifyExchange();
    assertThat(clientRequest.url())
            .isEqualTo(URI.create("http://example.ca"));
    assertThat(clientRequest.method())
            .isEqualTo(HttpMethod.GET);
    assertThat(clientRequest.headers().getFirst(HttpHeaders.ACCEPT))
            .isEqualTo(MediaType.APPLICATION_JSON_VALUE);
    assertThat(clientRequest.headers().getFirst(HttpHeaders.CONTENT_TYPE))
            .isEqualTo(MediaType.APPLICATION_XML_VALUE);
}

@Override
public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException, IOException,
    ServletException {
  if (!HttpMethod.POST.name().equals(request.getMethod()) || !WebUtil.isAjax(request)) {
    if (logger.isDebugEnabled()) {
      logger.debug("Authentication method not supported. Request method: " + request.getMethod());
    }
    throw new AuthMethodNotSupportedException("Authentication method not supported");
  }

  LoginRequest loginRequest = objectMapper.readValue(request.getReader(), LoginRequest.class);

  if (StringUtils.isBlank(loginRequest.getUsername()) || StringUtils.isBlank(loginRequest.getPassword())) {
    throw new AuthenticationServiceException("Username or Password not provided");
  }

  AdminUserAuthenticationToken token = new AdminUserAuthenticationToken(loginRequest.getUsername(), loginRequest.getPassword());

  return this.getAuthenticationManager().authenticate(token);
}

@When("^client_two does a DELETE on (.*?) with (.*?) in zone (.*?)$")
public void client_two_does_a_DELETE_on_api_with_identifier_in_test_zone_dev(final String api,
        final String identifier, final String zone) throws Throwable {

    OAuth2RestTemplate acsTemplate = this.acsZone2Template;
    String zoneName = getZoneName(zone);

    HttpHeaders zoneHeaders = ACSTestUtil.httpHeaders();
    zoneHeaders.set(PolicyHelper.PREDIX_ZONE_ID, zoneName);

    String encodedIdentifier = URLEncoder.encode(identifier, "UTF-8");
    URI uri = URI.create(this.acsUrl + ACS_VERSION + "/" + api + "/" + encodedIdentifier);
    try {
        this.status = acsTemplate
                .exchange(uri, HttpMethod.DELETE, new HttpEntity<>(zoneHeaders), ResponseEntity.class)
                .getStatusCode().value();
    } catch (HttpClientErrorException e) {
        Assert.fail("Unable to DELETE identifier: " + identifier + " for api: " + api);
    }
}

@Test
public void testSubmit()
    throws ExecutionException, InterruptedException {
  String packageData = "this_is_a_package";

  // This test is *very* limited as Spring doesn't have any easy way to check
  // requests with multipart form data...
  server.expect(requestTo("/tasks.json"))
      .andExpect(method(HttpMethod.POST))
      .andExpect(content().contentTypeCompatibleWith(MediaType.MULTIPART_FORM_DATA))
      .andRespond(withSuccess("{\"status\":\"ok\"}", MediaType.APPLICATION_JSON));

  UUID submissionId = UUID.randomUUID();

  CompletableFuture<SubmissionResponse> responseFuture = sender
      .sendSubmission(submissionId, packageData.getBytes());
  SubmissionResponse response = responseFuture.get();

  assertTrue(response.getStatus().equals(SubmissionResponse.OK));
}

@HystrixCommand(fallbackMethod = "defaultComments")
public List<Comment> getComments(Image image, String sessionId) {

    ResponseEntity<List<Comment>> results = restTemplate.exchange(
        "http://COMMENTS/comments/{imageId}",
        HttpMethod.GET,
        new HttpEntity<>(new HttpHeaders() {{
            String credentials = imagesConfiguration.getCommentsUser() + ":" +
                imagesConfiguration.getCommentsPassword();
            String token = new String(Base64Utils.encode(credentials.getBytes()));
            set(AUTHORIZATION, "Basic " + token);
            set("SESSION", sessionId);
        }}),
        new ParameterizedTypeReference<List<Comment>>() {},
        image.getId());
    return results.getBody();
}

/**
 * Gets the topology flows.
 *
 * @return the topology flows
 */
public List<TopologyFlowsResponse> getTopologyFlows() {
    List<TopologyFlowsResponse> flowPathList = new ArrayList<TopologyFlowsResponse>();
    try {
        HttpResponse response =
                restClientManager.invoke(applicationProperties.getTopologyFlows(),
                        HttpMethod.GET, "", "", util.kildaAuthHeader());
        if (RestClientManager.isValidResponse(response)) {

            flowPathList =
                    restClientManager.getResponseList(response, TopologyFlowsResponse.class);
        }

    } catch (Exception exception) {
        log.error("Exception in getTopologyFlows " + exception.getMessage());
    }
    return flowPathList;
}

public synchronized void authenticate() {
    if(enable) {
        String url = webUrl + "/authenticate";
        HttpHeaders headers = getJsonHeaders();
        Map<String, String> body = new HashMap<String, String>();
        body.put("login", login);
        body.put("password", password);
        HttpEntity entity = new HttpEntity(body, headers);  
        HttpEntity<String> response = restTemplate.exchange(url, HttpMethod.POST, entity, String.class);
        HttpHeaders httpHeadersResponse = response.getHeaders();
        log.info("Headers response for crous api authentication : " + httpHeadersResponse);
        List<String> authorizations = httpHeadersResponse.get("authorization");
        if(authorizations!=null && !authorizations.isEmpty()) {
            authToken = authorizations.get(0);
            log.info("Auth Token of Crous API is renew : " + authToken);
        } else {
            throw new SgcRuntimeException("No authorization header when crous authentication : " + httpHeadersResponse, null);
        }
    }
}

@Test
public void should_put_return_406_when_case_not_have_an_id() throws Exception {
    // given
    Case caseEntity = new Case();
    caseEntity.setIllnessStartDate(LocalDate.MAX);
    caseEntity.setNickname("R2-D2");
    caseEntity.setSymptoms("Lorem ipsum dolor sit amet");
    caseEntity.setNote("superiz");
    Case persistedCase = caseRepository.save(caseEntity);
    Long caseId = persistedCase.getId();

    Case updatedCaseOnClientSide = persistedCase;
    updatedCaseOnClientSide.setId(null);

    // when
    ResponseEntity<Void> putResponse = testRestTemplate
            .withBasicAuth("1", "1")
            .exchange("/v1/cases/" + caseId,
                    HttpMethod.PUT,
                    new HttpEntity<>(updatedCaseOnClientSide),
                    Void.class);

    // then
    assertThat(putResponse.getStatusCode()).isEqualTo(HttpStatus.NOT_ACCEPTABLE);
}

/**
 * Gets the HTTP method indicating the operation to perform on the resource identified in the
 * client's HTTP request. This method converts GemFire's HttpMethod enumerated value from the Link
 * into a corresponding Spring HttpMethod enumerated value.
 * <p/>
 * 
 * @return a Spring HttpMethod enumerated value indicating the operation to perform on the
 *         resource identified in the client's HTTP request.
 * @see org.apache.geode.management.internal.web.http.HttpMethod
 * @see org.apache.geode.management.internal.web.domain.Link#getMethod()
 * @see org.springframework.http.HttpMethod
 * @see org.springframework.http.HttpRequest#getMethod()
 */
@Override
public HttpMethod getMethod() {
  switch (getLink().getMethod()) {
    case DELETE:
      return HttpMethod.DELETE;
    case HEAD:
      return HttpMethod.HEAD;
    case OPTIONS:
      return HttpMethod.OPTIONS;
    case POST:
      return HttpMethod.POST;
    case PUT:
      return HttpMethod.PUT;
    case TRACE:
      return HttpMethod.TRACE;
    case GET:
    default:
      return HttpMethod.GET;
  }
}

@Test
public void whenGetCalledThenExpectEmailAlertsConfigToBeReturned() throws Exception {

    final String emailAlertsConfigInJson = objectMapper.writeValueAsString(someEmailAlertsConfig);

    mockServer.expect(requestTo(REST_ENDPOINT_BASE_URL + EMAIL_ALERTS_RESOURCE_PATH))
            .andExpect(method(HttpMethod.GET))
            .andRespond(withSuccess(emailAlertsConfigInJson, MediaType.APPLICATION_JSON));

    final EmailAlertsConfig emailAlertsConfig = restClient.get(botConfig);
    assertThat(emailAlertsConfig.getId()).isEqualTo(BOT_ID);
    assertThat(emailAlertsConfig.isEnabled()).isEqualTo(ENABLED);
    assertThat(emailAlertsConfig.getSmtpConfig().getAccountUsername()).isEqualTo(ACCOUNT_USERNAME);
    assertThat(emailAlertsConfig.getSmtpConfig().getAccountPassword()).isEqualTo(ACCOUNT_PASSWORD);
    assertThat(emailAlertsConfig.getSmtpConfig().getHost()).isEqualTo(HOST);
    assertThat(emailAlertsConfig.getSmtpConfig().getTlsPort()).isEqualTo(TLS_PORT);
    assertThat(emailAlertsConfig.getSmtpConfig().getFromAddress()).isEqualTo(FROM_ADDRESS);
    assertThat(emailAlertsConfig.getSmtpConfig().getToAddress()).isEqualTo(TO_ADDRESS);

    mockServer.verify();
}

@Override
 public void configure(final HttpSecurity http) throws Exception {
    http
        .requestMatchers().antMatchers("/doctor/**", "/rx/**", "/account/**")
        .and()
        .authorizeRequests()
        .antMatchers(HttpMethod.GET,"/doctor/**").access("#oauth2.hasScope('doctor') and #oauth2.hasScope('read')")
.antMatchers(HttpMethod.POST,"/doctor/**").access("#oauth2.hasScope('doctor') and #oauth2.hasScope('write')")
.antMatchers(HttpMethod.GET,"/rx/**").access("#oauth2.hasScope('doctor') and #oauth2.hasScope('read')")
.antMatchers(HttpMethod.POST,"/rx/**").access("#oauth2.hasScope('doctor') and #oauth2.hasScope('write')")   
.antMatchers("/account/**").permitAll()
.and()
.exceptionHandling().accessDeniedHandler(new OAuth2AccessDeniedHandler())
.and()
.csrf().disable();

 }

@Test
public void whenSaveCalledThenExpectRepositoryToSaveItAndReturnSavedEngineConfig() throws Exception {

    final String engineConfigInJson = objectMapper.writeValueAsString(someEngineConfig);

    mockServer.expect(requestTo(REST_ENDPOINT_BASE_URL + ENGINE_RESOURCE_PATH))
            .andExpect(method(HttpMethod.PUT))
            .andRespond(withSuccess(engineConfigInJson, MediaType.APPLICATION_JSON));

    final EngineConfig engineConfig = restClient.save(botConfig, someEngineConfig);
    assertThat(engineConfig.getId()).isEqualTo(BOT_ID);
    assertThat(engineConfig.getBotName()).isEqualTo(BOT_ALIAS);
    assertThat(engineConfig.getTradeCycleInterval()).isEqualTo(ENGINE_TRADE_CYCLE_INTERVAL);
    assertThat(engineConfig.getEmergencyStopCurrency()).isEqualTo(ENGINE_EMERGENCY_STOP_CURRENCY);
    assertThat(engineConfig.getEmergencyStopBalance()).isEqualTo(ENGINE_EMERGENCY_STOP_BALANCE);

    mockServer.verify();
}

@Test
public void whenSaveCalledThenExpectRepositoryToSaveItAndReturnSavedEmailAlertsConfig() throws Exception {

    final String emailAlertsConfigInJson = objectMapper.writeValueAsString(someEmailAlertsConfig);

    mockServer.expect(requestTo(REST_ENDPOINT_BASE_URL + EMAIL_ALERTS_RESOURCE_PATH))
            .andExpect(method(HttpMethod.PUT))
            .andRespond(withSuccess(emailAlertsConfigInJson, MediaType.APPLICATION_JSON));

    final EmailAlertsConfig emailAlertsConfig = restClient.save(botConfig, someEmailAlertsConfig);
    assertThat(emailAlertsConfig.getId()).isEqualTo(BOT_ID);
    assertThat(emailAlertsConfig.isEnabled()).isEqualTo(ENABLED);
    assertThat(emailAlertsConfig.getSmtpConfig().getAccountUsername()).isEqualTo(ACCOUNT_USERNAME);
    assertThat(emailAlertsConfig.getSmtpConfig().getAccountPassword()).isEqualTo(ACCOUNT_PASSWORD);
    assertThat(emailAlertsConfig.getSmtpConfig().getHost()).isEqualTo(HOST);
    assertThat(emailAlertsConfig.getSmtpConfig().getTlsPort()).isEqualTo(TLS_PORT);
    assertThat(emailAlertsConfig.getSmtpConfig().getFromAddress()).isEqualTo(FROM_ADDRESS);
    assertThat(emailAlertsConfig.getSmtpConfig().getToAddress()).isEqualTo(TO_ADDRESS);

    mockServer.verify();
}

@Override
@Nullable
protected <T> T doExecute(URI url, @Nullable HttpMethod method, @Nullable RequestCallback requestCallback,
                          @Nullable ResponseExtractor<T> responseExtractor) throws RestClientException {
    String from = name;
    String to = url.
            toString().
            replace("http://", "").
            replace("http:// www.", "").
            replace("www.", "").
            replace("/", "%20").
            toLowerCase();

    System.out.println(from);
    System.out.println(to);

    try {
        restTemplate.postForObject("http://trace-callback-service/" + from + "/" + to, null, Object.class);
    } catch (Exception exception) {
    }

    return super.doExecute(url, method, requestCallback, responseExtractor);
}

@Test
public void testPagedCollection() throws IOException
{
    ResourceWithMetadata relationResource = locator.locateRelationResource(api,"sheep", "baaahh", HttpMethod.GET);
    assertNotNull(relationResource);
    RelationshipResourceAction.Read<?> getter = (RelationshipResourceAction.Read<?>) relationResource.getResource();
    CollectionWithPagingInfo<?> resources = getter.readAll("123",Params.valueOf("", null, null));
    assertNotNull(resources);
    assertTrue(resources.getTotalItems().intValue() == 3);
    assertFalse(resources.hasMoreItems());
    String out = writeResponse(helper.processAdditionsToTheResponse(mock(WebScriptResponse.class), api,null, Params.valueOf("notUsed", null, null), resources));
    assertTrue("There must be json output as List with pagination", StringUtils.startsWith(out, "{\"list\":{\"pagination\":{\"count\":3,"));

    resources = getter.readAll("123",ParamsExtender.valueOf(Paging.valueOf(0, 1),"123"));
    assertTrue(resources.getCollection().size() == 1);
    assertTrue(resources.hasMoreItems());
    out = writeResponse(helper.processAdditionsToTheResponse(mock(WebScriptResponse.class), api,null, Params.valueOf("notUsed", null, null), resources));
    assertTrue("There must be json output as List with pagination", StringUtils.startsWith(out, "{\"list\":{\"pagination\":{\"count\":1,"));

}

private <T> T doExecute(HttpMethod method, ServiceDTO service, String path, Object request,
                        Class<T> responseType,
                        Object... uriVariables) {
  T result = null;
  switch (method) {
    case GET:
      result = restTemplate.getForObject(parseHost(service) + path, responseType, uriVariables);
      break;
    case POST:
      result =
          restTemplate.postForEntity(parseHost(service) + path, request, responseType, uriVariables).getBody();
      break;
    case PUT:
      restTemplate.put(parseHost(service) + path, request, uriVariables);
      break;
    case DELETE:
      restTemplate.delete(parseHost(service) + path, uriVariables);
      break;
    default:
      throw new UnsupportedOperationException(String.format("unsupported http method(method=%s)", method));
  }
  return result;
}

@Test
public void testPingWebServerTwice() throws Exception {
    when(mockClientHttpResponse.getStatusCode()).thenReturn(HttpStatus.OK);
    when(mockClientHttpRequest.execute()).thenReturn(mockClientHttpResponse);
    when(mockHttpRequestFactory.createRequest(any(URI.class), eq(HttpMethod.GET))).thenReturn(mockClientHttpRequest);
    final Identifier<WebServer> id = new Identifier<>(1L);
    when(mockWebServer.getId()).thenReturn(id);
    webServerStateSetterWorker.pingWebServer(mockWebServer);
    verify(mockWebServerService).updateState(any(Identifier.class), eq(WebServerReachableState.WS_REACHABLE),
            eq(StringUtils.EMPTY));
    verify(mockMessagingService).send(any(WebServerState.class));


    reset(mockWebServerService);
    reset(mockMessagingService);
    webServerStateSetterWorker.pingWebServer(mockWebServer);
    verify(mockWebServerService, never()).updateState(any(Identifier.class), eq(WebServerReachableState.WS_REACHABLE),
            eq(StringUtils.EMPTY));
    verify(mockMessagingService, never()).send(any(WebServerState.class));
}

@Test
public void should_delete_return_404_for_non_existing_medicine() throws Exception {
    //given

    // when
    ResponseEntity<Void> deleteResponse = testRestTemplate
            .withBasicAuth("1", "1")
            .exchange(url + "/1234321",
                    HttpMethod.DELETE,
                    HttpEntity.EMPTY,
                    Void.class);

    // then
    assertThat(deleteResponse.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND);

}

@Test
public void should_put_return_404_for_nonexisting_treatment() throws Exception {

    // given
    ResponseEntity<Void> response = getCreateTreatmentResponse();
    URI location = response.getHeaders().getLocation();
    String id = RestHelper.extractIdStringFromURI(location);

    Treatment savedTreatment = treatmentRepository.findOne(Long.parseLong(id));

    // when
    ResponseEntity<Void> putResponse = testRestTemplate
            .withBasicAuth("1", "1")
            .exchange("/v1/treatments/1938412",
                    HttpMethod.PUT,
                    new HttpEntity<>(savedTreatment),
                    Void.class);

    // then
    assertThat(putResponse.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND);
}

@Test
public void executeWithUnderlyingRestTemplate() {
  RequestCallback requestCallback = clientHttpRequest -> {
  };
  ResponseExtractor<ResponseEntity<String>> responseExtractor = clientHttpResponse -> responseEntity;

  ResponseEntity<String> actual;

  for (HttpMethod method : httpMethods) {
    when(underlying.execute(url, method, requestCallback, responseExtractor, param1, param2))
        .thenReturn(responseEntity);
    actual = wrapper.execute(url, method, requestCallback, responseExtractor, param1, param2);
    assertThat(actual, is(responseEntity));
    verify(underlying).execute(url, method, requestCallback, responseExtractor, param1, param2);

    when(underlying.execute(url, method, requestCallback, responseExtractor, paramsMap)).thenReturn(responseEntity);
    actual = wrapper.execute(url, method, requestCallback, responseExtractor, paramsMap);
    assertThat(actual, is(responseEntity));
    verify(underlying).execute(url, method, requestCallback, responseExtractor, paramsMap);

    when(underlying.execute(uri, method, requestCallback, responseExtractor)).thenReturn(responseEntity);
    actual = wrapper.execute(uri, method, requestCallback, responseExtractor);
    assertThat(actual, is(responseEntity));
    verify(underlying).execute(uri, method, requestCallback, responseExtractor);
  }
}

@Override
protected void configure(HttpSecurity http) throws Exception {
    http
            // 使用JWT不需要csrf
            .csrf().disable()
            // 基于token不需要session
            .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            .and()
            .authorizeRequests()
            .antMatchers(HttpMethod.GET, "/info").permitAll()
            // login route is only publicly available for POST requests
            .antMatchers(HttpMethod.POST, "/register").permitAll()
            .antMatchers(HttpMethod.GET, "/login").permitAll()
            .antMatchers(HttpMethod.GET, "/refresh").permitAll()
            .anyRequest().authenticated()
            .and()
            // And filter other requests to check the presence of JWT in header
            // 集成JWT和Spring Security
            // 如果客户端请求体中包含token，在检查token之后才放行
            .addFilterBefore(authenticationFilterBean(),
                    UsernamePasswordAuthenticationFilter.class);
    // 禁用缓存
    http.headers().cacheControl();
}

@Override
public <T> ListenableFuture<ResponseEntity<T>> postForEntity(String url, HttpEntity<?> request,
        Class<T> responseType, Object... uriVariables) throws RestClientException {
    AsyncRequestCallback requestCallback = httpEntityCallback(request, responseType);
    ResponseExtractor<ResponseEntity<T>> responseExtractor =
            responseEntityExtractor(responseType);
    return execute(url, HttpMethod.POST, requestCallback, responseExtractor,
            uriVariables);
}

@Override
public String manifest(String releaseName) {
    ParameterizedTypeReference<Resource<Manifest>> typeReference =
            new ParameterizedTypeReference<Resource<Manifest>>() {  };
    Map<String, String> uriVariables = new HashMap<String, String>();
    uriVariables.put("releaseName", releaseName);
    ResponseEntity<Resource<Manifest>> resourceResponseEntity =
            restTemplate.exchange(baseUri + "/release/manifest/{releaseName}",
                    HttpMethod.GET,
                    null,
                    typeReference,
                    uriVariables);
    return resourceResponseEntity.getBody().getContent().getData();
}

@Test
@Sql(scripts = "/integration-test/cleanup.sql", executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD)
public void testPollNotificationWithMultipleNamespacesAndIncorrectCase() throws Exception {
  AtomicBoolean stop = new AtomicBoolean();
  String key = assembleKey(someAppId, someCluster, somePublicNamespace);
  periodicSendMessage(executorService, key, stop);

  String someDefaultNamespaceWithIncorrectCase = defaultNamespace.toUpperCase();
  String somePublicNamespaceWithIncorrectCase = somePublicNamespace.toUpperCase();

  ResponseEntity<List<ApolloConfigNotification>> result = restTemplate.exchange(
      "{baseurl}/notifications/v2?appId={appId}&cluster={clusterName}&notifications={notifications}",
      HttpMethod.GET, null, typeReference,
      getHostUrl(), someAppId, someCluster,
      transformApolloConfigNotificationsToString(defaultNamespace + ".properties",
          ConfigConsts.NOTIFICATION_ID_PLACEHOLDER, someDefaultNamespaceWithIncorrectCase,
          ConfigConsts.NOTIFICATION_ID_PLACEHOLDER, somePublicNamespaceWithIncorrectCase,
          ConfigConsts.NOTIFICATION_ID_PLACEHOLDER));

  stop.set(true);

  List<ApolloConfigNotification> notifications = result.getBody();
  assertEquals(HttpStatus.OK, result.getStatusCode());
  assertEquals(1, notifications.size());
  assertEquals(somePublicNamespaceWithIncorrectCase, notifications.get(0).getNamespaceName());
  assertNotEquals(0, notifications.get(0).getNotificationId());

  ApolloNotificationMessages messages = result.getBody().get(0).getMessages();
  assertEquals(1, messages.getDetails().size());
  assertTrue(messages.has(key));
  assertNotEquals(ConfigConsts.NOTIFICATION_ID_PLACEHOLDER, messages.get(key).longValue());
}

@Retryable(value = { TccCoordinatorException.class }, maxAttempts = 5, backoff = @Backoff(value = 0))
public void retryConfirm(Participant participant) {
    final ResponseEntity<String> response = restTemplate.exchange(participant.getUri(), HttpMethod.PUT,
            REQUEST_ENTITY, String.class);
    count++;
    if (count < 4 || response.getStatusCode() != HttpStatus.NO_CONTENT) {
        throw new TccCoordinatorException("事务处理失败");
    }
    count = 0;
}

@Override
public <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
        ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables) throws RestClientException {

    Type type = responseType.getType();
    RequestCallback requestCallback = httpEntityCallback(requestEntity, type);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(type);
    return execute(url, method, requestCallback, responseExtractor, uriVariables);
}

@Test(expected=org.alfresco.rest.framework.core.exceptions.UnsupportedResourceOperationException.class)
public void testLocateResource()
{
    Map<String, String> templateVars = new HashMap<String, String>();
    templateVars.put(ResourceLocator.COLLECTION_RESOURCE, "sheep");
    ResourceWithMetadata collResource = locator.locateResource(api, templateVars, HttpMethod.GET);
    assertNotNull(collResource);
    assertNotNull(collResource.getMetaData().getOperation(HttpMethod.GET));

    collResource = locator.locateResource(api, templateVars, HttpMethod.POST);
    assertNotNull(collResource);
    assertNotNull(collResource.getMetaData().getOperation(HttpMethod.POST));

    templateVars.put(ResourceLocator.ENTITY_ID, "farmersUniqueId");
    ResourceWithMetadata entityResource = locator.locateResource(api,templateVars, HttpMethod.GET);
    assertNotNull(entityResource);
    assertNotNull(entityResource.getMetaData().getOperation(HttpMethod.GET));

    entityResource = locator.locateResource(api, templateVars, HttpMethod.PUT);
    assertNotNull(entityResource);
    assertNotNull(entityResource.getMetaData().getOperation(HttpMethod.PUT));

    templateVars.clear();
    templateVars.put(ResourceLocator.COLLECTION_RESOURCE, "sheepnoaction");
    collResource = locator.locateResource(api,templateVars, HttpMethod.GET);

}

@Override
public OrgInfoModel[] GetAvailiableOrgsByUser() {
    ParameterizedTypeReference<PmsResultModel<String>> typeRef = new ParameterizedTypeReference<PmsResultModel<String>>() { };
    PmsResultModel<String> result = pmsRestClient.GetClient().exchange(requestCallContext.GetUser().getUrl()+"/API/Configure/GetAvailiableOrgsByUser", HttpMethod.GET, null,typeRef).getBody();
    if (result.getCode() != 0) {
        throw new IllegalArgumentException(result.getMessage());
    }

    return JsonUtils.Deserialize(result.getContent(),OrgInfoModel[].class);
}

@Test
public void whenSaveCalledAndRemoteCallFailsThenReturnNullMarket() throws Exception {

    mockServer.expect(requestTo(REST_ENDPOINT_BASE_URL + MARKETS_RESOURCE_PATH))
            .andExpect(method(HttpMethod.PUT))
            .andRespond(withServerError());

    final MarketConfig marketConfig = restClient.save(botConfig, unrecognizedMarketConfig());
    assertThat(marketConfig).isEqualTo(null);

    mockServer.verify();
}

@Override
public void configure(HttpSecurity http) throws Exception {
    http
            .authorizeRequests()
            .antMatchers("/").permitAll()
            .antMatchers("/v2/**","/swagger**", "/druid/**").permitAll()
            .antMatchers(HttpMethod.GET, "/user/{id}").permitAll()
            .antMatchers("/user/password").authenticated()
            .antMatchers("/user/**").hasAuthority("admin")
            .anyRequest().permitAll();
}

@GetMapping("/restore/snapshots/transfer/{projectId}/{transferId}")
public ResponseEntity<String> transferSnapshots(@PathVariable String projectId,
                                                @PathVariable String transferId) {
    ParameterizedTypeReference<String> reference = new ParameterizedTypeReference<String>() {
    };

    return restTemplate.exchange(
            SERVICE + "/snapshots/transfer/{projectId}/{transferId}", HttpMethod.GET,
            null, reference, projectId, transferId);
}

@Async
public Future<ResponseEntity<ProcessStartedDTO>> startProcess(
    @RequestBody final ProcessStartDTO processStartDTO, final HttpHeaderUser headerUser)
    throws URISyntaxException {
  LOG.debug("Create request to start process instance");

  final URIBuilder uri =
      new URIBuilder(gatewayConfig.getProcessEngineAddress()).setPath("/processes/startProcess");

  final HttpHeaders header = headerUser.getHttpHeaders();
  return createRequest(uri, HttpMethod.POST, processStartDTO, ProcessStartedDTO.class, header);
}

public BaseResource[] listResources(final RestTemplate restTemplate, final String acsEndpoint,
        final HttpHeaders headers) {
    URI uri = URI.create(acsEndpoint + ACS_RESOURCE_API_PATH);
    ResponseEntity<BaseResource[]> response = restTemplate.exchange(uri, HttpMethod.GET, new HttpEntity<>(headers),
            BaseResource[].class);
    return response.getBody();
}

@Test(dataProvider = "requestUrlProvider")
public void testDeleteConnectorDeniedWithoutSufficientScope(final String endpointUrl) throws Exception {
    try {
        this.zone1ConnectorReadClient.exchange(this.acsUrl + V1 + endpointUrl, HttpMethod.DELETE,
                new HttpEntity<>(this.zone1Headers), String.class);
        Assert.fail("No exception thrown when deleting connector without sufficient scope.");
    } catch (HttpClientErrorException e) {
        Assert.assertEquals(e.getStatusCode(), HttpStatus.FORBIDDEN);
    }
}

@Test(timeout = 5000L)
@Sql(scripts = "/integration-test/test-release.sql", executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD)
@Sql(scripts = "/integration-test/cleanup.sql", executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD)
public void testPollNotificationWthMultipleNamespacesAndMultipleNamespacesChanged()
    throws Exception {
  String publicAppId = "somePublicAppId";
  String someDC = "someDC";

  AtomicBoolean stop = new AtomicBoolean();
  String key = assembleKey(publicAppId, someDC, somePublicNamespace);
  periodicSendMessage(executorService, key, stop);

  ResponseEntity<List<ApolloConfigNotification>> result = restTemplate.exchange(
      "{baseurl}/notifications/v2?appId={appId}&cluster={clusterName}&notifications={notifications}&dataCenter={dataCenter}",
      HttpMethod.GET, null, typeReference,
      getHostUrl(), someAppId, someCluster,
      transformApolloConfigNotificationsToString(defaultNamespace, ConfigConsts.NOTIFICATION_ID_PLACEHOLDER,
          somePublicNamespace, ConfigConsts.NOTIFICATION_ID_PLACEHOLDER),
      someDC);

  stop.set(true);

  List<ApolloConfigNotification> notifications = result.getBody();
  assertEquals(HttpStatus.OK, result.getStatusCode());
  assertEquals(1, notifications.size());
  assertEquals(somePublicNamespace, notifications.get(0).getNamespaceName());
  assertNotEquals(0, notifications.get(0).getNotificationId());

  ApolloNotificationMessages messages = result.getBody().get(0).getMessages();
  assertEquals(1, messages.getDetails().size());
  assertTrue(messages.has(key));
  assertNotEquals(ConfigConsts.NOTIFICATION_ID_PLACEHOLDER, messages.get(key).longValue());
}

@Override
public <T> T execute(String url, HttpMethod method, RequestCallback requestCallback,
        ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables) throws RestClientException {

    URI expanded = new UriTemplate(url).expand(urlVariables);
    return doExecute(expanded, method, requestCallback, responseExtractor);
}

@Test
public void patchMapping_shouldExtract_HttpMethodPatch() throws NoSuchMethodException {
  Method method = ChildRestApi_Annotations.class.getMethod("patchMapping");

  RestApiProxyInvocationHandler handler = new RestApiProxyInvocationHandler();
  HttpMethod httpMethod = handler.extractMapping(method).getHttpMethod();

  assertEquals(httpMethod, HttpMethod.PATCH);
}