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

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

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

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

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

  • מקליטים את סקריפט הרובוט ואז עורכים אותו באופן ידני. (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 האלה בפלט של הסריקה. כדי למנוע התנגשויות, מומלץ להקצות לסקריפטים של 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. מידע נוסף זמין במאמר מתארי רכיבים.
visionText הטקסט במסך מזוהה באמצעות API של זיהוי תווים אופטי (OCR). ‫visionText משמש בשילוב עם התנאי element_present. המאפיין הזה בלעדי למאפיין elementDescriptors.
nonRoboscriptActionCount מספר הפעולות הרצופות שלא בוצעו על ידי סקריפט Robo לפני כן. הוא משמש בשילוב עם התנאי non_roboscript_action_performed כדי להפעיל סקריפט Robo אחרי כל פעולת Robo nonRoboscriptActionCount. כברירת מחדל, הערך הוא 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 תצטרך "למלא את הפערים" באמצעות הפעולות הרגילות שלה.

עדיפויות

אם סקריפט Robo מגיע לmaxNumberOfRuns, אי אפשר יותר להפעיל אותו בסריקה נתונה. אם יש יותר מסקריפט 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 נתונה:

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

סקריפט 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 ב-Android Studio, פועלים לפי השלבים במאמר בנושא הקלטת סקריפט Robo באמצעות Test Lab ב-Android Studio.

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

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

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

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

אם התנאי שצוין הוא true, סקריפט ה-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) של רכיב ה-UI שצוין כיעד.

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

מאפיין תיאור
"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"
    }
  ]
}

השלבים הבאים