כיצד להשתמש בהערות @Before ו-@After ב-JUnit

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

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

ההערה @BeforeAll

מחלקת בדיקה JUnit יכולה לכלול שיטת בדיקה אחת או יותר. ההערה @BeforeAll מסמנת שמתודה ספציפית צריכה להתבצע לפני כל שיטות הבדיקה במחלקת בדיקה. השיטה המשויכת להערה זו מופעלת פעם אחת בלבד (בתחילת הבדיקה) ללא קשר למספר שיטות הבדיקה במחלקת הבדיקה.

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

כיתת המחשבון

חֲבִילָה com.app;
פּוּמְבֵּימעמדמַחשְׁבוֹן{
פּוּמְבֵּיסטָטִיintלְהוֹסִיף(int מספר 1, int מספר 2){
לַחֲזוֹר num1 + num2;
 }
פּוּמְבֵּיסטָטִיintלהחסיר(int מספר 1, int מספר 2){
לַחֲזוֹר num1 - num2;
 }
פּוּמְבֵּיסטָטִיintלְהַכפִּיל(int מספר 1, int מספר 2){
לַחֲזוֹר num1 * num2;
 }
פּוּמְבֵּיסטָטִיintלחלק(int מספר 1, int מספר 2){
לַחֲזוֹר num1 / num2;
 }
}

כיתת מבחן מחשבון

יְבוּאסטָטִיorg.junit.צדק.api.הצהרות.*;
יְבוּאorg.junit.צדק.api.לפני הכל;
יְבוּאorg.junit.צדק.api.מִבְחָן;
יְבוּאorg.junit.צדק.api.הצג שם;
@DisplayName("שיעור מבחן המדגים כיצד להשתמש ה לפניולאחר הערות.")
מעמדמחשבון מבחן{
@BeforeAll
פּוּמְבֵּיסטָטִיבָּטֵלpowerOnCalculator(){
 System.out.println("המחשבון פועל");
 }
@מִבְחָן
 @הצג שם("שיטת בדיקה שמוסיפה שני ערכים שלמים.")
פּוּמְבֵּיבָּטֵלtestAdd(){
assertEquals(7, מַחשְׁבוֹן.לְהוֹסִיף(3, 4));
 } 
@מִבְחָן
 @הצג שם("שיטת בדיקה המפחיתה ערך מספר שלם אחד לאחר.")
פּוּמְבֵּיבָּטֵלמבחן חיסור(){
assertEquals(6, מַחשְׁבוֹן.להחסיר(9, 3));
 }
@מִבְחָן
 @הצג שם("שיטת בדיקה המכפילה שני ערכים שלמים")
פּוּמְבֵּיבָּטֵלבדיקה הכפל(){
assertEquals(10, מַחשְׁבוֹן.לְהַכפִּיל(5, 2));
 }
@מִבְחָן
 @הצג שם("שיטת בדיקה המחלקת ערך שלם אחד באחר")
פּוּמְבֵּיבָּטֵלtestdivide(){
assertEquals(2, מַחשְׁבוֹן.לחלק(4, 2));
 }
}

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

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

הערת @BeforeEach

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

יְבוּאסטָטִיorg.junit.צדק.api.הצהרות.*;
יְבוּאorg.junit.צדק.api.לפני הכל;
יְבוּאorg.junit.צדק.api.לפני כל אחד;
יְבוּאorg.junit.צדק.api.מִבְחָן;
@DisplayName("שיעור מבחן המדגים כיצד להשתמש ה לפניולאחר הערות.")
מעמדמחשבון מבחן{
@BeforeAll
פּוּמְבֵּיסטָטִיבָּטֵלpowerOnCalculator(){
 System.out.println("המחשבון פועל");
 }
@BeforeEach
פּוּמְבֵּיבָּטֵלclearCalculator(){
 System.out.println("המחשבון מוכן");
 }
@מִבְחָן
 @הצג שם("שיטת בדיקה שמוסיפה שני ערכים שלמים.")
פּוּמְבֵּיבָּטֵלtestAdd(){
assertEquals(7, מַחשְׁבוֹן.לְהוֹסִיף(3, 4));
 } 
@מִבְחָן
 @הצג שם("שיטת בדיקה המפחיתה ערך מספר שלם אחד לאחר.")
פּוּמְבֵּיבָּטֵלמבחן חיסור(){
assertEquals(6, מַחשְׁבוֹן.להחסיר(9, 3));
 }
@מִבְחָן
 @הצג שם("שיטת בדיקה המכפילה שני ערכים שלמים")
פּוּמְבֵּיבָּטֵלבדיקה הכפל(){
assertEquals(10, מַחשְׁבוֹן.לְהַכפִּיל(5, 2));
 }
@מִבְחָן
 @הצג שם("שיטת בדיקה המחלקת ערך שלם אחד באחר")
פּוּמְבֵּיבָּטֵלtestdivide(){
assertEquals(2, מַחשְׁבוֹן.לחלק(4, 2));
 }
}

הוספת ההערה @BeforeEach למחלקה CalculatorTest מייצרת את הפלט הבא:

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

ההערה @AfterAll

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

@אחרי הכל
פּוּמְבֵּיסטָטִיבָּטֵלpowerOffCalculator(){
 System.out.println("המחשבון כבוי");
}

הוספת השיטה המוערת @AfterAll למחלקה הקיימת CalculatorTest מדפיסה את הפלט הבא למסוף:

שים לב שהשיטה powerOffCalculator() המשתמשת בביאור @AfterAll, מדפיסה בסוף מחלקת הבדיקה, לאחר ביצוע כל שיטות הבדיקה.

ההערה @AfterEach

ההערה @AfterEach היא המקבילה להערת @BeforeEach. יש להם אותן תנאי חובה, שהם מעט שונים מאלה של ההערות @BeforeAll ו-@AfterAll. מה שמבדיל את ההערה @AfterEach מהביאור @BeforeEach (מלבד שמותיהם) הוא ששיטת @AfterEach פועלת לאחר כל שיטת בדיקה.

@אחרי כל אחד
פּוּמְבֵּיבָּטֵלהחזר תוצאות(){
 System.out.println("התוצאות מוכנות");
}

ביצוע מחלקת CalculatorTest מדפיס את הפלט הבא למסוף:

הפלט מראה שהשיטה הקשורה להערת @AfterEach (returnResults) מודפסת ארבע פעמים. כל ביצוע של שיטת returnResults() מתרחשת רק לאחר ביצוע כל מבחן יחידה. הדבר ניכר בעובדה שהפלט של שיטת returnResults() מופיע אחרי כל פלט מהשיטה המשויכת לביאור @BeforeEach.

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

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

שתי דוגמאות הקוד שמציגות את מחלקת CalculatorTest המלאה משתמשות בהערת @DisplayName. ההערה @DisplayName עוזרת לך ליצור שמות משמעותיים יותר עבור שיעורי המבחן ושיטות המבחן שלך.