תבנית עיצוב COM לאוטומציה עם סלניום וקוקומבר

הַתְּצוּרָה שֶׁל אוֹבֵיֶקט הַרְכַּבָּה (COM) הִיא דֶגֶם עֵיצוּב שֶׁמַּאפשֵׁר לָך לְמַַדֵר אֶת הַבִּדְקוֹת בִּפְרוֹיֶקטִים שֶׁל אוֹטוֹמַצִיָּה שֶׁל בִּדְקוֹת. מוּסָרַת עַל יְדֵי הַדֶגֶם הַפּוֹפוּלָרִי שֶׁל מוֹדֶל עַמוּד הַאוֹבֵיֶקט (POM), COM עוֹבֵר עַל טִיפוּסִים שְׁלֵמִים וּמְתַמֵּךְ בִּרכֻזִים סְפֵצִיפִיִּים שֶׁל מַמְעִילִי מַמְשֵׁג, כְּגוֹן כְּפָפוֹת, שָׂדוֹת טֵקְסְט, תַּפְלִית נְפִילוֹת, אוֹ אֵלֶמֶנטִים שֶׁנִּשְׁתַּמֵּשׁ בָּהֶם שֹׁנִים.

בְּמַסְלוּל זֶה, אֲנַחְנוּ נַבְחִין אֵיך לְיַצֵּר אֶת COM כְּדֵי לְבַדוֹק אֲפַלִיקַצְיָה אֲנַגוּלִית עִם נוֹהֵג נְסִיעָה שֶׁל Selenium וְCucumber וְאֵיך גַּם גַּם הַגִּישָׁה הַזֹּאת עוֹשָׁה אֶת הַבִּדְקוֹת שֶׁלְּךָ יוֹתֵר גֻּמְלִיּוֹת, מוֹדוּלָרִיּוֹת, וּקְלִילוֹת יוֹתֵר לְתִחְזֵק.

מַה הוּא הַדֶגֶם שֶׁל אוֹבֵיֶקט הַרְכַּבָּה?

הַתְּצוּרָה שֶׁל אוֹבֵיֶקט הַרְכַּבָּה (COM) הִיא הַתְּגִיּוּת שֶׁל מוֹדֶל עַמוּד. בְּמָקוֹם לִמְדֹל אוֹתוֹ עַמוּד כְּאוֹבֵיֶקט עִם שִׁיטוֹת שַׁפְעָה עַל כָּל מַמְשֵׁג הָעַמוּד, COM מַפְרִיד אֶת מַמְעִיל הַמַמְשֵׁג לְרִכְלָאוֹת יְחִידוֹת, כְּמוֹ:

• כְּפָפוֹת
• שָׂדוֹת טֵקְסְט
• תַּפְלִית נְפִילוֹת
• סְרָגִים חַיְפָה
• שֻׁלְחָנוֹת

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

למה להשתמש ב-COM במקום POM?

1. רמת רפידה גבוהה

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

2. יכולת חוזרת וגמישות

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

3. תחזוקה פשוטה

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

4. מותאם לממשקים דינמיים

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

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

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

6. מניעת חזרה על עבודה בין בודקים

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

ארכיטקטורת פרוייקט COM

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

1. רכיבים

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

כאן דוגמה למחלקת ButtonComponent:

public class ButtonComponent {

​

      private WebDriver driver;

      public ButtonComponent(WebDriver driver) {

          this.driver = driver;

}

      public void clickButton(String buttonText) {

          WebElement button = driver.findElement(By.xpath("//button[text()='" + buttonText + "']"));

          button.click();

}

  }

​

2. הגדרות של שלבים

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

כאן דוגמה ל- ButtonStepDefinition:

public class ButtonStepDefinition {

      private ButtonComponent buttonComponent;

​

      public ButtonStepDefinition(WebDriver driver) {

          this.buttonComponent = new ButtonComponent(driver);

}

​

      @When("I click on the button {string}")

      public void iClickOnTheButton(String buttonText) {

          buttonComponent.clickButton(buttonText);

}

  }

3. מפעיל

מחלקת המפעיל אחראית על הרצת הבדיקות באמצעות JUnit או TestNG. היא מגדירה את Cucumber לטעינת תרחישי הבדיקה שהוגדרו בקבצי .feature ומפעילה אותם באמצעות ההגדרות של שלבים.

כאן דוגמה ל- TestRunner:

@RunWith(Cucumber.class)

  @CucumberOptions(

          features = "src/test/resources/features",

          glue = "com.componentObjectModel.stepDefinitions",

          plugin = {"pretty", "html:target/cucumber-reports.html"}

)

  public class TestRunner {

​

  }

כתיבה והסבר של תרחיש Gherkin

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

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

Scenario: User clicks on the "Submit" button
   Given I am on the login page
   When I click on the button "Submit"
   Then I should be redirected to the homepage

הסבר על התרחיש

תרחיש

התרחיש מתאר את הפעולה בה משתמש לוחץ על לחצן 'שלח' בדף הכניסה ווודא שהוא מופנה לעמוד הבית לאחר לחיצה.

• בהנחה שאני נמצא בדף ההתחברות: מצב התחלתי של הבדיקה הוא שהמשתמש נמצא בדף ההתחברות.
• כאשר אני לוחץ על הלחצן "שלח"": הפעולה שבוצעת בבדיקה היא לחיצה על לחצן 'שלח'.
• אז, עלי להיות מופנה לעמוד הבית: הוודאות הצפויה היא שהמשתמש מופנה לעמוד הבית לאחר לחיצה על הלחצן.

קישור עם COM

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

הסבר נוסף

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

השימושיות של שלבים עם COM

אחת מיתרונות העיקרים של COM היא היכולת לשימוש מחדש של הגדרות שלבים עבור כפתורים שונים. לדוגמה, אותו שלב "כאשר אני לוחץ על הכפתור {string}" יכול לשמש עבור כל הכפתורים, ללא קשר לטקסט שמוצג על הכפתור. הגישה COM מאפשרת לך להפרמטר דינמית את פעולת הלחיצה בהתבסס על טקסט הכפתור.

נבחן תרחיש נוסף עם כפתור שונה:

תרחיש

User clicks on the "Login" button

    Given I am on the login page

    When I click on the button "Login"

    Then, I should be redirected to the dashboard

בבתי המקרה שנתבארו, תשמש שיטת clickButton אותה במחלקת ButtonComponent, אך הטקסט של הכפתור ישתנה בהתאם לתרחיש. זה מדגים איך COM מאפשר להשתמש מחדש באותה רכיב והגדרת שלב, ומהופך את הבדיקות לגמישות ומודולריות.

איך COM משפר אוטומצית בדיקות

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

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

מתי מומלץ להשתמש בתבנית העיצוב של COM?

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

שימוש חוזר בהגדרות צעדים במוצרים מרובים

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

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

מסקנה

הַמוֹדֶל הַאוֹבֵיּקטִי שֶׁל רָכֶבַַת הַרְכַּבִים (COM) הוּא דוּגְמָת עֵיצוּב עֶזֶר לַאִרגוֹן שֶׁל הַאוֹטוֹמַצִיָה בַּבדִיקוֹת. עַל יְדֵי הִתְמָקֶדוּת בְּרַכֶבַַת רַכַּבִים שֶׁנִיתַנָה לַשְׁכֶּל, COM מַאֲפִשֵׁר לְךָ לִיצוֹר בִּדִיאָל יוֹתֵר מוֹדוּלָרִי, נִיתָן לְהַחְזִיר וְנִיתָן לְהַפְחִית בַּגַּדִירוֹת הֲפָרָדוֹת. דוּגְמָת זוֹ מֵאד שָׁפָה לַיָישׁוּמִים הַמוּדְרְנִיִים, שֶׁבָּהֶם מַמְּשֵׁכֶת הַמַמְשׁךִים בְּמִהִירוּת, וְשֶׁבָּהֶם נִדְרוֹשׁ הַתֵּגִישׁ עִם רַכֶבַַת רַכַּבִים עֲצַמָאִיִים.

עם בדיקות ניתנות לשימוש מחדש, תחזוקה פשוטה, וארכיטקטורה גמישה, COM היא הפתרון האידיאלי לאוטומציה של בדיקות בפרויקטים של Selenium ו-Cucumber.