root
/
spring-boot
mirror of https://github.com/spring-projects/spring-boot.git
1
0
Fork 0
Code Issues Actions 12 Packages Projects Releases Wiki Activity

Fix build failure

This commit is contained in:
Stephane Nicoll 2019-04-06 18:00:13 +02:00
parent 87af1a60df
commit 84735f58f3
2 changed files with 196 additions and 185 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

160
spring-boot-project/spring-boot-actuator-autoconfigure/src/test/java/org/springframework/boot/actuate/autoconfigure/integrationtest/WebFluxEndpointCorsIntegrationTests.java
View File

@ -16,7 +16,8 @@
package org.springframework.boot.actuate.autoconfigure.integrationtest;
import org.junit.Before;
import java.util.function.Consumer;
import org.junit.Test;
import org.springframework.boot.actuate.autoconfigure.beans.BeansEndpointAutoConfiguration;
@ -25,12 +26,14 @@ import org.springframework.boot.actuate.autoconfigure.endpoint.web.WebEndpointAu
import org.springframework.boot.actuate.autoconfigure.endpoint.web.reactive.WebFluxEndpointManagementContextConfiguration;
import org.springframework.boot.actuate.autoconfigure.web.reactive.ReactiveManagementContextAutoConfiguration;
import org.springframework.boot.actuate.autoconfigure.web.server.ManagementContextAutoConfiguration;
import org.springframework.boot.autoconfigure.AutoConfigurations;
import org.springframework.boot.autoconfigure.http.codec.CodecsAutoConfiguration;
import org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration;
import org.springframework.boot.autoconfigure.web.reactive.HttpHandlerAutoConfiguration;
import org.springframework.boot.autoconfigure.web.reactive.WebFluxAutoConfiguration;
import org.springframework.boot.test.util.TestPropertyValues;
import org.springframework.boot.web.reactive.context.AnnotationConfigReactiveWebApplicationContext;
import org.springframework.boot.test.context.runner.ContextConsumer;
import org.springframework.boot.test.context.runner.ReactiveWebApplicationContextRunner;
import org.springframework.boot.web.reactive.context.ReactiveWebApplicationContext;
import org.springframework.http.HttpHeaders;
import org.springframework.test.web.reactive.server.WebTestClient;
@ -38,143 +41,142 @@ import org.springframework.test.web.reactive.server.WebTestClient;
* Integration tests for the WebFlux actuator endpoints' CORS support
*
* @author Brian Clozel
* @author Stephane Nicoll
* @see WebFluxEndpointManagementContextConfiguration
*/
public class WebFluxEndpointCorsIntegrationTests {
private AnnotationConfigReactiveWebApplicationContext context;
@Before
public void createContext() {
this.context = new AnnotationConfigReactiveWebApplicationContext();
this.context.register(JacksonAutoConfiguration.class,
private ReactiveWebApplicationContextRunner contextRunner = new ReactiveWebApplicationContextRunner()
.withConfiguration(AutoConfigurations.of(JacksonAutoConfiguration.class,
CodecsAutoConfiguration.class, WebFluxAutoConfiguration.class,
HttpHandlerAutoConfiguration.class, EndpointAutoConfiguration.class,
WebEndpointAutoConfiguration.class,
ManagementContextAutoConfiguration.class,
ReactiveManagementContextAutoConfiguration.class,
BeansEndpointAutoConfiguration.class);
TestPropertyValues.of("management.endpoints.web.exposure.include:*")
.applyTo(this.context);
}
BeansEndpointAutoConfiguration.class))
.withPropertyValues("management.endpoints.web.exposure.include:*");
@Test
public void corsIsDisabledByDefault() {
createWebTestClient().options().uri("/actuator/beans")
.header("Origin", "spring.example.org")
this.contextRunner.run(withWebTestClient((webTestClient) -> webTestClient
.options().uri("/actuator/beans").header("Origin", "spring.example.org")
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, "GET").exchange()
.expectHeader().doesNotExist(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN);
.expectHeader().doesNotExist(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN)));
}
@Test
public void settingAllowedOriginsEnablesCors() {
TestPropertyValues
.of("management.endpoints.web.cors.allowed-origins:spring.example.org")
.applyTo(this.context);
createWebTestClient().options().uri("/actuator/beans")
this.contextRunner.withPropertyValues(
"management.endpoints.web.cors.allowed-origins:spring.example.org")
.run(withWebTestClient((webTestClient) -> {
webTestClient.options().uri("/actuator/beans")
.header("Origin", "test.example.org")
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, "GET").exchange()
.expectStatus().isForbidden();
performAcceptedCorsRequest("/actuator/beans");
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, "GET")
.exchange().expectStatus().isForbidden();
performAcceptedCorsRequest(webTestClient, "/actuator/beans");
}));
}
@Test
public void maxAgeDefaultsTo30Minutes() {
TestPropertyValues
.of("management.endpoints.web.cors.allowed-origins:spring.example.org")
.applyTo(this.context);
performAcceptedCorsRequest("/actuator/beans").expectHeader()
.valueEquals(HttpHeaders.ACCESS_CONTROL_MAX_AGE, "1800");
this.contextRunner.withPropertyValues(
"management.endpoints.web.cors.allowed-origins:spring.example.org")
.run(withWebTestClient(
(webTestClient) -> performAcceptedCorsRequest(webTestClient,
"/actuator/beans").expectHeader().valueEquals(
HttpHeaders.ACCESS_CONTROL_MAX_AGE, "1800")));
}
@Test
public void maxAgeCanBeConfigured() {
TestPropertyValues
.of("management.endpoints.web.cors.allowed-origins:spring.example.org",
this.contextRunner.withPropertyValues(
"management.endpoints.web.cors.allowed-origins:spring.example.org",
"management.endpoints.web.cors.max-age: 2400")
.applyTo(this.context);
performAcceptedCorsRequest("/actuator/beans").expectHeader()
.valueEquals(HttpHeaders.ACCESS_CONTROL_MAX_AGE, "2400");
.run(withWebTestClient(
(webTestClient) -> performAcceptedCorsRequest(webTestClient,
"/actuator/beans").expectHeader().valueEquals(
HttpHeaders.ACCESS_CONTROL_MAX_AGE, "2400")));
}
@Test
public void requestsWithDisallowedHeadersAreRejected() {
TestPropertyValues
.of("management.endpoints.web.cors.allowed-origins:spring.example.org")
.applyTo(this.context);
createWebTestClient().options().uri("/actuator/beans")
.header("Origin", "spring.example.org")
this.contextRunner.withPropertyValues(
"management.endpoints.web.cors.allowed-origins:spring.example.org")
.run(withWebTestClient((webTestClient) -> webTestClient.options()
.uri("/actuator/beans").header("Origin", "spring.example.org")
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, "GET")
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_HEADERS, "Alpha").exchange()
.expectStatus().isForbidden();
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_HEADERS, "Alpha")
.exchange().expectStatus().isForbidden()));
}
@Test
public void allowedHeadersCanBeConfigured() {
TestPropertyValues
.of("management.endpoints.web.cors.allowed-origins:spring.example.org",
this.contextRunner.withPropertyValues(
"management.endpoints.web.cors.allowed-origins:spring.example.org",
"management.endpoints.web.cors.allowed-headers:Alpha,Bravo")
.applyTo(this.context);
createWebTestClient().options().uri("/actuator/beans")
.header("Origin", "spring.example.org")
.run(withWebTestClient((webTestClient) -> webTestClient.options()
.uri("/actuator/beans").header("Origin", "spring.example.org")
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, "GET")
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_HEADERS, "Alpha").exchange()
.expectStatus().isOk().expectHeader()
.valueEquals(HttpHeaders.ACCESS_CONTROL_ALLOW_HEADERS, "Alpha");
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_HEADERS, "Alpha")
.exchange().expectStatus().isOk().expectHeader()
.valueEquals(HttpHeaders.ACCESS_CONTROL_ALLOW_HEADERS, "Alpha")));
}
@Test
public void requestsWithDisallowedMethodsAreRejected() {
TestPropertyValues
.of("management.endpoints.web.cors.allowed-origins:spring.example.org")
.applyTo(this.context);
createWebTestClient().options().uri("/actuator/beans")
.header("Origin", "spring.example.org")
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, "PATCH").exchange()
.expectStatus().isForbidden();
this.contextRunner.withPropertyValues(
"management.endpoints.web.cors.allowed-origins:spring.example.org")
.run(withWebTestClient((webTestClient) -> webTestClient.options()
.uri("/actuator/beans").header("Origin", "spring.example.org")
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, "PATCH")
.exchange().expectStatus().isForbidden()));
}
@Test
public void allowedMethodsCanBeConfigured() {
TestPropertyValues
.of("management.endpoints.web.cors.allowed-origins:spring.example.org",
this.contextRunner.withPropertyValues(
"management.endpoints.web.cors.allowed-origins:spring.example.org",
"management.endpoints.web.cors.allowed-methods:GET,HEAD")
.applyTo(this.context);
createWebTestClient().options().uri("/actuator/beans")
.header("Origin", "spring.example.org")
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, "HEAD").exchange()
.expectStatus().isOk().expectHeader()
.valueEquals(HttpHeaders.ACCESS_CONTROL_ALLOW_METHODS, "GET,HEAD");
.run(withWebTestClient((webTestClient) -> webTestClient.options()
.uri("/actuator/beans").header("Origin", "spring.example.org")
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, "HEAD")
.exchange().expectStatus().isOk().expectHeader().valueEquals(
HttpHeaders.ACCESS_CONTROL_ALLOW_METHODS, "GET,HEAD")));
}
@Test
public void credentialsCanBeAllowed() {
TestPropertyValues
.of("management.endpoints.web.cors.allowed-origins:spring.example.org",
this.contextRunner.withPropertyValues(
"management.endpoints.web.cors.allowed-origins:spring.example.org",
"management.endpoints.web.cors.allow-credentials:true")
.applyTo(this.context);
performAcceptedCorsRequest("/actuator/beans").expectHeader()
.valueEquals(HttpHeaders.ACCESS_CONTROL_ALLOW_CREDENTIALS, "true");
.run(withWebTestClient(
(webTestClient) -> performAcceptedCorsRequest(webTestClient,
"/actuator/beans").expectHeader().valueEquals(
HttpHeaders.ACCESS_CONTROL_ALLOW_CREDENTIALS,
"true")));
}
@Test
public void credentialsCanBeDisabled() {
TestPropertyValues
.of("management.endpoints.web.cors.allowed-origins:spring.example.org",
this.contextRunner.withPropertyValues(
"management.endpoints.web.cors.allowed-origins:spring.example.org",
"management.endpoints.web.cors.allow-credentials:false")
.applyTo(this.context);
performAcceptedCorsRequest("/actuator/beans").expectHeader()
.doesNotExist(HttpHeaders.ACCESS_CONTROL_ALLOW_CREDENTIALS);
.run(withWebTestClient(
(webTestClient) -> performAcceptedCorsRequest(webTestClient,
"/actuator/beans").expectHeader().doesNotExist(
HttpHeaders.ACCESS_CONTROL_ALLOW_CREDENTIALS)));
}
private WebTestClient createWebTestClient() {
this.context.refresh();
return WebTestClient.bindToApplicationContext(this.context).configureClient()
.baseUrl("https://spring.example.org").build();
private ContextConsumer<ReactiveWebApplicationContext> withWebTestClient(
Consumer<WebTestClient> webTestClient) {
return (context) -> webTestClient
.accept(WebTestClient.bindToApplicationContext(context).configureClient()
.baseUrl("https://spring.example.org").build());
}
private WebTestClient.ResponseSpec performAcceptedCorsRequest(String url) {
return createWebTestClient().options().uri(url)
private WebTestClient.ResponseSpec performAcceptedCorsRequest(
WebTestClient webTestClient, String url) {
return webTestClient.options().uri(url)
.header(HttpHeaders.ORIGIN, "spring.example.org")
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, "GET").exchange()
.expectHeader().valueEquals(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN,

183
spring-boot-project/spring-boot-actuator-autoconfigure/src/test/java/org/springframework/boot/actuate/autoconfigure/integrationtest/WebMvcEndpointCorsIntegrationTests.java
View File

@ -16,7 +16,6 @@
package org.springframework.boot.actuate.autoconfigure.integrationtest;
import org.junit.Before;
import org.junit.Test;
import org.springframework.boot.actuate.autoconfigure.beans.BeansEndpointAutoConfiguration;
@ -25,17 +24,18 @@ import org.springframework.boot.actuate.autoconfigure.endpoint.web.WebEndpointAu
import org.springframework.boot.actuate.autoconfigure.endpoint.web.servlet.WebMvcEndpointManagementContextConfiguration;
import org.springframework.boot.actuate.autoconfigure.web.server.ManagementContextAutoConfiguration;
import org.springframework.boot.actuate.autoconfigure.web.servlet.ServletManagementContextAutoConfiguration;
import org.springframework.boot.autoconfigure.AutoConfigurations;
import org.springframework.boot.autoconfigure.http.HttpMessageConvertersAutoConfiguration;
import org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration;
import org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration;
import org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration;
import org.springframework.boot.test.util.TestPropertyValues;
import org.springframework.boot.web.servlet.context.AnnotationConfigServletWebApplicationContext;
import org.springframework.boot.test.context.runner.ContextConsumer;
import org.springframework.boot.test.context.runner.WebApplicationContextRunner;
import org.springframework.http.HttpHeaders;
import org.springframework.mock.web.MockServletContext;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.ResultActions;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.options;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.header;
@ -45,150 +45,152 @@ import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.
* Integration tests for the MVC actuator endpoints' CORS support
*
* @author Andy Wilkinson
* @author Stephane Nicoll
* @see WebMvcEndpointManagementContextConfiguration
*/
public class WebMvcEndpointCorsIntegrationTests {
private AnnotationConfigServletWebApplicationContext context;
@Before
public void createContext() {
this.context = new AnnotationConfigServletWebApplicationContext();
this.context.setServletContext(new MockServletContext());
this.context.register(JacksonAutoConfiguration.class,
private final WebApplicationContextRunner contextRunner = new WebApplicationContextRunner()
.withConfiguration(AutoConfigurations.of(JacksonAutoConfiguration.class,
HttpMessageConvertersAutoConfiguration.class,
WebMvcAutoConfiguration.class, DispatcherServletAutoConfiguration.class,
WebMvcAutoConfiguration.class,
DispatcherServletAutoConfiguration.class,
EndpointAutoConfiguration.class, WebEndpointAutoConfiguration.class,
ManagementContextAutoConfiguration.class,
ServletManagementContextAutoConfiguration.class,
BeansEndpointAutoConfiguration.class);
TestPropertyValues.of("management.endpoints.web.exposure.include:*")
.applyTo(this.context);
}
BeansEndpointAutoConfiguration.class))
.withPropertyValues("management.endpoints.web.exposure.include:*");
@Test
public void corsIsDisabledByDefault() throws Exception {
createMockMvc()
public void corsIsDisabledByDefault() {
this.contextRunner.run(withMockMvc((mockMvc) -> mockMvc
.perform(options("/actuator/beans").header("Origin", "foo.example.com")
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, "GET"))
.andExpect(
header().doesNotExist(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN));
header().doesNotExist(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN))));
}
@Test
public void settingAllowedOriginsEnablesCors() throws Exception {
TestPropertyValues
.of("management.endpoints.web.cors.allowed-origins:foo.example.com")
.applyTo(this.context);
createMockMvc()
.perform(options("/actuator/beans").header("Origin", "bar.example.com")
public void settingAllowedOriginsEnablesCors() {
this.contextRunner
.withPropertyValues(
"management.endpoints.web.cors.allowed-origins:foo.example.com")
.run(withMockMvc((mockMvc) -> {
mockMvc.perform(options("/actuator/beans")
.header("Origin", "bar.example.com")
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, "GET"))
.andExpect(status().isForbidden());
performAcceptedCorsRequest();
performAcceptedCorsRequest(mockMvc);
}));
}
@Test
public void maxAgeDefaultsTo30Minutes() throws Exception {
TestPropertyValues
.of("management.endpoints.web.cors.allowed-origins:foo.example.com")
.applyTo(this.context);
performAcceptedCorsRequest()
.andExpect(header().string(HttpHeaders.ACCESS_CONTROL_MAX_AGE, "1800"));
public void maxAgeDefaultsTo30Minutes() {
this.contextRunner
.withPropertyValues(
"management.endpoints.web.cors.allowed-origins:foo.example.com")
.run(withMockMvc((mockMvc) -> performAcceptedCorsRequest(mockMvc)
.andExpect(header().string(HttpHeaders.ACCESS_CONTROL_MAX_AGE,
"1800"))));
}
@Test
public void maxAgeCanBeConfigured() throws Exception {
TestPropertyValues
.of("management.endpoints.web.cors.allowed-origins:foo.example.com",
public void maxAgeCanBeConfigured() {
this.contextRunner
.withPropertyValues(
"management.endpoints.web.cors.allowed-origins:foo.example.com",
"management.endpoints.web.cors.max-age: 2400")
.applyTo(this.context);
performAcceptedCorsRequest()
.andExpect(header().string(HttpHeaders.ACCESS_CONTROL_MAX_AGE, "2400"));
.run(withMockMvc((mockMvc) -> performAcceptedCorsRequest(mockMvc)
.andExpect(header().string(HttpHeaders.ACCESS_CONTROL_MAX_AGE,
"2400"))));
}
@Test
public void requestsWithDisallowedHeadersAreRejected() throws Exception {
TestPropertyValues
.of("management.endpoints.web.cors.allowed-origins:foo.example.com")
.applyTo(this.context);
createMockMvc()
.perform(options("/actuator/beans").header("Origin", "foo.example.com")
public void requestsWithDisallowedHeadersAreRejected() {
this.contextRunner
.withPropertyValues(
"management.endpoints.web.cors.allowed-origins:foo.example.com")
.run(withMockMvc((mockMvc) ->
mockMvc.perform(options("/actuator/beans")
.header("Origin", "foo.example.com")
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, "GET")
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_HEADERS, "Alpha"))
.andExpect(status().isForbidden());
.andExpect(status().isForbidden())));
}
@Test
public void allowedHeadersCanBeConfigured() throws Exception {
TestPropertyValues
.of("management.endpoints.web.cors.allowed-origins:foo.example.com",
public void allowedHeadersCanBeConfigured() {
this.contextRunner
.withPropertyValues(
"management.endpoints.web.cors.allowed-origins:foo.example.com",
"management.endpoints.web.cors.allowed-headers:Alpha,Bravo")
.applyTo(this.context);
createMockMvc()
.perform(options("/actuator/beans").header("Origin", "foo.example.com")
.run(withMockMvc((mockMvc) -> mockMvc.perform(options("/actuator/beans")
.header("Origin", "foo.example.com")
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, "GET")
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_HEADERS, "Alpha"))
.andExpect(status().isOk()).andExpect(header()
.string(HttpHeaders.ACCESS_CONTROL_ALLOW_HEADERS, "Alpha"));
.andExpect(status().isOk()).andExpect(header().string(
HttpHeaders.ACCESS_CONTROL_ALLOW_HEADERS, "Alpha"))));
}
@Test
public void requestsWithDisallowedMethodsAreRejected() throws Exception {
TestPropertyValues
.of("management.endpoints.web.cors.allowed-origins:foo.example.com")
.applyTo(this.context);
createMockMvc()
.perform(options("/actuator/beans")
public void requestsWithDisallowedMethodsAreRejected() {
this.contextRunner
.withPropertyValues(
"management.endpoints.web.cors.allowed-origins:foo.example.com")
.run(withMockMvc((mockMvc) -> mockMvc.perform(options("/actuator/beans")
.header(HttpHeaders.ORIGIN, "foo.example.com")
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, "PATCH"))
.andExpect(status().isForbidden());
.andExpect(status().isForbidden())));
}
@Test
public void allowedMethodsCanBeConfigured() throws Exception {
TestPropertyValues
.of("management.endpoints.web.cors.allowed-origins:foo.example.com",
public void allowedMethodsCanBeConfigured() {
this.contextRunner
.withPropertyValues(
"management.endpoints.web.cors.allowed-origins:foo.example.com",
"management.endpoints.web.cors.allowed-methods:GET,HEAD")
.applyTo(this.context);
createMockMvc()
.perform(options("/actuator/beans")
.run(withMockMvc((mockMvc) -> mockMvc.perform(options("/actuator/beans")
.header(HttpHeaders.ORIGIN, "foo.example.com")
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, "HEAD"))
.andExpect(status().isOk()).andExpect(header()
.string(HttpHeaders.ACCESS_CONTROL_ALLOW_METHODS, "GET,HEAD"));
.andExpect(status().isOk()).andExpect(header().string(
HttpHeaders.ACCESS_CONTROL_ALLOW_METHODS, "GET,HEAD"))));
}
@Test
public void credentialsCanBeAllowed() throws Exception {
TestPropertyValues
.of("management.endpoints.web.cors.allowed-origins:foo.example.com",
public void credentialsCanBeAllowed() {
this.contextRunner
.withPropertyValues(
"management.endpoints.web.cors.allowed-origins:foo.example.com",
"management.endpoints.web.cors.allow-credentials:true")
.applyTo(this.context);
performAcceptedCorsRequest().andExpect(
header().string(HttpHeaders.ACCESS_CONTROL_ALLOW_CREDENTIALS, "true"));
.run(withMockMvc((mockMvc) -> performAcceptedCorsRequest(mockMvc)
.andExpect(header().string(
HttpHeaders.ACCESS_CONTROL_ALLOW_CREDENTIALS, "true"))));
}
@Test
public void credentialsCanBeDisabled() throws Exception {
TestPropertyValues
.of("management.endpoints.web.cors.allowed-origins:foo.example.com",
public void credentialsCanBeDisabled() {
this.contextRunner
.withPropertyValues(
"management.endpoints.web.cors.allowed-origins:foo.example.com",
"management.endpoints.web.cors.allow-credentials:false")
.applyTo(this.context);
performAcceptedCorsRequest().andExpect(
header().doesNotExist(HttpHeaders.ACCESS_CONTROL_ALLOW_CREDENTIALS));
.run(withMockMvc((mockMvc) -> performAcceptedCorsRequest(mockMvc)
.andExpect(header().doesNotExist(
HttpHeaders.ACCESS_CONTROL_ALLOW_CREDENTIALS))));
}
private MockMvc createMockMvc() {
this.context.refresh();
return MockMvcBuilders.webAppContextSetup(this.context).build();
private ContextConsumer<WebApplicationContext> withMockMvc(MockMvcConsumer mockMvc) {
return (context) -> mockMvc
.accept(MockMvcBuilders.webAppContextSetup(context).build());
}
private ResultActions performAcceptedCorsRequest() throws Exception {
return performAcceptedCorsRequest("/actuator/beans");
private ResultActions performAcceptedCorsRequest(MockMvc mockMvc) throws Exception {
return performAcceptedCorsRequest(mockMvc, "/actuator/beans");
}
private ResultActions performAcceptedCorsRequest(String url) throws Exception {
return createMockMvc()
private ResultActions performAcceptedCorsRequest(MockMvc mockMvc, String url)
throws Exception {
return mockMvc
.perform(options(url).header(HttpHeaders.ORIGIN, "foo.example.com")
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, "GET"))
.andExpect(header().string(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN,
@ -196,4 +198,11 @@ public class WebMvcEndpointCorsIntegrationTests {
.andExpect(status().isOk());
}
@FunctionalInterface
private interface MockMvcConsumer {
void accept(MockMvc mockMvc) throws Exception;
}
}