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-ում, ինչը հնարավորություն տվեց գրել պրոդյուսերի թեստերը։ Դրանք հաստատում են, որ պրոդյուսերը արձակում է կոնտրակտին բավարարող իրադարձություններ։
Հուսով եմ՝ այժմ լավ հասկանում եք կոնտրակտային թեստավորումը և պատրաստ եք նման թեստեր ներդնել ձեր սեփական նախագծում։
Հաջողություն։