מדריך עזר לסקריפטים 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+:

• הצהרת בעלות
• קליק
• לחיצה ארוכה
• החלקה
• התעלמות מכל הרכיבים
• המתן
• צילום מסך
• סיום הסריקה

המאפיינים המזהים הבאים בתיאור הרכיבים נתמכים ב-iOS ואילך:

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

תנאי ההפעלה הבאים בתיאור ההקשר נתמכים ב-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" : "DELAYED_MESSAGE_POSTED",
      "delayTime" : 5000
    }]
}

פעולות

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

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

[
  {
    "eventType": "DELAYED_MESSAGE_POSTED",
    "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": "DELAYED_MESSAGE_POSTED",
    "delayTime": 3000
  }
]

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

פרמטר תבנית הוא placeholder בסקריפט של Robo שמוחליף את הערך בפועל כשבדיקת 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 script נעשה שימוש בשיטות הבאות:

עדיפויות

אם סקריפט 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": "DELAYED_MESSAGE_POSTED",
        "delayTime": 3000
      }
    ]
  },
  {
    "id": 1001,
    "description": "Robo script 2",
    "priority": "2",
    "contextDescriptor": {
      "condition": "app_under_test_shown"
    },
    "actions": [
      {
        "eventType": "DELAYED_MESSAGE_POSTED",
        "delayTime": 3000
      }
    ]
  },
  {
    "id": 1002,
    "description": "Robo script 3",
    "contextDescriptor": {
      "condition": "app_under_test_shown"
    },
    "actions": [
      {
        "eventType": "DELAYED_MESSAGE_POSTED",
        "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 שמנקה את נתוני המשתמש של האפליקציה בבדיקה לפני שהיא מתחילה לסרוק אותם:

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

{
  "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": "DELAYED_MESSAGE_POSTED",
      "delayTime": 10000
    },
    {
      "description": "Screen on",
      "eventType": "ADB_SHELL_COMMAND",
      "command": "input keyevent 82"
    },
    {
      "description": "Wait for 10 seconds",
      "eventType": "DELAYED_MESSAGE_POSTED",
      "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"
}

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

הפעולה הזו גורמת ל-Robotest לגלול קדימה את הווידג'ט של ממשק המשתמש שתואם ל-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": "DELAYED_MESSAGE_POSTED",
  "delayTime": 3000
}

המתנה לרכיב

הפעולה הזו גורמת ל-Robo Test להמתין לאלמנט שיופיע במסך עד לתפוגת הזמן שצוינה.

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

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

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

השלבים הבאים

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