org.springframework.test.web.reactive.server.WebTestClient Java Examples

@BeforeEach
public void setUp() {
	this.service = new BookStoreService(repository);

	BookStoreController bookStoreController = new BookStoreController(service);
	BookController bookController = new BookController(service);

	this.client = WebTestClient.bindToController(bookStoreController, bookController)
			.build();

	this.bookStoreId = service.createBookStore()
			.flatMap(bookStore -> service.putBookInStore(bookStore.getId(),
					new Book(BOOK1_ISBN, BOOK1_TITLE, BOOK1_AUTHOR))
					.then(service.putBookInStore(bookStore.getId(),
							new Book(BOOK2_ISBN, BOOK2_TITLE, BOOK2_AUTHOR)))
					.thenReturn(bookStore.getId()))
			.block();
}
 

private WebTestClient.BodyContentSpec getAndVerifyRecommendationsByProductId(String productIdQuery, HttpStatus expectedStatus) {
	return client.get()
		.uri("/recommendation" + productIdQuery)
		.accept(APPLICATION_JSON_UTF8)
		.exchange()
		.expectStatus().isEqualTo(expectedStatus)
		.expectHeader().contentType(APPLICATION_JSON_UTF8)
		.expectBody();
}
 

@Before
public void setup() {
    this.rest = WebTestClient
        .bindToApplicationContext(this.context)
        .configureClient()
        .build();
}
 

@BeforeAll
public void setup() {
    this.client = WebTestClient
            .bindToApplicationContext(this.context)
            .configureClient()
            .build();
}
 

@Test
@Ignore
public void mockServerWorks() {
	WebTestClient client = WebTestClient.bindToApplicationContext(this.context)
			.build();
	client.get().uri("/mockexample").exchange().expectStatus()
			.value(Matchers.lessThan(500));
}
 

@Test
public void testWebTestClientWithServerURL() {
    WebTestClient.bindToServer()
        .baseUrl("http://localhost:" + port)
        .build()
        .get()
        .uri("/resource")
        .exchange()
        .expectStatus()
        .isOk()
        .expectBody();
}
 

@BeforeEach
public void setup() {
    this.rest = WebTestClient
        .bindToServer()
        .responseTimeout(Duration.ofDays(1))
        .baseUrl("http://localhost:8080")
        .build();
}
 

@BeforeClass
public static void setup() throws Exception {
    server = new FunctionalWebApplication().start();
    client = WebTestClient.bindToServer()
        .baseUrl("http://localhost:" + server.getPort())
        .build();
}
 

@Before
public void setup() {
    this.rest = WebTestClient
        .bindToApplicationContext(this.context)
        .apply(springSecurity())
        .configureClient()
        .filter(basicAuthentication())
        .build();
}
 

@BeforeAll
public void setup() {
    this.client = WebTestClient
        .bindToController(this.ctrl)
        .configureClient()
        .build();
}
 

@Before
public void setUp() throws Exception {

	AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
	context.register(WebConfig.class);
	context.refresh();

	this.client = WebTestClient.bindToApplicationContext(context).build();
}
 

@Before
public void start() throws Exception {
	HttpHandler httpHandler = RouterFunctions.toHttpHandler(
			route(GET("/test"), request -> ServerResponse.ok().syncBody("It works!")));

	this.server = new ReactorHttpServer();
	this.server.setHandler(httpHandler);
	this.server.afterPropertiesSet();
	this.server.start();

	this.client = WebTestClient.bindToServer()
			.baseUrl("http://localhost:" + this.server.getPort())
			.build();
}
 

private WebTestClient.BodyContentSpec getAndVerifyReviewsByProductId(String productIdQuery, HttpStatus expectedStatus) {
	return client.get()
		.uri("/review" + productIdQuery)
		.accept(APPLICATION_JSON_UTF8)
		.exchange()
		.expectStatus().isEqualTo(expectedStatus)
		.expectHeader().contentType(APPLICATION_JSON_UTF8)
		.expectBody();
}
 

@BeforeClass
public static void setUpClass() {
    when(jobOperations.getJobsAndTasks()).thenReturn(Collections.emptyList());

    baseURI = jaxRsServer.getBaseURI() + ApplicationSlaManagementEndpoint.PATH_API_V2_MANAGEMENT_APPLICATIONS + '/';
    testClient = WebTestClient.bindToServer()
            .baseUrl(baseURI)
            .defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON)
            .build();
}
 

private WebTestClient.BodyContentSpec getAndVerifyProduct(String productIdPath, HttpStatus expectedStatus) {
	return client.get()
		.uri("/product" + productIdPath)
		.accept(APPLICATION_JSON_UTF8)
		.exchange()
		.expectStatus().isEqualTo(expectedStatus)
		.expectHeader().contentType(APPLICATION_JSON_UTF8)
		.expectBody();
}
 

@Test
public void shouldRegisterBean() {
    given(mockFactory.getBeanNamesForType(WebTestClient.class, false, false))
        .willReturn(new String[]{});

    registrar.postProcessBeanDefinitionRegistry(mockRegistry);

    ArgumentCaptor<RootBeanDefinition> definitionCaptor = ArgumentCaptor.forClass(RootBeanDefinition.class);
    verify(mockRegistry).registerBeanDefinition(eq(WebTestClient.class.getName()), definitionCaptor.capture());

    RootBeanDefinition definition = definitionCaptor.getValue();
    assertThat(definition.getBeanClass()).isEqualTo(WebTestClient.class);
    assertThat(definition.getInstanceSupplier()).isInstanceOf(VertxWebTestClientSupplier.class);
    assertThat(definition.isLazyInit()).isTrue();
}
 

@Before
public void setUp() throws Exception {

	RouterFunction<?> route = route(GET("/test"), request ->
			ServerResponse.ok().syncBody("It works!"));

	this.testClient = WebTestClient.bindToRouterFunction(route).build();
}
 

@BeforeAll
public static void setup() {
    client = WebTestClient.bindToServer()
        .baseUrl(BASE_URL)
        .defaultHeader("Origin", CORS_DEFAULT_ORIGIN)
        .build();
}
 

@BeforeEach
public void setup() {
    this.client = WebTestClient
        .bindToServer()
        .responseTimeout(Duration.ofDays(1))
        .baseUrl("http://localhost:8080")
        .build();
}
 

private WebTestClient.BodyContentSpec getAndVerifyRecommendationsByProductId(String productIdQuery, HttpStatus expectedStatus) {
	return client.get()
		.uri("/recommendation" + productIdQuery)
		.accept(APPLICATION_JSON_UTF8)
		.exchange()
		.expectStatus().isEqualTo(expectedStatus)
		.expectHeader().contentType(APPLICATION_JSON_UTF8)
		.expectBody();
}
 

@BeforeAll
public void setup() {
    this.client = WebTestClient
        .bindToController(this.ctrl)
        .configureClient()
        .build();
}
 

@BeforeEach
public void setup() {
    this.client = WebTestClient
            .bindToServer()
            .responseTimeout(Duration.ofSeconds(300))
            .baseUrl("http://localhost:8080")
            .build();
}
 

private WebTestClient.BodyContentSpec getAndVerifyReviewsByProductId(String productIdQuery, HttpStatus expectedStatus) {
	return client.get()
		.uri("/review" + productIdQuery)
		.accept(APPLICATION_JSON_UTF8)
		.exchange()
		.expectStatus().isEqualTo(expectedStatus)
		.expectHeader().contentType(APPLICATION_JSON_UTF8)
		.expectBody();
}
 

@BeforeEach
public void setUp() {
	instance = new SpringApplicationBuilder().sources(AdminReactiveApplicationTest.TestAdminApplication.class)
			.web(WebApplicationType.REACTIVE).run("--server.port=0", "--eureka.client.enabled=false");

	localPort = instance.getEnvironment().getProperty("local.server.port", Integer.class, 0);

	this.client = WebTestClient.bindToServer().baseUrl("http://localhost:" + localPort).build();
	this.register_as_test = "{ \"name\": \"test\", \"healthUrl\": \"http://localhost:" + localPort
			+ "/application/health\" }";
	this.register_as_twice = "{ \"name\": \"twice\", \"healthUrl\": \"http://localhost:" + localPort
			+ "/application/health\" }";
}
 

@Before
public void setup() {
    this.rest = WebTestClient
        .bindToServer()
        .responseTimeout(Duration.ofDays(1))
        .baseUrl("http://localhost:" + this.port)
        .build();
}
 

@Test
public void testRenameBoard() throws Exception {

    WebTestClient.bindToController( this.controller )
            .build()
            .patch()
            .uri(  "/boards/{boardUuid}?name={name}", boardUuid, "New Name" )
            .exchange()
            .expectStatus().isAccepted();

}
 

@BeforeAll
public void setup() {
    this.disposableServer = this.httpServer.bindNow();
    this.client = WebTestClient
            .bindToServer()
            .responseTimeout(Duration.ofDays(1))
            .baseUrl("http://localhost:" + this.port)
            .build();
}
 

protected void setup(ClientHttpConnector httpConnector, String baseUri) {
	this.baseUri = baseUri;
	this.webClient = WebClient.builder().clientConnector(httpConnector)
			.baseUrl(this.baseUri).build();
	this.testClient = WebTestClient.bindToServer(httpConnector).baseUrl(this.baseUri)
			.build();
}
 

protected void setUpClient(ConfigurableApplicationContext context) {
	int localPort = context.getEnvironment().getProperty("local.server.port", Integer.class, 0);
	this.client = WebTestClient.bindToServer().baseUrl("http://localhost:" + localPort)
			.responseTimeout(Duration.ofSeconds(10)).build();

	this.instanceId = registerInstance("/instance1");
}
 

private WebTestClient.BodyContentSpec getAndVerifyRecommendationsByProductId(String productIdQuery, HttpStatus expectedStatus) {
	return client.get()
		.uri("/recommendation" + productIdQuery)
		.accept(APPLICATION_JSON_UTF8)
		.exchange()
		.expectStatus().isEqualTo(expectedStatus)
		.expectHeader().contentType(APPLICATION_JSON_UTF8)
		.expectBody();
}