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

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

אפשר ליצור תסריט 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"
      }
    ]
  }
]

מאפיין לתיאור ההקשר

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

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

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

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