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

Kafka-ի վրա հիմնված իրադարձություններով ղեկավարվող համակարգի կոնտրակտային թեստեր Pact-ով

Ասինխրոն, իրադարձություններով ղեկավարվող համակարգերի թեստավորումը դառնում է ավելի հեշտ կոնտրակտային թեստերով։ Այս հոդվածը ցույց է տալիս, թե ինչպես։

8 րոպե
KafkaApache KafkaԹեստավորումԿոնտրակտային թեստերPactԻրադարձություններով ղեկավարվող համակարգերԿոնտրակտային թեստավորում

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

Ենթադրում եմ, որ դուք արդեն գիտեք իրադարձություններով ղեկավարվող ճարտարապետության հիմունքները և աշխատել եք Kafka բրոքերի հետ։

Օրինակում օգտագործվում են order-service և payment-service։ Երբ պատվեր է ստեղծվում, order-service-ը Kafka-ում հրապարակում է OrderCreated իրադարձությունը։ Payment-service-ը սպառում է այդ իրադարձությունը և սկսում է վճարման գործընթացը։

OrderCreated իրադարձությունն ունի հետևյալ տեսքը՝

{
  "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
}

Այս ձեռնարկի թեստերը գրված են Groovy-ով՝ Spock-ով, իսկ build գործիքը Gradle-ն է։ Kafka բրոքերը աշխատում է Testcontainers-ում։

Այժմ տեսնենք, թե ինչպես է Pact-ը թույլ տալիս թեստավորել այս հաղորդակցությունը։

Կոնտրակտի գրառումը

Pact-ում կոնտրակտի սպասելիքները գտնվում են սպառողի (consumer) թեստերում։ Ինչպես HTTP հաղորդակցության համար, այստեղ էլ կա հատուկ API՝ հաղորդագրություններով կամ իրադարձություններով ղեկավարվող հաղորդակցությունը նկարագրելու համար։ Այստեղ payment-service-ը խաղում է սպառողի դերը, ուստի կոնտրակտը մտնում է նրա թեստերի մեջ։ OrderCreated իրադարձության սպասելիքներն այսպիսին են՝

new PactMessageBuilder().call {
    serviceConsumer 'payment-service'
    hasPactWith 'order-service'

    expectsToReceive 'OrderCreatedEvent when order is created'
    withContent(contentType: 'application/json') {
        eventId uuid()
        occurredAt datetime()
        orderId uuid()
        accountId uuid()
        total decimal()
    }
}

PactMessageBuilder դասի օգնությամբ նկարագրում եք, թե ինչպիսին պետք է լինի հաղորդագրությունը։ Սպասելիքները դրվում են call() մեթոդին փոխանցվող closure-ի մեջ։ Սկսում ենք փոխանակմանը մասնակցող սերվիսների անվանումից։ serviceConsumer() builder մեթոդը սպառողի անունը սահմանում է payment-service, իսկ hasPactWith()-ը նշում է, որ այս սերվիսը խոսում է պրովայդերի՝ order-service-ի հետ կամ նրա հետ ունի pact (կոնտրակտ)։

expectsToRecive() մեթոդը կոնտրակտին անուն է տալիս։ Ես այն անվանել եմ “OrderCreatedEvent when order is created”, որպեսզի այն արտացոլի թեստավորվող բիզնես սցենարը։ Անունը կարևոր է, քանի որ հենց դրանով է կոնտրակտը նույնականացվում PactBroker-ում, և պրոդյուսերը նույնպես պետք է հղվի դրան, ինչպես ցույց կտամ ավելի ուշ։ Վերջում withContent()-ը նկարագրում է իրադարձության մարմինը։ Ես OrderCreated իրադարձության մարմնի բոլոր դաշտերը թվարկել եմ uuid(), datetime() և decimal() համապատասխանեցուցիչներով (matchers)։

Եվ վերջ – order-service-ի և payment-service-ի միջև կոնտրակտը պատրաստ է։ Հաջորդը գրենք թեստ, որը ստուգում է՝ արդյոք payment-service-ը ճիշտ է մշակում այս իրադարձությունը։

Սպառողի կողմի թեստը

Ստուգելու համար, որ payment-service-ը ճիշտ է սպառում և մշակում OrderCreated իրադարձությունը, պետք է նմանակենք պրովայդերին, որն այս իրադարձությունը ուղարկում է բրոքերին։ Սա կարելի է անել մի քանի ձևով. ես ընտրել եմ իրական Kafka բրոքեր, որը աշխատում է Testcontainers-ում։

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

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

Թեստում իրադարձությունը արտադրվում է Spring-ի KafkaTemplate-ով։ Then բաժինը ստուգում է, որ իրադարձության սպառումը առաջացրել է սպասվող բիզնես վարքագիծը՝ այստեղ այն, որ սերվիսը վճարում է ստեղծել և մշակել։

def "should initiate payment on OrderCreatedEvent"() {
    given:
    def eventFlow = new PactMessageBuilder().call {
        serviceConsumer 'payment-service'
        (…) // already explained above
    }

    when:
    eventFlow.run { Message message ->
        kafkaTemplate.send('OrderCreated', message.contentsAsBytes())
    }

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

Թեստի աշխատանքի ընթացքում Pact-ը գեներացնում է իրադարձությունը՝ լցնելով այն հայտարարված դաշտերի տիպերին համապատասխանող պատահական արժեքներով։ Այնուհետև իրադարձությունը ուղարկվում է Kafka, որտեղից payment-service-ը վերցնում է այն։ Ի վերջո այն մշակվում է, և վճարում է ստեղծվում։ Սա ապացուցում է, որ payment-service-ը հասկանում է OrderCreated իրադարձությունը և կարող է գործել դրա հիման վրա։

Բնականաբար, այս թեստը իրականացնելու և աշխատեցնելու համար պետք են ճիշտ կախվածություններ։ Մասնավորապես, մեզ պետք է Pact-ի կախվածությունը Groovy-ի համար՝

testImplementation 'au.com.dius.pact.consumer:groovy:4.4.4'

Ստորև բերված դիագրամը ամփոփում է թեստի աշխատանքը՝

Ինչպես երևում է, կոնտրակտը հայտնվում է Pact broker-ում, քանի որ ուզում ենք, որ պրովայդերը հասանելիություն ունենա դրան։ Դրա համար Pact plugin-ը պետք է ավելացվի և կարգավորվի build.gradle-ում՝

id "au.com.dius.pact" version "4.3.6"
(…)

pact {
    publish {
        pactBrokerUrl = 'http://localhost:9292/'
    }
}

Կոնտրակտը Pact broker-ում հրապարակելու համար աշխատեցրեք այս հրամանը՝

./gradlew pactPublish

Pact broker-ը այժմ ցուցադրում է կոնտրակտը, բայց այն դեռ չի ստուգվել պրովայդերի դեմ։

Երբ բացում եք order-service – payment-service ինտեգրացիայի մանրամասները (փաստաթղթի պատկերակով), կնկատեք, որ կոնտրակտը նույնականացվում է expectsToReceive()-ին կոնտրակտի սպասելիքներում փոխանցված անունով (ստորև բերված հատվածում՝ description դաշտը)։

Հաջորդը պրոդյուսերի թեստն է։

Պրոդյուսերի կողմի թեստը

Այս պահին կոնտրակտը սահմանված է և պահվում է Pact broker-ում, և մենք ստուգել ենք, որ սպառողը ճիշտ է մշակում նկարագրված հաղորդագրությունը։ Մնում է հաստատել, որ պրոդյուսերը հարգում է կոնտրակտը և արձակում է ճիշտ իրադարձությունը։ Դրա համար պետք է իրականացնենք մեթոդ, որը վերադարձնում է պրոդյուսերի հրապարակած իրադարձությունը։ Կրկին մի քանի տարբերակ կա։ Ես ընտրել եմ աշխատեցնել այն բիզնես տրամաբանությունը, որը իրականում արտադրում է OrderCreated իրադարձությունը, և հաղորդագրությունը ստանալ Testcontainers-ում աշխատող Kafka բրոքերից։ Թեստը սպառում է հաղորդագրությունը և այն հետ է փոխանցում Pact-ին ստուգման համար։ Կարող է թվալ՝ չափազանց բարդ է, բայց այսպես ես գիտեմ, որ ստուգվում է հենց Kafka ուղարկված հաղորդագրությունը՝ առանց արտադրության և թեստի սերիալիզացիայի կարգավորումների միջև բացթողումի։

Ահա թե ինչպես է թեստում կարգավորվում սպառումը՝

@PactBroker(url = "http://localhost:9292")
@Provider("order-service")
@SpringBootTest(webEnvironment = NONE)
@Testcontainers
class ContractVerificationSpec extends Specification {

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

    @Shared
    private static final Set<String> consumedEvents = Collections.synchronizedSet(new HashSet<String>())

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

    @KafkaListener(topics = "OrderCreated")
    void orderCreatedEventListener(ConsumerRecord record) {
        consumedEvents.add((String) record.value())
    }
    ( ... )
}

Դասն ունի մի քանի անոտացիա՝

  • @PactBroker-ը ֆրեյմվորքին ասում է կոնտրակտները վերցնել Pact Broker-ից
  • @Provider-ը սահմանում է պրովայդեր սերվիսի անունը, որով Pact Broker-ում փնտրվում են նրա կոնտրակտները
  • @SpringBootTest-ը կառուցում է ApplicationContext-ը
  • @Testcontainer-ը միացնում է Kafka կոնտեյները

Դասի սկզբում ես հայտարարել եմ Kafka կոնտեյներ KafkaContainer-ով և Set, որը պահում է սպառված հաղորդագրությունները։ @DynamicPropertySource-ով նշված մեթոդը անհրաժեշտ է Kafka կոնտեյները գործարկելու և spring.kafka.bootstrap-server հատկությունը կոնտեյների բացահայտած հասցեին ուղղելու համար։ Վերջապես իրադարձությունների թեստային սպառողը կառուցվում է @KafkaListener անոտացիայով. այն պարզապես ավելացնում է յուրաքանչյուր սպառված իրադարձություն բազմության մեջ։ Թեստային դասի այս հատվածը հոգ է տանում Kafka-ից իրադարձություններ կարդալու մասին։

Լռելյայն Pact-ը կարգավորված է HTTP հաղորդակցությունը ստուգելու համար, ուստի պետք է այն փոխարկենք հաղորդագրությունների ստուգման։ Ստորև բերված կոդը հենց դա է անում՝ թիրախը դարձնելով հաղորդագրությունների վրա հիմնված։

@BeforeEach
void setTargetToMessage(PactVerificationContext context) {
    context.setTarget(new MessageTestTarget())
}

Ժամանակն է գրել հենց թեստը։ Հիշո՞ւմ եք, թե ինչպես էի շեշտում, որ կոնտրակտի անունը կարևոր է։ Հենց այստեղ է այն գործի անցնում։ Յուրաքանչյուր կոնտրակտի համար պետք է մեթոդ, որը վերադարձնում է ստուգվելիք հաղորդագրությունը, և այդ մեթոդը պետք է նշված լինի @PactVerifyProvider-ով, որի value պարամետրը կոնտրակտի անունն է (այստեղ՝ “OrderCreatedEvent when order is created”)՝

@PactVerifyProvider('OrderCreatedEvent when order is created')
String "should publish OrderCreated event"() {
    orderCreator.createOrder(randomUUID(),randomUUID(), BigDecimal.valueOf(10.5))

    new PollingConditions().eventually {
        assert consumedEvents.stream().findFirst().isPresent()
    }

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

Մեթոդը աշխատեցնում է պատվերի ստեղծման տրամաբանությունը, որը կուլիսների հետևում հրապարակում է OrderCreated իրադարձությունը, ապա սպասում է, մինչև իրադարձությունը հայտնվի consumedEvents բազմության մեջ (այսինքն՝ մինչև ավելի վաղ սահմանված listener-ը այն սպառի)։ Իրադարձությունը վերադարձվում է, և Pact-ը ստուգում է՝ արդյոք նրա կառուցվածքը համապատասխանում է կոնտրակտի սպասելիքներին։ Ստուգումը գործարկվում է Pact համատեքստի վրա verifyInteraction() մեթոդը կանչելով՝

@TestTemplate
@ExtendWith(PactVerificationInvocationContextProvider)
void initInteractionVerification(PactVerificationContext context) {
    context.verifyInteraction()
}

Երբ order-service-ի build-ը աշխատում է, Pact-ը միանում է Pact broker-ին և ներբեռնում է այս սերվիսի համար սահմանված բոլոր կոնտրակտները։ Յուրաքանչյուրի համար այն փնտրում է @PactVerifyProvider-ով անոտացված մեթոդ՝ համապատասխան անունով։ Եթե այդպիսի մեթոդ չկա, սխալ է հաղորդվում, քանի որ յուրաքանչյուր կոնտրակտ պետք է թեստ ունենա։ Սա երաշխավորում է, որ բոլոր սցենարները ծածկված են։ Ստորև պատկերը ամփոփում է այս թեստի ընթացքը՝

Սերվիսի build-ը պետք է կոնտրակտի ստուգման արդյունքները ուղարկի Pact broker, որտեղ դրանք կարող են օգտագործվել, օրինակ, can-i-deploy գործիքի կողմից։

Եզրափակում

Այս ձեռնարկը ցույց տվեց, թե ինչպես կարող է Pact ֆրեյմվորքը թեստավորել սերվիսների միջև ասինխրոն, իրադարձությունների վրա հիմնված հաղորդակցությունը։ Սպառողի թեստում (payment-service) մենք նկարագրեցինք կոնտրակտի սպասելիքները՝ օգտագործելով հատուկ DLS-ը։ Ապա գրեցինք թեստ, որը ստուգում է՝ արդյոք սպառողը ճիշտ է մշակում իրադարձությունը և ի պատասխան աշխատեցնում է սպասվող բիզնես տրամաբանությունը։ Դրանից հետո կոնտրակտը հրապարակվեց Pact Broker-ում, ինչը հնարավորություն տվեց գրել պրոդյուսերի թեստերը։ Դրանք հաստատում են, որ պրոդյուսերը արձակում է կոնտրակտին բավարարող իրադարձություններ։

Հուսով եմ՝ այժմ լավ հասկանում եք կոնտրակտային թեստավորումը և պատրաստ եք նման թեստեր ներդնել ձեր սեփական նախագծում։

Հաջողություն։