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

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

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

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

 

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

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

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

 

Object Oriented Programing Language

למי שעדיין לא יודע, מפתח אוטומציה הוא מפתח תוכנה. ועל כן, את הבסיס צריך לרכוש על ידי לימודים של שפת תכנות כזו או אחרת, שחשוב שהיא תתמוך בעקרונות התיכנות מונחה עצמים (Object Oriented), מבין השפות הנפוצות והפופולריות באוטומציה, ראוי לציין את שפת Java וכן את שפת Python הנחשבת קלה יותר ללימודים. כמו כן, מפתחי אוטומציה כותבים גם ב-#C , ב-JavaScript, וחלקם גם ב-Ruby.

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

Data Types, Variables, Operators, Statements, OOP (Classes, Objects, Methods, Constructors, Inheritance, Abstract Classes, Interfaces, Polymorphism), Exceptions & Errors, Files, Regular Expressions…

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

מי שרוצה ללמוד #C יכול לקחת את הקורסים של Mosh Hamedani או של Tim Corey המצויינים (יש עוד הרבה מלבד השניים הללו)

מי שרוצה ללמוד Java , מוזמן להציץ בהדרכות של Tim Buchalka ושל Imtiaz Ahmad, ויש את המדריך המקיף של Beginners Book

בפייתון יש לנו את Mosh Hamedani שוב ויש גם את Free Code Camp שהם לא רעים והרבה אחרים כמובן

בג'אווה סקריפט יש את Derek Benas שהוא שם דבר בעולם ההדרכות, למעשה יש לו המון הדרכות על המון נושאים שונים (גם כאלו שלא קשורים לעולם התוכנה)

 

 

Development Eco System

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

Data Structures, Algorithm, Clean Code, Application Programming Interface (API), Design Patterns, Version Control Management (Git), Repositories, Build Management Tools (Maven / Gradle / Ivy…), Package Managers (NPM / Composor / Nuget / Pip / Gems…)

מקורות לימוד: לכל אחד מהנושאים הללו יש רשימות ארוכת של מקורות לימוד, אני רוצה לציין קורס מעולה (אחד הטובים שיצא לי לראות) של Christopher Okhravi על Design Patterns, על גיט אני ממליץ לקחת את הקורס של Jason Taylor וכדי ללמוד על Clean Code יש כמובן את Mosh Hamedani עם קורס מעולה

 

Unit Testing Frameworks

אוקיי, אנחנו הולכים ומתכנסים (בלימודים) יותר לעולם הבדיקות ולעולם האוטמציה ובעולם הזה קיימים לנו מגוון של פריימוורקים לבדיקות יחידה אותם אנו רותמים למעשה לבדיקות… Whatever (לא רק יחידה). הפריימוורקים הללו יאפשרו לנו לקחת את הקוד שאנו למדנו לכתוב ולהפוך אותו לקוד בדיקתי ע"י פקודות מטה-דאטה שנקראות Annotations או Attributes, כמו כן, על ידי אותם פריימוורקים אנו נוכל גם להכניס פונקציונליות של בדיקות, מנגנוני הרצה שונים, דוחות וכו'. ישנם כמה פריימוורקים פופולריים כמו Junit ו-TestNG בשפת Java,יש את Nunit ,MSTest ו-xUnit בשפת #C , יש את Unittest ואת pytest עם Python , יש את Mocha או Jasmin ו-Chai עם JavaScript ועוד…. להלן רשימת נושאים שרצוי ללמוד כשעובדים עם פריימוורק לבדיקות יחידה

Annotations / Attributes, Runners (with Parallel), Assertions, Test Suites, CI Integration

מקורות לימוד: מקורות הלימוד מתחלקים כאן לפי סוגיי הפריימוורקים, למשל כאן ל-TestNG יש מדריך לא רע, לא מזמן העלתי כאן בבלוג פוסט שמדבר על ה-Junit5 , מדריך נחמד על Nunit תוכלו למצוא ב-c-sharpcorner וכמובן שגם Mosh Hamedani מסביר על זה לא רע. על pytest תוכלו ללמוד בין היתר מ-JetBrainsTV

 

 

Server Side: Web Services

השלב הראשון לטעמי שצריך ללמוד מפתחי אוטומציה אשר רוצים להתמקצע בבדיקות צד שרת הוא על Web Services ועל הפרוטוקולים השונים שעובדים עם שירותים אלו, הנושאים אותם צריכים ללמוד (הכינו את עצמכם להרבה ראשי תיבות):

Simple Object Access Protocol (SOAP), Representational State Transfer (REST), Web Services Description Language (WDSL), Universal Description, Discovery and Integration (UDDI)

מקורות לימוד: יש קורס לא רע בכלל ב-YouTube על אוטומציה על Web Services של Raghav Pal , המדריך הזה של Guru99 נותן סקירה טובה והסברים יפים על REST.

 

 

Server Side: Data Structure

ה-Data Structures הם אותם סוגים של מבני נתונים אותם אנו מעבירים בין השירותים השונים, אלו הם פורמטים שונים המיוצגים על ידי קבצים בסופו של דבר, נכון להיום רוב הקבצים הינם בפורמט XML ו(בעיקר) JSON.

בנושא זה, אתם אמורים להכיר את הפורמטים הללו וכן ללמוד על שפות שיכולות להוציא מהם מידע, כגון XPath ו-JSONPath.

מקורות לימוד: באתר של quackit יש מדריך טוב על בניית XML, לימודי xpath והרבה מעבר לכך, את ה- JSON תוכלו ללמוד גם כן מאותו אתר

 

 

Server Side: API Testing

החלק המרכזי של בדיקות צד שרת יגיע בתצורה של API Testing, בדיקות שנעשות על ידי קריאות API לצד אחר, יתבצעו ללא GUI, כאן לא יהיו לנו אלמנטים או אובייקטים כפי שנוכחנו לראות בבדיקות צד לקוח (כפתורים, שדות טקסט וכו'), כאן אין לנו את ה-Look & Feel. בעולם הזה של ה-API Testing אנו נשלח קריאות (requests) לצד השני ונצפה ממנו להחזיר לנו תגובה (response) – אותה אח"כ נוכל לפרסר, לעבד ולבדוק.

כאן גם תצטרכו ללמוד לעבוד עם הכלים \ הפריימוורקים של API Testing כמו למשל REST Assured, REST Sharp, Http Client

אלו הנושאים החשובים שתצטרכו ללמוד בשביל לכתוב API Testing:

Methods: GET / POST / DELETE / PUT / PATCH , Dynamic Payload, Serialize, De-Serialize, Authentications

מקורות לימוד: באתר של RestAPITutorial.com יש הסברים בסיסיים אך מספיים בשביל להבין את הקונספט, Execute Automation הוציאו סדרה נפלאה של סרטונים על Rest Sharp

 

 

Server Side: DB Testing

בדיקות על בסיסי נתונים, הן בדיקות פחות שכיחות בתעשייה, אך בכל זאת בשביל להתחבר לבסיסי נתונים אנו צריכים ללמוד שכבות שעובדות מולם, כמו למשל ה-JDBC (קיצור של Java DataBase Connectivity) שהוא למעשה API לחיבור התוכניות שלנו בג'אווה לבסיסי נתונים שונים, ה-API הזה כולל בתוכו ממשקים שונים כמו ה-Driver, Connection, Statement, ResultSet ועוד… גם בעולם ה-NET. יש לנו API שמגיעים כבר עם התשתית עצמה כמו OLDB , OLEDB , SQL ועוד.

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

מקורות לימוד: ערוץ היוטיוב: Genuine Coder מביא לנו סדרת סרטונים טובה של חיבור ל-DB עם JDBC , התחברות לערוץ יוטיוב נוסף: The Net Ninja , יביא לכם מדריך בן 16 סרטונים על חיבור ועבודה מול MongoDB.

 

 

Client Side: HTML, CSS, JS

כאן נשאלת השאלה, למה לעזאזל אנחנו צריכים לדעת טכנולוגיה של בניית אפליקציות Web, הרי אנחנו בכלל אמורים לבדוק אותה לא לבנות אותה ? אוקיי אז התשובה המתבקשת היא – אם אנחנו מבצעים אוטומציה על Web ומנוע האוטומציה שלנו יודע לקרוא דפי HTML, אז כדאי מאוד שגם אנחנו נדע. דפי HTML מגיעים גם עם CSS שאחראי על עיצוב האפליקציה ועם JavaScript שאחראי על הדינאמיות של האתר, הרמה אינה אמורה להיות כמפתח Front End אמנם, אך בהחלט את ה-Basic אנו אמורים להכיר, ואפילו מעבר לזה.

ברמת ה-HTML אנו אמורים לדעת מהו ה-DOM, כיצד בנויה אפליקציית Web, רצוי ללמוד על תגיות ה-HTML , בטח שעל הנפוצות שבהן, כמו כן, יש להכיר את ה-Attributes של התגיות בשפה, ולחקור חזק חזק את ה- Developers Tool של הדפדפן, במיוחד את האיזור של ה-Elements , Console וה-Network.

 

מקורות לימוד: רוב האנשים שרוצים ללמוד על HTML ישר יגיעו ל-W3School ובצדק. כך זה יהיה גם ללימודי CSS ולימודי JavaScript (אם כי את השניים האחרונים, אפשר ללמוד ברמת ההטמעה שלהם בתוך ה-HTML בלבד לטעמי). מקור טוב נוסף ממנו ניתן ללמוד על HTML הוא learn-html.org ושוב ה-quackit

 

 

Client Side: Web

אוטומציה על ה-Web היא האוטומציה הפופולריות ביותר שנמצאת כיום בשוק, הפלטפורמה המובילה (By far) היא Selenium WebDriver ויש לאוטומציה על Web את ה-Eco System הגדול ביותר. אני חייב לציין כי בזמן האחרון צצים להם יותר ויותר מוצרי אוטומציה ל-Web אשר אינם מבוססים Selenium כשהמוכר מביניהם הוא ה-Cypress והמוכרים פחות : Puppeteer, NightWatch ו-TestCafe

מכיוון שהרבה מוצרים ופתרונות אוטומציה (לא רק על Web) מבוססים על פרוטוקול ה-WebDriver (לשעבר JSON Wire Protocol), כדאי מאוד שנכיר לעומק את מרחב המחיה שלו, כדאי שנלמד על ממשקי ה-WebDriver וה-WebElement, נבין מהו ה-RemoteWebDriver וכמו כן את הפונקציונליות המממשת אותם:

Locators, Synchronization, Switches, Actions, Page Objects, Interacting Browsers, JSExecutor, Event Listeners

מקורות לימוד: טוב, יש כאן המון… קודם כל אתם מוזמנים להיכנס לקורס האונליין החינמי אצלי באתר, הוא בעברית, הוא עם תירגולים, עם סרטונים ולא צריך אפילו להירשם בשביל לעשות אותו. מעבר לכך, מידע נרחב ניתן למצוא ב-Software Testing Materials וכמו כן ב-Execute Automation יש מערך סרטונים נרחב בשפת #C , יסלחו לי עוד בערך מליון מקורות לימוד שלא הכנסתי אותם, יש פשוט המון, מוזמנים גם להיכנס ל-Udemy או Pluralsight

ולנבור שם, לא חסר…

 

 

Client Side: Mobile

רוב מפתחי האוטומציה שעוסקים בבדיקות על Mobile, בד"כ כותבים את הבדיקות שלהם עם Appium, אמנם ישנן גם פלטפורמות אחרות (כמו EarlGray, Esspresso, Robotium, Selendroid, Calabash ועוד…), אך הן די מיעוט בשוק של היום. היתרונות הגדולים ביותר של Appium על פני הפלטפורמות האחרות מתבטא בעיקר בשני אופנים:

  1. תמיכה בשתי מערכות ההפעלה הנפוצות ביותר: Android , IOS (אהה… כן, הם גם תומכים ב-Firefox OS למי שבעניין)
  2. תמיכה בפרוטוקול ה-WebDriver, כך שמי שכבר מגיע מעולם אוטומציה על ה-Web עם Selenium לא יתקשה במיוחד לעשות את המעבר ל-Appium, למעשה התשתית יכולה (אמורה) להיות אותה תשתית שתטפל בשתי הפטפורמות הללו, זה יתרון עצום מאשר למשל להתחיל לכתוב תשתית חדשה ב… נגיד UFT (שגם תומך ב-Mobile)

על כן, הנושאים אותם יש ללמוד ולהכיר ב-Appium בד"כ יגיעו אחרי שאתם כבר מכירים את הנושאים שב-Selenium WebDriver , למעשה ספריות הקוד של Appium הן הרחבה של Selenium ועליהן צריך להתמקד כאן, כשבנוסף עלינו להכיר גם את הארכיטקטורה השונה מזו של Selenium (כאן יש לנו Appium Server במקום ה-ChromeDriver/ GeckoDriver וכו'…), אז אם אתם כבר כאן, אחרי Selenium, תשקיעו בנושאים הבאים:

Appium Driver, Appium Methods, Appium Gestures, Appium Environment (Client – Server), Android Debug Bridge (ADB), XCode

מקורות לימוד: ל-Appium לא חסרים מדריכים כיום, זה לא סוד כי תהליך ההתקנה של Appium הוא די כאב ראש מציק, אבל כיום זה לא בעיה לראות כיצד עושים זאת שלב אחר שלב במדריכים מפורטים, למשל ניתן להירשם לקורס הזה של Rahul Shetty ב-Udemy ,  כמו כן, יש את המדריך החביב הזה של automationtestinghub על Appium

 

 

Client Side: Desktop

אמנם אוטומציה על אפליקציות Desktop היא פחות נפוצה מבין השתיים שמצויינות מעלה, אך עדיין ישנם אירוגנים שזקוקים לזה כמו בלון חמצן, בעיקר כשיש להם מערכת Back Office מרכזית הכתובה ב-Winform או WPF למשל והם צריכים לבצע עליה בדיקות רבות. אני חייב לציין כי מספר הכלים התומכים באוטומציה על אפליקציות Desktop הוא יחסית מצומצם, הרבה מן הכלים הללו גם לא כל כך בשלים ולא כל כך נפוצים. בשוק הזה, לטעמי דווקא הכלים המסחריים הם אלו ששולטים, בזמן שיש לנו את Ranorex, TestComplete ו-UFT שעושים עבודה טובה בתחום הזה (אבל דורשים רשיונות בגובה של אלפי דולרים), מהצד החינמי יש לנו בעיקר את WinAppDriver , את Winium (שכבר לא מתוחזק), ואת White.

העבודה עם הכלים הללו (אני מתכוון לחינמיים) ממשיכה בגדול את הקו של פרוטוקול ה-WebDriver עמו התחלנו ב-Selenium ואח"כ המשכנו ב-Appium, למעשה הפעולות הן אותן פעולות, פחות או יותר, האיתחול של האובייקטים יהיה שונה אבל.

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

 

 

Test Automation Infrastructure

זהו אולי החלק החשוב ביותר לתפקיד מפתח אוטומציה (ביחד עם לימודי שפת תכנות). למדתם עד כה איך כותבים אוטומציה על מגוון פלטפורמות (Web / Mobile / Desktop / Server…), יפה. עכשיו אתם צריכים ללמוד איך כותבים את זה נכון, בעזרת תשתית אוטומציה טובה, חזקה, אינטלגנטית, מודולרית, אחת כזו שתהיה חסינה לשינויים (עד כמה שניתן) ותחזיק לנו את הפרוייקט לאורך זמן עם מינימום מאמץ.

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

Object Repository, Failure Mechanism, Recovery, Reporting System, Screen Shots, Screen Casts, External Config Files, Several Client Support, Parallel Executions, Logging System, Database Support, Data Driver Testing, Keyword Driven Testing, Behavior Driven Development, Time Schedulers

 

מקורות לימוד: לצערי, בזמן שהאינטרנט מפוצץ במקורות טובים לעבודה עם כלי אוטומציה על Web / Mobile / Server וכו', כמעט ולא ניתן למצוא מדריכים טובים על בניית תשתית טובה,

לפני זמן מה העלתי פוסט חשוב המדבר על מהן תשתיות אוטומציה אצלי בבלוג, מוזמנים לקרוא. אחד מהקורסים המשמעותיים בנושא תשתיות הוא זה של Execute Automation עליו אני מאוד ממליץ אבל לצערי הוא עדיין מוגבל רק ל-Web.

לדעתי, קורס ה-Full Stack Test Automation של עתיד האוטומציה, המכיל כתיבת תשתיות למגוון פלטפורמות (Mobile, Web, Desktop, Visual, Electron, Server וכו') זה משהו שלא תמצאו בכל רחבי האינטרנט (אגב, אשמח לדעת אם אני טועה, מוזמנים להגיב לי)

 

 

Standards and Best Practices

כמו לכל פרוייקט תוכנה, גם כאן אצלינו באוטומציה ישנם סטנדרטים של כתיבה ו-Best Practice. בנושא זה אנו לא מדברים רק על תהליך של כתיבה ועיצוב הקוד (למשל עבודה עם SOLID או Clean Code) , אלא גם או בעיקר עיצוב הבדיקות שלנו, כיצד אנו נתכנן את הבדיקות האוטומטיות שלנו, מהן ההנחות שאנו חייבים להניח כשאנו עובדים באוטומציה, ניתוח של ROI למוצרים שונים בחברה או פיצ'רים שונים במוצר, עיצוב הארכיטקטורה של הפרוייקט (לא רק הבדיקות) ושימוש בטכניקות שונות, כמו למשל בידוד בין סביבות \ טסטים, Refactoring להסרה של קוד משוכפל, חקירת שגיאות ונפילות של טסטים ועוד.

מקורות לימוד: לא מצאתי כאלו באינטרנט, אלו הם נושאים מתקדמים באוטומציה עם חומרים שמגיעים עם יועץ אוטומציה (ממה שאני מכיר)

 

 

DevOps

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

א. כי יש לנו (אנשי האוטומציה) נגיעות עם אנשי ה-DevOps הקלאסיים ואנו צריכים לדעת כיצד "לחבר" את סוויטת הבדיקות שלנו לתהליך האוטומטי של שיחרור הגרסה (במילים אחרות CI / CD)

ב. בחברות קטנות המתנהלות כסטארטאפ, מאוד יכול להיות שאותו מפתח אוטומציה יהה גם איש ה-DevOps (וכנראה גם דברים אחרים – Full Stack Test Automation)

בגלל שאנו כיום עובדים בעולם האג'ילי (פיתוח תוכנה זריז) ובגלל שאנו שואפים לעבוד בתהליכי CI/CD אוטומטיים, מאוד חשוב לנו להכיר גם את תפקיד ה-DevOps בכל ההקשר של האוטומציה, הנושאים עליהם יש לשים את הדגש בעולם זה אלו הכלים \ מערכות:

Git, Grid, Building Tools, Continuous Integration, Continuous Deployment, וכמו כן מערכות ווירטואליזציה מבוססות Docker

מקורות לימוד: בעוץ ה-YouTube של Edureka יש המון סרטוני הדרכה על DevOps

 

 

Git

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

Push, Pull, Merge, Github, BitBucket, GitLab, Branch, Fork

מקורות לימוד: ישנם טונות של מדריכים על Git, אני דווקא התחברתי לזה של Traversy Media (ללא סיבה מיוחדת),  ויש אחד רציני יותר ב-Udemy של Jason Taylor

 

 

Build Tool

תהליך בניית התוכנה (Building tool) הוא חלק חשוב מעוד בתהליך ה-CI/CD ולמעשה הוא אחראי לקחת את כל ה-sources שלנו (הקוד שלנו) ולייצר מהם תוכנה, למשל קובץ exe. ישנם לא מעט כלים לבניית תוכנה, הגדולים והמוכרים הינם Maven של ג'אווה ו-MSBuild של NET. כשאנו כותבים את פרוייקט האוטומציה שלנו, נרצה גם כן לבנות את התוכנה שלנו, כך שבסופו של דבר ההרצה תהיה ממקור אחד (למשל ע"י שורת פקודה או הרצה של קובץ bat), את הנושאים לבניית תוכנה תוכלו לראות כאן:

Dependencies, Plugins, POM, Profiles, Build Life Cycle (Validate, Compile, test, Package, Verify, Install, Deploy)

מקורות לימוד: יש את ערוץ ה-YouTube של ProgrammingKnowledge שהוא לא רע, וכן את המאמר באתר של jenkov (שהוא כשלעצמו מקור ידע מצויין)

 

 

Grid / Parallel

טוב, זה לא סוד שאת הבדיקות שלנו באוטומציה אנו נרצה להריץ במקביל , על סביבות שונות ועל קלייטים שונים (Web / Mobile) בשביל לחסוך בזמן בעיקר, הרי יש לנו לא מעט בדיקות בריגרסיה ולהריץ על סביבות שונות זה תהליך יקר. לכן נרצה לצמצם עלויות על ידי הרצות במקביל. הפלטפורמה המקובלת כיום היא הרצה מקבילית עם Selenium Grid , ובעולמות המסחריים קיימים לנו גם כל אותם שירותי ענן כמו Browser Stack, Sauce Labs, Perfecto Mobile וכו'… בשביל להטמיע זאת, אנו נצטרך ללמוד על הארכיטקטורה של ה-Grid (קלייינט – סרבר, או Hub – Nodes) עם הקונפיגורציות והפרמטרים.

מקורות לימוד: כדאי לכם להעיף מבט על 2 הסרטונים של Naveen AutomationLabs המסבירים עם דוגמאות על Selenium Grid, זהו חלק 1 , וזהו חלק 2

 

 

CI Tool

כבר הזכרתי את המושג הזה CI כמה פעמים בפוסט, אותו תהליך של Continuous Integration נועד לעזור לנו לשחרר גרסאות בצורה יעילה ומהירה, וזה לא הכי טריביאלי כשמדובר על קבוצה R&D שמכילה כמה צוותי פיתוח לדוגמא, צוות האוטומציה הוא כמובן חלק בלתי נפרד מהתהליך הזה, כאשר הוא אחראי לכתוב, לתחזק ולהעלות את סוויטת הבדיקות שלו לתהליך (שכאמור כולל גם צוותים אחרים), ישנם כמה כלים מנהלים את ה-CI, הגדול, הנפוץ והפופולרי שביניהם הוא ה-Jenkins , האחרים הם: Team City, Bamboo, וכו'.

מפתחי האוטומציה צריכים לכל הפחות לדעת לעבוד עם כלים אלו (אחד מהם) , להכיר ברמה של לכתוב:

Jobs, Schedulers, Pipeline, Parameters, Dependencies, Plugins, Reports

מקורות לימוד:  באותו ערוץ של ProgrammingKnowledge שכבר הזכרתי בעבר, יש גם מדריך טוב על Jenkins, מוזמנים לראות

 

 

Docker

את הטכנולוגיה של Docker מפתחי אוטומציה אמורים להכיר בשל הקדמה הטכנולוגית אותה היא מביאה. אנו מתעסקים לא מעט בתחום הווירטואליזציה בכל הנוגע להרצות על מכונות שונות, אז נכון, אנחנו יכולים להשתמש בטכנולוגיות המיושנות של VMWare או VirtualBox , מה שיגזול מאיתנו לא מעט משאבים מהאירגון, בעזרת Docker עם Images ו-Containers אנחנו נוכל להקים סביבות ווירטואליות בקלות ודי בזול, הרצות אוטומטיות מעולם לא נראו קל יותר כשיש לנו את Zalenium למשל. לפני הפרקטיקה חשוב מאוד להבין את המאחורי הקלעים של טכנולוגיה זו, תצטרכו ללמוד על הנושאים הבאים:

Virtualization, Daemon, Images, Containers, dockerfile, docker-compose, Docker Hub, Zalenium, Swarm, Selenoid, Kitematic, Kubernates, PoweShell

מקורות לימוד: ישנם לא מעט קורסים מעולים ב-Udemy כמו זה של Bret Fisher למשל, וכן את זה של Execute Automation שיותר מוכוון לעולם האוטומציה

 

 

אז מה ראינו בפוסט (הארוך) הזה ?

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

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

בהצלחה,

יוני

3 תגובות נוספו

  1. מתוך 100% אנשים שעוסקים באוטומציה רק אחוז קטן (אולי 20%) יידרשו באמת להיות מפתחי תשתיות אוטומציה – הרוב יידרשו להיות מה שאני קורא לו "מיישמי אוטומציה" – לאלו ניתן לחתוך הדיאגרמה מעל בערך במחציתה (כאשר תמיד פתוחה הדרך להמשיך הלאה)
    בצורה זו התהליך ייראה קצת פחות מפחיד.
    כמו כן – לא לכל בלוק בדיאגרמה זו משקל זהה, ולא את כולם צריך ללמוד לעומק – שפת תכנות היא אחד השלבים היותר כבדים שדורשים גם תרגול רב, הבנה בצד הסרבר (וכך גם הקליינט) לא חייבת להיות מעמיקה אולי עם קצת יותר התמקדות ב-API – אבל כל הבלוקים הללו עדיין לא מגיעים למשקל של ללמוד שפת תכנות אחת כראוי.
    כפי שרשמתי מעל – רבים לא יהפכו למתכנתי תשתיות ולכן יזדקקו רק להכרה בסיסית של הנושא,
    ליכולות אדמין של DevOps רבים לא יידרשו – אבל כן רצוי להכיר הנושאים בגדול.
    למידה מרוכזת של כל הנושאים לעומק כאשר לא באמת משתמשים בהם תביא מהר מאוד לשיכחה של החומר הנלמד ובמקביל תקשה על קליטת וזכירת החומר שכן חשוב לאותו בודק/ת בשלב הראשוני של כניסה לעולם האוטומציה.
    לכן הייתי מחלק את כמות הלימוד ומקורות הלימוד בהתאם – כמה להשקיע בשביל הבנה עקרונית, ולמי שכבר התנסה ויש מקום בו יכול להמשיך לשלב ההתנסות הבא – חומר לימוד מורחב למפתחי אוטומציה.
    תגובה זו נכתבה במקור בדיון בנושא בקב הדיונים בפייסבוק:
    https://www.facebook.com/groups/IL.Testing.QA
    קובי

    • מסכים Kobi Halperin
      אם הייתי צריך לכמת \ לדרג את החשיבות והמורכבות של כל אחד מהנושאים, אז:
      במקום הראשון הייתי מכניס את Test Automation Infrastructure , גם בגלל שהוא מאוד קשה, גם בגלל שהוא מאוד ארוך למימוש וגם (בעיקר ולהבדיל מהמקום השני) שכמעט ואין למצוא חומרים ללימוד עצמי באינטרנט, ישנם כמה מדריכי אונליין של בניית תשתית אוטומציה, אבל לצערי הם לא מספיק טובים.
      במקום השני זוהי שפת התכנות, שהיא כידוע הבסיס להכל.
      ובמקום השלישי לדעתי יהיה ה-Development Eco System
      לגביי 100% ו-20% , בגדול מסכים גם כן, לא סגור בדיוק על האחוזים אבל זה בעיקרון נכון, ולא רק לאוטומציה אלא לכל פרוייקט תכונה שהוא
      גם כשבן אדם נכנס לצוות אוטומציה עם תשתית אוטומציה מוכנה, הוא עדיין צריך להכיר את הפרוייקט מקרוב. הוא יצטרך ברוב המקרים בעתיד לכתוב פיצ'רים חדשים, הוא יצטרך בעתיד לתקן באגים בתשתית וכו'.

  2. Ilan Malyanker 08/09/2019 הגב

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

    אם כבר מדברים על תחומים קרובים, אז הייתי מזכיר גם shell scripts. הרבה פעמים מתחילים לייעל תהליכים על ידי סקריפטים פשוטים. וכן כל הממשק ל-Jenkins, הטיפול ב-slaves שלו, כל העבודה ב- Git, והרבה התעסקות שוטפת מצריכה ידע גם בזה.

השאר הערה\הודעה