org.springframework.http.HttpMethod Java Examples

@Test
public void testMultiLayerObjectParam_rt() {
  MultiLayerObjectParam request = new MultiLayerObjectParam("sss-1", new Date(),
      new MultiLayerObjectParam2("sss-2", 12.12, FlattenObjectRequest.createFlattenObjectRequest()));
  ResponseEntity<MultiLayerObjectParam> responseEntity = consumers.getSCBRestTemplate()
      .exchange("/testMultiLayerObjectParam", HttpMethod.PUT,
          new HttpEntity<>(request), MultiLayerObjectParam.class);
  assertEquals(request, responseEntity.getBody());
  assertEquals(200, responseEntity.getStatusCodeValue());

  responseEntity = consumers.getSCBRestTemplate()
      .exchange("/testMultiLayerObjectParam", HttpMethod.PUT,
          new HttpEntity<>(null), MultiLayerObjectParam.class);
  //  Highway will not give null return value
  Assert.assertTrue(responseEntity.getBody() == null || responseEntity.getBody().getString() == null);
  assertEquals(200, responseEntity.getStatusCodeValue());
}
 

@Test
public void preflightRequestCredentialsWithOriginWildcard() throws Exception {
	this.request.setMethod(HttpMethod.OPTIONS.name());
	this.request.addHeader(HttpHeaders.ORIGIN, "https://domain2.com");
	this.request.addHeader(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, "GET");
	this.request.addHeader(HttpHeaders.ACCESS_CONTROL_REQUEST_HEADERS, "Header1");
	this.conf.addAllowedOrigin("https://domain1.com");
	this.conf.addAllowedOrigin("*");
	this.conf.addAllowedOrigin("http://domain3.com");
	this.conf.addAllowedHeader("Header1");
	this.conf.setAllowCredentials(true);

	this.processor.processRequest(this.conf, this.request, this.response);
	assertTrue(this.response.containsHeader(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN));
	assertEquals("https://domain2.com", this.response.getHeader(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN));
	assertThat(this.response.getHeaders(HttpHeaders.VARY), contains(HttpHeaders.ORIGIN,
			HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, HttpHeaders.ACCESS_CONTROL_REQUEST_HEADERS));
	assertEquals(HttpServletResponse.SC_OK, this.response.getStatus());
}
 

@Override
public Void execute(final ResourceWithMetadata resource, final Params params, final WebScriptResponse res, boolean isReadOnly)
{
    final ResourceOperation operation = resource.getMetaData().getOperation(HttpMethod.DELETE);
    final WithResponse callBack = new WithResponse(operation.getSuccessStatus(), DEFAULT_JSON_CONTENT,CACHE_NEVER);

    // MNT-20308 - allow write transactions for authentication api
    RetryingTransactionHelper transHelper = getTransactionHelper(resource.getMetaData().getApi().getName());

    transHelper.doInTransaction(
        new RetryingTransactionCallback<Void>()
        {
            @Override
            public Void execute() throws Throwable
            {
                executeAction(resource, params, callBack); //ignore return result
                return null;
            }
        }, false, true);
    setResponse(res,callBack);
    return null;

}
 

private void mockBlogRestTemplateCall(String jsonResponse, String registryHost, String registryPort,
		String repository, String digest) {

	UriComponents blobUriComponents = UriComponentsBuilder.newInstance()
			.scheme("https")
			.host(registryHost)
			.port(StringUtils.hasText(registryPort) ? registryPort : null)
			.path("v2/{repository}/blobs/{digest}")
			.build().expand(repository, digest);

	when(mockRestTemplate.exchange(
			eq(blobUriComponents.toUri()),
			eq(HttpMethod.GET),
			any(HttpEntity.class),
			eq(String.class)))
			.thenReturn(new ResponseEntity<>(jsonResponse, HttpStatus.OK));
}
 

/**
 * Define the security that applies to the proxy
 */
@Override
   public void configure(HttpSecurity http) throws Exception {
       http
       	.authorizeRequests()
       	//Allow access to all static resources without authentication
       	.antMatchers("/","/**/*.html").permitAll()
       	.anyRequest().authenticated()
       	.antMatchers(HttpMethod.GET, "/api/user/**","/api/task/**").access("#oauth2.hasScope('read')")
           .antMatchers(HttpMethod.OPTIONS, "/api/user/**","/api/task/**").access("#oauth2.hasScope('read')")
           .antMatchers(HttpMethod.POST, "/api/user/**","/api/task/**").access("#oauth2.hasScope('write')")
           .antMatchers(HttpMethod.PUT, "/api/user/**","/api/task/**").access("#oauth2.hasScope('write')")
           .antMatchers(HttpMethod.PATCH, "/api/user/**","/api/task/**").access("#oauth2.hasScope('write')")
           .antMatchers(HttpMethod.DELETE, "/api/user/**","/api/task/**").access("#oauth2.hasScope('write')")
           .and().csrf().csrfTokenRepository(this.getCSRFTokenRepository())
           .and().addFilterAfter(this.createCSRFHeaderFilter(), CsrfFilter.class);
   }
 

private String getChecksum(String defaultValue, String url,
		String version) {
	String result = defaultValue;
	if (result == null && StringUtils.hasText(url)) {
		CloseableHttpClient httpClient = HttpClients.custom()
				.setSSLHostnameVerifier(new NoopHostnameVerifier())
				.build();
		HttpComponentsClientHttpRequestFactory requestFactory
				= new HttpComponentsClientHttpRequestFactory();
		requestFactory.setHttpClient(httpClient);
		url = constructUrl(url, version);
		try {
			ResponseEntity<String> response
					= new RestTemplate(requestFactory).exchange(
					url, HttpMethod.GET, null, String.class);
			if (response.getStatusCode().equals(HttpStatus.OK)) {
				result = response.getBody();
			}
		}
		catch (HttpClientErrorException httpException) {
			// no action necessary set result to undefined
			logger.debug("Didn't retrieve checksum because", httpException);
		}
	}
	return result;
}
 

public Endpoints endpoints(final EndpointQuery query) throws Exception {
    final URL queryFileUrl = Resources.getResource("endpoints.gql");
    final String queryString = Resources.readLines(queryFileUrl, StandardCharsets.UTF_8)
                                        .stream()
                                        .filter(it -> !it.startsWith("#"))
                                        .collect(Collectors.joining())
                                        .replace("{serviceId}", query.serviceId());
    final ResponseEntity<GQLResponse<Endpoints>> responseEntity = restTemplate.exchange(
        new RequestEntity<>(queryString, HttpMethod.POST, URI.create(endpointUrl)),
        new ParameterizedTypeReference<GQLResponse<Endpoints>>() {
        }
    );

    if (responseEntity.getStatusCode() != HttpStatus.OK) {
        throw new RuntimeException("Response status != 200, actual: " + responseEntity.getStatusCode());
    }

    return Objects.requireNonNull(responseEntity.getBody()).getData();
}
 

private synchronized JSONObject getLoginInfoFromApi() {
    if (loginInfo != null) {
        return loginInfo;
    }

    Map<String, Object> parameters = Maps.newLinkedHashMap();
    parameters.put("username", restCredentials.getUsername());

    try {
        ResponseEntity<String> response = restTemplate.exchange(LOGIN_INFO_URL, HttpMethod.GET, HttpEntity.EMPTY, String.class, parameters);

        if (StringUtils.isBlank(response.getBody())) {
            throw new RestApiException("Failed to dynamically determine REST urls with username " + restCredentials.getUsername());
        }

        this.loginInfo = new JSONObject(response.getBody());

        return this.loginInfo;
    } catch(RestClientException | JSONException e) {
        log.error("Error occurred dynamically determining REST urls with username " + restCredentials.getUsername(), e);

        throw new RestApiException("Failed to dynamically determine REST urls with username " + restCredentials.getUsername());
    }
}
 

private Map getTaskDetail(Integer taskId, String user, String ujesAddress, String clusterName) throws TaskNotExistException, ClusterInfoNotConfigException {
    String url = getPath(ujesAddress).path(linkisConfig.getStatus()).toString();
    url = url.replace("{id}", String.valueOf(taskId));

    HttpHeaders headers = new HttpHeaders();
    headers.setContentType(MediaType.APPLICATION_JSON);
    headers.add("Token-User", user);
    headers.add("Token-Code", getToken(clusterName));
    HttpEntity entity = new HttpEntity<>(headers);

    LOGGER.info("Start to get job status from linkis. url: {}, method: {}, body: {}", url, javax.ws.rs.HttpMethod.GET, entity);
    Map response = restTemplate.exchange(url, HttpMethod.GET, entity, Map.class).getBody();
    LOGGER.info("Succeed to get job status from linkis. response: {}", response);

    if (!checkResponse(response)) {
        throw new TaskNotExistException("Can not get status of task, task_id : " + taskId);
    }

    if (((Map)response.get("data")).get("task") == null) {
        throw new TaskNotExistException("Job id: " + taskId + " does not exist");
    }

    return response;
}
 

@Test // SPR-14694
public void repeatedAccessToResponseViaResource() {

	Resource resource = new ClassPathResource("ludwig.json", this.getClass());

	RestTemplate restTemplate = new RestTemplate();
	restTemplate.setInterceptors(Collections.singletonList(new ContentInterceptor(resource)));

	MockRestServiceServer mockServer = MockRestServiceServer.bindTo(restTemplate)
			.ignoreExpectOrder(true)
			.bufferContent()  // enable repeated reads of response body
			.build();

	mockServer.expect(requestTo("/composers/42")).andExpect(method(HttpMethod.GET))
			.andRespond(withSuccess(resource, MediaType.APPLICATION_JSON));

	restTemplate.getForObject("/composers/{id}", Person.class, 42);

	mockServer.verify();
}
 

@Test
public void testRender() throws Exception {

	ConfigView configView = ConfigView.getInstance();

	Model configData = new LinkedHashModelFactory().createEmptyModel();
	configData.add(RDF.ALT, RDF.TYPE, RDFS.CLASS);

	Map<Object, Object> map = new LinkedHashMap<>();
	map.put(ConfigView.HEADERS_ONLY, false);
	map.put(ConfigView.CONFIG_DATA_KEY, configData);
	map.put(ConfigView.FORMAT_KEY, RDFFormat.NTRIPLES);

	final MockHttpServletRequest request = new MockHttpServletRequest();
	request.setMethod(HttpMethod.GET.name());
	request.addHeader("Accept", RDFFormat.NTRIPLES.getDefaultMIMEType());

	MockHttpServletResponse response = new MockHttpServletResponse();

	configView.render(map, request, response);

	String ntriplesData = response.getContentAsString();
	Model renderedData = Rio.parse(new StringReader(ntriplesData), "", RDFFormat.NTRIPLES);
	assertThat(renderedData).isNotEmpty();
}
 

@Test
public void options() throws ServletException, IOException {
	MockHttpServletRequest servletRequest = new MockHttpServletRequest("OPTIONS", "/");
	ServerRequest request = new DefaultServerRequest(servletRequest, Collections.singletonList(messageConverter));

	ServerResponse response = this.handlerFunction.handle(request);
	assertEquals(HttpStatus.OK, response.statusCode());
	assertEquals(EnumSet.of(HttpMethod.GET, HttpMethod.HEAD, HttpMethod.OPTIONS), response.headers().getAllow());

	MockHttpServletResponse servletResponse = new MockHttpServletResponse();
	ModelAndView mav = response.writeTo(servletRequest, servletResponse, this.context);
	assertNull(mav);

	assertEquals(200, servletResponse.getStatus());
	assertEquals("GET,HEAD,OPTIONS", servletResponse.getHeader("Allow"));
	byte[] actualBytes = servletResponse.getContentAsByteArray();
	assertEquals(0, actualBytes.length);
}
 

@Test
public void nonAdminUserShouldBeRedirectedToIdm() {
    String configsUrl = "http://localhost:" + serverPort + "/flowable-admin/app/rest/server-configs";
    HttpHeaders headers = new HttpHeaders();
    headers.set(HttpHeaders.COOKIE, rememberMeCookie("user", "test-user-value"));
    HttpEntity<?> request = new HttpEntity<>(headers);
    ResponseEntity<Object> result = restTemplate.exchange(configsUrl, HttpMethod.GET, request, Object.class);

    assertThat(result.getStatusCode())
        .as("GET server-configs")
        .isEqualTo(HttpStatus.FOUND);

    assertThat(result.getHeaders().getFirst(HttpHeaders.LOCATION))
        .as("redirect location")
        .isEqualTo("http://localhost:8080/flowable-idm/#/login?redirectOnAuthSuccess=true&redirectUrl=" + configsUrl);
}
 

@Test
public void shouldReturnErrorCreateIuguCustomer() {
    IuguCustomer iuguCustomer = IuguCustomer.builder()
            .email("[email protected]")
            .name("Iugu Customer")
            .zipCode("05500-100")
            .street("Avenida dos Testes")
            .city("São Paulo")
            .state("SP")
            .build();

    HttpEntity<IuguCustomer> request = new HttpEntity<>(iuguCustomer);
    ResponseEntity<IuguCustomer> responseEntity = ResponseEntity.badRequest().body(null);
    when(restTemplate.exchange("https://api.iugu.com/v1/customers?api_token=b17421313f9a8db907afa7b7047fbcd8",
            HttpMethod.POST,
            request,
            IuguCustomer.class))
            .thenReturn(responseEntity);

    ServiceResponse<IuguCustomer> response = iuguService.createIuguCustomer(iuguCustomer);

    Assert.assertThat(response, hasErrorMessage(IuguService.Validations.IUGU_CUSTOMER_CREATION_ERROR.getCode()));
}
 

@Test
public void containerImageMetadataResolverWithActiveSSL() throws URISyntaxException {
	assertThat(containerImageMetadataResolver).isNotNull();
	Map<String, String> labels = containerImageMetadataResolver.getImageLabels("demo.goharbor.io/test/image:1.0.0");
	assertThat(labels).containsExactly(Collections.singletonMap("foo", "bar").entrySet().iterator().next());

	// Determine the OAuth2 token service entry point.
	verify(noSslVerificationContainerRestTemplate)
			.exchange(eq(new URI("https://demo.goharbor.io/v2/_catalog")), eq(HttpMethod.GET), any(), eq(Map.class));

	// Get authorization token
	verify(containerRestTemplate).exchange(
			eq(new URI("https://demo.goharbor.io/service/token?service=demo-registry2&scope=repository:test/image:pull")),
			eq(HttpMethod.GET), any(), eq(Map.class));
	// Get Manifest
	verify(containerRestTemplate).exchange(eq(new URI("https://demo.goharbor.io/v2/test/image/manifests/1.0.0")),
			eq(HttpMethod.GET), any(), eq(Map.class));
	// Get Blobs
	verify(containerRestTemplate).exchange(eq(new URI("https://demo.goharbor.io/v2/test/image/blobs/test_digest")),
			eq(HttpMethod.GET), any(), eq(String.class));
}
 

/**
 * By default a newly created {@code CorsConfiguration} does not permit any
 * cross-origin requests and must be configured explicitly to indicate what
 * should be allowed.
 * <p>Use this method to flip the initialization model to start with open
 * defaults that permit all cross-origin requests for GET, HEAD, and POST
 * requests. Note however that this method will not override any existing
 * values already set.
 * <p>The following defaults are applied if not already set:
 * <ul>
 * <li>Allow all origins.</li>
 * <li>Allow "simple" methods {@code GET}, {@code HEAD} and {@code POST}.</li>
 * <li>Allow all headers.</li>
 * <li>Set max age to 1800 seconds (30 minutes).</li>
 * </ul>
 */
public CorsConfiguration applyPermitDefaultValues() {
	if (this.allowedOrigins == null) {
		this.allowedOrigins = DEFAULT_PERMIT_ALL;
	}
	if (this.allowedMethods == null) {
		this.allowedMethods = DEFAULT_PERMIT_METHODS;
		this.resolvedMethods = DEFAULT_PERMIT_METHODS
				.stream().map(HttpMethod::resolve).collect(Collectors.toList());
	}
	if (this.allowedHeaders == null) {
		this.allowedHeaders = DEFAULT_PERMIT_ALL;
	}
	if (this.maxAge == null) {
		this.maxAge = 1800L;
	}
	return this;
}
 

@Test
void testGetAllTasksByWorkbasketIdWithinSinglePlannedTimeInterval() {

  Instant plannedFromInstant = Instant.now().minus(6, ChronoUnit.DAYS);
  Instant plannedToInstant = Instant.now().minus(3, ChronoUnit.DAYS);

  ResponseEntity<TaskanaPagedModel<TaskSummaryRepresentationModel>> response =
      TEMPLATE.exchange(
          restHelper.toUrl(Mapping.URL_TASKS)
              + "?workbasket-id=WBI:100000000000000000000000000000000001"
              + "&planned-from="
              + plannedFromInstant
              + "&planned-until="
              + plannedToInstant
              + "&sort-by=planned",
          HttpMethod.GET,
          restHelper.defaultRequest(),
          TASK_SUMMARY_PAGE_MODEL_TYPE);
  assertThat(response.getBody()).isNotNull();
  assertThat((response.getBody()).getLink(IanaLinkRelations.SELF)).isNotNull();
  assertThat(response.getBody().getContent()).hasSize(3);
}
 

@Override
public void configure(WebSecurity web) throws Exception {
    web.ignoring()
        .antMatchers(HttpMethod.OPTIONS, "/**")
        .antMatchers("/app/**/*.{js,html}")
        .antMatchers("/i18n/**")
        .antMatchers("/content/**")
        .antMatchers("/swagger-ui/index.html")
        .antMatchers("/test/**");
}
 

@Override
	protected ServiceInfoResponse makeServiceCall(CommonRequest payload)
			throws UpstreamServiceTimedOutException, UpstreamServiceFailedException {
		MultiValueMap<String, String> urlQueryParams = new LinkedMultiValueMap<>();

		String endPoint = Validator.isNotNull(payload.getEndpoint()) ? payload.getEndpoint() : DossierStatisticConfig.get(DossierStatisticConstants.SERVICE_INFO_ENDPOINT);

		// get the params for EE
		HashMap<String, String> urlPathSegments = new HashMap<>();

		//urlPathSegments.put("s", payload.getKeyword());

		// build the url
		String url = buildUrl(endPoint, urlPathSegments, urlQueryParams) + StringPool.FORWARD_SLASH + payload.getKeyword();

		HttpHeaders httpHeaders = new HttpHeaders();

		httpHeaders.add(DossierStatisticConstants.GROUP_ID, Long.toString(payload.getGroupId()));
//		if (Validator.isNotNull(PropsUtil.get(ServerConfigContants.SERVER_SYNC_KEY))
//				&& Validator.isNotNull(PropsUtil.get(ServerConfigContants.SERVER_SYNC_SECRET))) {
//			setHttpHeadersAuthorization(httpHeaders, PropsUtil.get(ServerConfigContants.SERVER_SYNC_KEY), PropsUtil.get(ServerConfigContants.SERVER_SYNC_SECRET));
//		}
//		else {
//			httpHeaders.add("Authorization", "Basic " + DossierStatisticConfig.get(DossierStatisticConstants.OPENCPS_AUTHENCATION));
//		}
		if (Validator.isNotNull(payload.getUsername()) && Validator.isNotNull(payload.getPassword())) {
			httpHeaders.add("Authorization", "Basic " + Base64.getEncoder().encodeToString((payload.getUsername() + ":" + payload.getPassword()).getBytes()));			
		}
		
		return executeGenericRestCall(url, HttpMethod.GET, httpHeaders, payload, ServiceInfoResponse.class).getBody();
	}
 

private void assertHttpMethod(String method) {
	for (HttpMethod httpMethod : HttpMethod.values()) {
		if (httpMethod.name().equalsIgnoreCase(method)) {
			return;
		}
	}
	throw new IllegalArgumentException("Invalid HTTP method: " + method);
}
 

@Test
public void preflightRequestWithoutRequestMethod() throws Exception {
	this.request.setMethod(HttpMethod.OPTIONS.name());
	this.request.addHeader(HttpHeaders.ORIGIN, "https://domain2.com");
	this.request.addHeader(HttpHeaders.ACCESS_CONTROL_REQUEST_HEADERS, "Header1");

	this.processor.processRequest(this.conf, this.request, this.response);
	assertFalse(this.response.containsHeader(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN));
	assertThat(this.response.getHeaders(HttpHeaders.VARY), contains(HttpHeaders.ORIGIN,
			HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, HttpHeaders.ACCESS_CONTROL_REQUEST_HEADERS));
	assertEquals(HttpServletResponse.SC_FORBIDDEN, this.response.getStatus());
}
 

private <T> ListenableFuture<T> execute(final URI url, final HttpMethod method,
        @Nullable final Entity entity, final Route route, final Function<ClientHttpResponse, T> function) {

    final CompletableFuture<T> future = http.execute(method, url)
            .body(entity)
            .call(route(route))
            .thenApply(function);

    return new CompletableToListenableFutureAdapter<>(future);
}
 

@Override
protected void configure(HttpSecurity http) throws Exception {// @formatter:off
    http.cors()
        .and()
          .authorizeRequests()
            .antMatchers(HttpMethod.GET, "/user/info", "/api/foos/**")
              .hasAuthority("SCOPE_read")
            .antMatchers(HttpMethod.POST, "/api/foos")
              .hasAuthority("SCOPE_write")
            .anyRequest()
              .authenticated()
        .and()
          .oauth2ResourceServer()
            .jwt();
}
 

@Override
protected ResponseEntity<String> doBusinessProcess(IPageData pd, JSONObject paramIn) {
    ResponseEntity<String> responseEntity = null;
    super.validateStoreStaffCommunityRelationship(pd, restTemplate);

    responseEntity = this.callCenterService(restTemplate, pd, paramIn.toJSONString(),
            ServiceConstant.SERVICE_API_URL + "/api/inspectionRoute.saveInspectionRoutePoint",
            HttpMethod.POST);
    return responseEntity;
}
 

/**
 * Test the GET /v1/restaurants/{id} API for no content
 */
@Test
public void testGetById_NoContent() {

  HttpHeaders headers = new HttpHeaders();
  HttpEntity<Object> entity = new HttpEntity<>(headers);
  ResponseEntity<Map> responseE = restTemplate
      .exchange("http://localhost:" + port + "/v1/restaurants/99", HttpMethod.GET, entity,
          Map.class);

  assertNotNull(responseE);

  // Should return no content as there is no restaurant with id 99
  assertEquals(HttpStatus.NO_CONTENT, responseE.getStatusCode());
}
 

@Override
        protected void configure(HttpSecurity http) throws Exception {
            final String uiPrefix = "/ui/";
            final String loginUrl = uiPrefix + "login.html";

            TokenAuthFilterConfigurer<HttpSecurity> tokenFilterConfigurer =
                    new TokenAuthFilterConfigurer<>(new RequestTokenHeaderRequestMatcher(),
                            new TokenAuthProvider(tokenValidator, userDetailsService, authProcessor));
            http.csrf().disable()
                    .authenticationProvider(provider).userDetailsService(userDetailsService)
                    .anonymous().principal(SecurityUtils.USER_ANONYMOUS).and()
                    .authorizeRequests().antMatchers(uiPrefix + "/token/login").permitAll()
                    .antMatchers(HttpMethod.OPTIONS, "/**").permitAll()//allow CORS option calls
                    .antMatchers(uiPrefix + "**").authenticated()
                    .and().headers().cacheControl().disable()
                    .and().formLogin().loginPage(loginUrl).permitAll().defaultSuccessUrl(uiPrefix)
                    .and().logout().logoutUrl(uiPrefix + "logout").logoutSuccessUrl(loginUrl)
                    .and().apply(tokenFilterConfigurer);
//                enable after testing
//                        .and().sessionManagement()
//                        .sessionCreationPolicy(SessionCreationPolicy.STATELESS);

            // X-Frame-Options
            http.headers()
              .frameOptions().sameOrigin();

            http.addFilterAfter(new AccessContextFilter(aclContextFactory), SwitchUserFilter.class);

            //we use basic in testing and scripts
            if (basicAuthEnable) {
                http.httpBasic();
            }

        }
 

/**
 * Transform an HTTP POST into another method based on {@code methodParamName}.
 * @param exchange the current server exchange
 * @param chain provides a way to delegate to the next filter
 * @return {@code Mono<Void>} to indicate when request processing is complete
 */
@Override
public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {

	if (exchange.getRequest().getMethod() != HttpMethod.POST) {
		return chain.filter(exchange);
	}

	return exchange.getFormData()
			.map(formData -> {
				String method = formData.getFirst(this.methodParamName);
				return StringUtils.hasLength(method) ? mapExchange(exchange, method) : exchange;
			})
			.flatMap(chain::filter);
}
 

@Test
void fatalErrorOnlyLogs() {
	ProjectRequest request = createProjectRequest();
	ProjectGeneratedEvent event = new ProjectGeneratedEvent(request, this.metadata);
	this.retryTemplate.setRetryPolicy(new SimpleRetryPolicy(2, Collections.singletonMap(Exception.class, true)));

	this.mockServer.expect(requestTo("https://example.com/elastic/initializr/request"))
			.andExpect(method(HttpMethod.POST)).andRespond(withStatus(HttpStatus.INTERNAL_SERVER_ERROR));

	this.mockServer.expect(requestTo("https://example.com/elastic/initializr/request"))
			.andExpect(method(HttpMethod.POST)).andRespond(withStatus(HttpStatus.INTERNAL_SERVER_ERROR));

	this.statPublisher.handleEvent(event);
	this.mockServer.verify();
}
 

@Test
void shouldUsingAuthenticationSteps() {

	this.mockRest.expect(requestTo("/auth/aws/login")).andExpect(method(HttpMethod.POST))
			.andExpect(jsonPath("$.iam_http_request_method").value("POST"))
			.andExpect(jsonPath("$.iam_request_url").exists()).andExpect(jsonPath("$.iam_request_body").exists())
			.andExpect(jsonPath("$.iam_request_headers").exists()).andExpect(jsonPath("$.role").value("foo-role"))
			.andRespond(withSuccess().contentType(MediaType.APPLICATION_JSON).body(
					"{" + "\"auth\":{\"client_token\":\"my-token\", \"renewable\": true, \"lease_duration\": 10}"
							+ "}"));

	AwsIamAuthenticationOptions options = AwsIamAuthenticationOptions.builder().role("foo-role")
			.credentials(new BasicAWSCredentials("foo", "bar")).build();

	AuthenticationSteps steps = AwsIamAuthentication.createAuthenticationSteps(options);
	AuthenticationStepsExecutor executor = new AuthenticationStepsExecutor(steps, this.restTemplate);

	VaultToken login = executor.login();

	assertThat(login).isInstanceOf(LoginToken.class);
	assertThat(login.getToken()).isEqualTo("my-token");
	assertThat(((LoginToken) login).getLeaseDuration()).isEqualTo(Duration.ofSeconds(10));
	assertThat(((LoginToken) login).isRenewable()).isTrue();
}
 

@Test
public void notFound() {
	try {
		template.execute(baseUrl + "/status/notfound", HttpMethod.GET, null, null);
		fail("HttpClientErrorException expected");
	}
	catch (HttpClientErrorException ex) {
		assertEquals(HttpStatus.NOT_FOUND, ex.getStatusCode());
		assertNotNull(ex.getStatusText());
		assertNotNull(ex.getResponseBodyAsString());
	}
}