M365Con 2027 – כנס אונליין חינמי · 11–22 Jan 2027 · 120 sessions→ m365con.net

בלוג · Mirko Peters

בדיקות יחידה, אינטגרציה וקצה-לקצה: איפה AI עוזר הכי הרבה

By · · Updated

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

Automatically translated with AI from the original post. Read the English original

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

עיקרי הדברים

  • בדיקת יחידה בודקת חתיכת קוד אחת, בדיקת אינטגרציה בודקת את הקשר למשהו שנמצא מחוץ לאפליקציה, ובדיקת קצה-לקצה מפעילה את המערכת שנפרסה דרך הממשק שלה.
  • פירמידת הבדיקות קובעת שכדאי לכתוב הרבה בדיקות יחידה קטנות ומהירות, מעט בדיקות ברמה גבוהה יותר ומעט מאוד בדיקות ברמה הגבוהה ביותר, משום שרמות גבוהות יותר איטיות ודורשות יותר תחזוקה.
  • AI שימושי במיוחד במקומות שבהם הפלט קטן וקל לבדיקה, כמו כתיבת טיוטות של בדיקות יחידה ו-API, ובמקומות שבהם אדם יכול לבחון כל בדיקה שנוצרה.
  • בדיקות שנוצרו על ידי AI עלולות לנפח את כיסוי הקוד בלי לאמת התנהגות, למשל בדיקות שמריצות קוד אך כוללות טענות (assertions) חלשות או חסרות.
  • יש להתייחס לפלט של AI כטיוטה בכל רמה, ולהשאיר שיקול דעת אנושי לזרימות לא חד-משמעיות, לבדיקות חזותיות ולבדיקות נגישות.

בדיקות יחידה לעומת אינטגרציה לעומת קצה-לקצה: מה כל אחת בודקת

המאמר The Practical Test Pyramid של מרטין פאולר (Martin Fowler) מספק הגדרות ברורות.

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

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

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

כמה מכל סוג: פירמידת הבדיקות

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

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

חוסר היציבות הזה ניתן למדידה בקנה מידה גדול. פוסט בבלוג הבדיקות של Google, Flaky Tests at Google and How We Mitigate Them, מדווח שכ-1.5 אחוזים מהרצות הבדיקות שלה נתנו תוצאה לא יציבה, וכמעט 16 אחוזים מהבדיקות שלה הציגו איזושהי אי-יציבות.

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

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

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

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

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

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

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

בדיקות אלה קלות לאוטומציה בתוך Pipeline. TestRail אומרת שבדיקות יחידה רצות בדרך כלל מוקדם, לעיתים מיד אחרי push או pull request, ובדיקות אינטגרציה רצות מאוחר יותר, לאחר שהאפליקציה נפרסה לסביבת staging או בדיקות. יחד הן יוצרות שער איכות (quality gate).

היכן AI עוזר הכי הרבה

הכלים המבוססים על AI generative שונים זה מזה, אך מופיע דפוס בהנחיות של ספקים. המאמר של Parasoft על השימוש ב-AI בבדיקות תוכנה ממליץ לצוותים ליצור בדיקות יחידה ובדיקות API בזמן שהשינויים עדיין טריים, ומזכיר עזרה של AI ביצירת בדיקות API, בהצעת assertions ובבניית תרחישי נתונים. הוא מציין גם ש-service virtualization, שמדמה תלויות איטיות, יקרות או לא זמינות, תומך בבדיקות אינטגרציה.

זה מתאים לפירמידה. הנימוקים הם הסקה שלנו, ולא מדידה:

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

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

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

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

היכן AI עוזר הכי פחות, ומה כדאי לשים לב אליו

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

אסטרטגיות בדיקה שמשתמשות ב-AI צריכות ארבע בדיקות:

  1. כיסוי שעולה אבל לא תופס כלום. בדקו טענות (assertions), ולא רק מספרי כיסוי.
  2. בדיקות שמשקפות את הקוד. בדיקה שחוזרת על המימוש תעבור גם כשהלוגיקה שגויה.
  3. פלט לא יציב. אם בדיקה שנוצרה משתנה בין הרצות, נעלו את הגרסה שסקרתם.
  4. נתונים יוצאים מהארגון. אל תדביקו סודות, נתוני לקוחות או מידע מוסדר לתוך פרומפט.

דוגמה: על מה צוות אחד מוציא את המאמץ

המספרים בדוגמה פיקטיביים.

לצוות יש 600 בדיקות אוטומטיות: 450 בדיקות יחידה, 110 בדיקות אינטגרציה ו-40 בדיקות קצה-לקצה. בדיקות הדפדפן לוקחות 50 דקות מתוך צינור של 60 דקות, ששש מהן נכשלות באופן אקראי בכל שבוע.

ראש צוות ה-QA מבצע שלושה צעדים. ראשית, עוזר AI מנסח בדיקות יחידה לקוד חדש, ומפתח סוקר כל טיוטה. בחודש הראשון העוזר ניסח 120 בדיקות. הסוקרים דחו 30 מהן כי הטענות חלשות, ולכן 90 נכנסו לחבילה.

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

שלישית, ל-40 בדיקות הקצה-לקצה אין עזרה מ-AI. ראש הצוות מסיר שש כפילויות שכבר מכוסות על ידי בדיקה נמוכה יותר ומהירה יותר, וצינור העבודה יורד מ-60 דקות ל-48. מאמץ ה-AI הופנה לשכבה שבה הסקירה זולה ביותר, והשכבה האיטית התכווצה.

טעויות נפוצות

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

איך תוכנה יכולה לעזור

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

הצעד הבא

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

Entities in this article

Unit testing Integration testing End-to-end testing Generative AI

Related articles

RSS