תחילת העבודה עם Mockito @Mock, @Spy, @Captor ו- @ InjectMocks

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

במדריך זה נסקור את ביאורים לספריית Mockito@לִלְעוֹג, @מרגל, @שַׁבַּאי, ו @InjectMocks.

לקבלת טוב יותר Mockito, עיין בסדרה כאן.

2. אפשר הערות Mockito

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

2.1. MockitoJUnitRunner

האפשרות הראשונה שיש לנו היא רשום את מבחן JUnit באמצעות א MockitoJUnitRunner כמו בדוגמה הבאה:

@RunWith (MockitoJUnitRunner.class) מעמד ציבורי MockitoAnnotationTest {...}

2.2. MockitoAnnotations.initMocks ()

לחלופין, אנחנו יכולים אפשר הערות Mockito באופן פרוגרמטי כמו כן, על ידי הפעלת MockitoAnnotations.initMocks ():

@ לפני init בטל פומבי () {MockitoAnnotations.initMocks (זה); }

2.3. MockitoJUnit.rule ()

לבסוף, אנחנו יכולים להשתמש ב- MockitoJUnit.rule ()כפי שמוצג מטה:

מחלקה ציבורית MockitoInitWithMockitoJUnitRuleUnitTest {@Rule MockitoRule ציבורית initRule = MockitoJUnit.rule (); ...}

במקרה זה עלינו לזכור לקבוע את הכלל שלנו פּוּמְבֵּי.

3. @לִלְעוֹג ביאור

ההערה הנפוצה ביותר במוקיטו היא @לִלְעוֹג. אנחנו יכולים להשתמש @לִלְעוֹג ליצור ולהזריק מקרים לעגים מבלי שתצטרך להתקשר Mockito.mock באופן ידני.

בדוגמה הבאה - ניצור לעג רשימת מערך עם הדרך הידנית ללא שימוש @לִלְעוֹג ביאור:

@Test הציבור בטל כאשרNotUseMockAnnotation_thenCorrect () {רשימה mockList = Mockito.mock (ArrayList.class); mockList.add ("אחד"); Mockito.verify (mockList) .add ("אחד"); assertEquals (0, mockList.size ()); Mockito.when (mockList.size ()). ואז החזר (100); assertEquals (100, mockList.size ()); }

ועכשיו נעשה את אותו הדבר אבל נזריק את הלעג באמצעות ה- @לִלְעוֹג ביאור:

רשימת @Mock mockedList; @ מבחן ציבורי בטל כאשר UsMockAnnotation_thenMockIsInjected () {mockedList.add ("אחד"); Mockito.verify (mockedList) .add ("אחד"); assertEquals (0, mockedList.size ()); Mockito.when (mockedList.size ()). ואז החזר (100); assertEquals (100, mockedList.size ()); }

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

4. @מרגל ביאור

עכשיו - בואו נראה איך להשתמש @מרגל ביאור לרגל אחר מקרה קיים.

בדוגמה הבאה - אנו יוצרים מרגל של a רשימה עם הדרך הישנה בלי להשתמש @מרגל ביאור:

@ מבחן ציבורי בטל כאשרNotUseSpyAnnotation_thenCorrect () {רשימה spyList = Mockito.spy (ArrayList חדש ()); spyList.add ("אחד"); spyList.add ("שניים"); Mockito.verify (spyList) .add ("אחד"); Mockito.verify (spyList) .add ("שניים"); assertEquals (2, spyList.size ()); Mockito.doReturn (100). When (spyList) .size (); assertEquals (100, spyList.size ()); }

בואו נעשה עכשיו את אותו הדבר - לרגל ברשימה - אך נעשה זאת באמצעות ה- @מרגל ביאור:

רשימת @Spy spiedList = ArrayList חדש (); @ מבחן ציבורי בטל כאשר UsSpyAnnotation_thenSpyIsInjectedCorrectly () {spiedList.add ("one"); spiedList.add ("שניים"); Mockito.verify (spiedList) .add ("אחד"); Mockito.verify (spiedList) .add ("שניים"); assertEquals (2, spiedList.size ()); Mockito.doReturn (100). When (spiedList) .Size (); assertEquals (100, spiedList.size ()); }

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

  • השתמשו ב- אמיתי שיטה spiedList.add () להוסיף אלמנטים ל spiedList.
  • סתום השיטה spiedList.size () לחזור 100 במקום 2 באמצעות Mockito.doReturn ().

5. @שַׁבַּאי ביאור

הבא - בואו נראה כיצד להשתמש ב- @שַׁבַּאי ביאור ליצירת ArgumentCaptor למשל.

בדוגמה הבאה - אנו יוצרים ArgumentCaptor עם הדרך הישנה בלי להשתמש @שַׁבַּאי ביאור:

@Test הציבור בטל כאשרNotUseCaptorAnnotation_thenCorrect () {List mockList = Mockito.mock (List.class); ArgumentCaptor arg = ArgumentCaptor.forClass (String.class); mockList.add ("אחד"); Mockito.verify (mockList) .add (arg.capture ()); assertEquals ("one", arg.getValue ()); }

בואו עכשיו לעשות שימוש ב @שַׁבַּאילאותה מטרה - ליצור ArgumentCaptor למשל:

רשימת @Mock mockedList; @Captor ArgumentCaptor argCaptor; @ מבחן ציבורי בטל כאשר UsCaptorAnnotation_thenTheSam () {mockedList.add ("one"); Mockito.verify (mockedList) .add (argCaptor.capture ()); assertEquals ("one", argCaptor.getValue ()); }

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

6. @InjectMocks ביאור

עכשיו - בואו נדבר על אופן השימוש @InjectMocks ביאור - להזרים שדות מדומים לאובייקט שנבדק באופן אוטומטי.

בדוגמה הבאה - אנו משתמשים @InjectMocks להזריק את הלעג wordMap לתוך ה המילון שליdic:

@Mock Map wordMap; @InjectMocks MyDictionary dic = MyDictionary חדש (); @ מבחן פומבי בטל כאשר UseInjectMocksAnnotation_thenCorrect () {Mockito.when (wordMap.get ("aWord")). ואז החזר ("aMeaning"); assertEquals ("aMeaning", dic.getMeaning ("aWord")); }

והנה הכיתה המילון שלי:

מחלקה ציבורית MyDictionary {Map wordMap; MyDictionary ציבורי () {wordMap = HashMap חדש (); } הוסף ריק ריק (מילת מחרוזת סופית, משמעות מחרוזת סופית) {wordMap.put (מילה, משמעות); } מחרוזת ציבורית getMeaning (מילת מחרוזת סופית) {return wordMap.get (word); }} 

7. הזרקת דמות למרגל

בדומה למבחן הנ"ל, כדאי שנזריק דמה למרגל:

@Mock Map wordMap; @Spy MyDictionary spyDic = MyDictionary חדש ();

עם זאת, Mockito אינו תומך בהזרקת לעגים למרגלים, ותוצאות הבדיקה הבאות בחריג:

@ מבחן פומבי בטל כאשר UseInjectMocksAnnotation_thenCorrect () {Mockito.when (wordMap.get ("aWord")). ואז החזר ("aMeaning"); assertEquals ("aMeaning", spyDic.getMeaning ("aWord")); }

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

MyDictionary (מפה wordMap) {this.wordMap = wordMap; }

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

@Mock Map wordMap; MyDictionary spyDic; @ לפני init בטל פומבי () {MockitoAnnotations.initMocks (זה); spyDic = Mockito.spy (MyDictionary חדש (wordMap)); } 

המבחן יעבור כעת.

8. ריצה ל- NPE תוך שימוש בהערות

לעתים קרובות, אנו עשויים להיתקל NullPointerException כאשר אנו מנסים להשתמש בפועל במופע שמסומן עליו @לִלְעוֹג אוֹ @מרגל:

מחלקה ציבורית MockitoAnnotationsUninitializedUnitTest {@Mock List mockedList; @Test (צפוי = NullPointerException.class) בטל בציבור כאשרMockitoAnnotationsUninitialized_thenNPEThrown () {Mockito.when (mockedList.size ()). ThenReturn (1); }}

לרוב זה קורה פשוט מכיוון ששכחנו להפעיל כראוי הערות מוקיטו.

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

9. הערות

לבסוף - הנה כמה הערות על הערות מוקיטו:

  • ההערות של Mockito ממזערות את יצירת יצירת הלעג החוזרת
  • הם הופכים את המבחנים לקריאים יותר
  • @InjectMocks נחוץ להזרקת שניהם @מרגל ו @לִלְעוֹג מקרים

10. מסקנה

במדריך מהיר זה, הראינו את היסודות של ביאורים בספריית Mockito.

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

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