בודקים עם האמת של גוגל

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

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

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

2. תלות Maven

ראשית, עלינו להוסיף את אֶמֶת ו אמת-java8-הרחבה שלנו pom.xml:

 com.google.truth אמת 0.32 com.google.truth.extensions אמת-java8-הרחבה 0.32 מבחן 

תוכל למצוא את הגרסאות האחרונות של אמת ואמת-java8-הרחבה ב- Maven Central.

3. הקדמה

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

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

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

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

לדוגמא, כאשר טוענים ברשימה, אֶמֶת מחזירה IterableSubject למשל הגדרת שיטות כמו מכיל () ו containAnyOf (), בין היתר. כאשר טוענים א מַפָּה, זה מחזיר א MapSubject שמצהיר על שיטות כמו containEntry () ו containKey ().

4. תחילת העבודה

כדי להתחיל לכתוב טענות, בוא נייבא תחילה אֶמֶתנקודות כניסה:

ייבא com.google.common.truth.Truth. * סטטי. ייבא com.google.common.truth.Truth8 סטטי. *;

כעת, בואו נכתוב כיתה פשוטה בה נשתמש בכמה מהדוגמאות הבאות:

משתמש בכיתה ציבורית {private String name = "John Doe"; אימיילים של רשימה פרטית = Arrays.asList ("[מוגן באמצעות דוא"ל]", "[מוגן באמצעות דוא"ל]"); ציבורי בוליאני שווה (Object obj) {if (obj == null || getClass ()! = obj.getClass ()) {return false; } משתמש אחר = (משתמש) אובייקט; להחזיר Objects.equals (this.name, other.name); } // בונים סטנדרטיים, גטרים וקובעים}

שימו לב למנהג שווים() שיטה, בה אנו קובעים ששניים מִשׁתַמֵשׁ אובייקטים שווים אם שמם.

5. קביעות Java סטנדרטיות

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

5.1. לְהִתְנַגֵד קביעות

אֶמֶת מספק את נושא עטיפה לביצוע טענות על אובייקטים. נושא הוא גם האב לכל שאר העטיפות בספריה ומצהיר על שיטות לקביעת אם לְהִתְנַגֵד, במקרה שלנו א מִשׁתַמֵשׁ, שווה לאובייקט אחר:

@ מבחן ציבורי בטל כאשרהשוואת משתמשים_ואזת () {משתמש aUser = משתמש חדש ("ג'ון דו"); משתמש אחר משתמש = משתמש חדש ("ג'ון דו"); assertThat (aUser) .isEqualTo (משתמש אחר); }

או אם זה שווה לאובייקט נתון ברשימה:

@ מבחן ציבורי בטל כאשרהשוואת משתמש_תוךInList () {משתמש aUser = משתמש חדש (); assertThat (aUser) .isIn (Arrays.asList (1, 3, aUser, null)); }

או אם זה לא:

@ מבחן ציבורי בטל כאשרהשוואת משתמש_ואז לאינליסט () {// ... assertThat (aUser) .isNotIn (Arrays.asList (1, 3, "שלוש")); }

אם זה אפס או לא:

@ מבחן ציבורי בטל כאשרהשוואת משתמש_את-איזול () {משתמש aUser = null; assertThat (aUser) .isNull (); } @Test ציבורי בטל כאשרהשוואת משתמש_ואז לאנול () {משתמש aUser = משתמש חדש (); assertThat (aUser) .isNotNull (); }

או אם זה מופע של מחלקה מסוימת:

@Test הציבור בטל כאשר השוואה User_thenInstanceOf () {// ... assertThat (aUser) .isInstanceOf (User.class); }

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

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

5.2. מספר שלם, לָצוּף, ו לְהַכפִּיל קביעות

מספר שלם, לָצוּף, ו לְהַכפִּיל ניתן להשוות מקרים בשוויון:

@ מבחן ציבורי בטל whenComparingInteger_thenEqual () {int anInt = 10; assertThat (anInt) .isEqualTo (10); }

אם הם גדולים יותר:

@Test הציבור בטל כאשרComparingFloat_thenIsBigger () {float aFloat = 10.0f; assertThat (aFloat) .isGreaterThan (1.0f); }

או קטן יותר:

@ מבחן ציבורי בטל whenComparingDouble_thenIsSmaller () {כפול aDouble = 10.0f; assertThat (aDouble) .isLessThan (20.0); }

יתר על כן, לצוף ו לְהַכפִּיל ניתן לבדוק מקרים גם אם הם נמצאים בדיוק המדויק או לא:

@ מבחן פומבי בטל כאשרComparingDouble_thenWithinPrecision () {כפול aDouble = 22.18; assertThat (aDouble) .isWithin (2) .of (23d); } @Test הציבור בטל כאשרComparingFloat_thenNotWithinPrecision () {float aFloat = 23.04f; assertThat (aFloat) .isNotWithin (1.3f) .of (100f); }

5.3. BigDecimal קביעות

מלבד הקבוצות הנפוצות, ניתן להשוות סוג זה תוך התעלמות מקנה המידה שלו:

@ מבחן ציבורי בטל כאשרComparingBigDecimal_thenEqualIgnoringScale () {BigDecimal aBigDecimal = BigDecimal.valueOf (1000, 3); assertThat (aBigDecimal) .isEqualToIgnoringScale (BigDecimal חדש (1.0)); }

5.4. בוליאני קביעות

שתי שיטות רלוונטיות בלבד ניתנות, נכון() ו isFalse ():

@Test ציבורי בטל כאשרCheckingBoolean_thenTrue () {בוליאני aBoolean = נכון; assertThat (aBoolean) .isTrue (); }

5.5. חוּט קביעות

אנו יכולים לבדוק האם א חוּט מתחיל בטקסט מסוים:

@Test ציבורי בטל כאשרCheckingString_thenStartsWith () {String aString = "זו מחרוזת"; assertThat (aString) .startsWith ("זה"); }

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

5.6. קביעות מערך

אנחנו יכולים לבדוק מַעֲרָךכדי לראות אם הם שווים למערכים אחרים:

@ מבחן פומבי בטל כאשרComparingArrays_thenEqual () {String [] firstArrayOfStrings = {"one", "two", "three"}; מחרוזת [] secondArrayOfStrings = {"one", "two", "three"}; assertThat (firstArrayOfStrings) .isEqualTo (secondArrayOfStrings); }

או אם הם ריקים:

@Test ציבורי בטל כאשרCheckingArray_thenEmpty () {Object [] anArray = {}; assertThat (anArray) .isEmpty (); }

5.7. ניתן להשוות קביעות

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

@ מבחן ציבורי בטל כאשרCheckingComparable_thenAtLeast () {Comparable aComparable = 5; assertThat (aComparable) .isAtLeast (1); }

כמו כן, אנו יכולים לבדוק האם הם נמצאים בטווח מסוים:

@Test הציבור בטל כאשרCheckingComparable_thenInRange () {// ... assertThat (aComparable) .isIn (Range.closed (1, 10)); }

או ברשימה מסוימת:

@Test הציבור בטל כאשרCheckingComparable_thenInList () {// ... assertThat (aComparable) .isIn (Arrays.asList (4, 5, 6)); }

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

ראשית, בואו לשנות את שלנו מִשׁתַמֵשׁ בכיתה ליישם את ניתן להשוות מִמְשָׁק:

מחלקה ציבורית מיישמת משתמשים השוואה {// ... public int CompareTo (User o) {להחזיר this.getName (). CompareToIgnoreCase (o.getName ()); }}

עכשיו, בואו נאמר ששני משתמשים עם אותו שם שווים:

@ מבחן ציבורי מבוטל כאשרהשוואה המשתמשים_ואחרים () {משתמש aUser = משתמש חדש (); aUser.setName ("ג'ון דו"); משתמש אחר משתמש = משתמש חדש (); anotherUser.setName ("ג'ון איילה"); assertThat (aUser) .isEquivalentAccordingToCompareTo (anotherUser); }

5.8. ניתן לנידון קביעות

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

@Test ציבורי בטל כאשרCheckingIterable_thenContains () {List aList = Arrays.asList (4, 5, 6); assertThat (aList). מכיל (5); }

שהוא מכיל כל אלמנט של אחר ניתן לנידון:

@Test הציבור בטל כאשרCheckingIterable_thenContainsAnyInList () {List aList = Arrays.asList (1, 2, 3); assertThat (aList) .containsAnyIn (Arrays.asList (1, 5, 10)); }

וכי לנושא יש אותם אלמנטים, באותו סדר, כמו אחר:

@Test ציבורי בטל כאשרCheckingIterable_thenContainsExactElements () {List aList = Arrays.asList ("10", "20", "30"); רשימת AnotherList = Arrays.asList ("10", "20", "30"); assertThat (aList) .containsExactlyElementsIn (anotherList) .inOrder (); }

ואם הוא הוזמן באמצעות משווה מותאם אישית:

@Test הציבור בטל שניתןComparator_whenCheckingIterable_thenOrdered () {Comparator aComparator = (a, b) -> Float new (a) .compareTo (Float new (b)); רשימה aList = Arrays.asList ("1", "012", "0020", "100"); assertThat (aList) .is הוזמן (aComparator); }

5.9. מַפָּה קביעות

בנוסף לטענה כי א מַפָּה מופע ריק או לא, או שיש לו גודל ספציפי; אנחנו יכולים לבדוק אם יש לו ערך ספציפי:

@ מבחן ציבורי בטל כאשר CheckCheckingMap_thenContainsEntry () {Map aMap = new HashMap (); aMap.put ("one", 1L); assertThat (aMap) .containsEntry ("one", 1L); }

אם יש לו מפתח ספציפי:

@Test הציבור בטל כאשרCheckingMap_thenContainsKey () {// ... assertThat (map) .containsKey ("one"); }

או אם יש לו אותם ערכים כמו אחר מַפָּה:

@Test ציבורי בטל כאשרCheckingMap_thenContainsEntries () {Map aMap = HashMap new (); aMap.put ("ראשון", 1 ליטר); aMap.put ("שנייה", 2.0); aMap.put ("שלישי", 3f); למפות עוד מפה = HashMap חדש (aMap); assertThat (aMap) .containsExactlyEntriesIn (anotherMap); }

5.10. יוצא מן הכלל קביעות

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

אנו יכולים לכתוב קביעות המופנות לגורם החריג:

@ מבחן פומבי בטל כאשרCheckingException_thenInstanceOf () {Exception anException = IllegalArgumentException חדש (NumberFormatException חדש ()); assertThat (anException) .hasCauseThat () .isInstanceOf (NumberFormatException.class); }

או למסר שלה:

@ מבחן ציבורי בטל כאשרCheckingException_thenCauseMessageIsKnown () {Exception anException = new IllegalArgumentException ("ערך רע"); assertThat (anException) .hasMessageThat () .startsWith ("רע"); }

5.11. מעמד קביעות

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

@Test ציבורי בטל כאשרCheckingClass_thenIsAssignable () {Class aClass = Double.class; assertThat (aClass) .isAssignableTo (Number.class); }

6. קביעות Java 8

אופציונאלי ו זרם הם שני סוגי Java 8 היחידים אֶמֶת תומך.

6.1. אופציונאלי קביעות

ישנן שלוש שיטות חשובות לאימות אופציונאלי.

אנו יכולים לבדוק האם יש לו ערך מסוים:

@ מבחן ציבורי בטל כאשרCheckingJavaOptional_thenHasValue () {Optional anOptional = Optional.of (1); assertThat (anOptional) .hasValue (1); }

אם הערך קיים:

@ מבחן ציבורי בטל כאשרCheckingJavaOptional_thenPresent () {Optional anOptional = Optional.of ("Baeldung"); assertThat (anOptional) .isPresent (); }

או אם הערך אינו קיים:

@ מבחן ציבורי בטל כאשרCheckingJavaOptional_thenEmpty () {Optional anOptional = Optional.empty (); assertThat (anOptional) .isEmpty (); }

6.2. זרם קביעות

טענות לא זרם דומים מאוד לאלה של ניתן לנידון.

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

@ מבחן ציבורי בטל כאשרCheckingStream_thenContainsInOrder () {Stream anStream = Stream.of (1, 2, 3); assertThat (anStream) .containsAllOf (1, 2, 3) .inOrder (); }

לקבלת דוגמאות נוספות, עיין ב ניתן לנידון סעיף קביעות.

7. קביעות גויאבה

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

7.1. אופציונאלי קביעות

ישנן שלוש שיטות קביעה חשובות עבור גויאבה אופציונאלי. ה hasValue () ו isPresent () שיטות מתנהגות בדיוק כמו ב- Java 8 אופציונאלי.

אבל במקום זה ריק() לטעון כי an אופציונאלי אינו קיים, אנו משתמשים isAbsent ():

@ מבחן ציבורי בטל כאשרCheckingGuavaOptional_thenIsAbsent () {Optional anOptional = Optional.absent (); assertThat (anOptional) .isAbsent (); }

7.2. מולטימפה קביעות

מולטימפה וסטנדרטי מַפָּה הטענות דומות מאוד.

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

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

@ מבחן ציבורי בטל כאשרCheckingGuavaMultimap_thenExpectedSize () {Multimap aMultimap = ArrayListMultimap.create (); aMultimap.put ("one", 1L); aMultimap.put ("אחד", 2.0); assertThat (aMultimap) .valuesForKey ("one") .hasSize (2); }

לקבלת דוגמאות נוספות, עיין ב מַפָּה סעיף קביעות.

7.3. מולטי סט קביעות

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

@Test ציבורי בטל כאשרCheckingGuavaMultiset_thenExpectedCount () {TreeMultiset aMultiset = TreeMultiset.create (); aMultiset.add ("באלדונג", 10); assertThat (aMultiset) .hasCount ("baeldung", 10); }

7.4. שולחן קביעות

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

@Test ציבורי בטל כאשרCheckingGuavaTable_thenContains () {טבלה aTable = TreeBasedTable.create (); aTable.put ("firstRow", "firstColumn", "baeldung"); assertThat (aTable) .contains ("firstRow", "firstColumn"); }

או אם הוא מכיל תא מסוים:

@Test ציבורי בטל כאשרCheckingGuavaTable_thenContainsCell () {טבלה aTable = getDummyGuavaTable (); assertThat (aTable) .containsCell ("firstRow", "firstColumn", "baeldung"); }

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

8. הודעות ותוויות כשל בהתאמה אישית

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

אֶמֶת מאפשר לנו להתאים אישית את הודעות הכישלון האלה:

@Test ציבורי בטל כאשר FailingAssertion_thenCustomMessage () {assertWithMessage ("TEST-985: נושא המשתמש הסודי לא היה ריק!") .That (משתמש חדש ()) .isNull (); }

לאחר הפעלת הבדיקה, אנו מקבלים את הפלט הבא:

TEST-985: נושא המשתמש הסודי לא היה ריק !: לא נכון ש <[מוגן באמצעות דוא"ל] הוא ריק

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

@ מבחן ציבורי בטל whenFailingAssertion_thenMessagePrefix () {משתמש aUser = משתמש חדש (); assertThat (aUser). בשם ("משתמש [% s]", aUser.getName ()) .isNull (); }

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

לא נכון שמשתמש [ג'ון דו] (<[מוגן באמצעות דוא"ל]>) הוא אפס

9. הרחבות

מַאֲרִיך אֶמֶת פירושו שנוכל להוסיף תמיכה לסוגים מותאמים אישית. לשם כך עלינו ליצור מחלקה ש:

  • מרחיב את נושא כיתה או אחת משתי קבוצות המשנה שלה
  • מגדיר קונסטרוקטור המקבל שני טיעונים - א FailureStrategy ומופע מהסוג המותאם אישית שלנו
  • מכריז על שדה של נושא מפעל סוג, אשר אֶמֶת ישמש ליצירת מופעים של הנושא המותאם אישית שלנו
  • מיישם סטטי assertThat () שיטה המקבלת את הסוג המותאם אישית שלנו
  • חושף את ממשק ה- API של קביעת הבדיקה שלנו

עכשיו כשאנחנו יודעים להרחיב אֶמֶת, בואו ליצור מחלקה שמוסיפה תמיכה לאובייקטים מהסוג מִשׁתַמֵשׁ:

מחלקה ציבורית UserSubject מרחיבה ComparableSubject {UserSubject פרטי (FailureStrategy failureStrategy, User target) {super (failureStrategy, target); } פרטי סטטי סופי SubjectFactory USER_SUBJECT_FACTORY = נושא חדש Factory () {ציבורי UserSubject getSubject (FailureStrategy failureStrategy, יעד משתמש) {החזר UserSubject חדש (failureStrategy, יעד); }}; הצהרה סטטית ציבורית UserSubject assertThat (משתמש משתמש) {להחזיר Truth.assertAbout (USER_SUBJECT_FACTORY) .that (user); } חלל ציבורי hasName (שם מחרוזת) {if (! בפועל (). getName (). שווה (שם)) {fail ("יש שם", שם); }} חלל ציבורי hasNameIgnoringCase (שם מחרוזת) {if (! actual (). getName (). equalsIgnoreCase (name)) {fail ("יש שם שמתעלם מהמקרה", שם); }} דוא"ל ציבורי של IterableSubject () {החזר Truth.assertThat (בפועל (). getEmails ()); }}

כעת אנו יכולים לייבא את ה- statically assertThat () שיטת הנושא המותאם אישית שלנו וכתוב כמה מבחנים:

@ מבחן ציבורי בטל כאשרCheckingUser_thenHasName () {משתמש aUser = משתמש חדש (); assertThat (aUser) .hasName ("ג'ון דו"); } @Test ציבורי בטל כאשר בדיקת משתמש_ואזתנאייגינגקייס () {// ... assertThat (aUser) .hasNameIgnoringCase ("ג'ון דו"); } @Test ציבורי בטל givenUser_whenCheckingEmails_thenExpectedSize () {// ... assertThat (aUser) .emails () .hasSize (2); }

10. מסקנה

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

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

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


$config[zx-auto] not found$config[zx-overlay] not found