המסגרת של Mockito מספקת מגוון שיטות כגון mock(), verify(), when() וכו', המשמשות לבדיקת יישומי Java. שימוש בשיטות מוגדרות מראש אלו מקל מאוד על הבדיקה.

התיאור הקצר של שיטות Mockito ניתן להלן:

apurva padgaonkar

שיטת Mockito mock()

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

להלן שיטות ה-mock() עם פרמטרים שונים:

שיטת mock() עם Class:הוא משמש ליצירת אובייקטים מדומים של מחלקה בטון או ממשק. זה לוקח מחלקה או שם ממשק כפרמטר.
תחביר: mock(Class classToMock)שיטת mock() עם תשובה:הוא משמש ליצירת אובייקטים מדומים של מחלקה או ממשק עם הליך ספציפי. זוהי שיטת מדומה מתקדמת, שניתן להשתמש בה בעת עבודה עם מערכות מדור קודם. זה לוקח את התשובה כפרמטר יחד עם שם המחלקה או הממשק. התשובה היא ספירה של תשובות מדומה שהוגדרו מראש.
תחביר: mock(Class classToMock, Answer defaultAnswer)שיטת mock() עם MockSettings:הוא משמש ליצירת אובייקטים מדומים עם כמה הגדרות לא סטנדרטיות. זה לוקח את MockSettings כפרמטר הגדרה נוסף יחד עם שם המחלקה או הממשק. MockSettings מאפשרת יצירת אובייקטים מדומים עם הגדרות נוספות.
תחביר: mock(Class classToMock, MockSettings mockSettings)שיטת mock() עם ReturnValues:זה מאפשר יצירת אובייקטים מדומים של מחלקה או ממשק נתון. כעת, הוא הוצא משימוש, שכן ReturnValues ​​מוחלפים ב-Answer.
תחביר: mock(Class classToMock, ReturnValues ​​returnValues)שיטת mock() עם String:הוא משמש ליצירת אובייקטים מדומים על ידי ציון השמות המדומה. באיתור באגים, מתן שמות לאובייקטים מדומים יכול להיות מועיל בעוד שזו בחירה גרועה בשימוש בקוד גדול ומורכב.
תחביר: mock(Class classToMock, שם מחרוזת)

קטע הקוד הבא מראה כיצד להשתמש לִלְעוֹג() שיטה:

 ToDoService doService = mock(ToDoService.class); 

שיטת Mockito when()

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

תחביר: when(T methodCall)

קטע הקוד הבא מראה כיצד להשתמש בשיטת when():

 when(mock.someCode ()).thenReturn(5); 

בקוד למעלה, thenReturn() משמש בעיקר עם מתי() שיטה.

שיטת Mockito verify()

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

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

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

ישנם שני סוגים של שיטות verify() הזמינות במחלקה Mockito, הניתנות להלן:

שיטת verify():זה מאמת שהתנהגות מסוימת קרתה פעם אחת.
תחביר: לאמת (ללעג)שיטת verify() עם VerificationMode:זה מאמת שהתנהגות כלשהי התרחשה לפחות פעם אחת, מספר מדויק של פעמים, או אף פעם.
תחביר: לאמת (T mock, מצב VerificationMode)

שיטת Mockito spy()

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

ישנם שני סוגים של שיטות spy() זמינות במחלקה Mockito:

שיטת spy():זה יוצר מרגל של האובייקט האמיתי. שיטת הריגול קוראת לשיטות האמיתיות, אלא אם כן הן עצומות. עלינו להשתמש במרגלים האמיתיים בזהירות ומדי פעם, למשל, כאשר אנו עוסקים בקוד המורשת.
תחביר: מרגל (אובייקט T)שיטת spy() עם Class:זה יוצר אובייקט ריגול המבוסס על מחלקה במקום אובייקט. שיטת spy(T object) שימושית במיוחד עבור ריגול מחלקות מופשטות מכיוון שלא ניתן ליצור אותן.
תחביר: spion(Class classToSpy)

קטע הקוד הבא מראה כיצד להשתמש בשיטת spy():

 List spyArrayList = spy(ArrayList.class); 

שיטת Mockito reset()

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

החתימה של שיטת reset() היא:

דוגמאות לעצים בינאריים

 public static void reset(T ... mocks) { MOCKITO_CORE.reset(mocks); } 

שיטת Mockito verifyNoMoreInteractions()‎

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

החתימה של שיטת verifyNoMoreInteractions() היא:

 public static void verifyNoMoreInteractions(Object... mocks) { MOCKITO_CORE.verifyNoMoreInteractions(mocks); } 

שיטת Mockito verifyZeroInteractions()‎

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

החתימה של שיטת verifyZeroInteractions() היא:

 public static void verifyZeroInteractions(Object... mocks) { MOCKITO_CORE.verifyNoMoreInteractions(mocks); } 

שיטת Mockito doThrow()

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

שיטת doThrow() עם Throwable:שיטה זו משמשת כאשר אנו רוצים לבטל שיטה ריקנית עם חריגה. תחביר: doThrow(Throwable toBeThrown)
החתימה של שיטת doThrow() היא:

 public static Stubber doThrow(Throwable toBeThrown) { return MOCKITO_CORE.doAnswer(new ThrowsException(toBeThrown)); } 

שיטת doThrow() עם Class:שיטה זו משמשת כאשר אנו רוצים להדביק שיטה void כדי לזרוק חריג של מחלקה שצוינה.
תחביר: doThrow(Class toBeThrown)
החתימה של שיטת doThrow() היא:

 public static Stubber doThrow(Class toBeThrown) { return MOCKITO_CORE.doAnswer(new ThrowsExceptionClass(toBeThrown)); } 

שיטת Mockito doCallRealMethod().

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

החתימה של שיטת doCallRealMethod() היא:

 public static Stubber doCallRealMethod() { return MOCKITO_CORE.doAnswer(new CallsRealMethods()); } 

שיטת Mockito doAnswer()

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

 public static Stubber doAnswer(Answer answer) { return MOCKITO_CORE.doAnswer(answer); } 

שיטת Mockito doNothing().

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

החתימה של שיטת doNothing() היא:

 public static Stubber doNothing() { return MOCKITO_CORE.doAnswer(new DoesNothing()); } 

שיטת Mockito doReturn()

הוא משמש במקרים נדירים שבהם איננו יכולים להשתמש ב-Mockito.when(object). השיטה Mockito.when(object) מוצעת תמיד ל-stubbing מכיוון שהיא בטוחה לסוג ארגומנט וקריא יותר בהשוואה לשיטת doReturn()‎.

החתימה של שיטת doReturn() היא:

תכונות חומצה

 public static Stubber doReturn(Object toBeReturned) { return MOCKITO_CORE.doAnswer(new Returns(toBeReturned)); } 

שיטת Mockito inOrder()

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

החתימה של שיטת Mockito.inOrder() היא:

 public static InOrder inOrder(Object... mocks) { return MOCKITO_CORE.inOrder(mocks); } 

שיטת Mockito ignoreStubs()

הוא משמש כדי להתעלם מהשיטות המעופפות של לעג נתון לצורך אימות. זה שימושי עם שיטות verifyNoMoreInteractions() או אימות inOrder(). זה גם עוזר בהימנעות מאימות מיותר של שיחות עצומות.

החתימה של שיטת ignoreStubs() היא:

 public static Object[] ignoreStubs(Object... mocks) { return MOCKITO_CORE.ignoreStubs(mocks); } 

שיטת Mockito times()

הוא משמש לאימות המספר המדויק של הפעלות לשיטה, מה שאומר שהוא מצהיר כמה פעמים שיטה מופעלת. החתימה של שיטת times() היא:

 public static VerificationMode times(int wantedNumberOfInvocations) { return VerificationModeFactory.times(wantedNumberOfInvocations); } 

שיטת Mockito never()

הוא משמש כדי לוודא שהאינטראקציה לא התרחשה. החתימה של שיטת never() היא:

 public static VerificationMode never() { return times(0); } 

שיטת Mockito atLeastOnce()

הוא משמש לאימות הפנייה לפחות פעם אחת, כלומר יש להפעיל את השיטה לפחות פעם אחת.

החתימה של השיטה atLeastOnce() היא:

 public static VerificationMode atLeastOnce() { return VerificationModeFactory.atLeastOnce(); } 

שיטת Mockito atLeast()

הוא משמש כדי לאמת את ההתקשרות לפחות x מספר פעמים. למשל, נתון לפחות(3) פירושו שהשיטה תפעיל לפחות שלוש פעמים.

החתימה של השיטה atLeast() היא:

 public static VerificationMode atLeast(int minNumberOfInvocations) { return VerificationModeFactory.atLeast(minNumberOfInvocations); } 

שיטת Mockito atMost()

הוא משמש לאימות הפנייה לכל היותר x מספר פעמים. למשל, נתון atMost(3) פירושו שהשיטה תפעיל מקסימום שלוש פעמים.

החתימה של שיטת atMost() היא:

 public static VerificationMode atMost(int maxNumberOfInvocations) { return VerificationModeFactory.atMost(maxNumberOfInvocations); } 

שיטת Mockito calls()

זה מאפשר אימות לא חמדני לפי הסדר. ניתן להשתמש בו רק עם שיטת האימות inOrder() . לדוגמה, inOrder.verify(mock, calls(3)).xyzMethod('...');

החתימה של שיטת calls() היא:

 public static VerificationMode calls( int wantedNumberOfInvocations ){ return VerificationModeFactory.calls( wantedNumberOfInvocations ); } 

שיטת Mockito only()

הוא בודק שהשיטה הנתונה הייתה השיטה היחידה שהופעלה. החתימה של השיטה only() היא:

מחרוזת דומה

 public static VerificationMode only() { return VerificationModeFactory.only(); } 

שיטת Mockito timeout()

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

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

החתימה של שיטת timeout() היא:

 public static VerificationWithTimeout timeout(long millis) { return new Timeout(millis, VerificationModeFactory.times(1)); } 

שיטת Mockito after()

זה מאפשר ל-Mockito לאמת על פני פרק זמן נתון. כבר דנו בכך ששיטת after() שונה משיטת timeout() .

החתימה של שיטת after() היא:

 public static VerificationAfterDelay after(long millis) { return new After(millis, VerificationModeFactory.times(1)); } 

Mockito validateMockitoUsage() שיטה

הוא משמש לאימות מפורש של מצב המסגרת כדי לזהות שימוש לא חוקי במסגרת Mockito. זוהי תכונה אופציונלית של Mockito מכיוון שהיא מאמתת את השימוש כל הזמן. שניהם, הרץ המובנה (MockitoJUnitRunner) והכלל (MockitoRule) קורא לשיטת validateMockitoUsage() לאחר כל שיטת בדיקה.

החתימה של שיטת validateMockitoUsage() היא:

 public static void validateMockitoUsage() { MOCKITO_CORE.validateMockitoUsage(); } 

שיטת Mockito withSettings().

הוא משמש ליצירת דוגמיות עם הגדרות דוגמיות נוספות. יש להשתמש בו מדי פעם בבדיקה. במקום להשתמש בשיטת withSettings(), צור בדיקות פשוטות באמצעות דוגמיות פשוטות. הסיבות העיקריות לשימוש ב-MockSettings הן

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

החתימה של שיטת withSettings() היא:

 public static MockSettings withSettings() { return new MockSettingsImpl().defaultAnswer(RETURNS_DEFAULTS); }