מדריך עזר לסקריפטים Robo

במסמך הזה מפורט מידע על סקריפטים של Robo, כולל מבנה, יכולות, שימוש, הקלטה ופעולות. סקריפטים של Robo הם בדיקות שמבצעות אוטומציה של משימות ידניות של בקרת איכות (QA) באפליקציות לנייד, ומאפשרות אינטגרציה רציפה (CI) ואסטרטגיות בדיקה לפני השקה. סקריפט Robo הוא קובץ JSON שמתאר רצף של פעולות בממשק המשתמש (UI) ופעולות אחרות.

אפשר ליצור תסריט רובוט בדרכים הבאות:

• שימוש בתכונה 'הקלטת סקריפט של רובוט'. (Android בלבד)

• יוצרים את סקריפט ה-Robo באופן ידני. ‫(Android ו-iOS+)

• מקליטים את סקריפט ה-Robo ואז עורכים אותו באופן ידני. (Android בלבד)

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

מבוא

סקריפט Robo מסופק לבדיקת Robo לצד קלט אחר, כמו חבילת האפליקציה של Android (APK) שנבדקת.

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

[
  {
    "crawlStage": "crawl",
    "contextDescriptor": {
      "condition": "app_under_test_shown"
    },
    "actions": [
      {
        "eventType": "VIEW_TEXT_CHANGED",
        "replacementText": "user123",
        "elementDescriptors": [
          {
            "resourceId": "my.app.package:id/username"
          }
        ]
      },
      {
        "eventType": "VIEW_TEXT_CHANGED",
        "replacementText": "12345",
        "elementDescriptors": [
          {
            "resourceId": "my.app.package:id/password"
          }
        ]
      },
      {
        "eventType": "VIEW_CLICKED",
        "elementDescriptors": [
          {
            "resourceId": "my.app.package:id/login"
          }
        ]
      }
    ]
  }
]

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

[
  {
    "eventType": "VIEW_TEXT_CHANGED",
    "replacementText": "user123",
    "elementDescriptors": [
      {
        "resourceId": "my.app.package:id/username"
      }
    ]
  },
  {
    "eventType": "VIEW_TEXT_CHANGED",
    "replacementText": "12345",
    "elementDescriptors": [
      {
        "resourceId": "my.app.package:id/password"
      }
    ]
  },
  {
    "eventType": "VIEW_CLICKED",
    "elementDescriptors": [
      {
        "resourceId": "my.app.package:id/login"
      }
    ]
  }
]

תמיכה ב-iOS+ בסקריפטים של Robo

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

הפעולות הבאות נתמכות ב-iOS ומעלה:

• טענת נכוֹנוּת (assertion
• קליק
• לחיצה ארוכה
• החלקה
• התעלמות מכל האלמנטים
• המתן
• צילום מסך
• סיום הסריקה

ב-iOS+, יש תמיכה במאפייני הזיהוי הבאים בתיאורי רכיבים:

• שם הכיתה
• שם מחלקת האב
• תיאור תוכן (וביטוי רגולרי)
• טקסט (וביטוי רגולרי)

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

• האפליקציה בבדיקה מוצגת
• האלמנט קיים
• בוצעה פעולת סקריפט שלא על ידי Robo

מבנה

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

קובץ יחיד מכיל אוסף של סקריפטים של Robo.

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

[
  {
    "id": 1000,
    "description": "My first Robo script",
    "actions": [
      {
        "eventType": "DISABLE_KEYBOARD"
      }
    ]
  },
  {
    "id": 1001,
    "description": "My second Robo script",
    "actions": [
      {
        "eventType": "PRESSED_BACK"
      }
    ]
  }
]

תיאור הקשר

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

זו דוגמה לסקריפט Robo שמופעל על ידי ווידג'ט בממשק המשתמש עם מזהה משאב "my.app.package:id/page_header" שמופיע במסך:

{
  "id": 1000,
  "contextDescriptor": {
    "condition": "element_present",
    "elementDescriptors": [
      {
        "resourceId": "my.app.package:id/page_header"
      }
    ]
  },
  "actions": [
    {
      "eventType": "VIEW_CLICKED",
      "elementDescriptors": [
        {
          "text": "Settings"
        }
      ]
    }
  ]
}

הנה דוגמה לסקריפט Robo שמופעל על ידי "Privacy Policy" שזוהה על ידי זיהוי תווים אופטי (OCR):

{
  "id": 1000,
  "description": "Vision text Robo script",
  "contextDescriptor": {
    "condition": "element_present",
    "visionText": "Privacy Policy"
  },
  "actions": [
    {
      "eventType": "VIEW_CLICKED",
      "visionText": "Privacy Policy"
    }
  ]
}

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

{
  "contextDescriptor": {
    "condition": "non_roboscript_action_performed"
  },
  "maxNumberOfRuns" : 1000,
  "actions" : [
    {
      "eventType" : "WAIT",
      "delayTime" : 5000
    }]
}

פעולות

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

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

[
  {
    "eventType": "WAIT",
    "delayTime": 3000
  },
  {
    "eventType": "PRESSED_BACK"
  }
]

תיאורי אלמנטים

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

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

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

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

[
  {
    "eventType": "VIEW_TEXT_CHANGED",
    "replacementText": "John",
    "elementDescriptors": [
      {
        "className": "android.support.v7.widget.AppCompatEditText",
        "groupViewChildPosition": 0,
        "resourceId": "com.google.samples.apps.topeka:id/first_name"
      },
      {
        "className": "android.widget.FrameLayout",
        "groupViewChildPosition": 0
      },
      {
        "className": "android.support.design.widget.TextInputLayout",
        "groupViewChildPosition": 1
      }
    ]
  },
  {
    "eventType": "VIEW_CLICKED",
    "elementDescriptors": [
      {
        "className": "android.support.design.widget.FloatingActionButton",
        "groupViewChildPosition": 1,
        "resourceId": "com.google.samples.apps.topeka:id/done"
      },
      {
        "className": "android.widget.FrameLayout",
        "groupViewChildPosition": 1,
        "resourceId": "com.google.samples.apps.topeka:id/content"
      },
      {
        "className": "android.widget.FrameLayout",
        "groupViewChildPosition": 0,
        "resourceId": "com.google.samples.apps.topeka:id/sign_in_content"
      }
    ]
  }
]

אפשרויות הביצוע

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

סקריפטים של Robo תומכים באפשרויות ההרצה הבאות:

• ‫executionMode – אפשרויות הביצוע שמוחלות כשמריצים סקריפט של Robo:
  • ‫strict – אם הערך מוגדר כ-true, סקריפט Robo לא משתמש בהתאמה חלקית, מדלג על הפעולה הנוכחית ומשעה את הפעולה. כלומר, סקריפט Robo מופעל כבדיקת מכשור רגילה ונכשל ברגע שלא ניתן לבצע אחת מהפעולות שלו. כברירת מחדל, הערך הוא false.
  • ‫dismiss_popups – אם הערך הוא true, בדיקת Robo סוגרת תיבות דו-שיח לא צפויות במהלך הפעלת סקריפט Robo, גם במצב strict. לאפשרות הזו אין השפעה כשלא נמצאים במצב strict. ערך ברירת המחדל הוא false.
  • ‫notify – אם הערך מוגדר כ-false, סקריפט Robo לא מציג התראות במסך בתחילת הביצוע ובסופו. ערך ברירת המחדל הוא true.
• ‫postscript – אפשרויות הביצוע שמוחלות אחרי שסקריפט Robo מסתיים:
  • ‫terminate – אם הערך מוגדר כ-true, בדיקת Robo מפסיקה לסרוק אחרי שהסקריפט של Robo מסתיים. כברירת מחדל, הערך הוא false.

הדוגמה הבאה היא של סקריפט Robo שמופעל במצב strict בלי התראות במסך. הסקריפט ממתין שלוש שניות, ואז הסריקה נעצרת:

"roboscript": {
  "executionMode": {
    "strict": true,
    "notify": false
  },
  "postscript": {
    "terminate": true
  }
}
[
  {
    "eventType": "WAIT",
    "delayTime": 3000
  }
]

פרמטרים של תבניות

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

תסריטי Robo תומכים בפרמטר התבנית הבא:

• ‫__%APP_PACKAGE_NAME%__ – שם החבילה של האפליקציה שנבדקת.

בדוגמה הבאה מוצג סקריפט Robo שמפסיק את התהליך של האפליקציה שנבדקת:

[
  {
    "eventType": "ADB_SHELL_COMMAND",
    "command": "am force-stop __%APP_PACKAGE_NAME%__"
  }
]

תגובות

תסריט Robo יכול להכיל שורות הערות, שהן שורות שמתחילות ב-# או ב-//.

דוגמה לסקריפט Robo עם כמה הערות:

# Confirm a user account.
[
  {
    // Click the DONE button.
    "eventType": "VIEW_CLICKED",
    "elementDescriptors": [
      {
        "resourceId": "com.google.samples.apps.topeka:id/done"
      }
    ]
  }
]

יכולות

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

עדיפויות

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

1. כולל מאפיין contextDescriptor.
2. הערך הכי גבוה של priority (כברירת מחדל, לכל סקריפטים של Robo יש אותו priority של 1).
3. מופיע הכי מוקדם ברשימת סקריפטים של Robo, אם העדיפויות של סקריפטים של Robo זהות.

בדוגמה הבאה מוצג קובץ עם שלושה סקריפטים של Robo שמבצעים את אותה פעולה ומופעלים על ידי אותו תנאי – האפליקציה שנבדקת נמצאת בחזית:

[
  {
    "id": 1000,
    "description": "Robo script 1",
    "contextDescriptor": {
      "condition": "app_under_test_shown"
    },
    "actions": [
      {
        "eventType": "WAIT",
        "delayTime": 3000
      }
    ]
  },
  {
    "id": 1001,
    "description": "Robo script 2",
    "priority": "2",
    "contextDescriptor": {
      "condition": "app_under_test_shown"
    },
    "actions": [
      {
        "eventType": "WAIT",
        "delayTime": 3000
      }
    ]
  },
  {
    "id": 1002,
    "description": "Robo script 3",
    "contextDescriptor": {
      "condition": "app_under_test_shown"
    },
    "actions": [
      {
        "eventType": "WAIT",
        "delayTime": 3000
      }
    ]
  }
]

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

1. ‫"Robo script 2" כי יש לו את העדיפות הכי גבוהה.
2. ‫"Robo script 1" כי הוא מופיע מוקדם יותר בין סקריפטים רלוונטיים אחרים של Robo עם אותה עדיפות.
3. ‫"Robo script 3" בתור סקריפט Robo האחרון שרלוונטי.

הפעלות חוזרות

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

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

{
  "id": 1000,
  "maxNumberOfRuns": 10,
  "contextDescriptor": {
    "condition": "app_under_test_shown"
  },
  "actions": [
    {
      "eventType": "GO_HOME"
    }
  ]
}

שלב הסריקה

סקריפטים של Robo רלוונטיים בשלבים שונים של סריקת Robo נתונה:

אם לא מציינים את המאפיין crawlStage של סקריפט Robo, ברירת המחדל היא crawl.

הדוגמה הבאה מציגה סקריפט Robo שמנקה את נתוני המשתמש של האפליקציה שנבדקת לפני ש-Robo מתחיל לסרוק אותה:

{
  "id": 1000,
  "crawlStage": "pre_crawl",
  "actions": [
    {
      "eventType": "ADB_SHELL_COMMAND",
      "command": "pm clear __%APP_PACKAGE_NAME%__"
    }
  ]
}

הדוגמה הבאה היא של סקריפט Robo שמורה ל-Robo ללחוץ על "Cancel" בכל פעם שהוא מנסה לחזור (לסגת) מתיבת דו-שיח של אישור:

{
  "id": 1000,
  "crawlStage": "close_screen",
  "maxNumberOfRuns": 999,
  "contextDescriptor": {
    "condition": "element_present",
    "elementDescriptors": [
      {
        "resourceId": "my.app.package:id/confirmation_dialog"
      }
    ]
  },
  "actions": [
    {
      "eventType": "VIEW_CLICKED",
      "elementDescriptors": [
        {
          "text": "Cancel"
        }
      ]
    }
  ]
}

פעולות מותנות

תסריט Robo יכול להכיל פעולות מותנות. לפעולות מותנות יש שלושה מאפיינים נוספים שמתארים איך Robo מבצע אותן:

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

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

{
  "id": 1000,
  "actions": [
    {
      "description": "Dismiss popup",
      "maxNumberOfRuns": 100,
      "contextDescriptor": {
        "condition": "default_launcher_shown",
        "negateCondition": true
      },
      "eventType": "GO_HOME"
    },
    {
      "description": "Screen off",
      "eventType": "ADB_SHELL_COMMAND",
      "command": "input keyevent 26"
    },
    {
      "description": "Wait for 10 seconds",
      "eventType": "WAIT",
      "delayTime": 10000
    },
    {
      "description": "Screen on",
      "eventType": "ADB_SHELL_COMMAND",
      "command": "input keyevent 82"
    },
    {
      "description": "Wait for 10 seconds",
      "eventType": "WAIT",
      "delayTime": 10000
    }
}

התעלמות מפעולות

תסריט Robo יכול להכיל הוראות ל-Robo להתעלם מווידג'טים ספציפיים בממשק המשתמש או מכל הווידג'טים בממשק המשתמש במסך מסוים. ההוראות האלה מיוצגות באמצעות התעלמות מ'פעולות' עם eventType ELEMENT_IGNORED ו-ALL_ELEMENTS_IGNORED בהתאמה.

בכל פעם שהמאפיין contextDescriptor של סקריפט Robo שמכיל פעולות התעלמות תואם למסך נתון, Robo לא מקיים אינטראקציה עם אף אחד מווידג'טים של ממשק המשתמש שמכוונים על ידי פעולות ההתעלמות (אלא אם פעולה אחרת של סקריפט Robo גורמת ל-Robo לבצע פעולה באחד מווידג'טים של ממשק המשתמש שהמערכת מתעלמת מהם).

סקריפט Robo יכול להכיל שילוב של פעולות התעלמות, פעולות מותנות ופעולות לא מותנות. בניגוד לפעולות אחרות בסקריפט Robo, פעולות התעלמות מוחלות כל עוד הערך של contextDescriptor בסקריפט Robo שמכיל אותן תואם למסך במהלך סריקת Robo, ללא קשר לערכים של המאפיינים priority ו-maxNumberOfRuns.

דוגמה לקובץ עם שני סקריפטים של Robo: הסקריפט הראשון של Robo גורם ל-Robo להתעלם מכל הווידג'טים של ממשק המשתמש במסך שמכיל ווידג'ט של ממשק משתמש עם מזהה משאב "my.app.package:id/ignored_screen". הסקריפט השני של Robo גורם ל-Robo להתעלם מרכיבי UI שהמזהים שלהם תואמים לביטוי הרגולרי ".*:id/done" ב-Java במסך שמכיל רכיב UI עם מזהה משאב "my.app.package:id/main_screen":

[
  {
    "id": 1000,
    "contextDescriptor": {
      "condition": "element_present",
      "elementDescriptors": [
        {
          "resourceId": "my.app.package:id/ignored_screen"
        }
      ]
    },
    "actions": [
      {
        "eventType": "ALL_ELEMENTS_IGNORED"
      }
    ]
  },
  {
    "id": 1001,
    "contextDescriptor": {
      "condition": "element_present",
      "elementDescriptors": [
        {
          "resourceId": "my.app.package:id/main_screen"
        }
      ]
    },
    "actions": [
      {
        "eventType": "ELEMENT_IGNORED",
        "elementDescriptors": [
          {
            "resourceIdRegex": ".*:id/done"
          }
        ]
      }
    ]
  }
]

תמיכה ב-RecyclerView וב-AdapterView

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

לכן, סקריפט Robo מתעד את מיקומי הנתונים המוחלטים של רכיבי צאצא של RecyclerView שהם יעדים של פעולות סקריפט Robo בתור recyclerViewChildPosition. תסריט Robo גם מתעד את מיקומי הנתונים המוחלטים של רכיבי צאצא של AdapterView שהם יעדים של פעולות תסריט Robo בתור adapterViewChildPosition.

הפעולות ברכיבי צאצא של RecyclerView ו-AdapterView מתבצעות בשלבים הבאים:

1. בדיקת Robo מוודאת שהילד המתאים מוצג במסך באמצעות פעולת מיקום ב-RecyclerView או ב-AdapterView שמכילים אותו.

2. הבדיקה של Robo מבצעת את הפעולה המתועדת ישירות ברכיב הצאצא, כי הוא כבר מוצג במסך.

הדוגמה הבאה מציגה פעולת קליק על רכיב צאצא של AdapterView (android.widget.GridView):

{
  "eventType": "VIEW_CLICKED",
  "elementDescriptors": [
    {
      "className": "com.google.samples.apps.topeka.widget.AvatarView",
      "adapterViewChildPosition": 5,
      "resourceId": "com.google.samples.apps.topeka:id/avatar",
      "contentDescription": "Avatar 6"
    },
    {
      "className": "android.widget.GridView",
      "groupViewChildPosition": 1,
      "resourceId": "com.google.samples.apps.topeka:id/avatars"
    },
    {
      "className": "android.widget.LinearLayout",
      "groupViewChildPosition": 1
    },
    {
      "className": "android.widget.LinearLayout",
      "groupViewChildPosition": 0
    }
  ]
}

הדוגמה הבאה מציגה פעולת לחיצה על רכיב צאצא של RecyclerView ‏(android.support.v7.widget.RecyclerView):

{
  "eventType": "VIEW_CLICKED",
  "elementDescriptors": [
    {
      "className": "android.support.v7.widget.AppCompatTextView",
      "groupViewChildPosition": 1,
      "resourceId": "com.google.samples.apps.topeka:id/category_title"
    },
    {
      "className": "android.widget.FrameLayout",
      "recyclerViewChildPosition": 8,
      "resourceId": "com.google.samples.apps.topeka:id/category_item"
    },
    {
      "className": "android.support.v7.widget.RecyclerView",
      "groupViewChildPosition": 1,
      "resourceId": "com.google.samples.apps.topeka:id/categories"
    },
    {
      "className": "android.widget.FrameLayout",
      "groupViewChildPosition": 1,
      "resourceId": "com.google.samples.apps.topeka:id/category_container"
    },
    {
      "className": "android.widget.LinearLayout",
      "groupViewChildPosition": 0
    }
  ]
}

הקלטת סקריפט Robo ב-Android Studio והרצה שלו ב-Test Lab

אפשר ליצור סקריפט Robo ב-Android Studio, והסקריפט יישמר כקובץ JSON. אחר כך אפשר להעלות את קובץ ה-JSON אל Firebase Test Lab עם האפליקציה ולהריץ את הבדיקה בהתאם.

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

כדי ליצור קובץ JSON של סקריפט Robo ב-Android Studio, פועלים לפי השלבים במאמר הקלטת סקריפט Robo באמצעות Test Lab ב-Android Studio.

פעולות בסקריפט של רובו

המאפיין האופציונלי הנפוץ הבא רלוונטי לכל הפעולות:

• ‫description – עוזר לעקוב אחרי הביצוע של פעולת הסקריפט הזו של Robo בפלט של RoboTest.

טענת נכוֹנוּת (assertion

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

בטבלה הבאה מפורטים מאפייני החובה:

בדוגמה הבאה מוצגת טענת Robo script שבודקת אם האפליקציה שנבדקת נמצאת בחזית:

{
  "eventType": "ASSERTION",
  "contextDescriptor": {
    "condition": "app_under_test_shown"
  }
}

הדוגמה הבאה היא של טענת סקריפט של Robo שבודקת אם ווידג'ט של ממשק משתמש עם מזהה המשאב "com.google.samples.apps.topeka:id/done" מוצג במסך:

{
  "eventType": "ASSERTION",
  "contextDescriptor": {
    "condition": "element_present",
    "elementDescriptors": [
      {
        "resourceId": "com.google.samples.apps.topeka:id/done"
      }
    ]
  }
}

הדוגמה הבאה היא של טענת סקריפט של Robo שבודקת אם "Settings" לא מזוהה במסך באמצעות OCR:

{
  "eventType": "ASSERTION",
  "contextDescriptor": {
    "condition": "element_present",
    "negateCondition": true,
    "visionText": "Settings"
  }
}

קליק

בטבלה הבאה מפורטים מאפייני החובה:

הנה דוגמה לפעולה בסקריפט Robo שלוחצת על לחצן עם מזהה המשאב "com.google.samples.apps.topeka:id/done":

{
  "eventType": "VIEW_CLICKED",
  "elementDescriptors": [
    {
      "resourceId": "com.google.samples.apps.topeka:id/done"
    }
  ]
}

הדוגמה הבאה היא של פעולת סקריפט של Robo שמבצעת קליק על המופע השני של המילה "Search" שזוהתה במסך באמצעות OCR:

{
  "eventType": "VIEW_CLICKED",
  "visionText": "Search",
  "matchIndex": 1
}

הדוגמה הבאה היא של פעולת סקריפט Robo שכוללת קליק על אלמנט של מקלדת וירטואלית עם תיאור תוכן "Emoji button":

{
  "eventType": "SOFT_KEYBOARD_CLICK",
  "elementDescriptors": [
    {
      "contentDescription": "Emoji button"
    }
  ]
}

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

{
  "eventType": "SOFT_KEYBOARD_RANDOM_CLICK",
  "maxNumberOfRuns": 5
}

השבתת המקלדת הווירטואלית

בטבלה הבאה מפורטים מאפייני החובה:

הדוגמה הבאה מציגה פעולה בסקריפט Robo שמשביתה את המקלדת הווירטואלית:

{
  "eventType": "DISABLE_KEYBOARD"
}

הפעלת פקודת adb shell

בטבלה הבאה מפורטים מאפייני החובה:

המאפיין הבא הוא אופציונלי:

• ‫expectedOutputRegex – הפלט הצפוי של הפקודה כביטוי רגולרי של Java. אם הפלט לא תואם, פעולת התסריט של Robo נכשלת. כברירת מחדל, זהו מחרוזת ריקה, כלומר הפלט לא נבדק.

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

{
  "eventType": "ADB_SHELL_COMMAND",
  "command": "pm clear __%APP_PACKAGE_NAME%__"
}

מתן הרשאות

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

בטבלה הבאה מפורטים מאפייני החובה:

התעלמות מכל הרכיבים במסך

הפעולה הזו גורמת ל-Robo להתעלם מכל הרכיבים בכל מסך שמפעיל את סקריפט ה-Robo שמכיל את הפעולה.

בטבלה הבאה מפורטים מאפייני החובה:

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

{
  "eventType": "ALL_ELEMENTS_IGNORED"
}

התעלמות מרכיב

הפעולה הזו גורמת ל-Robo להתעלם מאלמנט (או מאלמנטים) שתואם לelementDescriptors שצוין.

בטבלה הבאה מפורטים מאפייני החובה:

המאפיין הבא הוא אופציונלי:

• ‫ignoreChildren – אם הערך מוגדר כ-true, בדיקת Robo מתעלמת גם מכל צאצאי הווידג'טים של ממשק המשתמש שהמערכת מתעלמת מהם. כברירת מחדל, הערך הוא false.

הדוגמה הבאה מציגה פעולה בסקריפט Robo שגורמת ל-Robo להתעלם מכל הרכיבים שהתיאורים שלהם מתחילים ב-"Avatar":

{
  "eventType": "ELEMENT_IGNORED",
  "elementDescriptors": [
    {
      "contentDescriptionRegex": "Avatar.*"
    }
  ]
}

טקסט קלט

בטבלה הבאה מפורטים מאפייני החובה:

בדוגמה הבאה מוצגת פעולה בסקריפט Robo שמזינה את הערך "John" לווידג'ט בממשק המשתמש עם מזהה המשאב "com.google.samples.apps.topeka:id/first_name":

{
  "eventType": "VIEW_TEXT_CHANGED",
  "replacementText": "John",
  "elementDescriptors": [
    {
      "resourceId": "com.google.samples.apps.topeka:id/first_name"
    }
  ]
}

לחיצה ארוכה

בטבלה הבאה מפורטים מאפייני החובה:

המאפיין הבא הוא אופציונלי:

• ‫delayTime – מציין את משך הזמן של הלחיצה הארוכה של קליק ארוך, באלפיות שנייה.

הנה דוגמה לפעולת סקריפט של Robo שמבצעת קליק למשך חמש שניות על ווידג'ט בממשק המשתמש עם תיאור תוכן "Avatar 8":

{
  "eventType": "VIEW_LONG_CLICKED",
  "elementDescriptors": [
    {
      "contentDescription": "Avatar 8"
    }
  ],
  "delayTime": 5000
}

ביצוע תנועה עם נקודה אחת

בטבלה הבאה מפורטים מאפייני החובה:

המאפיין הבא הוא אופציונלי:

• ‫dragAndDrop – אם מוגדר הערך true, תנועת האצבע האחת מבצעת פעולת גרירה ושחרור. ערך ברירת המחדל הוא false.

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

{
  "eventType": "ONE_POINT_GESTURE",
  "coordinates": "(50%,25%)->(50%,75%)"
}

ביצוע תנועה בשתי אצבעות

בטבלה הבאה מפורטים מאפייני החובה:

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

{
  "eventType": "TWO_POINT_GESTURE",
  "coordinates": "(50%,50%)->(25%,50%),(50%,50%)->(75%,50%)"
}

ביצוע פעולה ב-IME

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

בטבלה הבאה מפורטים מאפייני החובה:

הדוגמה הבאה מציגה פעולת סקריפט של Robo שמבצעת פעולת IME בווידג'ט של ממשק משתמש עם מזהה המשאב "com.google.samples.apps.topeka:id/first_name":

{
  "eventType": "PRESSED_EDITOR_ACTION",
  "elementDescriptors": [
    {
      "resourceId": "com.google.samples.apps.topeka:id/first_name"
    }
  ]
}

לחיצה על 'חזרה'

בטבלה הבאה מפורטים מאפייני החובה:

דוגמה לפעולה בסקריפט Robo שבה לוחצים על 'הקודם':

{
  "eventType": "PRESSED_BACK"
}

לחיצה על הכפתור הראשי

הפעולה הזו שולחת אירוע KEYCODE_HOME למכשיר.

בטבלה הבאה מפורטים מאפייני החובה:

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

{
  "eventType": "GO_HOME"
}

גלילה עד שהרכיב יהיה גלוי לעין

הפעולה הזו גורמת ל-Robo test לגלול קדימה את הווידג'ט של ממשק המשתמש שתואם ל-elementDescriptors שצוין עד שהווידג'ט של ממשק המשתמש שתואם ל-childElementDescriptors שצוין מופיע במסך, או עד שלא ניתן יותר לגלול את הווידג'ט, או עד שמגיעים למספר המקסימלי של 50 גלילות.

בטבלה הבאה מפורטים מאפייני החובה:

הדוגמה הבאה מציגה פעולה של סקריפט Robo שמגללת את הווידג'ט של ממשק המשתמש עם מזהה המשאב "my.app.package:id/scrollable_card_container" עד שהווידג'ט של ממשק המשתמש עם הטקסט "Orange" מוצג במסך (או עד שלא ניתן לבצע עוד גלילות, או עד שמגיעים למספר המקסימלי של 50 גלילות):

{
  "eventType": "ELEMENT_SCROLL_INTO_VIEW",
  "elementDescriptors": [
    {
      "resourceId": "my.app.package:id/scrollable_card_container"
    }
  ],
  "childElementDescriptors": [
    {
      "text": "Orange"
    }
  ]
}

החלקה

בטבלה הבאה מפורטים מאפייני החובה:

הדוגמה הבאה מציגה פעולה בסקריפט Robo שמבצעת החלקה כלפי מעלה בווידג'ט של ממשק המשתמש עם מזהה המשאב "my.app.package:id/custom_content":

{
  "eventType": "VIEW_SWIPED",
  "swipeDirection": "Up",
  "elementDescriptors": [
    {
      "resourceId": "my.app.package:id/custom_content"
    }
  ]
}

צילום מסך

בטבלה הבאה מפורטים מאפייני החובה:

דוגמה לפעולה בסקריפט Robo שמצלמת צילום מסך:

{
  "eventType": "TAKE_SCREENSHOT",
  "screenshotName": "my_screenshot"
}

מקישים על נקודה במסך

בטבלה הבאה מפורטים מאפייני החובה:

הדוגמה הבאה היא של פעולה בסקריפט Robo שמקישה באמצע המסך:

{
  "eventType": "POINT_TAP",
  "pointTapXPercent": 50,
  "pointTapYPercent": 50
}

הקשה על נקודה בתוך אלמנט

בטבלה הבאה מפורטים מאפייני החובה:

הדוגמה הבאה ממחישה פעולת סקריפט של Robo שמזיזה את פס הזזה של סרגל ההתקדמות ימינה:

{
  "eventType": "POINT_TAP_ELEMENT",
  "pointTapXPercent": 80,
  "pointTapYPercent": 50,
  "elementDescriptors": [
    {
      "resourceId": "my.app.package:id/my_seekbar"
    }
  ]
}

סיום הסריקה

הפעולה הזו תפסיק את בדיקת Robo.

בטבלה הבאה מפורטים מאפייני החובה:

הדוגמה הבאה מציגה פעולה בסקריפט Robo שמפסיקה בדיקת Robo:

{
  "eventType": "TERMINATE_CRAWL"
}

המתן

בטבלה הבאה מפורטים מאפייני החובה:

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

{
  "eventType": "WAIT",
  "delayTime": 3000
}

המתנה לרכיב

הפעולה הזו גורמת לבדיקת Robo להמתין עד שרכיב יופיע במסך, עד לזמן הקצוב לתפוגה שצוין.

בטבלה הבאה מפורטים מאפייני החובה:

הדוגמה הבאה מציגה פעולה של סקריפט Robo שממתינה עד 30 שניות להופעת ווידג'ט בממשק המשתמש עם מזהה המשאב "my.app.package:id/confirmation_button" במסך:

{
  "eventType": "WAIT_FOR_ELEMENT",
  "delayTime": 30000,
  "elementDescriptors": [
    {
      "resourceId": "my.app.package:id/confirmation_button"
    }
  ]
}

השלבים הבאים

• איך מריצים סקריפט של Robo