Գնահատել նախագիծը
← Բոլոր հրապարակումները

Kafka-ի և Spring Cloud Contract-ի վրա հիմնված իրադարձություններով (event-driven) հավելվածի կոնտրակտային թեստեր

Այս հոդվածը ցույց է տալիս, թե ինչպես կարելի է Spring Cloud Contract-ով ստուգել միկրոսերվիսների ասինխրոն հաղորդակցությունը, երբ որպես հաղորդագրությունների բրոքեր օգտագործվում է Kafka-ն։

14 րոպե
ԹեստավորումԿոնտրակտային թեստերspring cloudapache kafka

Նախկինում ես ցույց էի տվել, թե ինչպես գրել կոնտրակտային թեստեր REST API-ով իրականացվող սինխրոն հաղորդակցության համար։ Դա բավականին պարզ ու տարածված դեպք է, և ինտերնետում կոնտրակտային թեստավորման մասին հոդվածների մեծ մասը հենց դրա մասին է։ Շատ ավելի դժվար է գտնել ուղեցույց հաղորդագրությունների բրոքերի վրա կառուցված ասինխրոն հաղորդակցության թեստավորման մասին։

Այստեղ ես կանդրադառնամ ասինխրոն, իրադարձություններով (event-driven) հաղորդակցության թեստավորմանը, որտեղ որպես հաղորդագրությունների բրոքեր օգտագործվում է Kafka-ն։ Հոդվածը հասկանալու համար անհրաժեշտ են Kafka-ի հիմնական գիտելիքներ, քանի որ նրա աշխատանքի նկարագրությունը դուրս է այս գրառման շրջանակից։ Այնպես որ, եթե Kafka-ն ձեզ համար նոր է, խորհուրդ եմ տալիս նախ ծանոթանալ նրա հիմնական գաղափարներին։

Եթե ձեզ հետաքրքրում է, թե ինչպես են Kafka-ն և իրադարձություններով ճարտարապետությունը օգնում բաշխված համակարգերի մշակմանը, խորհուրդ եմ տալիս ստորև նշված հոդվածը։

Այս շարքի նախորդ մասերը կառուցված են էլեկտրոնային առևտրի հարթակում ավտոմատ վճարվող պատվերի շուրջ։ Երկու սերվիսները՝ order-service-ը և payment-service-ը, շփվում են REST API-ի միջոցով. order-service-ը կանչում է payment-service-ի API-ն։ Այս մասում ես շրջել եմ կախվածությունները, որպեսզի ցույց տամ, թե ինչպես կարելի է նույն սցենարը իրականացնել իրադարձություններով մոտեցմամբ։ Այժմ order-service-ը հայտարարում է պատվերի ստեղծման մասին՝ արձակելով իրադարձություն, որը հայտնվում է Kafka-ի թոփիքում։ payment-service-ը այդ թոփիքի բաժանորդներից մեկն է և յուրաքանչյուր պատվերի համար սկսում է վճարում։

Կոնտրակտային թեստավորման տերմիններով այս փոփոխությունը order-service-ը դարձնում է արտադրող (producer), իսկ payment-service-ը՝ սպառող (consumer)։ Պարզության համար իրադարձությունները սերիալիզացվում են JSON-ով։ Յուրաքանչյուրը պարունակում է մետատվյալներ (eventId և տեղի ունենալու ժամանակը) և ստեղծված պատվերի մանրամասները։

{
  "eventId": "9c465a8f-bf77-4f3a-b357-d760ced8b26f",
  "occuredAt": "2023-12-02T13:00:00",
  "orderId": "59404950-bc8d-4722-a521-0dee64b680d6",
  "accountId": "5c2c2407-7202-4720-9a45-f0d0f8175ef1",
  "total": 120.8
}

Այս ձեռնարկը բացատրում է, թե ինչպես կարելի է նման հաղորդակցությունը թեստավորել Spring Cloud Contract-ով։ Ինչպես REST API-ի թեստավորման դեպքում, առաջին քայլը կոնտրակտի սահմանումն է։

Կոնտրակտի սահմանումը

Կոնտրակտը կարելի է արտահայտել Spring Cloud Contract-ի առաջարկած DSL-ով, որը կարելի է գրել Java-ով, Kotlin-ով, Groovy-ով կամ Yaml-ով։ Ստորև բերված է order-service-ի արձակած OrderCreated իրադարձության Groovy կոնտրակտը։

Contract.make {
    description("Should produce OrderCreated event when order was created")
    input {
        triggeredBy("createOrder()")
    }
    label("triggerOrderCreatedEvent")
    outputMessage {
        sentTo("OrderCreated")
        body([
                eventId: anyUuid(),
                occurredAt: anyDateTime(),
                orderId: anyUuid(),
                accountId: anyUuid(),
                total: $(consumer(regex("(\\d+\\.\\d+)")))
        ])
    }
}

Ինչպես տեսնում եք, այն որոշ չափով տարբերվում է REST API-ի կոնտրակտից։ Դա սպասելի է, քանի որ այս տեսակի հաղորդակցությունը այլ կանոններով է աշխատում։ Չկա սերվեր, որը մշակում է սպառողի հարցումները. փոխարենը արտադրողը (այստեղ՝ order-service-ը) արձակում է իրադարձություն՝ որպես բիզնես գործողության արդյունք։ Այդ պատճառով թեստը պետք է ինչ-որ կերպ գործարկի այն։ input բաժինը նշում է, թե ինչն է առաջացնում հաղորդագրության ուղարկումը. տվյալ դեպքում դա createOrder() մեթոդն է։ Գեներացված թեստերը օգտագործում են այն, ինչպես կտեսնեք ստորև։

Սպառողի կողմից նույնպես անհրաժեշտ է միջոց՝ հաղորդագրության առաքումը Kafka-ի սպառողին գործարկելու համար։ Դրա համար է label մեթոդը։ Ես պիտակը անվանել եմ triggerOrderCreatedEvent, և այն պետք է իմանաք սպառողի թեստերը գրելիս։

Վերջում outputMessage բաժինը նկարագրում է, թե ուր է գնում հաղորդագրությունը և ինչ է պարունակում։ sentTo() մեթոդը նշում է, որ հաղորդագրությունը ուղարկվում է OrderCreated թոփիքին։ body() մեթոդը հայտարարում է, որ հաղորդագրության մարմինը պետք է պարունակի 5 դաշտ նշված տիպերով։ Ինչպես REST API-ի թեստավորման մասին հոդվածում, այստեղ էլ դաշտերի կոնկրետ արժեքներ չենք գրում։ Փոխարենը սահմանում ենք, որ eventId-ն, orderId-ն և accountId-ն պետք է պարունակեն ցանկացած վավեր UUID, occurredAt-ը (իրադարձության տեղի ունենալու ժամանակը) պետք է լինի ամսաթիվ-ժամանակ արժեք, իսկ total-ը՝ դրական double։

Կոնտրակտը պետք է տեղադրվի /src/contractTest/resources թղթապանակում, իսկ ենթաթղթապանակները կարելի է օգտագործել կոնտրակտները ըստ սպառողների խմբավորելու համար։ Այստեղ order-service-ը արտադրողն է, ուստի նրա կոնտրակտները գտնվում են այս նախագծում հետևյալ թղթապանակում՝
order-service/src/contractTest/resources/contracts/paymentService։

Արտադրողի թեստավորումը

Կոնտրակտից թեստեր և stub-եր գեներացնելու և արտադրողի թեստերը գործարկելու համար անհրաժեշտ են Spring Cloud Contract-ի կախվածությունը և պլագինը։

plugins {
    id 'org.springframework.cloud.contract' version '4.0.0'
}

dependencies {
    testImplementation 'org.springframework.cloud:spring-cloud-starter-contract-verifier:4.0.0'
}

Համառոտության համար ես բաց եմ թողել թեստերը գործարկելու համար անհրաժեշտ մյուս կախվածություններն ու պլագինները, ինչպիսիք են Spring Boot Test-ը կամ Spring Kafka-ն։ Gradle-ի build.gradle ֆայլում ես նաև ավելացրել եմ ֆրեյմվորքի համար անհրաժեշտ նվազագույն կոնֆիգուրացիան։

contracts {
    baseClassForTests = "pl.rmaciak.payment.BaseContractTestsSpec"
    testFramework = "SPOCK"
}

Սա նշում է, որ գեներացված թեստերը կգրվեն Spock-ով և, ամենակարևորը, կընդլայնեն BaseContractTestsSpec բազային դասը։ Այդ դասը արժե ավելի ուշադիր դիտարկել։

REST API-ը թեստավորելիս բազային դասը գործարկում է սերվերը (կամ սերվերի mock-ը), որի դեմ աշխատում են թեստերը։ Այնտեղ սերվերը REST API-ն ցուցաբերող արտադրողն է, իսկ թեստերը ստուգում են՝ արդյոք այդ API-ն բավարարում է կոնտրակտներում սահմանված պահանջներին։ Իրադարձություններով դեպքերում ամեն ինչ այլ կերպ է։ Արտադրողը API չի ցուցաբերում, այլ հաղորդագրություն է հրապարակում Kafka բրոքերին։ Թեստերը պետք է ստուգեն, թե արդյոք այդ հաղորդագրությունը բավարարում է կոնտրակտներում նշված պահանջներին։ Այսպիսով, պետք է որսալ բրոքերին ուղարկված հաղորդագրությունը և ստուգել այն կոնտրակտների դեմ։

Հաղորդագրությունը որսալու մի քանի եղանակ կա։ Տարբերակներից մեկը բրոքերը Docker կոնտեյների մեջ գործարկելն է՝ Testcontainers-ի և Kafka-ի image-ի միջոցով։ Կոնտրակտային թեստը գործարկում է իրադարձությունն արձակող ֆունկցիոնալությունը, և իրադարձությունը գնում է նոր գործարկված, կարճատև Kafka բրոքերի համապատասխան թոփիքին։ Հենց դրա համար է պատասխանատու BaseContractTestsSpec դասը։

@SpringBootTest(webEnvironment = NONE, classes = [OrderApplication.class])
@AutoConfigureMessageVerifier
@Testcontainers
abstract class BaseContractTestsSpec extends Specification {

    @Shared
    static KafkaContainer kafka = new KafkaContainer(DockerImageName.parse("confluentinc/cp-kafka:latest"))

    @Autowired
    private OrderCreator orderCreator

    @DynamicPropertySource
    static void kafkaProperties(DynamicPropertyRegistry registry) {
        kafka.start()
        registry.add("spring.kafka.bootstrap-servers", () -> kafka.getBootstrapServers())
    }

    void createOrder() {
        orderCreator.createOrder(
                UUID.randomUUID(),
                UUID.randomUUID(),
                BigDecimal.valueOf(120.8)
        )
    }
}

Դասը հայտարարում է Kafka կոնտեյներ՝ հիմնված Confluent-ի Kafka-ի community տարբերակի վերջին image-ի վրա (kafka դաշտը)։ Կոնտեյները գործարկվում է @DynamicPropertySource-ով նշված մեթոդում, որը նաև spring.kafka.bootstrap-server հատկությունը ուղղում է կոնտեյների ցուցաբերած հասցեին։ Դրա շնորհիվ Spring-ը կարող է իրադարձություններ հրապարակել և սպառել կոնտեյներացված բրոքերի միջոցով։ createOrder() մեթոդը հենց այն է, որ կոնտրակտում նշված է որպես գործարկող input։ Այն միայն կատարում է պատվերի ստեղծման տրամաբանությունը ներարկված OrderCreator-ի միջոցով, ինչի արդյունքում իրադարձությունը հրապարակվում է։

BaseContractTestsSpec-ը այսպես իրականացնելուց հետո սերվիսի տրամաբանությունը պարզապես հաղորդագրություններ է հրապարակում կոնտեյների մեջ աշխատող Kafka-ին։ Մեզ դեռ պակասում է հաղորդագրությունը ստանալու և այն կոնտրակտի դեմ ստուգելու միջոց։ Դա անում է Message Verifier-ը։ Ուշադրություն դարձրեք դասի վրա դրված @AutoConfigureMessageVerifier անոտացիային. այն ստեղծում և կարգավորում է այն bean-երը, որոնք Spring Cloud Contract-ը օգտագործում է հաղորդագրությունները ստուգելու համար։ Ֆրեյմվորքը մատակարարվում է JMS-ի, Apache Camel-ի, Spring Integration-ի և այլնի համար պատրաստի ստուգիչներով։ Ցավոք, դրանցից և ոչ մեկը Kafka բրոքերների համար չէ, ուստի մեզ անհրաժեշտ է ինքներս գրել այն։

Spring Cloud Contract-ը առաջարկում է MessageVerifierReceiver ինտերֆեյսը, որի իրականացումը թույլ է տալիս թեստին հաղորդագրություններ ստանալ Kafka-ից։ Այն հայտարարում է երկու գերբեռնված receive() մեթոդ, որոնք երկուսն էլ վերադարձնում են Spring Messaging-ի Message ինտերֆեյսը։ Spring Cloud Contract-ը այդ հաղորդագրությունը ստուգում է կոնտրակտի դեմ։ Բրոքերից հաղորդագրությունը ստանալու համար կարող ենք գրել թեստային սպառող. այս օրինակում այն հաղորդագրությունները պահում է բազմության (set) մեջ։ Այն լսում է միայն OrderCreated թոփիքը, ուստի սխալ հասցեով ուղարկված իրադարձությունը չի բռնվի, և թեստը կձախողվի։ receive() մեթոդները այդ բազմությունից վերցնում են հաղորդագրություն և վերադարձնում են այն, եթե այն կա։ Բնականաբար, հաղորդագրությունների սպառումը կարող է որոշ ժամանակ տևել, ուստի ստուգումը կրկնվում է մի քանի վայրկյան հետո։

class KafkaEventVerifier implements MessageVerifierReceiver<Message<?>> {

    private final Set<Message> consumedEvents = Collections.synchronizedSet(new HashSet<Message>())

    @KafkaListener(topics = ["OrderCreated"], groupId = "order-consumer")
    void consumeOrderCreated(ConsumerRecord payload) {
        consumedEvents.add(MessageBuilder.createMessage(payload.value(), new MessageHeaders(emptyMap())))
    }

    @Override
    Message receive(String destination, long timeout, TimeUnit timeUnit, @Nullable YamlContract contract) {
        for (int i = 0; i < timeout; i++) {
            Message msg = consumedEvents.stream().findFirst().orElse(null)
            if (msg != null) {
                return msg
            }

            timeUnit.sleep(1)
        }

        return consumedEvents.stream().findFirst().orElse(null)
    }

    @Override
    Message receive(String destination, YamlContract contract) {
        return receive(destination, 5, SECONDS, contract)
    }
}

Այս մոտեցման ճարտարապետությունը հետևյալն է.

Այս պահին մենք ունենք հաղորդագրությունը վավերացնելու համար անհրաժեշտ ամեն ինչ։ Այն հրապարակվում է Kafka-ում և որսվում մեր ստուգիչի կողմից։ Spring Cloud Contract-ը վերցնում է սպառված հաղորդագրությունը և ստուգում, թե արդյոք այն համապատասխանում է կոնտրակտների սպասումներին։ Դա կատարվում է գեներացված թեստերում, որոնք ֆրեյմվորքը ստեղծում է հավելվածի կառուցման ժամանակ։ Կարող եք դրանք գեներացնել հետևյալ հրամանով։

./gradlew check

Ահա մեր կոնտրակտից գեներացված թեստը։

@SuppressWarnings("rawtypes")
class PaymentServiceSpec extends BaseContractTestsSpec {
    @Inject ContractVerifierMessaging contractVerifierMessaging
    @Inject ContractVerifierObjectMapper contractVerifierObjectMapper

    def validate_shouldProduceOrderCreatedEvent() throws Exception {
        when:
            createOrder()

        then:
            ContractVerifierMessage response = contractVerifierMessaging.receive("OrderCreated",
                    contract(this, "shouldProduceOrderCreatedEvent.yml"))
            response != null

        and:
            DocumentContext parsedJson = JsonPath.parse(contractVerifierObjectMapper.writeValueAsString(response.getPayload()))
            assertThatJson(parsedJson).field("['eventId']").matches("[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}")
            assertThatJson(parsedJson).field("['occurredAt']").matches("([0-9]{4})-(1[0-2]|0[1-9])-(3[01]|0[1-9]|[12][0-9])T(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])")
            assertThatJson(parsedJson).field("['orderId']").matches("[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}")
            assertThatJson(parsedJson).field("['accountId']").matches("[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}")
            assertThatJson(parsedJson).field("['total']").matches("(\\d+\\.\\d+)")
    }
}

Թեստի դասը ընդլայնում է մեր BaseContractTestsSpec-ը, և նրա when բաժինը պարզապես կանչում է createOrder() գործարկող մեթոդը։ Արդյունքում հաղորդագրությունը հրապարակվում է Kafka բրոքերում, ապա ստացվում մեր սպառողի կողմից, ուստի then բաժնի receive() կանչը ի վերջո վերադարձնում է այն։ Վերջում հաղորդագրության յուրաքանչյուր դաշտ ստուգվում է։ Թեստը գտնվում է build/generated-test-sources թղթապանակում։

Թեստավորման այս փուլը ստուգում է, թե արդյոք վավեր հաղորդագրությունը հասել է Kafka բրոքերի ճիշտ թոփիքին։ Երբ թեստերը անցնում են, կարող ենք վստահ լինել, որ հաղորդագրությունը բավարարում է կոնտրակտի սպասումներին։ Իսկապես, պետք է որոշ կոդ գրել, հիմնականում այն պատճառով, որ Kafka-ն չունի ներկառուցված ստուգիչ։ Այդուհանդերձ, այդ կոդը բավականին ընդհանուր է և հեշտությամբ կարելի է ընդլայնել՝ այլ իրադարձություններ ևս ընդգրկելու համար։

Սպառողի թեստավորումը

REST API-ի կոնտրակտային թեստերում հավելվածի կառուցումը ստեղծում էր Wiremock stub-եր, որոնք արտացոլում էին կոնտրակտի ենթադրությունները, և սպառողի թեստերը կարող էին օգտագործել դրանք։ Հաղորդագրությունների բրոքերի միջոցով իրադարձային հաղորդակցությունը արտադրողի և սպառողի միջև ուղիղ HTTP կապ չի ենթադրում։ Այն հիմնվում է այն հաղորդագրությունների վրա, որոնք հրապարակվում են սերվիսների միջև գտնվող բրոքերին և սպառվում նրանից։ Ուստի սպառողի թեստավորումը իրականում նշանակում է ստուգել, թե արդյոք նա կարողանում է հասկանալ և մշակել արտադրողի արձակած իրադարձությունը։

Քանի որ սպառողը իրադարձություններ է սպառում, նա սովորաբար իրականացնում է իրադարձությունների լսող (listener)։ Թեստում մենք ուզում ենք համոզվել, որ կոնտրակտի կանոններին համապատասխանող հաղորդագրությունը ճիշտ սպառվում և մշակվում է։ Դրա համար պետք է Kafka-ին ուղարկենք նմուշային հաղորդագրություն, որպեսզի սպառողը վերցնի և մշակի այն։ Մեր դեպքում սպառողը payment-service-ն է, և նա սպառում է order-service-ից եկող իրադարձությունները։

Կոնտրակտին համապատասխանող հաղորդագրություն ստեղծելու և հրապարակելու համար պետք է իմանանք նրա կառուցվածքը։ Ահա թե ինչու արտադրողի համար կառուցված JAR-ը չի պարունակում Wiremock stub-եր, այլ պարունակում է հենց կոնտրակտը՝ ճիշտ նույնը, որ սահմանել էինք արտադրողի կողմում։ Այն մեզ ասում է.

  • ուր է գնում իրադարձությունը (թոփիք)
  • ինչպես է կառուցված հաղորդագրությունը
  • ինչն է առաջացնում հաղորդագրության ուղարկումը

Կոնտրակտը փաթեթավորված է JAR ֆայլում, որը գտնվում է build/libs թղթապանակում (order-service-0.0.1-SNAPSHOT-stubs.jar)։ JAR-ը կարելի է տեղադրել, օրինակ, տեղային Maven պահոց (.m2 թղթապանակ)։ Կոնտրակտը ձեռքի տակ ունենալով՝ կարող ենք գրել թեստեր, որոնք ստուգում են payment-service-ի տրամաբանությունը։ Հիշեցնեմ, որ այս սերվիսը պետք է սկսի վճարում ամեն անգամ, երբ ստանում է OrderCreated իրադարձություն։

Սա թեստավորելու համար նույնպես անհրաժեշտ է Kafka բրոքեր, և կրկին Kafka-ն գործարկում ենք որպես Docker կոնտեյներ՝ Testcontainers-ով։ Նմուշային հաղորդագրությունը բրոքերին ուղարկելու համար պետք է երկու բան.

  • հաղորդագրության սահմանումը (JAR-ում պահվող կոնտրակտը)
  • հաղորդագրությունը բրոքերին ուղարկելու միջոց։ Ինչպես նախկինում, Kafka-ն դրա համար ներկառուցված մեխանիզմ չունի, ուստի այն պետք է ինքներս գրենք։

Ահա թեստային դասը մեկ թեստային սցենարով։

@SpringBootTest(webEnvironment = NONE, classes = [PaymentApplication.class, TestConfiguration.class])
@AutoConfigureStubRunner(ids = ["com.rmaciak:order-service:0.0.1-SNAPSHOT:stubs:8088"], stubsMode = LOCAL)
@Testcontainers
class EventHandlerSpec extends Specification {

    @Shared
    static KafkaContainer kafka = new KafkaContainer(DockerImageName.parse("confluentinc/cp-kafka:latest"))

    @Autowired
    PaymentRepository paymentRepository

    @Autowired
    StubTrigger stubTrigger

    @DynamicPropertySource
    static void kafkaProperties(DynamicPropertyRegistry registry) {
        kafka.start()
        registry.add("spring.kafka.bootstrap-servers", () -> kafka.getBootstrapServers())
    }

    def "should initiate payment on OrderCreatedEvent"() {
        given:
        def conditions = new PollingConditions(timeout: 10, initialDelay: 1.5, factor: 1.25)

        when:
        stubTrigger.trigger("triggerOrderCreatedEvent")

        then:
        conditions.eventually {
            def payments = paymentRepository.getAll()
            assert payments.size() == 1
            assert payments[0].paymentStatus() == FINISHED
        }
    }
}

Այլ անոտացիաների շարքում այն ունի @AutoConfigureStubRunner, որին դուք գուցե արդեն ծանոթ եք։ Մեր թեստում այն տրամադրում է իրադարձությունը գեներացնելու համար օգտագործվող կոնտրակտը։ Կա նաև Kafka կոնտեյներ, որը հայտարարվում և գործարկվում է DynamicPropertySource-ով նշված մեթոդում, ինչպես նկարագրված էր արտադրողի բաժնում։ Այս թեստային դասի ամենահետաքրքիր դաշտը stubTrigger-ն է. Spring Cloud Contract-ի օբյեկտ, որը թույլ է տալիս գործարկել հաղորդագրության ուղարկումը։ Այն օգտագործվում է թեստային մեթոդի when բաժնում։ Այստեղ ես գործարկում եմ պիտակով, և triggerOrderCreatedEvent պիտակը գալիս է կոնտրակտից։ Spring Cloud Contract-ը առաջարկում է նաև գործարկման այլ մեխանիզմներ, որոնք նկարագրված են փաստաթղթերում։

Այս սցենարը ստուգում է, որ երբ սերվիսը սպառել է OrderCreated իրադարձությունը, վճարում է ստեղծվել և կատարվել (նրա կարգավիճակը FINISHED է)։ Վճարման և կարգավիճակի ստուգումը փաթեթավորված է PoolingCondition-ի մեջ, քանի որ իրադարձության հրապարակումը և սպառումը կատարվում են ասինխրոն և ավարտվում են միայն ժամանակի ընթացքում։

Թեստը բավականին պարզ է. այն գործարկում է հաղորդագրությունը և ստուգում, որ սպասվող տրամաբանությունը կատարվել է։ Բայց ի՞նչն է իրականում ուղարկում հաղորդագրությունը։ Դրա համար մենք իրականացնում ենք առանձին ինտերֆեյս՝ MessageVerifierSender, որը հաղորդագրությունն ուղարկում է Kafka-ին։

@Configuration
class TestConfiguration {

    @Bean
    MessageVerifierSender<Message<?>> standaloneMessageVerifier(KafkaTemplate kafkaTemplate) {
        return new MessageVerifierSender<Message<?>>() {

            @Override
            void send(Message<?> message, String destination, @Nullable YamlContract contract) {
                kafkaTemplate.send(message)
            }

            @Override
            <T> void send(T payload, Map<String, Object> headers, String destination, @Nullable YamlContract contract) {
                kafkaTemplate.send(
                        createMessage(payload, new MessageHeaders(Map.of(TOPIC, destination)))
                )
            }
        }
    }
}

Այն պարզապես հրապարակում է իրադարձությունը SpringKafka-ի KafkaTemplate-ով։ Այնուհետև payment-service-ի listener-ը սպառում և մշակում է այն։

Իրադարձության և՛ արտադրողը, և՛ սպառողը այժմ թեստավորված են նույն կոնտրակտի դեմ, ինչը երաշխավորում է, որ փոխանակման յուրաքանչյուր կողմը հետևում է իր հայտարարած կանոններին։ Թեև սերվիսները ուղիղ չեն շփվում, և նրանց միջև բրոքեր կա, կոնտրակտային թեստերը թույլ են տալիս համոզվել, որ նրանց հաղորդակցությունը ճիշտ է։

Ինչո՞ւ են ինձ անհրաժեշտ կոնտրակտային թեստեր Kafka հաղորդագրությունների համար

Այս պահին կարող եք հարցնել՝ ինչո՞ւ ձեռք զարկել Kafka հաղորդագրությունների կոնտրակտային թեստերին։ Հաղորդագրությունները սովորաբար JSON չեն. դրանք հաճախ օգտագործում են սխեմայի վրա հիմնված ձևաչափեր, ինչպիսին Avro-ն է՝ Schema Registry-ի հետ միասին, որոնք երաշխավորում են հաղորդագրությունների համատեղելիությունը։ Երկու պատասխան կա.

  1. Ինչ-ինչ պատճառներով դուք չեք ուզում կամ չեք կարող օգտագործել Avro + Schema Registry-ի նման բան
  2. Սխեման ստուգում է միայն հաղորդագրության իմաստային ճշտությունը։ Այն չի երաշխավորում, որ հաղորդագրությունը հրապարակվել և սպառվել է ճիշտ թոփիքից, և չի ստուգում, թե արդյոք հաղորդագրությունը վավեր է տվյալ սցենարի համար։ Օրինակ՝ հաղորդագրությունը կարող է ունենալ ոչ պարտադիր դաշտեր։ Եթե դրանցից և ոչ մեկը չկա, հաղորդագրությունը դեռ իմաստային առումով վավեր է։ Սակայն բիզնեսի տեսանկյունից նման հաղորդագրությունը իմաստ չունի, օրինակ՝ եթե վավեր լինելու համար անհրաժեշտ է գոնե մեկ ոչ պարտադիր դաշտ։

Այսպիսով, նույնիսկ երբ կա սխեմայի վրա հիմնված հաղորդագրության ձևաչափ և Schema Registry, արժե ավելացնել կոնտրակտային թեստեր՝ համոզվելու համար, որ հաղորդակցությունը ճիշտ է ոչ միայն իմաստային առումով, այլև ֆունկցիոնալ պահանջների տեսանկյունից։

Ամփոփում

Այս հոդվածը ցույց տվեց, թե ինչպես կարելի է Spring Cloud Contract-ով թեստավորել միկրոսերվիսների ասինխրոն հաղորդակցությունը, երբ հաղորդագրությունների բրոքերը Kafka-ն է։ Սկսեցինք այդ հաղորդակցության կոնտրակտի սահմանումից, ապա թեստավորեցինք և՛ արտադրողին, և՛ սպառողին նրա դեմ։ Ընթացքում ես նշեցի մի քանի տարբերություն այն մասին, թե ինչպես է ֆրեյմվորքը վերաբերվում REST API-ի թեստավորմանը և իրադարձային հաղորդակցությանը։

Ինչպես գուցե նկատեցիք, այս ֆրեյմվորքով Kafka իրադարձությունների թեստավորումը այնքան էլ հեշտ չէ (համեմատած, օրինակ, REST API-ի թեստավորման հետ)։ Պետք է կոդ գրել՝ ստուգելու համար, որ բրոքերին հրապարակված և նրանից սպառված հաղորդագրությունը ճիշտ է։ Ինչպես նշվեց, դա հիմնականում այն պատճառով է, որ Spring Cloud Contract-ը չունի Kafka հաղորդագրությունների թեստավորման ներկառուցված մեխանիզմ, ուստի պետք է ինքներս կառուցենք այն։ Այնուամենայնիվ, հուսով եմ, որ այս հոդվածը թեման ավելի հասկանալի է դարձնում և օգնում է ձեզ նման թեստեր իրականացնել ձեր նախագծում։

Շարքի հաջորդ և վերջին հոդվածը կանդրադառնա Kafka կոնտրակտների թեստավորմանը Pact broker-ով։ Խրախուսում եմ կարդալ այն և ընտրել այն մոտեցումը, որն ամենալավը հարմար է ձեր նախագծին։