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

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

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

• משתמשים בתכונה "הקלטת סקריפט Robo". (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"
      }
    ]
  }
]

תיאור ההקשר

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

הדוגמה הבאה היא של סקריפט 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 עם שתי פעולות בלי ווידג'טים של ממשק משתמש, כלומר הפעולות האלה לא פועלות על ווידג'ט ספציפי של ממשק משתמש:

[
  {
    "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 שמציין את אפשרויות ההפעלה של הסקריפט. כותרת ההגדרה הזו מתחילה במילת המפתח 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
  }
]

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

פרמטר תבנית הוא פלייסהולדר בסקריפט 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 מגיע ל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" בכל פעם שהוא מנסה לחזור אחורה (backtrack) מתיבת דו-שיח של אישור:

{
  "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 להתעלם מווידג'טים של ממשק המשתמש שמזהי המשאבים שלהם תואמים לביטוי הרגולרי של Java‏ ".*:id/done" במסך שמכיל ווידג'ט של ממשק המשתמש עם מזהה המשאב "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.

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

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

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

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

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

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

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

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

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

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

הדוגמה הבאה היא טענת נכוֹנוּת (assertion) של סקריפט 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

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

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

• ‫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 לגלול קדימה את הווידג'ט של ממשק המשתמש שתואם ל-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