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

اختبار الخدمات المصغّرة باستخدام اختبارات العقد

اختبار التطبيق المتجانس (monolith) أمر بسيط نسبيًا، أما الخدمات المصغّرة فتجعل الاختبار أكثر صعوبة بشكل ملحوظ. لحسن الحظ، لكل تحدٍّ نمطٌ يعالجه، وهنا يكون النمط هو اختبار العقد. تعرّف على كيفية تسهيله لاختبار الخدمات المصغّرة.

14 دقائق قراءة
Javaالخدمات المصغّرةالاختباراختبارات العقد

اختبار التطبيق المتجانس (monolith) أمر بسيط نسبيًا. نكتب اختبارات الوحدة واختبارات التكامل، وغالبًا اختبارات شاملة من طرف إلى طرف، مع محاولة إبقاء هرم الاختبار في أفضل حال ممكن. أما الخدمات المصغّرة فتجعل الاختبار أكثر تعقيدًا بعض الشيء. ما يميّزها حقًا هو التواصل بين الخدمات، وهو جوهر معمارية الخدمات المصغّرة. لحسن الحظ، لكل تحدٍّ نمطٌ يعالجه، وهنا يكون النمط هو اختبار العقد (contract testing). دعونا نرى كيف يساعدنا في اختبار الخدمات المصغّرة.

التطبيق المتجانس مقابل الخدمات المصغّرة

يعمل التطبيق المتجانس المقسّم إلى وحدات في عملية واحدة، وقد يكون ذلك نقطة قوة أو ضعف بحسب السياق. تتحدث وحداته مع بعضها عبر استدعاءات دوال محلية، لذلك لا تحتاج إتاحة الوظائف المطلوبة للأعمال إلى الشبكة. ونتيجة لذلك، تُكتب اختبارات الوحدة واختبارات التكامل التي تتحقق من هذه الوحدات بالاعتماد على واجهتها البرمجية العامة. وتعديل واجهة وحدة ما (كتغيير توقيع دالة مثلًا) يؤدي إلى خطأ في الترجمة. وهذا يجعل من الصعب كسر عقد التواصل بين الوحدات داخل التطبيق المتجانس.

أما مع الخدمات المصغّرة فالوضع أكثر تعقيدًا. فلكي تقدّم وظائف الأعمال، عليها أن تتحدث عبر الشبكة، ولم يعد المترجم قادرًا على مساعدتنا. الوحدات هنا مستقلة وموزّعة – فهي عمليًا تطبيقان منفصلان، وغالبًا لكلٍّ منهما مسارات الاختبار والنشر الخاصة به.

كيف نتأكد من أن الخدمات تعمل معًا قبل الانتقال إلى بيئة الإنتاج؟

اختبارات التكامل

اختبارات التكامل هي على الأرجح أول ما يخطر ببال معظم الناس. إنها إجابة بديهية عن هذا السؤال، وهي صحيحة جزئيًا. لكن قبل المضي قدمًا، أودّ أن أوضح ما أقصده باختبارات التكامل، إذ يعرّفها الناس بطرق مختلفة. بالنسبة لي، اختبار التكامل يتحقق مما إذا كانت أجزاء النظام المطوّرة بشكل منفصل تعمل معًا بشكل صحيح وتقدّم وظائف تلبّي المتطلبات. وقد يتحقق مثل هذا الاختبار من

  • واجهة برمجية مكشوفة (مثل REST API)
  • التفاعل مع خدمة أخرى
  • إنتاج الرسائل واستهلاكها
  • التكامل مع قاعدة البيانات

ينبغي تنفيذ اختبارات التكامل بمعزل عن غيرها. أي أنه لا حاجة إلى تشغيل أي خدمات كي تعمل الاختبارات. بل ينبغي أن نكون قادرين على تشغيلها دون أي اتصال بالشبكة على الإطلاق.

اختبارات التكامل مناسبة جدًا للتحقق من أن الخدمة (أو الوحدة) تعمل بشكل صحيح مع أجزاء النظام الأخرى، مثل قاعدة البيانات أو الخدمات الأخرى. وينبغي أن يكون هدفها الأساسي التأكد من أن وظائف الأعمال تعمل كما هو مقصود. للأسف، رأيتها كثيرًا تُستخدم للتحقق من عقود التواصل بين الخدمات. وهذا النهج له بعض العيوب، فلنلقِ عليها نظرة أقرب.

عقود التواصل بين الخدمات

لنفترض أننا نريد التحقق من كيفية تواصل خدمتين – الطلبات والدفع. تعرض الأخيرة واجهة REST API لبدء عملية دفع. وخدمة order-service مسؤولة عن إنشاء الطلبات، وهي تستدعي payment-service لإنشاء دفعة لكل طلب. وللتأكد من أن هذا التواصل يعمل، نحتاج إلى مجموعتين على الأقل من اختبارات التكامل:

  • اختبارات تتحقق من أن الواجهة البرمجية تلبّي المتطلبات. تتحقق هذه الاختبارات من أن الخدمة تُرجع المخرجات المتوقعة لطلب معيّن، بما في ذلك المسار والترويسات وبنية الجسم. ويجب أن تكون في payment-service وأن تحاكي استدعاء order-service للواجهة (انظر الشيفرة 1).
  • اختبارات تتحقق من أن order-service تستدعي واجهة payment-service بشكل صحيح. تتحقق هذه الاختبارات من أن عميل HTTP يستدعي payment-service كما ينبغي. ويجب أن تكون في order-service وأن تعتمد على نسخ بديلة (stubs) من payment-service (انظر الشيفرة 2).

الطلب والدفع

غُطّيت الواجهة البرمجية المكشوفة لخدمة payment-service باختبار التكامل أدناه، المكتوب باستخدام Spock وRestAssured.

def "should initiate payment"() {
   given:
   //skipped

   def request =
           """
           {
               "accountId": "$accountId",
               "orderDescription": "My first order",
               "quota": 128.5,
               "paymentType": "TRANSFER_ONLINE",
               "dueDate": "$dueDate" 
           }       
           """

   expect:
   given()
           .contentType(APPLICATION_JSON_VALUE)
           .accept(APPLICATION_JSON_VALUE)
           .and()
           .body(request)
           .when()
           .put("/payment/%s".formatted(paymentId))
           .then()
           .assertThat()
           .statusCode(200)
           .body("status", equalTo("FINISHED"))
           .body("paymentExternalId", equalTo("ext-%s".formatted(paymentId)))
}

الشيفرة 1. اختبار تكامل لواجهة payment-service

يثبت الاختبار أن الواجهة البرمجية تتصرف بالطريقة التي أرادها فريق payment-service. فهو يتحقق من أنها تقبل الطلب المحدد وتُرجع الاستجابة المتوقعة. وينبغي له أيضًا أن ينفّذ منطق الأعمال ذا الصلة (وقد حُذفت تلك الفحوص من الاختبار).

الطلب والدفع

في المقابل، كتب فريق order-service، بصفته العميل، اختبارات تكامل لمنطق إنشاء الطلب. وهذا الاختبار مكتوب أيضًا بـ Spock، وهو يستبدل payment-service بنسخة بديلة باستخدام WireMock.

def "should create order and initiate payment"() {
   given:
   //skipped

   def expectedRequest =
       """
       {
           "accountId": "$accountId",
           "quota": $quota,
           "paymentType": "TRANSFER_ONLINE",
           "dueDate": "$dueDate"                       
       }       
       """

def paymentServiceResponse =
       """
       {
           "paymentExternalId": "ext-$orderId",
           "status": "FINISHED"
       }       
       """

and:
wiremockServer.stubFor(put(urlMatching("/payment/([a-fA-F0-9-]*)"))
       .withRequestBody(equalToJson(expectedRequest))
       .willReturn(
               aResponse()
                       .withStatus(200)
                       .withHeader("Content-Type", "application/json")
                       .withHeader("Accept", "application/json")
                       .withBody(paymentServiceResponse)
       )
)

expect:
sut.createOrder(accountId, orderId, quota).paymentProcessed() == true

}

الشيفرة 2. اختبار تكامل لإنشاء الطلب مع نسخة بديلة من payment-service

هنا تُستخدم نسخ بديلة من payment-service للتحقق من منطق إنشاء الطلب. يفترض الاختبار أمورًا معينة حول سلوك الخدمة المستدعاة (كما تُحدَّد في النسخ البديلة).

فما المشكلة في هذه الاختبارات؟ في الواقع، هي تعمل جيدًا ما دام كل فريق يعرف تمامًا كيف يتصرف الطرف الآخر. يحتاج الطرفان إلى معرفة شكل الطلب المتوقع والاستجابة المُرجَعة – ومن الأفضل ألّا تكون هناك حاجة إلى تغيير العقد بينهما أبدًا.

ونتيجة لذلك، يعتمد عمل الخدمات معًا على تواصل الناس ومعرفتهم. تخيّل أن أحد أعضاء فريق payment-service لاحظ تسمية غير متّسقة في الاستجابة وقرر إعادة تسمية الحقل status إلى paymentStatus. من السهل إعادة تسمية الحقل وتحديث اختبار التكامل ليمرّ، ويمكن إرسال التغيير إلى الإنتاج. لكن ما لم تُعدَّل شيفرة العميل أيضًا، سينكسر التواصل بين الخدمات. وما إن تُنشر الخدمة المنتِجة في الإنتاج حتى تبدأ الاستدعاءات بالفشل، فتصبح الخدمة غير متاحة وتخسر الشركة المال.

ولإبلاغ العملاء بتغيير جذري قادم في الواجهة البرمجية، يحتاج فريق payment-service إلى معرفة من هم هؤلاء العملاء. وفوق ذلك، عليه أن يقرر ما إذا كان التغيير يؤثر فيهم، وهذا يتطلب معرفة كيفية استخدام العملاء للواجهة. اختبارات التكامل لا تستطيع إخباره بذلك. فهي لا تعبّر إلا عن افتراضات معينة حول العقد، ولا تقدّم أي ضمان بأن هذه هي الطريقة التي يستخدم بها العملاء الواجهة فعليًا في الإنتاج.

عيب آخر لهذا النهج هو أن العمل يُنجَز مرتين. فاختبار التواصل بين خدمتين يتطلب مجموعتين من الاختبارات، وتوجدان عادةً منفصلتين في مستودعي العميل والمنتِج. والأسوأ من ذلك أنه لا شيء يبقيهما متزامنتين. فعندما يغيّر فريق العميل العقد، لا تعكس شيفرة المنتِج ذلك، والعكس صحيح.

الصورة 1. توجد اختبارات التكامل الخاصة بكل طرف في مستودعات منفصلة ولا تُبقى متزامنة.

وأخيرًا، تميل اختبارات التكامل للواجهات البرمجية إلى أن تكون مملة ومتكررة إلى حد كبير. فقسم when يستدعي الواجهة قيد الاختبار، ثم يتحقق الاختبار من أن المخرجات المتوقعة قد عادت – حقلًا حقلًا، لكل حقل في الاستجابة.

هل هناك طريقة أفضل لاختبار هذا؟ سنصل إلى ذلك لاحقًا في المقال.

الاختبارات الشاملة من طرف إلى طرف (End-to-end)

دعوني أبدأ بتعريف الاختبارات الشاملة من طرف إلى طرف. هذه اختبارات تتحقق مما إذا كان النظام بأكمله يتصرف كما هو متوقع. فهي تعمل على نسخ حقيقية من الخدمات، دون عزل، وتُنشر عادةً فيما يسمى بيئة المرحلة التجريبية (stage). مهمتها التأكد من أن سيناريوهات الأعمال الرئيسية تعمل بشكل صحيح.

لا تعاني الاختبارات الشاملة من المشكلة الموصوفة أعلاه، لكن لها عيوبها الخاصة. من أهمها أن كل خدمة مصغّرة يجب أن تكون منشورة وقيد التشغيل قبل تنفيذ الاختبارات. ولذلك فإعداد مثل هذه البيئة وصيانتها صعب. كما أن هذا النهج مكلف إلى حد كبير، لأنه يحتاج إلى بنية تحتية ووقت لتشغيل الاختبارات. ولا يمكن التحقق من العقد بين خدمتين بمعزل عن غيرهما – إذ نحتاج إلى بنية تحتية تكون الشيفرة منشورة عليها مسبقًا. وهذا مرهق ويتعارض مع فلسفة الخدمات المصغّرة القائمة على خدمات مرتبطة ارتباطًا ضعيفًا ويمكن نشرها بشكل مستقل.

اختبارات العقد تأتي للإنقاذ

تقع اختبارات العقد في مكان ما بين اختبارات التكامل والاختبارات الشاملة. تتيح لنا الفكرة التحقق، بمعزل عن غيرها، من أن خدمتين تتواصلان بشكل صحيح. وهي تقوم على افتراض بسيط: إذا اختُبر كلٌّ من المستهلك والمنتِج بشكل مستقل مقابل العقد نفسه، فسيكونان قادرين على التواصل بشكل صحيح. هذا هو جوهر اختبار العقد. هناك عقد مشترك واحد بالضبط يصف كيفية تحدث الخدمات مع بعضها، سواء بشكل متزامن أو غير متزامن، وتُشتق منه اختبارات المستهلك والمنتِج معًا. أما اختبار التكامل فيعمل بشكل مختلف – إذ لدينا فيه مجموعتان مستقلتان من الاختبارات دون أي وسيلة آلية للحفاظ على تزامنهما.

عمليًا، العقد وثيقة تصف التواصل باستخدام DSL (لغة خاصة بالمجال). وبحسب إطار العمل، يمكن التعبير عنه بلغات وصيغ مختلفة، مثل Java وGroovy وJSON وYAML وغيرها. فيما يلي مثال لعقد مكتوب بلغة Java (إطار عمل Pact).

builder
      .given("test PUT)
        .uponReceiving(“PUT REQUEST")
        .path(“/payment”)
    .headers(expectedHeaders)
        .method(“PUT”)
      .willRespondWith()
        .status(200)
        .headers(headers)
        .body(“{\”accepted\”: true}")

المنتِج والمستهلك؟
يظهر هذان المصطلحان باستمرار عند الحديث عن اختبارات العقد.
المنتِج (ويسمى أحيانًا المزوِّد) هو خدمة تعرض واجهة برمجية. وفي التواصل القائم على الرسائل، هو الخدمة التي تنشر الرسائل.

والمستهلك هو خدمة تستخدم الواجهة البرمجية التي يعرضها المنتِج أو تستهلك الرسائل التي ينشرها.

في هذا المقال، المنتِج هو الخدمة التي تعرض الواجهة البرمجية، والمستهلك هو الخدمة التي تستخدمها.

كيف يساعد اختبار العقد؟

لنلقِ الآن نظرة على كيفية حله لمشكلات اختبار التكامل.

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

المستهلك والمنتِج

ولأن كل تفصيل في التواصل مسجّل في العقد، يعرف فريق المنتِج (payment-service) بدقة من يستخدم واجهته البرمجية وبأي طريقة. توجد العقود عادةً في مستودع المنتِج (أو في مستودع منفصل مخصص لها). وعندما يستخدم عدة عملاء الواجهة نفسها، يحصل كل تكامل على عقده الخاص، لأن العقود تُحدَّد لكل عميل. وهذا يتيح لفريق المنتِج تحديد المستدعين بسهولة. لنفترض أننا نريد إزالة حقل في الاستجابة أو تعديله. مع وجود عقود متفق عليها مع كل عميل، يمكننا ببساطة التحقق مما إذا كان هذا الحقل مستخدمًا. وهذا يجعل تطوير الواجهات البرمجية أكثر مرونة بكثير.

وبحسب إطار العمل، قد لا نضطر إلى صيانة أي اختبارات أو نسخ بديلة على الإطلاق. فاختبارات المنتِج تُولَّد من العقد، لذلك لا نكتبها بأنفسنا، وهي تتحقق من أن الواجهة تتصرف كما يحدده العقد. أما على جانب المستهلك، فتعتمد الاختبارات على نسخ بديلة تُولَّد من العقد نفسه. وهذا يُبقي الطرفين متزامنين فيما يخص التواصل واختباراته، كما يقلل كمية الشيفرة المكتوبة يدويًا.

وأخيرًا، يعمل العقد كشكل من أشكال التوثيق لكيفية ارتباط الخدمات. فكلا طرفي التواصل ينشئانه ويتفقان عليه، لذلك يسجّل ترتيباتهما. بل إن بعض أطر العمل قادرة على إنتاج وثائق OpenAPI من العقد، مما يمنحنا مصدرًا وحيدًا للحقيقة حول الواجهة البرمجية.

باختصار، مع هذا النهج، الشيء الوحيد الذي يجب صيانته هو العقد، الذي يصف كيفية تواصل الخدمات. وتُشغَّل اختبارات المنتِج والمستهلك مقابل القواعد المحددة فيه. وهذا يمنحنا الثقة بأن كل طرف منفَّذ بشكل صحيح وأنهما قادران على العمل معًا.

من يملك العقد؟

كما شرحت، لاختبار العقد مكان واحد يُعرَّف فيه العقد. وهذا يثير بطبيعة الحال سؤالًا حول من المسؤول عن تعريفه وصيانته. وبحسب العلاقة بين الخدمات المعنية (وفرقها)، هناك نهجان للاختبار:

اختبار العقد الموجَّه بالمستهلك (Consumer-Driven Contract Testing)

عندما يكون المنتِج خدمة تابعة (downstream) ينبغي أن تحاول تلبية احتياجات المستهلكين، تنطبق استراتيجية Consumer Driven. هنا يشكّل المستهلكون عقد التواصل بإخبار المنتِج كيف ينبغي أن تبدو الواجهة البرمجية. وبطبيعة الحال، ينبغي لفريق المنتِج أن يراجع هذا الاتفاق ويناقشه ويؤكده. ويحدث ذلك عادةً بأن يفتح فريق المستهلك طلب دمج (Pull Request) في مستودع العقود، يراجعه فريق المنتِج ثم ينفّذه في النهاية.

اختبار العقد الموجَّه بالمستهلك

لهذا النهج بعض الفوائد:

  • بما أن العقد مكتوب ومعتمد، لا يحتاج فريق المستهلك إلى انتظار المنتِج ليبني الميزة. يمكنهم توليد نسخ بديلة من العقد واستخدامها لاختبار تكامل الخدمة.
  • يعرف المنتِج من يستخدم واجهته البرمجية وبأي طريقة

وفي هذا النهج، يمكن لفريقي المستهلك والمنتِج مثلًا تنسيق عملهما باتباع التدفق التالي:

  1. لنفترض أن الفريق المسؤول عن order-service (المستهلك) يبني ميزة جديدة تحتاج إلى التكامل مع payment-service (المنتِج). وأثناء ممارسة TDD، يجدون أنهم بحاجة إلى نسخة بديلة من الواجهة البرمجية.
  2. يناقش الفريقان العقد ويعرّفانه باستخدام DSL. يُنشأ في مستودع payment-service ويُودَع فيه.
  3. تُولَّد اختبارات واجهة المنتِج من العقد. وفي هذه المرحلة تفشل لأن التنفيذ غير موجود.
  4. تُدفع العقود والاختبارات إلى المستودع. ويمكن أيضًا فتح طلب دمج ليتناوله فريق المنتِج.
  5. تُولَّد نسخ payment-service البديلة مع الاختبارات، ويمكن نشرها في مستودع للمخرجات (مثل Artifactory).
  6. باستخدام النسخ البديلة، يستطيع فريق المستهلك إكمال اختباراته.

وهذا يوضح أن المنتِج لا يحتاج إلى إنهاء تنفيذه كي يتقدم المستهلك في تنفيذه. وبطبيعة الحال، لا يمكن إرسال شيء إلى الإنتاج قبل أن ينفّذ فريق المنتِج ذلك، لكن المستهلك لا يتعطل.

في النهاية، يجب على فريق المنتِج تنفيذ الواجهة البرمجية وفق العقد. وما إن تنجح جميع الاختبارات حتى يمكن نشر الخدمة في الإنتاج. ولأن عميل HTTP لدى المستهلك والواجهة البرمجية لدى المنتِج بُنيا واختُبرا معًا مقابل عقد واحد، يمكننا أن نثق بأن الخدمات ستتواصل بشكل صحيح في الإنتاج.

لكن هناك تحديًا واحدًا. فكل هذا لا يعمل إلا إذا التزم كل مستهلك بالقواعد. فمستهلك واحد لا ينشئ عقدًا قد يقوّض الفكرة كلها. وفرض ذلك سهل عادةً بإلزام المستهلكين بإنشاء عقد والاتفاق عليه قبل أن يتمكنوا من التكامل مع خدمتنا. كما يمكن فرضه تقنيًا، مثلًا بحظر الدخول إلى خدمتنا (ingress).

اختبار العقد الموجَّه بالمنتِج (Producer-Driven Contract Testing)

وعلى العكس، قد تستخدم خدمتَنا أطراف كثيرة، ربما لا نعرف معظمها أصلًا. في هذه الحالة، لا نستطيع أن نعرف بالضبط من يريد استخدام واجهتنا البرمجية أو كيف. ويناسب هذا النهج أيضًا الحالة التي لا نريد فيها أن يكون للعملاء (المستهلكين) تأثير في واجهتنا البرمجية. هنا يكون المنتِج خدمة سابقة (upstream): فهو يحدد عقد الواجهة البرمجية ويخبر المستهلكين كيف يتكاملون معه. ويمكن للمستهلكين التعامل مع هذه العقود كوثائق، كما يمكنهم استخدامها لاختبار تكاملهم مع المنتِج دون نشر الشيفرة على خادم.

المنتِج والمستهلكون

فخ اختبار العقد

رأيت كثيرًا أشخاصًا يفرطون في استخدام اختبار العقد، وارتكبت الخطأ نفسه بنفسي. أقصد بالإفراط الاعتماد على اختبارات العقد بدلًا من اختبارات الوحدة أو التكامل. اختبار العقد مخصص للتحقق من عقد الخدمات التي تتواصل بشكل متزامن أو غير متزامن، وليس للتحقق من المنطق.

لنأخذ مثالًا واجهة payment-service، التي تُرجع حقل status في استجابتها. وبحسب السيناريو، يمكن أن تكون قيمته FINISHED أو IN_PROGRESS أو FAILED. لكن أي قيمة تُرجَع هو منطق داخلي لعملية الأعمال. وهذا ينبغي على الأرجح أن تغطيه اختبارات الوحدة لا اختبارات العقد. لا حاجة إلى سيناريو اختبار عقد منفصل لكل قيمة من قيم الحقل – يكفي سيناريو واحد يتحقق من أن الحقل يُرجَع بأي من تلك القيم.

يختلف الوضع عندما ينتج طلب معيّن استجابة مختلفة. فقد يكون مثلًا علَمًا (flag) يتسبب في ظهور حقل إضافي في الاستجابة، أو حالة خطأ يردّ فيها المنتِج برمز HTTP 400 على طلب غير صالح. ينبغي أن تغطي اختبارات العقد مثل هذه الحالات، لأنها تمثل حالة تواصل مختلفة.

وبالمضي أبعد من ذلك، إذا أُرجع الرمز 400 في 3 سيناريوهات وكانت الاستجابات تختلف في الرسالة فقط، فيكفي سيناريو واحد لاختبار العقد.

الخلاصة

بدأنا بإبراز صعوبات اختبار التواصل في معمارية الخدمات المصغّرة، ونظرنا في طريقتين شائعتين لاختباره – اختبارات التكامل والاختبارات الشاملة من طرف إلى طرف. ثم قدّمنا اختبار العقد كوسيلة لمعالجة تلك المشكلات.

اختبار العقد نهج يتيح اختبار التواصل (المتزامن وغير المتزامن على حد سواء) بين الخدمات بمعزل عن غيرها. وفكرته المركزية هي العقد – المكان الذي يتفق فيه الطرفان على قواعد التواصل ويسجلانها. يُعرَّف العقد في مكان واحد فقط، لذلك لا يحتاج الأطراف إلى التنسيق كلما تغيّر. وتُبنى اختبارات المنتِج والمستهلك كليهما على هذا العقد، مما يضمن أنها إذا نجحت فستعمل الخدمات معًا في الإنتاج.

بعد ذلك وصفت كيف يختلف نهجا Consumer Driven وProducer Driven ومتى يناسب كلٌّ منهما. وأخيرًا، شاركت نصيحة لتجنب فخ الإفراط في استخدام اختبار العقد.

في المقالات القادمة، سأعرض إطاري عمل اختبار العقد الأوسع استخدامًا – Spring Cloud Contract وPact. ترقبوا ذلك!