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

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

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

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

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

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

איך מריצים סקריפט 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