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

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

תסריטי 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 להתעלם מרכיבי UI ספציפיים או מכל רכיבי ה-UI במסך מסוים. ההוראות האלה מיוצגות כהתעלמות מ'פעולות' באמצעות eventType ELEMENT_IGNORED ו-ALL_ELEMENTS_IGNORED בהתאמה.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

איך מקליטים סקריפט של Robo ב-Android Studio ומריצים אותו ב-Test Lab

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

קליק

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

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

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

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

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

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

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

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

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

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

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

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

{
  "eventType": "DISABLE_KEYBOARD"
}

הרצת פקודת adb shell

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

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

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

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

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

מתן הרשאות

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

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

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

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

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

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

{
  "eventType": "ALL_ELEMENTS_IGNORED"
}

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

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

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

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

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

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

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

טקסט קלט

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

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

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

לחיצה ארוכה

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{
  "eventType": "PRESSED_BACK"
}

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

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

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

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

{
  "eventType": "GO_HOME"
}

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

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

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

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

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

השלבים הבאים

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