דף זה תורגם על ידי Cloud Translation API.

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

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

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

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

מאפיין	תיאור
`id`	מספר שלם שעוזר לעקוב אחרי סקריפט Robo הזה בפלט של הסריקה. ל-Robo יש סקריפטים מובנים של Robo עם `id` משלהם. למרות ששימוש באותו `id` בסקריפטים שונים של Robo לא משפיע על ההתנהגות שלהם, יכול להיות שיהיה קשה להבחין בין פעולות מהסקריפטים האלה בפלט של הסריקה. כדי למנוע התנגשויות, מומלץ להקצות לסקריפטים של Robo ערך ייחודי `id` של `1000` ומעלה.
`description`	דומה ל`id` אבל יותר תיאורי.
`crawlStage`	השלב בסריקה שבו סקריפט Robo מופעל. כברירת מחדל, זהו שלב הסריקה הראשי.
`priority`	העדיפות של סקריפט Robo הזה בהשוואה לסקריפטים אחרים של Robo. כברירת מחדל, לכל סקריפטי Robo יש עדיפות של `1`.
`maxNumberOfRuns`	ההגדרה קובעת כמה פעמים במהלך סריקה Robo יכול להריץ את סקריפט Robo הזה. כברירת מחדל, Robo יכול להריץ סקריפט Robo פעם אחת.
`contextDescriptor`	מתאר את ההקשר או התנאי שמפעילים את סקריפט ה-Robo הזה. אם לא מציינים תנאי, התנאי להפעלת סקריפט ה-Robo הזה נחשב כמתקיים תמיד. במילים אחרות, סקריפט ה-Robo הוא ללא תנאי.
`actions`	כל הפעולות של סקריפט ה-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 באמצעות מאפיין אחד או שילוב של כמה מאפיינים:

מאפיין	תיאור
`"condition": "always"`	תמיד מפעיל סקריפט של Robo.
`"condition": "element_present"`	בודקת אם ווידג'ט בממשק המשתמש שתואם ל-`elementDescriptors` או לטקסט שצוין על ידי `visionText` מוצג במסך.
`"condition": "element_disabled"`	בודקת אם יש בווידג'ט בממשק המשתמש שמתאים ל-`elementDescriptors` במסך, ואי אפשר לבצע בו אינטראקציה.
`"condition": "element_checked"`	בודקת אם ווידג'ט של ממשק משתמש שתואם ל-`elementDescriptors` מוצג במסך ומסומן.
`"condition": "app_under_test_shown"`	בודקת שהאפליקציה שנבדקת פועלת בחזית.
`"condition": "default_launcher_shown"`	בודק שמסך הבית של המכשיר מוצג, כלומר שאף אפליקציה לא פועלת בחזית.
`"condition": "non_roboscript_action_performed"`	בודק ש`nonRoboscriptActionCount` הפעולות הרצופות האחרונות שבוצעו על ידי Robo test לא היו פעולות של Robo script.
`negateCondition`	אם הערך הוא `true`, התנאי `condition` מבוטל. לדוגמה, אפשר להשתמש במאפיין הזה כדי לבדוק אם רכיב גרפי של ממשק משתמש לא מוצג במסך, או אם האפליקציה שנבדקת לא פועלת בחזית.
`elementDescriptors`	תיאור אלמנט אחד או יותר שמזהה ווידג'ט בממשק המשתמש במסך. הוא משמש בשילוב עם התנאים `element_present`,‏ `element_disabled` ו-`element_checked`. המאפיין הזה בלעדי למאפיין `visionText`. מידע נוסף זמין במאמר Element descriptors.
`visionText`	טקסט במסך מזוהה באמצעות Optical Character Recognition (OCR) API. ‫`visionText` משמש בשילוב עם התנאי `element_present`. בלעדי עם `elementDescriptors`.
`nonRoboscriptActionCount`	מספר הפעולות הרצופות שלא בוצעו על ידי סקריפט Robo לפני כן. הוא משמש בשילוב עם התנאי `non_roboscript_action_performed` כדי להפעיל סקריפט Robo אחרי כל `nonRoboscriptActionCount` פעולות Robo. ערך ברירת המחדל הוא `1`.

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

מאפיין	תיאור
`eventType`	מציין את סוג הפעולה, לדוגמה, קליק, עריכת טקסט וכו'. חובה לכל פעולה.
`elementDescriptors`	תיאורים שמזהים ווידג'ט בממשק משתמש. חובה לכל הפעולות שיש להן ווידג'ט של ממשק משתמש כיעד, כמו לחיצה על לחצן מסוים.
`optional`	אם הערך הוא `true`, המערכת מדלגת על הפעולה הזו אם אי אפשר לבצע אותה. לדוגמה, הפעולה הזו תדלג אם היא לא תמצא את הווידג'ט של ממשק המשתמש שלה במסך – בלי שהסקריפט המכיל של Robo ייכשל. ערך ברירת המחדל הוא `false`.
`replacementText`	הטקסט שיוזן בווידג'ט של ממשק המשתמש של היעד. חובה לפעולות של עריכת טקסט.
`swipeDirection`	מציין את כיוון ההחלקה. חובה להגדיר פעולות החלקה.
`delayTime`	מציינת את משך ההמתנה באלפיות שנייה. חובה לפעולות המתנה.
`pointTapXCoordinate` וגם `pointTapYCoordinate`	הקואורדינטות X ו-Y של הפיקסל בנקודה שבה לוחצים על המסך. בלעדי עם `pointTapXPercent` ועם `pointTapYPercent`. חובה לפעולות של הקשה על נקודה.
`pointTapXPercent` וגם `pointTapYPercent`	הקואורדינטות X ו-Y באחוזים של הנקודה שבה התרחשה ההקשה. בלעדי עם `pointTapXCoordinate` ועם `pointTapYCoordinate`. חובה לפעולות של הקשה על נקודה.

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

[
  {
    "eventType": "WAIT",
    "delayTime": 3000
  },
  {
    "eventType": "PRESSED_BACK"
  }
]

תיאורי אלמנטים

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

מאפיין	תיאור
`className`	–
`ancestorClassName`	שם המחלקה של רכיב האב בהיררכיית ממשק המשתמש של הרכיב. ישות אב היא כל אחד מצמתי ההורה בהיררכיית ממשק המשתמש של הרכיב, כולל הרכיב עצמו.
`resourceId`	–
`resourceIdRegex`	ביטוי רגולרי ב-Java שמתאים ל-`resourceId`.
`contentDescription`	–
`contentDescriptionRegex`	ביטוי רגולרי ב-Java שמתאים ל-`contentDescription`.
‫`text` (שמופיע במסך)	–
`textRegex`	ביטוי רגולרי ב-Java שמתאים ל-`text`.
`groupViewChildPosition`, `recyclerViewChildPosition`, או `adapterViewChildPosition`	מייצג את מיקום הצאצא של רכיב גרפי בממשק המשתמש, בהתאם לסוג רכיב ההורה שלו.

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

עדיפויות

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

כולל מאפיין contextDescriptor.
הערך הכי גבוה של priority (כברירת מחדל, לכל סקריפטים של Robo יש אותו priority של 1).
מופיע הכי מוקדם ברשימת סקריפטים של 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 מפעיל את הפעולות הבאות, לפי הסדר:

‫"Robo script 2" כי יש לו את העדיפות הכי גבוהה.
"Robo script 1" כי הוא מופיע מוקדם יותר בין סקריפטים רלוונטיים של Robo שנותרו עם אותה עדיפות.
‫"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 נתונה:

שלב הסריקה	תיאור
`pre_crawl`	לפני ש-Robo מופעל ומתחיל לסרוק את האפליקציה שנבדקת.
`post_crawl`	אחרי ש-Robo מסיים לסרוק את האפליקציה שנבדקת. אורך הסקריפט של הרובוט לא יכול להיות יותר מ-15 שניות, אחרת יכול להיות שהסריקה תסתיים בטיימ-אאוט.`post_crawl`
`crawl`	שלב הסריקה הראשי, שבו Robo סורק את האפליקציה שנבדקת.
`close_screen`	כש-Robo מנסה לחזור (backtrack) ממסך מסוים, אחרי שהוא בודק את כל הפעולות האפשריות במסך הזה. כברירת מחדל, 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 מבצע אותן:

מאפיין	תיאור
`priority`	העדיפות של הפעולה המותנית הזו בהשוואה לפעולות מותנות אחרות בסקריפט Robo שמכיל אותה. כברירת מחדל, לכל הפעולות המותנות יש עדיפות של `1`.
`maxNumberOfRuns`	כמה פעמים אפשר לבצע את הפעולה המותנית הזו במהלך הרצה אחת של סקריפט Robo שמכיל אותה. כברירת מחדל, אפשר לבצע את כל הפעולות המותנות פעם אחת לכל היותר בהרצה אחת של סקריפט Robo שמכיל אותן.
`contextDescriptor`	ההקשר או התנאי שמפעילים את הפעולה המותנית הזו. יש לו את אותו המבנה והוא מציע יכולות דומות ל-contextDescriptor של סקריפט 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 להתעלם מרכיבי 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 מתבצעות בשלבים הבאים:

בדיקת Robo מוודאת שהילד המתאים מוצג במסך באמצעות פעולת מיקום ב-RecyclerView או ב-AdapterView שמכילים אותו.
הבדיקה של 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 תיפסק בגלל טענת אימות שנכשלה.

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

מאפיין	תיאור
`"eventType": "ASSERTION"`	--
`contextDescriptor`	מתאר את ההקשר או התנאי שצוינו. המבנה שלו זהה למבנה של ה-contextDescriptor של סקריפט Robo, והוא מציע יכולות דומות.

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

{
  "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"
  }
}

קליק

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

מאפיין	תיאור
`eventType`	מציין את סוג הפעולה של סקריפט Robo.
`"eventType": "VIEW_CLICKED"`	לוחץ על אלמנט היעד של האפליקציה שנבדקת.
`"eventType": "SOFT_KEYBOARD_CLICK"`	לוחץ על אלמנט היעד של המקלדת הווירטואלית.
`"eventType": "SOFT_KEYBOARD_RANDOM_CLICK"`	מבצע קליקים אקראיים ברכיבים של המקלדת הווירטואלית עד `maxNumberOfRuns` פעמים.
`"eventType": "LIST_ITEM_CLICKED"`	המאפיין הזה משמש את כלי ההקלטה של סקריפטים של Robo ב-Android Studio ללחיצה על פריטים ברשימה.
`elementDescriptors`	מזהה את הווידג'ט של ממשק המשתמש שנלחץ באמצעות ההיררכיה של ממשק המשתמש של Android. המאפיין הזה בלעדי למאפיין `visionText`.
`visionText`	מזהה את הרכיב שנלחץ באמצעות OCR. בלעדי עם `elementDescriptors`.
`matchIndex`	מציין את האינדקס של המופע של רכיב היעד התואם, כשמזהים את רכיב היעד באמצעות `visionText`. אם הוא `0`, פעולת הסקריפט של Robo בוחרת את הרכיב הראשון שתואם, אם הוא `1`, פעולת הסקריפט של Robo בוחרת את הרכיב השני שתואם, וכן הלאה. הסדר נקבע משמאל לימין ומלמעלה למטה. ערך ברירת המחדל הוא `0` (ההתאמה הראשונה נבחרת).
`maxNumberOfRuns`	מציין כמה פעמים ללחוץ על רכיב אקראי במקלדת הרכה, כאשר `eventType` הוא `SOFT_KEYBOARD_RANDOM_CLICK`. ערך ברירת המחדל הוא `1`.

הנה דוגמה לפעולה בסקריפט 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
}

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

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

מאפיין	תיאור
`"eventType": "DISABLE_KEYBOARD"`	--

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

{
  "eventType": "DISABLE_KEYBOARD"
}

הפעלת פקודת adb shell

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

מאפיין	תיאור
`"eventType": "ADB_SHELL_COMMAND"`	--
`command`	פקודת המעטפת של ממשק הגישור של Android‏ (adb) להפעלה.

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

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

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

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

מתן הרשאות

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

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

מאפיין	תיאור
`"eventType": "PERMISSIONS_REQUEST"`	--

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

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

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

מאפיין	תיאור
`"eventType": "ALL_ELEMENTS_IGNORED"`	--

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

{
  "eventType": "ALL_ELEMENTS_IGNORED"
}

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

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

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

מאפיין	תיאור
`"eventType": "ELEMENT_IGNORED"`	--
`elementDescriptors`	מזהה את הווידג'טים של ממשק המשתמש שהמערכת התעלמה מהם באמצעות ההיררכיה של ממשק המשתמש ב-Android.

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

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

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

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

טקסט קלט

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

מאפיין	תיאור
`eventType`	מציין את סוג הפעולה של סקריפט Robo.
`"eventType": "VIEW_TEXT_CHANGED"`	הזנת הטקסט הנתון בווידג'ט של ממשק המשתמש של היעד.
`"eventType": "ENTER_TEXT"`	מזין את הטקסט הנתון לווידג'ט של ממשק המשתמש של היעד, ואז שולח אירוע `KEYCODE_ENTER` לווידג'ט הזה של ממשק המשתמש.
`elementDescriptors`	מזהה את הווידג'ט של ממשק המשתמש של היעד באמצעות היררכיית ממשק המשתמש של Android.
`replacementText`	הטקסט שיוזן בווידג'ט של ממשק המשתמש של היעד.

בדוגמה הבאה מוצגת פעולה בסקריפט 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"
    }
  ]
}

לחיצה ארוכה

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

מאפיין	תיאור
`"eventType": "VIEW_LONG_CLICKED"`	--
`elementDescriptors`	מזהה את הווידג'ט של ממשק המשתמש של היעד באמצעות היררכיית ממשק המשתמש של Android. לא כולל `visionText`.
`visionText`	מזהה את האלמנט שלחיצה ארוכה עליו בוצעה באמצעות OCR. בלעדי עם `elementDescriptors`.
`matchIndex`	מציין את האינדקס של המופע של רכיב היעד התואם, כשמזהים את רכיב היעד באמצעות `visionText`. אם הוא `0`, פעולת הסקריפט של Robo בוחרת את הרכיב הראשון שתואם, אם הוא `1`, פעולת הסקריפט של Robo בוחרת את הרכיב השני שתואם, וכן הלאה. הסדר נקבע משמאל לימין ומלמעלה למטה. ערך ברירת המחדל הוא `0` (ההתאמה הראשונה נבחרת).

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

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

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

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

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

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

מאפיין	תיאור
`"eventType": "ONE_POINT_GESTURE"`	--
`coordinates`	שתי קואורדינטות של תנועת מגע בנקודה אחת, בפורמט (x1,y1)->(x2,y2) כאחוזים או כפיקסלים.

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

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

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

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

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

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

מאפיין	תיאור
`"eventType": "TWO_POINT_GESTURE"`	--
`coordinates`	ארבעה קואורדינטות של תנועת מגע בשתי נקודות, בפורמט ‎"(x1,y1)->(x2,y2),(x3,y3)->(x4,y4)" כאחוזים או כפיקסלים.

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

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

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

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

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

מאפיין	תיאור
`"eventType": "PRESSED_EDITOR_ACTION"`	--
`elementDescriptors`	מזהה את הווידג'ט של ממשק המשתמש של היעד באמצעות היררכיית ממשק המשתמש של Android.

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

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

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

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

מאפיין	תיאור
`eventType`	מציין את סוג הפעולה של סקריפט Robo.
`"eventType": "PRESSED_BACK"`	שליחת אירוע `KEYCODE_BACK` למכשיר.
`"eventType": "PRESSED_BACK_EMULATOR_28"`	משמש את כלי ההקלטה של סקריפטים של Robo ב-Android Studio להקשה על 'הקודם' בסימולטורים API 28.

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

{
  "eventType": "PRESSED_BACK"
}

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

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

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

מאפיין	תיאור
`"eventType": "GO_HOME"`	--

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

{
  "eventType": "GO_HOME"
}

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

הפעולה הזו גורמת ל-Robo test לגלול קדימה את הווידג'ט של ממשק המשתמש שתואם ל-elementDescriptors שצוין עד שהווידג'ט של ממשק המשתמש שתואם ל-childElementDescriptors שצוין מופיע במסך, או עד שלא ניתן יותר לגלול את הווידג'ט, או עד שמגיעים למספר המקסימלי של 50 גלילות.

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

מאפיין	תיאור
`"eventType": "ELEMENT_SCROLL_INTO_VIEW"`	--
`elementDescriptors`	מזהה את הווידג'ט של ממשק המשתמש שבו מתבצעת הגלילה באמצעות היררכיית ממשק המשתמש של Android.
`childElementDescriptors`	מזהה את הווידג'ט בממשק המשתמש שאליו רוצים לגלול באמצעות ההיררכיה של ממשק המשתמש ב-Android.

הנה דוגמה לפעולה בסקריפט 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"
    }
  ]
}

החלקה

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

מאפיין	תיאור
`"eventType": "VIEW_SWIPED"`	--
`swipeDirection`	מציין את כיוון ההחלקה: `Left` `Right` `Up` `Down` ‫`Forward` – `Down` או `Right`, בהתאם לאפשרות הגלילה האנכית או האופקית של הווידג'ט בממשק המשתמש של היעד. ‫`Backward` – `Up` או `Left`, בהתאם לאפשרות הגלילה האנכית או האופקית של הווידג'ט של ממשק המשתמש של היעד.
`elementDescriptors`	מזהה את הווידג'ט של ממשק המשתמש של היעד באמצעות היררכיית ממשק המשתמש של Android.

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

{
  "eventType": "VIEW_SWIPED",
  "swipeDirection": "Up",
  "elementDescriptors": [
    {
      "resourceId": "my.app.package:id/custom_content"
    }
  ]
}

צילום מסך

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

מאפיין	תיאור
`"eventType": "TAKE_SCREENSHOT"`	--
`screenshotName`	מציין את שם הקובץ של צילום המסך.

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

{
  "eventType": "TAKE_SCREENSHOT",
  "screenshotName": "my_screenshot"
}

מקישים על נקודה במסך

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

מאפיין	תיאור
`"eventType": "POINT_TAP"`	--
`pointTapXCoordinate`	קואורדינטת ה-X של הפיקסל בנקודה שבה התבצעה ההקשה. המאפיין הזה בלעדי למאפיינים `pointTapXPercent` ו-`pointTapYPercent`.
`pointTapYCoordinate`	קואורדינטת ה-Y של הפיקסל של הנקודה שבה הקשקשתם. המאפיין הזה בלעדי למאפיינים `pointTapXPercent` ו-`pointTapYPercent`.
`pointTapXPercent`	קואורדינטת ה-X של הנקודה שבה לוחצים על המסך, באחוזים. המאפיין הזה בלעדי למאפיינים `pointTapXCoordinate` ו-`pointTapYCoordinate`.
`pointTapYPercent`	קואורדינטת ה-Y של הנקודה שבה הקשתם, באחוזים. המאפיין הזה בלעדי למאפיינים `pointTapXCoordinate` ו-`pointTapYCoordinate`.

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

{
  "eventType": "POINT_TAP",
  "pointTapXPercent": 50,
  "pointTapYPercent": 50
}

הקשה על נקודה בתוך אלמנט

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

מאפיין	תיאור
`"eventType": "POINT_TAP_ELEMENT"`	--
`pointTapXPercent`	קואורדינטת ה-X באחוזים בתוך רכיב היעד.
`pointTapYPercent`	קואורדינטת ה-Y באחוזים בתוך רכיב היעד.
`elementDescriptors`	מזהה את הווידג'ט של ממשק המשתמש של היעד באמצעות היררכיית ממשק המשתמש של Android.

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

{
  "eventType": "POINT_TAP_ELEMENT",
  "pointTapXPercent": 80,
  "pointTapYPercent": 50,
  "elementDescriptors": [
    {
      "resourceId": "my.app.package:id/my_seekbar"
    }
  ]
}

סיום הסריקה

הפעולה הזו תפסיק את בדיקת Robo.

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

מאפיין	תיאור
`"eventType": "TERMINATE_CRAWL"`	--

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

{
  "eventType": "TERMINATE_CRAWL"
}

המתן

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

מאפיין	תיאור
`"eventType": "WAIT" (or "DELAYED_MESSAGE_POSTED")`	--
`delayTime`	מציינת את משך ההמתנה באלפיות שנייה.

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

{
  "eventType": "WAIT",
  "delayTime": 3000
}

המתנה לרכיב

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

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

מאפיין	תיאור
`"eventType": "WAIT_FOR_ELEMENT"`	--
`delayTime`	מציין את זמן ההמתנה הקצוב לתפוגה, באלפיות השנייה.
`elementDescriptors`	מזהה את הווידג'ט של ממשק המשתמש שהמתין באמצעות ההיררכיה של ממשק המשתמש ב-Android.

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

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

השלבים הבאים

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

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

מבוא

תמיכה ב-iOS+ בסקריפטים של Robo

מבנה

תיאור הקשר

פעולות

תיאורי אלמנטים

אפשרויות הביצוע

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

תגובות

יכולות

עדיפויות

הפעלות חוזרות

שלב הסריקה

פעולות מותנות

התעלמות מפעולות

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

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

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

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

קליק

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

הפעלת פקודת adb shell

מתן הרשאות

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

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

טקסט קלט

לחיצה ארוכה

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

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

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

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

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

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

החלקה

צילום מסך

מקישים על נקודה במסך

הקשה על נקודה בתוך אלמנט

סיום הסריקה

המתן

המתנה לרכיב

השלבים הבאים

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