מדריך עזר לסקריפטים של רובו

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

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

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

  • צור את הסקריפט של רובו באופן ידני. (אנדרואיד ו-iOS+)

  • הקלט את התסריט של רובו ולאחר מכן ערוך אותו באופן ידני. (אנדרואיד בלבד)

למידע נוסף על שימוש בסקריפטים של רובו, ראה הפעלת סקריפט של רובו .

מבוא

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

הפעולות הבאות נתמכות ב-iOS+:

  • טַעֲנָה
  • נְקִישָׁה
  • קליק ארוך
  • לִגנוֹב
  • התעלם מכל הרכיבים
  • לַחֲכוֹת
  • קח צילום מסך
  • הפסקת זחילה

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

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

תנאי ההפעלה הבאים בתיאורי הקשר נתמכים ב-iOS+:

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

מִבְנֶה

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

תְכוּנָה תיאור
id מספר שלם שעוזר לעקוב אחר סקריפט Robo זה בפלטי סריקה. ל-Robo יש סקריפטים מובנים של רובו עם id משלהם. למרות שאותו id בסקריפטים שונים של Robo אינו משפיע על ההתנהגות שלהם, הבחנה בין פעולות לתסריטי Robo אלה בפלטי סריקה יכולה להיות מאתגרת. אנו ממליצים להקצות id ייחודי של 1000 ומעלה עבור סקריפטי הרובו שלך כדי למנוע התנגשויות.
description דומה id אבל יותר תיאורית.
crawlStage השלב של זחילה רובו מיישם את התסריט הזה של רובו. כברירת מחדל, זהו שלב הסריקה הראשי.
priority העדיפות של תסריט רובו זה בהשוואה לתסריטים אחרים של רובו. כברירת מחדל, לכל הסקריפטים של Robo יש עדיפות של 1 .
maxNumberOfRuns מציין כמה פעמים במהלך סריקה Robo יכול לבצע סקריפט Robo זה. כברירת מחדל, Robo יכול להפעיל סקריפט Robo פעם אחת.
contextDescriptor מתאר את ההקשר או המצב שמפעילים את סקריפט הרובו הזה. אם מושמט, תנאי ההפעלה של תסריט Robo זה נחשב כמתקיים תמיד; במילים אחרות, התסריט של רובו הוא ללא תנאי.
actions כל הפעולות של התסריט הזה של רובו.

קובץ בודד מכיל אוסף של סקריפט Robo אחד או יותר.

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

[
  {
    "id": 1000,
    "description": "My first Robo script",
    "actions": [
      {
        "eventType": "DISABLE_KEYBOARD"
      }
    ]
  },
  {
    "id": 1001,
    "description": "My second Robo script",
    "actions": [
      {
        "eventType": "PRESSED_BACK"
      }
    ]
  }
]

מתאר הקשר

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

תְכוּנָה תיאור
"condition": "always" תמיד מפעיל סקריפט רובו.
"condition": "element_present" בודק ש-widget של ממשק משתמש התואם elementDescriptors או לטקסט שצוין על-ידי visionText קיים על המסך.
"condition": "element_disabled" בודק ש-widget של ממשק משתמש התואם elementDescriptors קיים על המסך ולא ניתן ליצור איתו אינטראקציה.
"condition": "element_checked" בודק ש-widget של ממשק משתמש התואם elementDescriptors קיים על המסך ומסומן.
"condition": "app_under_test_shown" בודק שהאפליקציה שבבדיקה פועלת בחזית.
"condition": "default_launcher_shown" בודק שמסך הבית של מכשיר מוצג, מה שאומר שאף אפליקציות לא פועלות בחזית.
"condition": "non_roboscript_action_performed" בודק שהפעולות האחרונות nonRoboscriptActionCount שבוצעו על ידי מבחן Robo אינן פעולות סקריפט של Robo.
negateCondition אם מוגדר כ- true , שולל את condition . לדוגמה, אתה יכול להשתמש בתכונה זו כדי לבדוק אם יישומון ממשק משתמש אינו קיים על המסך, או שהאפליקציה הנבדקת אינה פועלת בחזית.
elementDescriptors מתאר אלמנט אחד או יותר המזהים ווידג'ט ממשק משתמש על המסך. הוא משמש בשילוב עם התנאים element_present , element_disabled ו- element_checked . בלעדי הדדית עם visionText . למידע נוסף, ראה מתארי אלמנטים .
visionText טקסט על המסך מזוהה באמצעות ה-API של זיהוי תווים אופטי (OCR). visionText משמש בשילוב עם התנאי element_present . בלעדי הדדית עם elementDescriptors .
nonRoboscriptActionCount מספר פעולות סקריפט רצופות שאינן רובו שבוצעו קודם לכן. הוא משמש בשילוב עם התנאי 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" : "DELAYED_MESSAGE_POSTED",
      "delayTime" : 5000
    }]
}

פעולות

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

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

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

[
  {
    "eventType": "DELAYED_MESSAGE_POSTED",
    "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 אינו משתמש בהתאמה חלקית, דילוג על הפעולה הנוכחית והשעיה . כלומר, התסריט של רובו מבוצע כמבחן מכשור רגיל ונכשל ברגע שלא ניתן לבצע כל אחת מהפעולות שלו. כברירת מחדל, הוא false .
    • notify - אם מוגדר כ- false , סקריפט Robo אינו מציג התראות על המסך בתחילת ובסוף הביצוע שלו. כברירת מחדל, זה true .
  • postscript - אפשרויות ביצוע שהוחלו לאחר השלמת סקריפט Robo:
    • terminate - אם מוגדר כ- true , מבחן Robo מפסיק את הסריקה לאחר השלמת הסקריפט של Robo. כברירת מחדל, הוא false .

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

"roboscript": {
  "executionMode": {
    "strict": true,
    "notify": false
  },
  "postscript": {
    "terminate": true
  }
}
[
  {
    "eventType": "DELAYED_MESSAGE_POSTED",
    "delayTime": 3000
  }
]

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

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

סקריפטים של רובו תומכים בפרמטר התבנית הבא:

  • __%APP_PACKAGE_NAME%__ - שם החבילה של האפליקציה שבבדיקה.

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

[
  {
    "eventType": "ADB_SHELL_COMMAND",
    "command": "am force-stop __%APP_PACKAGE_NAME%__"
  }
]

הערות

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

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

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

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

לְהַשְׁעוֹת אם לא ניתן להתאים פעולות סקריפט נוכחיות או עוקבות של Robo באופן מלא או חלקי, סקריפט Robo מושעה זמנית ובדיקת Robo בוחרת פעולה לביצוע באמצעות האסטרטגיות האחרות שלו. לאחר השלמת פעולה זו, מבחן Robo ממשיך בביצוע הסקריפט של Robo.

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

סדרי עדיפויות

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

  1. יש מאפיין contextDescriptor .
  2. בעל priority הגבוהה ביותר (כברירת מחדל, לכל הסקריפטים של Robo יש אותה priority ביצוע של 1 ).
  3. מופיע הכי מוקדם ברשימת התסריטים של רובו, אם סדרי העדיפויות של התסריטים של רובו זהים.

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

[
  {
    "id": 1000,
    "description": "Robo script 1",
    "contextDescriptor": {
      "condition": "app_under_test_shown"
    },
    "actions": [
      {
        "eventType": "DELAYED_MESSAGE_POSTED",
        "delayTime": 3000
      }
    ]
  },
  {
    "id": 1001,
    "description": "Robo script 2",
    "priority": "2",
    "contextDescriptor": {
      "condition": "app_under_test_shown"
    },
    "actions": [
      {
        "eventType": "DELAYED_MESSAGE_POSTED",
        "delayTime": 3000
      }
    ]
  },
  {
    "id": 1002,
    "description": "Robo script 3",
    "contextDescriptor": {
      "condition": "app_under_test_shown"
    },
    "actions": [
      {
        "eventType": "DELAYED_MESSAGE_POSTED",
        "delayTime": 3000
      }
    ]
  }
]

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

  1. "Robo script 2" כי יש לו את העדיפות הגבוהה ביותר.
  2. "Robo script 1" מכיוון שהוא מופיע מוקדם יותר בין שאר הסקריפטים הישימים של Robo עם אותה עדיפות.
  3. "Robo script 3" כתסריט הרובו האחרון הרלוונטי.

ריצות חוזרות ונשנות

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

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

{
  "id": 1000,
  "maxNumberOfRuns": 10,
  "contextDescriptor": {
    "condition": "app_under_test_shown"
  },
  "actions": [
    {
      "eventType": "GO_HOME"
    }
  ]
}

שלב הזחילה

סקריפטים של רובו ישימים בשלבים שונים של סריקת רובו נתונה:

שלב הזחילה תיאור
pre_crawl לפני שרובו מפעיל ומתחיל לסרוק את האפליקציה שבבדיקה.
post_crawl לאחר שרובו מסיים לסרוק את האפליקציה תחת בדיקה.
crawl שלב הסריקה הראשי, כאשר רובו סורק את האפליקציה שבבדיקה.
close_screen כאשר רובו מנסה לחזור אחורה (לאחור) ממסך נתון, כאשר כל הפעולות האפשריות במסך זה נבדקות. כברירת מחדל, רובו לוחץ לאחור, דבר שאינו רצוי בתרחישים מסוימים.

אם תכונת crawlStage של סקריפט Robo אינה מצוינת, היא משתמעת כ- crawl .

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

{
  "id": 1000,
  "crawlStage": "pre_crawl",
  "actions": [
    {
      "eventType": "ADB_SHELL_COMMAND",
      "command": "pm clear __%APP_PACKAGE_NAME%__"
    }
  ]
}

להלן דוגמה של סקריפט של Robo המורה לרובו ללחוץ על "Cancel" בכל פעם שהוא מנסה לחזור אחורה (במסלול אחורה) מתיבת דו-שיח לאישור:

{
  "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 יכול להכיל פעולות מותנות. לפעולות מותנות יש שלוש תכונות נוספות המתארות כיצד רובו מבצע אותן:

תְכוּנָה תיאור
priority העדיפות של פעולה מותנית זו בהשוואה לפעולות מותנות אחרות בתוך סקריפט Robo המכיל אותה. כברירת מחדל, לכל הפעולות המותנות יש עדיפות של 1 .
maxNumberOfRuns כמה פעמים ניתן לבצע פעולה מותנית זו במהלך ביצוע אחד של סקריפט Robo המכיל. כברירת מחדל, ניתן לבצע את כל הפעולות המותנות לכל היותר פעם אחת בביצוע יחיד של סקריפט Robo המכיל שלהם.
contextDescriptor ההקשר/מצב שמפעיל את הפעולה המותנית הזו. יש לו את אותו מבנה ומציע יכולות דומות כמו [הקונטקסט של סקריפט Robo](#context-descriptor).

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

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

{
  "id": 1000,
  "actions": [
    {
      "description": "Dismiss popup",
      "maxNumberOfRuns": 100,
      "contextDescriptor": {
        "condition": "default_launcher_shown",
        "negateCondition": true
      },
      "eventType": "GO_HOME"
    },
    {
      "description": "Screen off",
      "eventType": "ADB_SHELL_COMMAND",
      "command": "input keyevent 26"
    },
    {
      "description": "Wait for 10 seconds",
      "eventType": "DELAYED_MESSAGE_POSTED",
      "delayTime": 10000
    },
    {
      "description": "Screen on",
      "eventType": "ADB_SHELL_COMMAND",
      "command": "input keyevent 82"
    },
    {
      "description": "Wait for 10 seconds",
      "eventType": "DELAYED_MESSAGE_POSTED",
      "delayTime": 10000
    }
}

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

סקריפט Robo יכול להכיל הוראות ל-Robo להתעלם מווידג'טים ספציפיים של ממשק משתמש או מכל ווידג'טים של ממשק משתמש במסך מסוים. הוראות אלו מיוצגות כהתעלמות מ"פעולות" עם eventType ELEMENT_IGNORED ו- ALL_ELEMENTS_IGNORED בהתאם.

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

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

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

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

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

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

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

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

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

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

להלן דוגמה לפעולת לחיצה על ילד 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
    }
  ]
}

הקלט סקריפט של רובו ב-Android Studio והפעל אותו ב-Test Lab

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

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

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

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

התכונה האופציונלית הנפוצה הבאה חלה על כל הפעולות:

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

טַעֲנָה

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

הטבלה הבאה מפרטת את התכונות הנדרשות:

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

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

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

להלן דוגמה להצהרת סקריפט של Robo הבודקת ש-widget של ממשק משתמש עם מזהה המשאב "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 .
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 שלוחצת על "Privacy Policy" שזוהתה על מסך באמצעות OCR:

{
  "eventType": "VIEW_CLICKED",
  "visionText": "Privacy Policy"
}

להלן דוגמה לפעולת סקריפט 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 Debug Bridge (adb) לביצוע.

התכונה הבאה היא אופציונלית:

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

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

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

הענק הרשאות

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

הטבלה הבאה מפרטת את התכונות הנדרשות:

תְכוּנָה תיאור
"eventType": "PERMISSIONS_REQUEST" --

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

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

הטבלה הבאה מפרטת את התכונות הנדרשות:

תְכוּנָה תיאור
"eventType": "ALL_ELEMENTS_IGNORED" --

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

{
  "eventType": "ALL_ELEMENTS_IGNORED"
}

התעלם מאלמנט

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

הטבלה הבאה מפרטת את התכונות הנדרשות:

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

התכונה הבאה היא אופציונלית:

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

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

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

הקלד טקסט

הטבלה הבאה מפרטת את התכונות הנדרשות:

תְכוּנָה תיאור
eventType מציין את סוג פעולת הסקריפט של Robo.
"eventType": "VIEW_TEXT_CHANGED" מזין את הטקסט הנתון לווידג'ט ממשק המשתמש היעד.
"eventType": "ENTER_TEXT" מזין את הטקסט הנתון לתוך הווידג'ט של ממשק המשתמש ולאחר מכן שולח אירוע KEYCODE_ENTER לווידג'ט ממשק המשתמש הזה.
elementDescriptors מזהה את יישומון ממשק המשתמש היעד באמצעות היררכיית ממשק המשתמש של אנדרואיד.
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 מזהה את יישומון ממשק המשתמש היעד באמצעות היררכיית ממשק המשתמש של אנדרואיד. בלעדי הדדית עם visionText .
visionText מזהה את הרכיב שלוחץ ארוך באמצעות OCR. בלעדי הדדית עם elementDescriptors .

התכונה הבאה היא אופציונלית:

  • 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)" כאחוזים או פיקסלים.

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

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

בצע פעולת IME

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

הטבלה הבאה מפרטת את התכונות הנדרשות:

תְכוּנָה תיאור
"eventType": "PRESSED_EDITOR_ACTION" --
elementDescriptors מזהה את יישומון ממשק המשתמש היעד באמצעות היררכיית ממשק המשתמש של אנדרואיד.

להלן דוגמה לפעולת סקריפט 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 של emulators.

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

{
  "eventType": "PRESSED_BACK"
}

לחץ על הבית

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

הטבלה הבאה מפרטת את התכונות הנדרשות:

תְכוּנָה תיאור
"eventType": "GO_HOME" --

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

{
  "eventType": "GO_HOME"
}

גלול אלמנט לתצוגה

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

הטבלה הבאה מפרטת את התכונות הנדרשות:

תְכוּנָה תיאור
"eventType": "ELEMENT_SCROLL_INTO_VIEW" --
elementDescriptors מזהה את הווידג'ט של ממשק המשתמש הגלילה באמצעות היררכיית ממשק המשתמש של אנדרואיד.
childElementDescriptors מזהה את ווידג'ט ממשק המשתמש לגלול אליו באמצעות היררכיית ממשק המשתמש של אנדרואיד.

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

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

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

קח צילום מסך

הטבלה הבאה מפרטת את התכונות הנדרשות:

תְכוּנָה תיאור
"eventType": "TAKE_SCREENSHOT" --
screenshotName מציין את שם קובץ צילום המסך.

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

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

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

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

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

הטבלה הבאה מפרטת את התכונות הנדרשות:

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

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

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

הפסקת זחילה

פעולה זו עוצרת את מבחן הרובו.

הטבלה הבאה מפרטת את התכונות הנדרשות:

תְכוּנָה תיאור
"eventType": "TERMINATE_CRAWL" --

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

{
  "eventType": "TERMINATE_CRAWL"
}

לַחֲכוֹת

הטבלה הבאה מפרטת את התכונות הנדרשות:

תְכוּנָה תיאור
"eventType": "DELAYED_MESSAGE_POSTED" --
delayTime מציין כמה זמן לחכות, באלפיות שניות.

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

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

חכה לאלמנט

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

הטבלה הבאה מפרטת את התכונות הנדרשות:

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

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

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

הצעדים הבאים