تقدير المشروع
← كل المقالات

اختبارات العقود لنظام قائم على الأحداث مبني على Kafka باستخدام Pact

يصبح اختبار الأنظمة غير المتزامنة القائمة على الأحداث أسهل مع اختبارات العقود. توضح لك هذه المقالة كيف.

8 دقائق قراءة
KafkaApache Kafkaالاختباراختبارات العقودPactالأنظمة القائمة على الأحداثاختبار العقود

من المعروف أن الأنظمة غير المتزامنة القائمة على الأحداث يصعب اختبارها. ويجعل اختبار العقود المهمة أسهل، لأنه يتحقق من أن الخدمات تتواصل بشكل صحيح. يمكن بناء هذه الاختبارات باستخدام Spring Cloud Contract، لكن هذه المقالة تستعرض اختبار التواصل غير المتزامن الذي يمر عبر Kafka بوصفه وسيط الرسائل، باستخدام إطار العمل Pact.

أفترض أنك تعرف أساسيات العمارة القائمة على الأحداث وسبق أن عملت مع وسيط Kafka.

يستخدم المثال خدمتين: order-service و payment-service. كلما أُنشئ طلب، ينشر order-service حدث OrderCreated إلى Kafka. وتستهلك 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، وأداة البناء هي Gradle. ويعمل وسيط Kafka داخل Testcontainers.

والآن لنرَ كيف يتيح لنا Pact اختبار هذا التواصل.

كتابة العقد

في Pact توجد توقعات العقد داخل اختبارات المستهلك (consumer). وكما في التواصل عبر HTTP، توجد واجهة برمجية مخصصة لوصف التواصل القائم على الرسائل أو الأحداث. هنا تلعب 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 تصف كيف يُتوقع أن تبدو الرسالة. وتوضع التوقعات داخل closure تُمرَّر إلى الدالة call(). نبدأ بتسمية الخدمات المشاركة في التبادل. تضبط دالة المُنشئ serviceConsumer() اسم المستهلك على payment-service، وتنص hasPactWith() على أن هذه الخدمة تتحدث مع المزوّد (provider) – وهو order-service – أو لديها pact (عقد) معه.

تمنح الدالة expectsToRecive() العقد اسمه. سميته ‘OrderCreatedEvent when order is created’ ليعكس السيناريو التجاري قيد الاختبار. والاسم مهم، لأنه ما يعرّف العقد في PactBroker، ويجب أن يشير إليه المنتج أيضًا، كما سأوضح لاحقًا. وأخيرًا، تصف withContent() جسم الحدث. فقد سردت كل حقل من حقول جسم حدث OrderCreated باستخدام المطابِقات uuid() و datetime() و decimal().

وهذا كل شيء – أصبح العقد بين 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())
}

في الاختبار يُنتَج الحدث باستخدام KafkaTemplate من Spring. ويتحقق قسم 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، لأننا نريد أن يتمكن المزوّد من الوصول إليه. ولهذا يجب إضافة إضافة Pact وضبطها في build.gradle:

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

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

ولنشر العقد إلى وسيط Pact، شغّل هذا الأمر:

./gradlew pactPublish

يعرض وسيط Pact الآن العقد، لكنه لم يُتحقق منه بعد مقابل المزوّد.

عندما تفتح تفاصيل التكامل order-service – payment-service (عبر أيقونة المستند) ستلاحظ أن العقد معرَّف بالاسم الممرَّر إلى expectsToReceive() في توقعات العقد (حقل description في المقتطف أدناه).

والخطوة التالية هي اختبار المنتِج.

الاختبار من جهة المنتِج

في هذه المرحلة أصبح العقد محددًا ومخزنًا في وسيط Pact، وتحققنا من أن المستهلك يعالج الرسالة الموصوفة بشكل صحيح. ما تبقى هو التأكد من أن المنتِج يلتزم بالعقد ويُصدر الحدث الصحيح. ولفعل ذلك، علينا تنفيذ دالة تُرجع الحدث الذي ينشره المنتِج. ومرة أخرى توجد عدة خيارات. اخترت تشغيل منطق العمل الذي ينتج فعليًا حدث OrderCreated، واستقبال الرسالة من وسيط Kafka يعمل في Testcontainers. يستهلك الاختبار الرسالة ويعيدها إلى Pact للتحقق. قد يبدو ذلك معقدًا أكثر من اللازم، لكنني بهذه الطريقة أعرف أن ما يتم التحقق منه هو الرسالة المرسلة فعليًا إلى Kafka تمامًا، دون أي فجوة بين إعدادات التسلسل (serialization) في الإنتاج وفي الاختبار.

إليك كيف يُعدّ الاستهلاك في الاختبار:

@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())
    }
    ( ... )
}

تحمل الفئة عدة تعليقات توضيحية (annotations):

  • @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، مع اسم العقد قيمةً للمعامل (هنا ‘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 (أي حتى يستهلكه المستمع المعرَّف سابقًا). ثم يُرجع الحدث، ويتحقق Pact مما إذا كانت بنيته تطابق ما يتوقعه العقد. ويبدأ التحقق باستدعاء الدالة verifyInteraction() على سياق Pact:

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

عند تشغيل بناء order-service، يتصل Pact بوسيط Pact وينزّل كل عقد معرَّف لهذه الخدمة. ولكل عقد، يبحث عن دالة معلَّمة بـ @PactVerifyProvider تحمل الاسم المطابق. وإذا لم توجد دالة كهذه يُبلَّغ عن خطأ، لأن كل عقد يجب أن يكون له اختبار. وهذا يضمن تغطية جميع السيناريوهات. وتلخص الصورة أدناه تدفق هذا الاختبار:

ينبغي أن يدفع بناء الخدمة نتائج التحقق من العقد إلى وسيط Pact، حيث يمكن استخدامها، مثلًا، بواسطة أداة can-i-deploy.

الخلاصة

أوضح هذا الدليل كيف يمكن لإطار Pact اختبار التواصل غير المتزامن القائم على الأحداث بين الخدمات. ففي اختبار المستهلك (payment-service) وصفنا توقعات العقد باستخدام لغة DLS المخصصة. ثم كتبنا اختبارًا يتحقق مما إذا كان المستهلك يعالج الحدث بشكل صحيح وينفذ منطق العمل المتوقع استجابةً له. وبعد ذلك نُشر العقد إلى Pact Broker، مما أتاح كتابة اختبارات المنتِج. وهذه الاختبارات تؤكد أن المنتِج يُصدر أحداثًا تستوفي العقد.

آمل أن تكون قد فهمت اختبار العقود جيدًا وأن تشعر بالاستعداد لإدخال مثل هذه الاختبارات في مشروعك.

بالتوفيق!