שיטות טובות לכתיבה אובייקטים ב Tdd להנדסת הנדסה בדיקות תוכנה

מבוא לאובייקטים של Mock ב- TDD

Test-Driven Development (TDD) הוא אבן הפינה של בדיקות טכנולוגיות הנדסיות מודרניות, קידום אמינות קוד, שמירה, ו-Louta משוב עיצוב ברור. in TDD, מפתחים כותבים מבחן נכשל ראשון, ואז לייצר מספיק קוד ייצור כדי לעבור את המבחן הזה, ולבסוף לספק. כדי לבודד את היחידה תחת בדיקה של תלות חיצונית כמו מסדי נתונים, שירותי אינטרנט, מערכות קבצים, לעג להפוך לאובייקטים הכרחיים של התנהגות של ממשית של לעג, אך לא יעילה של טכניקות בקרה, אלא רק כדי למנוע השפעות בדיקה, אלא רק כדי למנוע תרחישים של יעילות, אלא רק כדי למנוע מוטציות, אלא רק כדי למנוע מוטציות של שיטות בקרה, אלא רק כדי למנוע לעג, אלא רק כדי למנוע מוטציות טכניות, אך ורק כדי למנוע לעג, אלא רק כדי למנוע מוטציות.

כאשר נעשה נכון, לעג עוזר לזהות פגמים עיצוב מוקדם, לאכוף את הכדאיות הרתיעה, ומייצר בדיקות מהירות, אמינות.עם זאת, לעגים בעלי מבנה נמוך להוביל לחבילות מבחן מלוטשות שקשה לבודד אותן, מאשר לחשוף אותן. מאמר זה חוקר את השיטות הטובות ביותר לכתיבת אובייקטים לעג בהקשר של TDD, עם הדרכה מעשית עבור צוותי הנדסה המבקשים לשפר את שיטות הבדיקה שלהם.

הבנת אובייקטים מנוק ותפקידם

לפני צלילה לשיטות הטובות ביותר, חשוב להבהיר את המינוח, בעוד שלעתים קרובות נעשה שימוש בחילופים, כפולי המבחן נופלים למספר קטגוריות, כל אחת עם מטרה ייחודית.מאמרו הקלאסי של מרטין פוולר:0 "Mocks Are't Stubs"FLT:1 מספק מס יסוד:

• (ב) [15] ,ב"ד: "החפץ עבר, אך מעולם לא נעשה בו שימוש, בדרך כלל כדי לספק חתימות של שיטות.
• (ב) ,0) ,StubveFLT:1 , מספק תשובות משומרות על שיחות שבוצעו במהלך הבדיקה, לעתים קרובות משמש לשליטה בקלטות עקיפות.
• (ב) ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇
• (ב) [ה]התקבלה: [ה]] [ה]]], [התקבלו] [ב]]] [התקבלו] [ב]]] [התקבלו] [ה] [התקבלו] [ה] [התקבלו] [ה] [התקבלו] [ה] [הת] [הת] [הת] [הת] [הת] [הת] [הת]]] [הת] [הת] [הת] [הת] [הת] [הת] [הת] [הת] [הת] [הת]]] [הת] [הת]]]]] [הת] [הת]]] [הת]]]]]]] [הת] [הת] [הת] [הת] [הת] [הת] [הת] [הת] [הת] [הת] [הת] [הת] [הת] [התקבלהת]]] [הת]]]] [הת] [
• (ב) [ה]התב"ה]: "התב"ה, "התב"ה, "מסד נתונים לא-זיכרון" שאינו מתאים לייצור אלא שימושי לבדיקות.

ב- TDD קפדני, לעג ו מרגלים הם הכלים העיקריים לבדיקה מבוססת אינטראקציה, בעוד שמגמים תומכים בבדיקות המבוססות על המדינה.הבנת ההבדלים האלה מסייעת למהנדסים לבחור את המבחן הנכון כפול עבור כל תרחיש.

מסגרות לעג מודרניות (למשל, Mockito, Jest, Unittest.mock) טשטשות את השורות הללו על ידי הצעת תכונות משולבות, אבל הבהירות המושגית נותרה קריטית. אובייקט ללעג ב- TDD צריך לוודא שהמערכת תחת בדיקה (SUT) אינטראקציה עם תלותה באופן הצפוי - קריאה שיטות ספציפיות עם טענות נכונות וכבוד של סדר או תדירות.

המונחים: Mock Objects

הנהלים הבאים מקושטים משנים של ניסיון בתעשייה וחוכמה קהילתית. Adhering להם יגרום למבחנים שלך אמין יותר, יקרא, ועמידה מחדש כדי לספק.

שמור על ocks Simple and Focused

עיצוב כל לעג לסימולציה של ההתנהגות המדויקת הנדרשת על ידי הבדיקה, להימנע מעומס יתר על המידה של לעג עם מגמגמות מיותרות, החזרת ערכים או אימותים.כאשר לעג עושה יותר מדי, כוונת המבחן הופכת לנעלמת, ועלויות תחזוקה להגדיל. לדוגמה, אם SUT רק קורא רצף של רצף:0 שיטת הלעג לא צריך גם להגדיר התנהגות עבור FLT:1 אלא אם כן הוא משמש את אותה כמות מינימלית של שימוש.

בנוסף, מומלץ להשתמש בתשובות ברירת מחדל או לעגנים (שם המסגרת מאפשרת) כדי להימנע מניתוחים כאשר SUT מתפתח. in Mockito,FLT:2 מונע שגיאות מיותרות כאשר שיטות מגודות אינן נקראות; ב Jest,FLT 3: מחזיר FLT:4 כברירת מחדל.

2. השתמש ב- Clear Ning Conventions

השם של משתנה לעג צריך להעביר את תפקידו ואת התלות שהוא מחליף במקום (FLT:5 או FLT:6), להשתמש בשמות תיאוריים כמו FLT 7 או FLT:8; זה חשוב במיוחד בסוויטות מבחן גדולות שבו מפתחים לסרוק במהירות את הקוד.

לשיטות לעג, אם אתה יוצר יישום לעג מותאם אישית (נדרש באופן טבעי עם מסגרות), השתמש בשמות שיטה המציינים בבירור את ההתנהגות המדומה, כגון FLT 9 או FLT:10 להימנע משמות גנריים כמו FLT:11 אשר מסתירים את הפרטים.

3.הסבר אינטראקציות באופן אקספונסיאלי

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

Mockito.verify(mockService, times(1)).processPayment(anyString(), eq(100.0));

ב Jest:

expect(mockService.processPayment).toHaveBeenCalledTimes(1);
expect(mockService.processPayment).toHaveBeenCalledWith('order-123', 100.0);

היזהרו רק מה חיוני לחוזה ההתנהגותי.Over-verifying (למשל, לבדוק כי לא היו שיטות אחרות נקראות באמצעות FLT:14 ללא הבחנה) יכולים לבצע בדיקות ליישב.

להימנע מניצול יתר

הocking אינו בחירה ברירת מחדל.Over-mocking מוביל לבדיקות שמקבילות בקפידה ליישום פרטים, מה שהופך את הקטורת הכואבת.

• (FLT:0)Mock רק גבולות חיצוניים 1FLT - תלותים שחצו את התהליך, הרשת או הגבולות I/O (למשל, לקוח מסד נתונים, REST API, מערכת קבצים).
• (FLT:0) קידום אובייקטים אמיתיים עבור מעבדי colLabatorsFLT 1:1 - אם משתפי פעולה הם פשוטים, מהירים, ונטולי תופעות לוואי (למשל, ערך או מעמד שירות), להשתמש בו ישירות ולא ללעג אותו.
• (ב) אם אתה שולט ביישום של תלות, שקול אם זיוף (גרסה קלת-זיכרון) יהיה יותר אמין מאשר לעג עם עשרות גמגמים.
• (FLT:0) בדיקות אינטגרציה עבור זרימת עבודה מורכבת 1 ; בעוד לעג הם גדולים עבור בדיקות יחידה, בדיקות אינטגרציה (באמצעות תלות אמיתית או מקוטבת) לתפוס באגים תיאום כי לעג לא יכול.

כלל טוב של אצבע: אם אתה מוצא את עצמך כותב 20 + שורות של לעג עבור מבחן יחידה אחת, זה עשוי להיות סימן כי SUT יש יותר מדי תלות או שאתה צריך לשקול גישה אחרת מבחן.

5.התלות נובעות באופן משמעותי

אובייקטים מנוק עובדים רק כאשר SUT מקבל את התלויות שלו באמצעות הזרקת בניה, פרמטרים שיטה או (אלא אם כן אידיאלי) הזרקת סטטר. שיטות סטטיות, המדינה העולמית, ויצירת אובייקטים בתוך ה- SUT (באמצעות שימוש ב-FLT:15) הם לעגים נגד-patterns. לכתוב את קוד הייצור שלך עם הזרקת התלות (DI) בראש.

public class OrderService {
 private final PaymentGateway paymentGateway;
 public OrderService(PaymentGateway paymentGateway) {
 this.paymentGateway = paymentGateway;
 }
 // ...
}

עיצוב זה מאפשר לבדיקות להחליף לעג 17 (אם קוד הבסיס שלך משתמש במכל DI, ודא כי תצורה של מבחן יכול להתגבר על יישום אמיתי עם לעג.

השתמש בנתונים אמיתיים ו- Edge-Case

ocks צריך להחזיר נתונים המציגים ערכי ייצור, כולל סוגים, טווחים ומבנים. להימנע משימוש בערכים בעלי מיקום טריוויאליים כמו מיתרים ריקים או 0 עבור כל מבחן אלא אם כן זה התרחיש שנבדק. השתמש בעומסים ריאליים כדי לחשוף פגמים מוקדם.לדוגמה, אם שיטה צופה רשימה של הזמנות, להחזיר רשימה עם פריטים מרובים, לא רשימה ריקה, אלא אם הבדיקה מכסה במפורש את המקרה הריק, כולל מקרים, באופן חריג, או מקרים, או חריגים.

טעות נפוצה היא ללעג לחזרה של חפץ כאשר היישום האמיתי עשוי להחזיר את ה-FLT 18 או לזרוק יוצא דופן.מבחנים לאחר מכן לעבור, אבל קוד הייצור נכשל.

איפוס בין בדיקות

בכל חבילת מבחן, לעג צריך להיות טרי עבור כל מקרה מבחן כדי למנוע דליפת המדינה (רוב המסגרות המודרניות מציעות סטיות או שיטות ההתקנה כדי לאפס לעג באופן אוטומטי. in JUnit 5 עם Mockito, להשתמש ב-FLT:19 ו-FLT:20 ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇

כלים ומסגרות ל-Mocking

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

ג'אווה: Mockito

(ב) [15] , ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇

JavaScript/TypeScript: Jest

(ב) ויקרא י"ד, ב[[1924]], [[1924]]]], [[1924]]]] ו[[1924]]]]]], [[1924]], [[1924]]]]]], [[1924]]]]]], [[1924]]]]]], [[1924]]]]]]]]]]]]]], [[1924]]]]]]]]]]]], [[1924]]]]]]]]]]]]]], [[1924]]]]]], [[1924]]]], [[1924]]]]]]]]]]]]]]]], [[1924]]]]]]]]]]]]]]]]]] ו[[1924]], [[1924]]]], [[1924]], [[1924]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]

Python: Unittest.mock

(ב) , ויקרא י"א) , ויקרא ויקרא י"א ויקרא י"א, ויקרא י"א , ויקרא י"ד , ויקרא י"ד ויקרא י"ד , ויקרא י"ד , ויקרא יט יט"ד , .

.NET: Moq

Moq היא הספרייה הלעגנית ביותר עבור .NET, באמצעות ממשק שוטפת: (FLT:40 ). Moq תומך התנהגות קפדנית ולעגת; להתחיל עם רופפת (default) ולהדק רק כאשר יש צורך.

רובי: RSpec Mocks

(הופנה מהדף [[1924]]]], [[1924]]]], [[1924]]]]]], [[1924]]]], [[1924]]]], [[1924]]]], [[1924]]]]]], [[1924]]]]]], [[1924]]]]]]]], [[1924]]]]]]]]

מלכודות נפוצות וכיצד להימנע מהם

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

« « « מקדימים הכל ב-Sight

זה מוביל לבדיקות שהן תיבות של לבן, שבריריות, איטיות לכתוב.במקום, ללעג רק בגבולות אדריכליים (למשל, I/O, שירותי צד שלישי) ללוגיקה פנימית, להשתמש באובייקטים אמיתיים.

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

החזרתם של ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇

המונחים: call order or Count

אלא אם כן צו קריאה הוא דרישה קריטית (למשל, זרימת עבודה בתשלום חייבת לאמת לפני הטעינה), להשתמש באימותים (FLT:49) באופן חד-משמעי.

התעלמות מדרך יוצאת דופן

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

טכניקות מתקדמות

לאחר שאתה שולט בבסיסים, שקול את הטכניקות האלה כדי להתמודד עם תרחישים מורכבים יותר.

זעזועים (Spies)

לפעמים צריך לבדוק אובייקט אמיתי אבל לנסח שיטה אחת. מסגרות כמו Mockito לאפשר יצירת מרגל על מקרה אמיתי: (FLT:51) להשתמש בספיגה זו - זה משלב התנהגות אמיתית וסימולציה, אשר יכול לבלבל את הכוונה במבחן.

שימוש ב-Argument Matchers

(ב) , ⁇ (ב) , ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇

« « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « «

לעג לעג נכשל אם שיטה בלתי צפויה נקראת; לעגנים נעימים מתעלמים מקריאות לא מוגדרות.לנטי הוא בדרך כלל יותר גמיש, במיוחד במהלך מתן מחדש.אם אתה מאמץ לעג קפדני (למשל, מגיפות קפדניות של מוקיטויטו), להיות מוכן לעדכונים מבחן תכופים.

שילוב עם CI /CD ו Test Containers

אובייקטים מנוק מאירים במבחנים יחידה, אך יש להם מגבלות.לאימות של אינטראקציות עם מערכות חיצוניות (למשל, מסדי נתונים, מתווךי הודעות), לשקול שימוש ב-FLT:0test מכולות ההרחבה 1 (למשל, Testludeers for Java, Test Containers for .NET) לצד לעג ברמות בדיקה גבוהות יותר.

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

מסקנה

אובייקטים מוק הם כלי חיוני בארסנל של מתרגל TDD, המאפשרים מבודד, ⁇ סטי ובדיקות יחידה מהירה.הפרקים הטובים ביותר המפורטים במאמר זה - שמירה על לעג פשוט, שם אותם בבירור, אימות אינטראקציות במפורש, הימנעות משימוש יתר, וזריקת תלות - להפוך בסיס מוצק ליצירת סוויטות בדיקה יעילות יותר.

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

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