משאבים למצב 'אספרסו'

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

זיהוי מתי יש צורך במשאבים בהמתנה לפעילות

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

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

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

  • הוספת שיחות אל Thread.sleep(). כשמוסיפים השהיות מלאכותיות לבדיקות, לוקח יותר זמן להשלים את ההרצה של חבילת המקרים לבדיקה, ועדיין יכול להיות שהבדיקות ייכשלו לפעמים כשהן מורצות במכשירים איטיים יותר. בנוסף, ההשהיות האלה לא מתאימות לשינויים בהיקף, כי יכול להיות שהאפליקציה תצטרך לבצע עבודה אסינכרונית שתימשך יותר זמן בגרסה עתידית.
  • הטמעת מעטפות לניסיון חוזר, שמשתמשות בלולאה כדי לבדוק שוב ושוב אם האפליקציה עדיין מבצעת עבודה אסינכרונית עד שמתרחש זמן קצוב לתפוגה. גם אם מציינים מספר מקסימלי של ניסיונות חוזרים בבדיקות, כל הפעלה מחדש צורכת משאבי מערכת, במיוחד CPU.
  • שימוש במופעים של CountDownLatch, שמאפשרים ל-thread אחד או יותר להמתין עד שמספר מסוים של פעולות שמבוצעות ב-thread אחר יושלמו. באובייקטים האלה צריך לציין את משך הזמן הקצוב לתפוגה, אחרת האפליקציה עלולה להיחסם ללא הגבלת זמן. בנוסף, ה-latches מוסיפים מורכבות מיותרת לקוד, מה שמקשה על התחזוקה.

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

תרחישים נפוצים לדוגמה

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

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

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

דוגמאות להטמעות של משאבים בהמתנה לפעילות

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

CountingIdlingResource
מונה את המשימות הפעילות. כשהמונה מגיע לאפס, המשאב המשויך נחשב כלא פעיל. הפונקציונליות הזו דומה מאוד לזו של Semaphore. ברוב המקרים, ההטמעה הזו מספיקה כדי לנהל את העבודה האסינכרונית של האפליקציה במהלך הבדיקה.
UriIdlingResource
בדומה ל-CountingIdlingResource, אבל המונה צריך להיות אפס למשך פרק זמן מסוים לפני שהמשאב נחשב כלא פעיל. תקופת ההמתנה הנוספת הזו מביאה בחשבון בקשות רצופות לאחזור מהרשת, שבהן אפליקציה בשרשור עשויה לשלוח בקשה חדשה מיד אחרי קבלת תגובה לבקשה קודמת.
IdlingThreadPoolExecutor
הטמעה בהתאמה אישית של ThreadPoolExecutor שעוקבת אחרי המספר הכולל של המשימות שפועלות במאגרי ה-threads שנוצרו. המחלקה הזו משתמשת ב-CountingIdlingResource כדי לשמור על מונה המשימות הפעילות.
IdlingScheduledThreadPoolExecutor
הטמעה בהתאמה אישית של ScheduledThreadPoolExecutor. הוא מספק את אותן פונקציונליות ויכולות כמו המחלקה IdlingThreadPoolExecutor, אבל הוא גם יכול לעקוב אחרי משימות שמתוזמנות לעתיד או מתוזמנות לביצוע מדי פעם.

יצירת משאב משלכם בהמתנה לפעילות

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

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

הפעלת מעברים למצב חוסר פעילות מחוץ לבדיקות של חוסר פעילות.
אחרי שהאפליקציה עוברת למצב של חוסר פעילות, מפעילים את onTransitionToIdle() מחוץ להטמעות של isIdleNow(). כך Espresso לא מבצע בדיקה שנייה ומיותרת כדי לקבוע אם משאב בהמתנה לפעילות מסוים נמצא במצב המתנה.

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

fun isIdle() {
    // DON'T call callback.onTransitionToIdle() here!
}

fun backgroundWorkDone() {
    // Background work finished.
    callback.onTransitionToIdle() // Good. Tells Espresso that the app is idle.

    // Don't do any post-processing work beyond this point. Espresso now
    // considers your app to be idle and moves on to the next test action.
}

לרשום משאבים בהמתנה לפעילות לפני שצריך אותם.

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

ברשימה הבאה מוצגות כמה דוגמאות למאפיין הזה:

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

כדי לחסוך במשאבי המערכת, כדאי לבטל את הרישום של משאבים בהמתנה לפעילות ברגע שאין בהם צורך. לדוגמה, אם רושמים משאב בהמתנה לפעילות ב-method עם ההערה @Before, מומלץ לבטל את הרישום של המשאב הזה ב-method תואמת עם ההערה @After.

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

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

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

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

רישום משאבים בהמתנה לפעילות

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

  • בבדיקות של האפליקציה, יוצרים הפניה ל-IdlingRegistry במקום למשאבים בהמתנה לפעילות שהוא מכיל.
  • לשמור על ההבדלים באוסף המשאבים בהמתנה לפעילות שבהם אתם משתמשים בכל וריאנט build.
  • הגדירו משאבים בהמתנה לפעילות בשירותים של האפליקציה, ולא ברכיבי ממשק המשתמש שמפנים לשירותים האלה.

שילוב משאבים בהמתנה לפעילות באפליקציה

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

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

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

גישות חלופיות

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

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

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

מקורות מידע נוספים

למידע נוסף על השימוש ב-Espresso בבדיקות של Android, עיינו במקורות המידע הבאים.

דוגמאות