streamalism.org

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

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

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

כאן נכנסת לתמונה מסגרת ה- PowerMock.

PowerMockito הוא ממשק ה- API של הרחבה של PowerMock לתמיכה ב- Mockito. הוא מספק יכולות לעבוד עם ממשק ה- API של Java Reflection בצורה פשוטה כדי להתגבר על הבעיות של Mockito, כגון היעדר יכולת ללעוג לשיטות סופיות, סטטיות או פרטיות.

מדריך זה ייתן מבוא ל- API של PowerMockito וכיצד הוא מיושם במבחנים.

2. הכנה לבדיקה באמצעות PowerMockito

הצעד הראשון לשילוב תמיכה ב- PowerMock ב- Mockito הוא לכלול את שתי התלות הבאות בקובץ Maven POM:

 org.powermock powermock-module-junit4 1.6.4 test org.powermock powermock-api-mockito 1.6.4 test 

בשלב הבא עלינו להכין את מקרי המבחן שלנו לעבודה PowerMockito על ידי יישום שתי ההערות הבאות:

@RunWith (PowerMockRunner.class) @PrepareForTest (fullyQualifiedNames = "com.baeldung.powermockito.introduction. *")

ה שמות מלאים אלמנט ב @PrepareForTest ביאור מייצג מערך של שמות מלאים של סוגים שאנחנו רוצים ללעוג להם. במקרה זה, אנו משתמשים בשם חבילה עם תו כללי PowerMockito להכין את כל הסוגים בתוך com.baeldung.powermockito.introduction חבילה ללעג.

עכשיו אנחנו מוכנים לנצל את כוחו של PowerMockito.

3. בוני ללעג ושיטות סופיות

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

class class CollaboratorWithFinalMethods {גמר ציבורי מחרוזת helloMethod () {להחזיר "שלום עולם!"; }}

ראשית, אנו יוצרים אובייקט מדומה באמצעות ה- PowerMockito ממשק API:

CollaboratorWithFinalMethods מדומה = מדומה (CollaboratorWithFinalMethods.class);

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

whenNew (CollaboratorWithFinalMethods.class) .withNoArguments (). thenReturn (מדומה);

בואו נראה איך הלעג הזה של בנייה פועל בפעולה על ידי הפעלת מיידית CollaboratorWithFinalMethods בכיתה באמצעות הבנאי המוגדר כברירת מחדל, ולאחר מכן אמת את ההתנהגויות של PowerMock:

CollaboratorWithFinalMethods משתף פעולה = CollaboratorWithFinalMethods חדש (); verifyNew (CollaboratorWithFinalMethods.class) .withNoArguments ();

בשלב הבא מוגדרת ציפייה לשיטה הסופית:

מתי (collaborator.helloMethod ()). ואז חזור ("שלום באלדונג!");

לאחר מכן מתבצעת שיטה זו:

מחרוזת בברכה = משתף פעולה. HelloMethod ();

הטענות הבאות מאשרות כי שלום מתודה השיטה נקראה על מְשַׁתֵף פְּעוּלָה אובייקט ומחזיר את הערך שנקבע על ידי הציפייה הלועגת:

Mockito.verify (משתף פעולה) .helloMethod (); assertEquals ("שלום באלדונג!", ברוך הבא);

אם אנו רוצים ללעוג לשיטה סופית ספציפית ולא לכל הסופיות בתוך אובייקט, Mockito.spy (אובייקט T) השיטה עשויה להיות שימושית. זה מתואר בסעיף 5.

4. שיטות סטטיות ללעג

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

class class CollaboratorWithStaticMethods {ציבורי סטטי ציבורי firstMethod (שם מחרוזת) {להחזיר "שלום" + שם + "!"; } מחרוזת סטטית ציבורית secondMethod () {להחזיר "שלום לאף אחד!"; } סטטי ציבורי מחרוזת thirdMethod () {להחזיר "שלום לאף אחד שוב!"; }}

על מנת ללעוג לשיטות סטטיות אלו, עלינו לרשום את הכיתה הסוגרת עם ה- PowerMockito ממשק API:

mockStatic (CollaboratorWithStaticMethods.class);

לחלופין, אנו עשויים להשתמש ב- Mockito.spy (כיתת כיתה) שיטה ללעוג לשיטה ספציפית כפי שהודגם בסעיף הבא.

לאחר מכן, ניתן להגדיר ציפיות להגדרת שיטות הערך שצריכות לחזור כאשר הן מופעלות:

מתי (CollaboratorWithStaticMethods.firstMethod (Mockito.anyString ())) .thenReturn ("שלום באלדונג!"); מתי (CollaboratorWithStaticMethods.secondMethod ()). ואז החזרה ("שום דבר מיוחד");

לחלופין, ניתן לקבוע חריג שייזרק בעת קריאת ה- שלישי שיטה:

doTrow (חדש RuntimeException ()). כאשר (CollaboratorWithStaticMethods.class); CollaboratorWithStaticMethods.thirdMethod ();

עכשיו הגיע הזמן לבצע את שתי השיטות הראשונות:

מחרוזת firstWelcome = CollaboratorWithStaticMethods.firstMethod ("מי שיהיה"); מחרוזת secondWelcome = CollaboratorWithStaticMethods.firstMethod ("מה שלא יהיה");

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

assertEquals ("שלום באלדונג!", ראשון ברוך הבא); assertEquals ("שלום באלדונג!", ברוכה הבאה);

אנו יכולים לאמת התנהגויות של שיטות הלעג, כולל כמה פעמים מתבצעת שיטה. במקרה זה, firstMethod נקרא פעמיים, ואילו ה- secondMethod מעולם לא:

verifyStatic (Mockito.times (2)); CollaboratorWithStaticMethods.firstMethod (Mockito.anyString ()); verifyStatic (Mockito.never ()); CollaboratorWithStaticMethods.secondMethod ();

הערה: ה אמת סטטי יש לקרוא לשיטה ממש לפני כל אימות שיטה סטטית עבור PowerMockito לדעת כי קריאת השיטה ברצף היא מה שצריך לאמת.

לבסוף, הסטטי שלישי השיטה צריכה לזרוק א חריגת זמן ריצה כפי שהוכרז על הלעג לפני. זה מאומת על ידי צָפוּי אלמנט של @מִבְחָן ביאור:

@Test (צפוי = RuntimeException.class) חלל ציבורי givenStaticMethods_whenUsingPowerMockito_thenCorrect () {// שיטות אחרות CollaboratorWithStaticMethods.thirdMethod (); }

5. ללעג חלקי

במקום ללעוג לכיתה שלמה, PowerMockito API מאפשר ללעוג לחלק ממנו באמצעות ה- מרגל שיטה. הכיתה הבאה תשמש כשיתוף הפעולה להמחשת התמיכה של PowerMock ללעג חלקי:

class class CollaboratorForPartialMocking {public static String SticMethod () {return "Hello Baeldung!"; } גמר ציבורי String finalMethod () {return "Hello Baeldung!"; } private String privateMethod () {return "Hello Baeldung!"; } public String privateMethodCaller () {return privateMethod () + "ברוך הבא לעולם ג'אווה."; }}

נתחיל ללעוג לשיטה סטטית ששמה נקרא staticMethod בהגדרת הכיתה לעיל. ראשית, השתמש ב- PowerMockito API ללעוג חלקית ל CollaboratorForPartialMocking לקבוע ולהגדיר ציפייה לשיטה הסטטית שלו:

מרגל (CollaboratorForPartialMocking.class); מתי (CollaboratorForPartialMocking.staticMethod ()). ואז החזר ("אני שיטה מדומה סטטית.");

לאחר מכן מתבצעת השיטה הסטטית:

returnValue = CollaboratorForPartialMocking.staticMethod ();

התנהגות הלגלוג אומתה כדלקמן:

verifyStatic (); CollaboratorForPartialMocking.staticMethod ();

הקביעה הבאה מאשרת כי שיטת ה- mock נקראה בפועל על ידי השוואת ערך ההחזר מול הציפייה:

assertEquals ("אני שיטה מדומה סטטית.", returnValue);

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

CollaboratorForPartialMocking משתף פעולה = CollaboratorForPartialMocking חדש (); CollaboratorForPartialMocking מדומה = מרגל (משתף פעולה);

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

מתי (mock.finalMethod ()). ואז חזור ("אני שיטה מדומה סופית."); returnValue = mock.finalMethod ();

הוכחה ההתנהגות של לעג לרוב לשיטה זו:

Mockito.verify (mock) .finalMethod ();

מבחן מאמת שקריאת ה- finalMethod השיטה תחזיר ערך שתואם את הציפייה:

assertEquals ("אני שיטה מדומה סופית.", returnValue);

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

מתי (מדומה, "privateMethod"). ואז חזור ("אני שיטה מדומה פרטית."); returnValue = mock.privateMethodCaller ();

הלעג של השיטה הפרטית אושר:

verifyPrivate (מדומה) .invoke ("privateMethod");

הבדיקה הבאה מוודאת שערך ההחזר מההפעלה של השיטה הפרטית זהה לציפייה:

assertEquals ("אני שיטה מדומה פרטית. ברוך הבא לעולם ג'אווה.", returnValue);

6. מסקנה

מדריך זה סיפק מבוא ל- PowerMockito API, המדגים את השימוש בו בפתרון חלק מהבעיות שמפתחים נתקלים בהם בעת שימוש במסגרת Mockito.

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