streamalism.org

1. סקירה כללית

במאמר מהיר זה, נבחן את הרעיון של חוזים מונחים על ידי הצרכן.

אנו נבדוק שילוב עם שירות REST חיצוני באמצעות חוזה שאנו מגדירים באמצעות ה- בְּרִית סִפְרִיָה. חוזה זה יכול להיות מוגדר על ידי הלקוח, ואז להרים אותו על ידי הספק ולהשתמש בפיתוח שירותיו.

אנו ניצור בדיקות המבוססות על החוזה הן עבור יישומי הלקוח והן עבור יישומי הספק.

2. מה זה בְּרִית?

באמצעות בְּרִית, אנו יכולים להגדיר את ציפיות הצרכן לספק נתון (שיכול להיות שירות HTTP REST) ​​בצורה של חוזה (ומכאן שמה של הספרייה).

אנו עומדים להקים חוזה זה באמצעות ה- DSL המסופק על ידי בְּרִית. לאחר הגדרתנו, אנו יכולים לבדוק אינטראקציות בין צרכנים לספק באמצעות שירות ה- mock שנוצר על בסיס החוזה שהוגדר. כמו כן, נבדוק את השירות כנגד החוזה באמצעות לקוח מדומה.

3. תלות של Maven

כדי להתחיל נצטרך להוסיף תלות ב- Maven ל pact-jvm-consumer-junit_2.11 סִפְרִיָה:

 מבחן au.com.dius pact-jvm-consumer-junit_2.11 3.5.0 

4. הגדרת חוזה

כשאנחנו רוצים ליצור מבחן באמצעות בְּרִיתראשית עלינו להגדיר א @כְּלָל שישמש במבחן שלנו:

@Ract PactProviderRuleMk2 פומבית mockProvider = PactProviderRuleMk2 חדש ("test_provider", "localhost", 8080, זה);

אנו מעבירים את שם הספק, המארח והיציאה עליהם יופעל הלעוג לשרת (שנוצר מהחוזה).

נניח שהשירות הגדיר את החוזה לשתי שיטות HTTP בהן הוא יכול להתמודד.

השיטה הראשונה היא בקשת GET שמחזירה את JSON עם שני שדות. כאשר הבקשה מצליחה, היא מחזירה קוד תגובה 200 HTTP ואת ה- Cאונטנט-סוג כותרת עבור JSON.

בואו נגדיר חוזה כזה באמצעות בְּרִית.

עלינו להשתמש ב- @בְּרִית ביאור ולהעביר את שם הצרכן שלשמו מוגדר החוזה. בתוך השיטה המבוארת, אנו יכולים להגדיר את חוזה ה- GET שלנו:

@Pact (צרכן = "test_consumer") RequestResponsePact ציבורי createPact (בונה PactDslWithProvider) ציבורי {כותרות מפה = HashMap חדש (); headers.put ("סוג תוכן", "application / json"); בונה החזרת .given ("test GET") .uponReceiving ("GET REQUEST") .path ("/ pact") .method ("GET") .willRespondWith () .status (200). headers (headers) .body ( "{\" תנאי \ ": נכון, \" שם \ ": \" טום \ "}") (...)}

משתמש ב בְּרִית DSL אנו מגדירים כי לבקשת GET נתונה אנו רוצים להחזיר 200 תשובות עם כותרות וגוף ספציפיים.

החלק השני של החוזה שלנו הוא שיטת POST. כאשר הלקוח שולח בקשת POST לנתיב /בְּרִית עם גוף JSON תקין הוא מחזיר קוד תגובה 201 HTTP.

בואו נגדיר חוזה כזה עם בְּרִית:

(...) .given ("test POST") .uponReceiving ("POST REQUEST") .method ("POST"). headers (headers) .body ("{\" name \ ": \" Michael \ "} "). path (" / pact ") .willRespondWith () .status (201) .toPact ();

שים לב שעלינו להתקשר ל- toPact () שיטה בסוף החוזה להחזרת מופע של RequestResponsePact.

4.1. חפץ ברית שהתקבל

כברירת מחדל, קבצי Pact ייווצרו ב- יעד / פקטים תיקיה. כדי להתאים אישית נתיב זה, אנו יכולים להגדיר את ה- תוסף maven-surefire:

 org.apache.maven.plugins maven-surefire-plugin יעד / mypacts ... 

בניית Maven תיצור קובץ בשם test_consumer-test_provider.json בתוך ה יעד / mypacts תיקייה המכילה את מבנה הבקשות והתגובות:

{"provider": {"name": "test_provider"}, "צרכן": {"name": "test_consumer"}, "אינטראקציות": [{"תיאור": "קבל בקשה", "בקשה": {" שיטה ":" GET "," path ":" / "}," response ": {" status ": 200," headers ": {" Type-Type ":" application / json "}," body ": { "condition": true, "name": "tom"}}, "providerStates": [{"name": "test GET"}]}, {"תיאור": "POST בקשה", ...}], "metadata": {"specific-pact": {"version": "3.0.0"}, "pact-jvm": {"version": "3.5.0"}}}

5. בדיקת הלקוח והספק באמצעות החוזה

כעת, כשיש לנו את החוזה, נוכל ליצור בדיקות נגדו הן עבור הלקוח והן עבור הספק.

כל אחד מהבדיקות הללו ישתמש בלעג של מקבילו המבוסס על החוזה, כלומר:

• הלקוח ישתמש בספק מדומה
• הספק ישתמש בלקוח מדומה

למעשה, הבדיקות נעשות כנגד החוזה.

5.1. בדיקת הלקוח

לאחר שהגדרנו את החוזה אנו יכולים לבדוק אינטראקציות עם השירות שייווצר על בסיס חוזה זה. אנו יכולים ליצור בדיקת JUnit רגילה אך עלינו לזכור לשים את ה- @PactVerification ביאור בתחילת המבחן.

בואו לכתוב מבחן לבקשת GET:

@Test @PactVerification () חלל ציבורי givenGet_whenSendRequest_shouldReturn200WithProperHeaderAndBody () {// when ResponseEntity response = new RestTemplate () .getForEntity (mockProvider.getUrl () + "/ pact", String.class); // ואז assertThat (response.getStatusCode (). value ()). isEqualTo (200); assertThat (response.getHeaders (). get ("סוג תוכן"). מכיל ("application / json")). isTrue (); assertThat (response.getBody ()). מכיל ("תנאי", "נכון", "שם", "טום"); }

ה @PactVerification ביאור דואג להפעלת שירות HTTP. במבחן, עלינו לשלוח רק את בקשת ה- GET ולהצהיר כי תגובתנו עומדת בחוזה.

בואו נוסיף את הבדיקה גם לשיחת שיטת POST:

HttpHeaders httpHeaders = HttpHeaders חדשים (); httpHeaders.setContentType (MediaType.APPLICATION_JSON); מחרוזת jsonBody = "{\" name \ ": \" Michael \ "}"; // כאשר ResponseEntity postResponse = RestTemplate () .exchange חדש (mockProvider.getUrl () + "/ create", HttpMethod.POST, HttpEntity חדש (jsonBody, httpHeaders), String.class); // ואז assertThat (postResponse.getStatusCode (). value ()). isEqualTo (201);

כפי שאנו רואים, קוד התגובה לבקשת ה- POST שווה ל- 201 - בדיוק כפי שהוגדר ב- בְּרִית חוֹזֶה.

כפי שהשתמשנו ב- @PactVerification () ביאור, ה בְּרִית הספרייה מפעילה את שרת האינטרנט בהתבסס על החוזה שהוגדר בעבר לפני מקרה הבדיקה שלנו.

5.2. בודקים את הספק

השלב השני של אימות החוזה שלנו הוא יצירת בדיקה לספק באמצעות לקוח מדומה על בסיס החוזה.

יישום הספקים שלנו יונע על ידי חוזה זה באופן TDD.

לדוגמא שלנו, נשתמש ב- API של Spring Boot REST.

ראשית, כדי ליצור את מבחן JUnit שלנו, נצטרך להוסיף את התלות pact-jvm-provider-junit_2.11:

 מבחן au.com.dius pact-jvm-provider-junit_2.11 3.5.0 

זה מאפשר לנו ליצור מבחן JUnit באמצעות ה- PactRunner ומפרט שם הספק ומיקום חפץ האמנה:

@RunWith (PactRunner.class) @Provider ("test_provider") @PactFolder ("pacts") מחלקה ציבורית PactProviderTest {// ...}

כדי שתצורה זו תפעל, עלינו למקם את test_consumer-test_provider.json קובץ ב- חוזים תיקיית פרויקט השירות REST שלנו.

לאחר מכן נגדיר את היעד שישמש לאימות האינטראקציות בחוזה ולהפעיל את אפליקציית Spring Boot לפני הפעלת הבדיקות:

@TestTarget סופי ציבורי יעד יעד = HttpTarget חדש ("http", "localhost", 8082, "/ spring-rest"); יישום פרטי סטטי ConfigurableWebApplicationContext; @BeforeClass התחל ריק סטטי ציבורי () {application = (ConfigurableWebApplicationContext) SpringApplication.run (MainApplication.class); }

לבסוף, נפרט את המדינות בחוזה שאותן אנו רוצים לבדוק:

@State ("test GET") בטל ציבורי toGetState () {} @State ("test POST") בטל ציבורי toPostState () {}

הפעלת מחלקת JUnit זו תבצע שתי בדיקות לשתי בקשות ה- GET וה- POST. בואו נסתכל על היומן:

אימות ברית בין test_consumer ל- test_provider שניתן מבחן GET GET REQUEST מחזירה תגובה שיש לה קוד סטטוס 200 (OK) כוללת כותרות "סוג תוכן" עם ערך "application / json" (OK) יש גוף תואם (OK) אימות אמנה בין test_consumer ו- test_provider שניתנה לבדיקה POST POST בקשת מחזירה תגובה שיש לה קוד סטטוס 201 (OK) עם גוף תואם (OK)

שים לב שלא כללנו כאן את הקוד ליצירת שירות REST. ניתן למצוא את השירות והמבחן המלא בפרויקט GitHub.

6. מסקנה

במדריך מהיר זה, הסתכלנו על חוזים מונחים על ידי הצרכן.

יצרנו חוזה באמצעות ה- בְּרִית סִפְרִיָה. לאחר שהגדרנו את החוזה, הצלחנו לבדוק את הלקוח והשירות מול החוזה ולהצהיר שהם עומדים במפרט.

ניתן למצוא את היישום של כל הדוגמאות וקטעי הקוד בפרויקט GitHub - זהו פרויקט Maven, כך שיהיה קל לייבא ולהפעיל אותו כפי שהוא.