מבט אישי על תכנות תיאורי (DP)

לאחר שקיבלנו רקע על חלק מהיכולות ואופן השימוש ב-Descriptive Programming, אני יכול לדבר על הנושא מזוית אישית יותר. עם השנים פיתחתי הרגלי כתיבת קוד שונים ומשונים, בין השאר בנוגע ל-DP. הרגלים הם שרירותיים מעצם טיבם, ויתכן שיש דרכים יעילות או טובות יותר להשתמש ב-DP, אבל אם אני כבר כאן, למה שלא אחלוק חלק מהם:

אני לא סומך על Regular Expressions ב-DP.
כאשר מכניסים תכונות זיהוי לאובייקט Description סטאטי, אפשר להגדיר את הערכים הצפויים בעזרת תבניות Regular Expression, באופן הבא:

Dim oDesc
Set oDesc = Description.Create

oDesc("property1").Value = "RegExPattern"
oDesc("property1").RegularExpression = True

אני אישית מעדיף לא לסמוך על RegEx במקרה הזה, היות ולפעמים הקריטריונים לזיהוי מורכבים מאוד, דורשים מגע בתכונות Run-Time, וכו'. במקום לסנן את האובייקטים כבר באמצעות תכונות הזיהוי שלהם, אני מעדיף לקבל את כל האובייקטים העונים למכנה משותף מאוד נמוך (לדוגמה – סוג האובייקט – Combobox/CheckBox וכו'); לפעמים אעדיף אפילו לקבל את כלל האובייקטים בחלון / אפליקציה.

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

Dim oDesc, oChildren
Dim i
Set oDesc = Description.Create

oDesc("micclass").Value = "VbCheckbox"
Set oChildren = VbWindow("Main").ChildObjects(oDesc)

For I = 0 to oChildren.Count -1
If oChildren(i).GetROProperty("ToolTipText") = "WantedToolTip" Then
oChildren(i).Set "ON"
End If
Next

העובדה שאני יכול לכתוב את קוד הזיהוי בעצמי (כלומר, את התנאים ב-IF) נותנת חופש וגמישות מוחלטים, ולרוב מאפשרת לכתוב קוד קריא בהרבה (אפשר לאחד הרבה פקודות oChildren ע"י קבלת כל האובייקטים, וטיפול במקרים השונים באמצעות Select Case)

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

Dim oObjectCollection
Set oObjectCollection = CreateObject("Scripting.Dictionary")

oObjectCollection.Add 0, VbWindow("Main")

משמעות השורה האחרונה, היא הוספת האובייקט VbWindow("Main"), וקביעת המזהה שלו כ-0 (הדרך בה יהיה ניתן "לשלוף" אותו). מזהים יכולים להיות גם מחרוזות, אולם על מנת לשמור על תאימות לאוספי האובייקטים הנוצרים באמצעות ChildObjects אני משתמשים במזהה מספרי (מתחיל מ-0). הגישה לאובייקט מתבצעת באופן דומה ל-DP רגיל (באמצעות המזהה) :

oObjectCollection(0).Click

לאובייקט Scripting.Dictionary ישנן תכונות מועילות רבות, וכדאי להשתמש בו באופן כללי, מעבר למסגרת המצומצמת של DP. למידע נוסף מומלץ לפנות לעזרה של ה-QTP, תחת הערך Dictionary Object.

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

אני תמיד משתמש בתכונת Index
הוספת תכונת הזיהוי Index להצהרות DP מגנה מפני מקרים בהם יש יותר מאובייקט אחד המתאים לתיאור שפרטנו. אני מעדיף להגן על עצמי מפני מצבים כאלו, במחיר אי-ידיעה האם היו אובייקטים כפולים במהלך הריצה. ב-QTP-8.2, תכונת Index הייתה עובדת רק כאשר יש יותר מאובייקט אחד שמתאים לתיאור, אבל בגרסאות 9 ומעלה הבעיה נפתרה, ופתחה את הדלת לשימוש חופשי בתכונה.

VBWindow("title:=Example", "index:=0").VBCheckBox("visible:=true", _
"index:=0").Set "ON"

יישור קו - תכנות תיאורי (DP)

To the English version of this post

לפני שנוכל לסקור נושאים מתקדמים, נבצע "יישור קו" לגבי מספר טכניקות בסיסיות ב-QTP (אם כי הן נחשבות למתקדמות בפני עצמן במקומות מסויימים).
אחת הטכניקות המהותיות לשימוש מתקדם ב-QTP נקראת Descriptive Programming, ואותה נסקור היום. כל ניסיון לתרגם את המונח Descriptive Programming לעברית נראה מטופש, ולכן נתייחס אליה פשוט כ-DP.

רקע והסבר כללי

---

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

על מנת להבין איך DP עובד, כדאי קודם להבין אין מאגר האובייקטים הרגיל של QTP עובד, ובמיוחד חשוב להבין כי מאגר האובייקטים אינו מנגנון מורכב ועמוק, אלא רק דרך נוחה לשמור קבוצות של תכונות וערכים ביחד. למה הכוונה? כאשר אנו מקליטים אובייקט כלשהו למאגר האובייקטים, QTP אוסף תכונות מהאובייקט הפיסי, ומתעד אותן כזוגות של הגדרה וערך. לדוגמה – גובה האובייקט הוא 400, הכותרת היא "ישות חדשה", ושם התוכנה שלו הוא "NewEntityID". תכונות אלו מתודעות במעין מילון, בו תחת הערך של האובייקט הרלוונטי מופיעות התכונות : Height = 400, Tile="ישות חדשה", vbname = " NewEntityID". כאשר QTP מריץ תסריט שמתייחס לאובייקט מסויים, הוא לוקח את אוסף התכונות של האובייקט, משווה אותן לתכונות של האובייקטים "הפיסיים" שפתוחים במחשב, ומוצא (או שלא) את האובייקט שאוסף התכונות מתאר אותו – ורק אותו. And that's all there is to it.

אופן השימוש

---

ב-DP, אנו מפרטים "ידנית" את אוסף התכונות על פיו נרצה לזהות אובייקט מסויים, ובכך גורמים ל-QTP להשתמש בתיאור הידני במקום בתיאורים השמורים במאגר האובייקטים שלו. הדרך המהירה לעשות זאת היא תוך כדי הפקודה המשתמשת באובייקט :
אופן השימוש הוא Class(PROPERTIESSTRINGS).Command, כאשר PROPERTIESSTRINGS מפרטות את התכונות והערכים לזיהוי. לדוגמה :

VBWindow("property1:=value1", "property2:=value2").Click

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

VBWindow("property1:=value1").VBCheckBox("property2:=value2").Click

כמובן ש-VBWindow הוא רק דוגמה למימוש בסביבת VB. באופן דומה ניתן לעבוד עם SWFWindow, Browser, וכו'. לדוגמה – Browser("name:=Test").Close.

כפי שניתן לראות, ההבדל היחיד בין השימוש ב-DP לדרך הרגילה בה אנו עובדים עם מאגר האובייקטים, היא בתוכן המוכנס בין הסוגריים של VBWindow(). כאשר עובדים עם מאגר האובייקטים, אנו מכניסים את השם הלוגי של האובייקט; וכאשר עובדים עם DP, מכניסים מחרוזות המתארות את התכונה לזיהוי, ואת הערך הצפוי בה (מופרדים ע"י :=).

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

'----Create Object----'
Dim oDesc
Set oDesc = Description.Create

'----Set ID properties & values---'
oDesc("property1").Value = "value1"
oDesc("property2").Value = "value2"

'----Use and reuse the description object---'
VBWindow(oDesc).Type "Something"
'…
'…
VBWindow(oDesc).Close

'----Release description object---'
Set oDesc = Nothing

וניתן לשלב בין שתי השיטות

VBWindows(oDesc).VBCheckBox("vbname:=DPIsCool").Set "ON"

שימושים נפוצים

---

(דוגמאות מפורטות ניתן למצוא בקובץ המצורף לפוסט)

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

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

התמודדות עם אובייקטים כפולים : במצב בו תכונות הזיהוי שהכנסנו מתאימות ליותר מאובייקט אחד, נקבל הודעת שגיאה – object's description matches more than one of the objects currently displayed in your application. כאשר משתמשים במאגר האובייקטים אין דרך קלה להתמודד עם המצב (ניתן באופן עקיף ומסורבל להשתמש ב-Recovery Scenario). כאשר משתמשים ב-DP, ניתן להוסיף לתכונות הזיהוי את : "index:=X", כאשר X הוא מספר רץ (מתחיל מ-0), ובכך להתייחס מיידית לחלון ה-X בעל התכונות שצויינו.

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

אובייקטים בהיררכיות משתנות: לעיתים אובייקט בן יופיע תחת אובייקט אב אחר בכל פעם (לדוגמה – Pop-Up שמופיע תחת החלון שהקפיץ אותו). ישנן אפליקציות בהן הדרך היחידה לעבוד עם אובייקט כזה הינה באמצעות DP, שמתעלם מהיררכיית האב, ופונה ישירות לאובייקט הרלוונטי.

שימוש שמגיע לו סעיף בפני עצמו

---

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

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

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

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

Dim oDesc
Dim oChildren
Dim i

oDesc = Description.Create
oDesc("micclass").Value = "VbCheckBox"
'----We could've left the oDesc object blank, To get all objects----'

Set oChildren = VBWindow("Main").ChildObjects(oDesc)
'----Now oChildren holds the checkboxs' collection----'

'----Run through the collection----'
For I = 0 to oChildren.Count-1
'----Set the specific checkbox to "ON"----'
oChildren(i).Set "ON"
Next

כפי שאולי שמתם לב, פקודת .ChildObjects צריכה אובייקט אב להתבצע בתוכו. המשמעות היא שלא ניתן לקבל אוסף של חלונות Top-Level, היות שאין אובייקט מעליהם בהיררכיה, עליו נוכל לבצע את הפקודה. הנושא טופל ב-QTP 9, בעזרת אובייקט העזר Desktop. האובייקט מכיל את כל חלונות ה-Top-Level, ומאפשר לקבל בחזרה אוסף שלהם ע"י ביצוע Desktop.ChildObjects(oDesc), ושלום על ישראל.

דוגמאות ושימושים נוספים ניתן לראות בקובץ המצורף.

קריאה נוספת

---

1. קבצי העזרה של QTP : ערך Using Programmatic Descriptions