Test yozish

WebTestClient API-interfeysini taqdim etadi, WebClient bilan bir xil, hattoki exchange() yordamida so'rovni bajarishgacha. Har qanday mazmun bilan so'rovni tayyorlash misollari, shu jumladan shakl ma'lumotlari, ko'p qismli ma'lumotlar va boshqa ko'plar WebClient hujjatlarida ko'ring.

exchange() chaqirgandan so'ng WebTestClient WebClientdan farqlanadi va buning o'rniga javoblarning ishonchliligini tekshirish jarayonini davom ettiradi.

Javob holati va sarlavhalarni tasdiqlash uchun quyidagilarni ishlating:

client.get().uri("/persons/1")
    .accept(MediaType.APPLICATION_JSON)
    .exchange()
    .expectStatus().isOk()
    .expectHeader().contentType(MediaType.APPLICATION_JSON);

client.get().uri("/persons/1")
    .accept(MediaType.APPLICATION_JSON)
    .exchange()
    .expectStatus().isOk()
    .expectHeader().contentType(MediaType.APPLICATION_JSON)

Agar hamma kutgan voqealar tasdiqlanishini istasangiz, hatto ulardan biri muvaffaqiyatsiz bo'lsa ham, bir nechta ketma-ket expect*(..) chaqirishlar o'rniga expectAll(..)dan foydalanishingiz mumkin. Bu funksiya AssertJ'dagi yumshoq tasdiqlashlar va JUnit Jupiter'dagi assertAll()ni qo'llab-quvvatlashga o'xshaydi.

client.get().uri("/persons/1")
    .accept(MediaType.APPLICATION_JSON)
    .exchange()
    .expectAll(
        spec -> spec.expectStatus().isOk(),
        spec -> spec.expectHeader().contentType(MediaType.APPLICATION_JSON)
    );

Keyin javob tanasini quyidagi yo'llardan birini ishlatib dekodlashni tanlashingiz mumkin:

• expectBody(Class<T>): Bir obyektga dekodlaymiz.

• expectBodyList(Class<T>): Obyektlarni List<T>ga dekodlaymiz va yig'amiz.

• expectBody(): JSON mazmuni yoki bo'sh tana uchun byte[]ga dekodlaymiz.

Va natijaviy obyekt(lar) bo'yicha yuqori darajadagi tasdiqlarni bajarish:

client.get().uri("/persons")
        .exchange()
        .expectStatus().isOk()
        .expectBodyList(Person.class).hasSize(3).contains(person);

import org.springframework.test.web.reactive.server.expectBodyList
client.get().uri("/persons")
        .exchange()
        .expectStatus().isOk()
        .expectBodyList<Person>().hasSize(3).contains(person)

Agar o'rnatilgan tasdiqlar etarli bo'lmasa, uning o'rniga obyektni ishlatishingiz va boshqa istalgan tasdiqlarni bajarishingiz mumkin:

import org.springframework.test.web.reactive.server.expectBody
client.get().uri("/persons/1")
        .exchange()
        .expectStatus().isOk()
        .expectBody(Person.class)
        .consumeWith(result -> {
            // maxsus tasdiqlar (masalan, AssertJ)...
        });

client.get().uri("/persons/1")
        .exchange()
        .expectStatus().isOk()
        .expectBody<Person>()
        .consumeWith {
            // maxsus tasdiqlar (masalan, AssertJ)...
        }

Yoki siz ish jarayonidan chiqishingiz va EntityExchangeResultni olishingiz mumkin:

EntityExchangeResult<Person> result = client.get().uri("/persons/1")
        .exchange()
        .expectStatus().isOk()
        .expectBody(Person.class)
        .returnResult();

import org.springframework.test.web.reactive.server.expectBody
val result = client.get().uri("/persons/1")
        .exchange()
        .expectStatus().isOk
        .expectBody<Person>()
        .returnResult()

Kontent yo'q

Agar javobda kontent bo'lmasligi kutilsa, unda buni quyidagicha tasdiqlashingiz mumkin:

client.post().uri("/persons")
        .body(personMono, Person.class)
        .exchange()
        .expectStatus().isCreated()
        .expectBody().isEmpty();

client.post().uri("/persons")
        .bodyValue(person)
        .exchange()
        .expectStatus().isCreated()
        .expectBody().isEmpty()

Agar javob kontentini e'tiborsiz qoldirish kerak bo'lsa, quyida hech qanday tasdiqsiz kontentni bo'shatish keltirilgan:

client.get().uri("/persons/123")
        .exchange()
        .expectStatus().isNotFound()
        .expectBody(Void.class);

client.get().uri("/persons/123")
        .exchange()
        .expectStatus().isNotFound
        .expectBody<Unit>()

JSON Kontent

expectBody()ni maqsadli tur yo'q holda ishlatib, formatlanmagan kontent uchun tasdiqlarni bajarishingiz mumkin, bu yuqori darajadagi obyekt(lar) orqali amalga oshirilmasdan.

To'liq JSON kontentini JSONAssert yordamida tekshirish uchun:

client.get().uri("/persons/1")
        .exchange()
        .expectStatus().isOk()
        .expectBody()
        .json("{\"name\":\"Jane\"}")

client.get().uri("/persons/1")
        .exchange()
        .expectStatus().isOk()
        .expectBody()
        .json("{\"name\":\"Jane\"}")

JSON kontentini JSONPath yordamida tekshirish uchun:

client.get().uri("/persons")
        .exchange()
        .expectStatus().isOk()
        .expectBody()
        .jsonPath("$[0].name").isEqualTo("Jane")
        .jsonPath("$[1].name").isEqualTo("Jason");

client.get().uri("/persons")
        .exchange()
        .expectStatus().isOk()
        .expectBody()
        .jsonPath("$[0].name").isEqualTo("Jane")
        .jsonPath("$[1].name").isEqualTo("Jason")

Streamli javoblar

"text/event-stream" yoki "application/x-ndjson" kabi potentsial cheksiz streamlarni tekshirish uchun, javobning holati va sarlavhalarini tekshirishdan boshlash va keyin FluxExchangeResultni olish:

FluxExchangeResult<MyEvent> result = client.get().uri("/events")
        .accept(TEXT_EVENT_STREAM)
        .exchange()
        .expectStatus().isOk()
        .returnResult(MyEvent.class);

import org.springframework.test.web.reactive.server.returnResult
val result = client.get().uri("/events")
        .accept(TEXT_EVENT_STREAM)
        .exchange()
        .expectStatus().isOk()
        .returnResult<MyEvent>()

Endi siz reactor-test'dan StepVerifier yordamida javob streamini iste'mol qilishga tayyorsiz:

Flux<Event> eventFlux = result.getResponseBody();
StepVerifier.create(eventFlux)
        .expectNext(person)
        .expectNextCount(4)
        .consumeNextWith(p -> ...)
        .thenCancel()
        .verify();

val eventFlux = result.getResponseBody()
StepVerifier.create(eventFlux)
        .expectNext(person)
        .expectNextCount(4)
        .consumeNextWith { p -> ... }
        .thenCancel()
        .verify()

MockMvc tasdiqlashlari

WebTestClient bu HTTP-mijoz, shuning uchun u faqat mijoz javobida nima borligini, shu jumladan holati, sarlavhalar va tanani tasdiqlashi mumkin.

Spring MVC ilovasini MockMvc server sozlamasi bilan test qilishda sizga server javobi uchun qo'shimcha tasdiqlarni bajarish imkoni ham beriladi. Buning uchun tanaga tasdiq qo'shilgandan keyin ExchangeResultni olishdan boshlang:

// Tanasi bo'lgan javob uchun
EntityExchangeResult<Person> result = client.get().uri("/persons/1")
        .exchange()
        .expectStatus().isOk()
        .expectBody(Person.class)
        .returnResult();
// Tanasiz javob uchun
EntityExchangeResult<Void> result = client.get().uri("/path")
        .exchange()
        .expectBody().isEmpty();

// Tanasi bo'lgan javob uchun
val result = client.get().uri("/persons/1")
        .exchange()
        .expectStatus().isOk()
        .expectBody(Person.class)
        .returnResult();
// Tanasiz javob uchun
val result = client.get().uri("/path")
        .exchange()
        .expectBody().isEmpty();

Keyin MockMvc server javobi tasdiqlariga o'ting:

MockMvcWebTestClient.resultActionsFor(result)
        .andExpect(model().attribute("integer", 3))
        .andExpect(model().attribute("string", "a string value"));

MockMvcWebTestClient.resultActionsFor(result)
        .andExpect(model().attribute("integer", 3))
        .andExpect(model().attribute("string", "a string value"));