למה להשתמש ב-Playwright לבדיקות API?
Playwright מוכר בעיקר ככלי מוביל לאוטומציה של בדיקות ממשק משתמש (UI), אך בשנים האחרונות הוא הפך גם לפתרון משמעותי לבדיקות API. באמצעות Playwright ניתן לשלוח בקשות HTTP, לבדוק תגובות של שרתים, לאמת נתונים, לבדוק הרשאות, לבצע תרחישי CRUD ולשלב בדיקות API עם בדיקות UI באותו פרויקט אוטומציה.
היתרון המרכזי הוא האפשרות לנהל מערך בדיקות אחד שמכסה כמה שכבות במערכת: החל מבדיקת שירותים ותקשורת מול השרת ועד לווידוא שהתוצאה מוצגת כראוי למשתמש בממשק.
עבור אנשי QA, ובמיוחד בודקי תוכנה המעוניינים להתקדם לתחום האוטומציה, Playwright מציע סביבת עבודה נוחה המבוססת על JavaScript או TypeScript, עם תמיכה מובנית בבקשות API, בדיקות Assertions, ניהול נתונים, Authentication, דוחות והרצת בדיקות במקביל.
במדריך זה נלמד כיצד לבצע בדיקות API באמצעות Playwright, כיצד להקים פרויקט, כיצד לשלוח בקשות GET, POST, PUT, PATCH ו-DELETE, כיצד לבדוק תגובות ושגיאות, כיצד לנהל הרשאות וכיצד לבנות תשתית בדיקות מקצועית.
מה זה Playwright וכיצד הוא משמש לבדיקות API?
Playwright הוא Framework לאוטומציה של בדיקות תוכנה שפותח במקור על ידי Microsoft. הוא מאפשר לבצע בדיקות אוטומטיות בדפדפנים כמו Chromium, Firefox ו-WebKit, ובנוסף מספק יכולות לבדיקת שירותי API ללא צורך בפתיחת דפדפן.
במסגרת Playwright Test קיימת יכולת בשם APIRequestContext, המאפשרת לשלוח בקשות HTTP ישירות לשרת ולקבל את התשובות שלו.
באמצעות יכולת זו אפשר לבדוק:
- האם נקודת קצה (Endpoint) מחזירה את הנתונים הצפויים.
- האם קוד התגובה HTTP תקין.
- האם מבנה ה-JSON תואם לחוזה שהוגדר.
- האם הרשאות המשתמש נאכפות כראוי.
- האם המערכת מטפלת בנתונים חסרים או שגויים.
- האם פעולות יצירה, עדכון ומחיקה פועלות כמצופה.
- האם שירותים שונים מתקשרים ביניהם בצורה תקינה.
- האם התנהגות המערכת נשארת תקינה גם במקרי קצה.
ההבדל החשוב הוא שבדיקת API באמצעות Playwright אינה מחייבת הפעלה של דפדפן. הבדיקות מתקשרות ישירות עם השירות, ולכן הן בדרך כלל מהירות יותר מבדיקות UI.
ההבדל בין בדיקות API עם Postman לבדיקות API עם Playwright
Postman ו-Playwright הם שני כלים שימושיים לבדיקות API, אך הם מתאימים לצרכים שונים.
Postman מספק ממשק גרפי נוח לשליחת בקשות, צפייה בתגובות, ניהול Collections וביצוע בדיקות ידניות ואוטומטיות באמצעות Scripts.
Playwright מאפשר לכתוב בדיקות API כחלק מקוד אוטומציה מלא, לשלב אותן בתהליכי CI/CD ולנהל תרחישים מורכבים באמצעות JavaScript או TypeScript.
הבדלים מרכזיים:
| מאפיין | Postman | Playwright |
|---|---|---|
| שליחת בקשות HTTP | כן | כן |
| בדיקות GET ו-POST | כן | כן |
| בדיקת JSON | כן | כן |
| כתיבת קוד JavaScript | כן | כן |
| ניהול בדיקות באמצעות קוד | אפשרי | מובנה |
| בדיקות UI | לא מיועד לכך | כן |
| שילוב API ו-UI | מוגבל | מובנה |
| הרצה ב-CI/CD | כן | כן |
| ניהול Assertions | באמצעות Scripts | באמצעות Test Runner |
| הרצה מקבילית | בהתאם למנגנון ההרצה | מובנית |
| דוחות בדיקה | כן | כן |
הבחירה תלויה במטרת הבדיקות. Postman מתאים במיוחד לבדיקות API ידניות, לחקירת שירותים ולבדיקות מהירות באמצעות ממשק גרפי. Playwright מתאים במיוחד לצוותי QA שרוצים לפתח תשתית אוטומציה בקוד ולשלב בדיקות API בתוך מערך בדיקות רחב.
להרחבה על הכלי Postman ועל אופן השימוש בו, מומלץ לקרוא את המדריך בדיקות API עם Postman – מדריך למתחילים.
התקנת Playwright והקמת פרויקט לבדיקות API
כדי להתחיל לעבוד עם Playwright נדרש להתקין Node.js בסביבת העבודה.
לאחר ההתקנה פותחים Terminal או Command Prompt ומריצים:
mkdir playwright-api-testscd playwright-api-testsnpm init -ynpm install -D @playwright/test
לאחר מכן יוצרים קובץ הגדרות:
npx playwright install
פקודה זו מתקינה גם את הדפדפנים הנדרשים ליכולות האוטומציה של Playwright. עבור בדיקות API בלבד אין צורך לפתוח דפדפן, אך ההתקנה שימושית אם מתכננים לשלב גם בדיקות UI.
כדי ליצור בדיקה ראשונה אפשר ליצור תיקייה בשם tests ובתוכה קובץ:
api.spec.js
מבנה הפרויקט יכול להיראות כך:
playwright-api-tests/│├── tests/│ ├── api.spec.js│ ├── users.spec.js│ └── authentication.spec.js│├── playwright.config.js├── package.json└── node_modules/
הפרדה בין קובצי הבדיקות מאפשרת לנהל תרחישים לפי מודולים עסקיים, שירותים או סוגי בדיקות.
בדיקת API ראשונה באמצעות Playwright
נניח שקיים שירות API ציבורי שמחזיר רשימת משתמשים.
לצורך הדוגמה נשתמש בכתובת:
ניצור בדיקה שמוודאת שהשרת מחזיר תשובה תקינה ושמבנה הנתונים מתאים לציפיות.
const { test, expect } = require('@playwright/test');test('GET users API', async ({ request }) => { const response = await request.get( 'https://jsonplaceholder.typicode.com/users' ); expect(response.status()).toBe(200); const users = await response.json(); expect(Array.isArray(users)).toBe(true); expect(users.length).toBeGreaterThan(0);});
נבחן את הקוד שלב אחר שלב:
- test מגדיר תרחיש בדיקה חדש.
- request הוא Fixture מובנה של Playwright המאפשר לשלוח בקשות HTTP.
- request.get שולח בקשת GET לשרת.
- response.status מחזיר את קוד התגובה.
- response.json ממיר את גוף התגובה לאובייקט JavaScript.
- expect מבצע בדיקות Assertions מול התוצאה שהתקבלה.
הבדיקה אינה מסתפקת בכך שהשרת ענה. היא גם בודקת שהתגובה מכילה מערך ושקיימים בו משתמשים.
זהו הבדל חשוב בין בדיקת זמינות שירות לבין בדיקה פונקציונלית של ה-API.
בדיקות GET באמצעות Playwright
GET היא בקשה המשמשת לקבלת נתונים משרת.
לדוגמה, נרצה לקבל פרטי משתמש ספציפי:
const { test, expect } = require('@playwright/test');test('GET specific user', async ({ request }) => { const response = await request.get( 'https://jsonplaceholder.typicode.com/users/1' ); expect(response.status()).toBe(200); const user = await response.json(); expect(user.id).toBe(1); expect(user.name).toBeTruthy(); expect(user.email).toContain('@');});
בבדיקה זו אנו מאמתים מספר דברים:
- קוד התגובה הוא 200.
- מזהה המשתמש הוא 1.
- שם המשתמש אינו ריק.
- כתובת הדואר האלקטרוני מכילה את התו @.
בודק QA מקצועי לא צריך להסתפק בבדיקת Status Code. ייתכן שהשרת יחזיר 200 אבל הנתונים עצמם יהיו שגויים.
לכן חשוב לבדוק גם את התוכן, את המבנה ואת המשמעות העסקית של התגובה.
בדיקות POST באמצעות Playwright
POST משמשת בדרך כלל ליצירת משאב חדש במערכת.
לדוגמה, נניח שאנו רוצים ליצור משתמש חדש באמצעות API.
const { test, expect } = require('@playwright/test');test('POST create user', async ({ request }) => { const response = await request.post( 'https://jsonplaceholder.typicode.com/users', { data: { name: 'Guy Test', username: 'guyqa', email: 'guy@example.com' } } ); expect(response.status()).toBe(201); const user = await response.json(); expect(user.name).toBe('Guy Test'); expect(user.username).toBe('guyqa'); expect(user.email).toBe('guy@example.com');});
הבדיקה שולחת נתונים בגוף הבקשה באמצעות data.
לאחר מכן היא מוודאת שהתקבלה תשובת 201 Created ושהשרת החזיר את הפרטים שהוזנו.
חשוב להכיר את ההבדל בין קוד 200 לקוד 201:
- 200 OK – הבקשה הסתיימה בהצלחה.
- 201 Created – משאב חדש נוצר בהצלחה.
במערכות אמיתיות חשוב לבדוק גם האם המשאב אכן נשמר במסד הנתונים ולא רק האם השרת החזיר תגובה חיובית.
שימו לב: JSONPlaceholder הוא שירות הדגמה. פעולת היצירה בו אינה שומרת נתונים באופן קבוע.
בדיקות PUT ו-PATCH לעדכון נתונים
PUT ו-PATCH משמשות לעדכון משאבים, אך קיים ביניהן הבדל.
PUT משמשת בדרך כלל להחלפת ייצוג המשאב כולו, בעוד PATCH מיועדת לעדכון חלקי.
לדוגמה, נרצה לעדכן פרטי משתמש:
test('PUT update user', async ({ request }) => { const response = await request.put( 'https://jsonplaceholder.typicode.com/users/1', { data: { id: 1, name: 'Updated User', username: 'updateduser', email: 'updated@example.com' } } ); expect(response.status()).toBe(200); const user = await response.json(); expect(user.name).toBe('Updated User'); expect(user.email).toBe('updated@example.com');});
דוגמה לעדכון חלקי באמצעות PATCH:
test('PATCH update user email', async ({ request }) => { const response = await request.patch( 'https://jsonplaceholder.typicode.com/users/1', { data: { email: 'newemail@example.com' } } ); expect(response.status()).toBe(200); const user = await response.json(); expect(user.email).toBe('newemail@example.com');});
במערכת אמיתית מומלץ לבדוק גם שהשדות שלא עודכנו נשארו ללא שינוי.
לדוגמה, אם עדכנו רק כתובת דואר אלקטרוני, יש לוודא ששמו של המשתמש לא השתנה בטעות.
בדיקות DELETE באמצעות Playwright
DELETE משמשת למחיקת משאב.
test('DELETE user', async ({ request }) => { const response = await request.delete( 'https://jsonplaceholder.typicode.com/users/1' ); expect(response.status()).toBe(200);});
בדיקת DELETE מקצועית צריכה לכלול יותר מאשר בדיקה שהתקבלה תשובה חיובית.
מומלץ לבדוק:
- האם המשאב נמחק בפועל.
- האם ניסיון לקבל את המשאב לאחר המחיקה מחזיר 404.
- האם ניסיון למחוק משאב שכבר אינו קיים מטופל כראוי.
- האם משתמש ללא הרשאות יכול לבצע מחיקה.
- האם מחיקה של משאב מקושר מטופלת בהתאם לחוקים העסקיים.
חשוב להתאים את קוד התגובה להתנהגות שהוגדרה ב-API. לדוגמה, מערכות מסוימות יחזירו 204 No Content לאחר מחיקה מוצלחת, ולא 200.
בדיקת Headers ו-Content-Type
Headers הם חלק חשוב בתקשורת בין הלקוח לשרת.
הם משמשים להעברת מידע כמו סוג התוכן, סוג התגובה המבוקש, הרשאות ומידע נוסף.
נוכל לבדוק שהשרת מחזיר תוכן בפורמט JSON:
test('Validate response headers', async ({ request }) => { const response = await request.get( 'https://jsonplaceholder.typicode.com/users/1' ); expect(response.status()).toBe(200); const contentType = response.headers()['content-type']; expect(contentType).toContain('application/json');});
בדיקה זו חשובה משום ששרת עשוי להחזיר קוד 200 אך תוכן בפורמט שאינו תואם לציפיות של המערכת.
בבדיקות API מתקדמות כדאי לבדוק גם:
- Cache-Control.
- Content-Length.
- Authorization.
- Accept.
- Content-Type.
- Access-Control-Allow-Origin, כאשר רלוונטי לתרחיש.
אין להניח שכל Header חייב להופיע בכל תגובה. יש לבדוק בהתאם לחוזה ה-API ולדרישות המערכת.
בדיקות Authentication והרשאות באמצעות Playwright
אחד הנושאים החשובים ביותר בבדיקות API הוא אימות זהות והרשאות.
מערכות רבות דורשות Token כדי לאפשר גישה לשירותים מוגנים.
נניח שקיבלנו Access Token ממערכת ההתחברות. נוכל לשלוח אותו ב-Authorization Header:
test('GET protected resource', async ({ request }) => { const response = await request.get( 'https://api.example.com/profile', { headers: { Authorization: 'Bearer YOUR_ACCESS_TOKEN' } } ); expect(response.status()).toBe(200);});
בדוגמה זו YOUR_ACCESS_TOKEN הוא ערך להמחשה בלבד ויש להחליפו ב-Token תקף.
במערכת אמיתית אין להכניס סיסמאות או Tokens ישירות לקוד הבדיקות.
מומלץ להשתמש במשתני סביבה:
const token = process.env.API_TOKEN;test('GET protected resource', async ({ request }) => { const response = await request.get( 'https://api.example.com/profile', { headers: { Authorization: `Bearer ${token}` } } ); expect(response.status()).toBe(200);});
אפשר להריץ את הבדיקה באמצעות משתנה סביבה מתאים בסביבת העבודה.
חשוב לבדוק גם תרחישים שליליים:
- בקשה ללא Token – האם מתקבל 401?
- בקשה עם Token לא תקף – האם הגישה נדחית?
- בקשה עם Token שפג תוקפו – האם המערכת מזהה זאת?
- בקשה של משתמש ללא הרשאה מתאימה – האם מתקבל 403?
- ניסיון לגשת למשאב של משתמש אחר – האם קיימת הגנה מפני חשיפת מידע?
ההבחנה בין 401 Unauthorized לבין 403 Forbidden חשובה:
- 401 מציין שהמשתמש לא עבר אימות תקין.
- 403 מציין שהמשתמש מזוהה, אך אינו מורשה לבצע את הפעולה.
בדיקות אלה הן חלק משמעותי מבדיקות אבטחת API.
שימוש ב-Base URL ובקובץ הגדרות Playwright
בפרויקט גדול לא מומלץ לכתוב את כתובת השרת מחדש בכל בדיקה.
אפשר להגדיר Base URL בקובץ playwright.config.js:
const { defineConfig } = require('@playwright/test');module.exports = defineConfig({ testDir: './tests', use: { baseURL: 'https://jsonplaceholder.typicode.com', extraHTTPHeaders: { Accept: 'application/json' } }, reporter: 'html'});
כעת אפשר לכתוב בדיקה קצרה יותר:
test('GET users', async ({ request }) => { const response = await request.get('/users'); expect(response.status()).toBe(200);});
היתרון הוא שאפשר להחליף בקלות בין סביבות שונות:
- Development.
- QA.
- Staging.
- Production.
בפרויקט מקצועי כדאי לנהל את כתובות הסביבות ואת פרטי ההתחברות באמצעות משתני סביבה ולא לשמור מידע רגיש בקובצי הקוד.
בדיקת JSON Schema באמצעות Playwright
אחד הדברים החשובים בבדיקות API הוא לוודא שמבנה התגובה תואם למבנה שהוגדר במפרט השירות.
לדוגמה, נניח שהמערכת מחזירה משתמש עם השדות הבאים:
- id – מספר מזהה.
- name – שם משתמש.
- username – שם משתמש במערכת.
- email – כתובת דואר אלקטרוני.
אפשר לבדוק את סוגי הנתונים באמצעות Assertions:
test('Validate user response structure', async ({ request }) => { const response = await request.get('/users/1'); expect(response.status()).toBe(200); const user = await response.json(); expect(typeof user.id).toBe('number'); expect(typeof user.name).toBe('string'); expect(typeof user.username).toBe('string'); expect(typeof user.email).toBe('string');});
הבדיקה מאמתת את סוגי הנתונים, אך אינה מחליפה בדיקת JSON Schema מלאה.
במערכות מורכבות אפשר להשתמש בספריות כגון Ajv כדי לבצע ולידציה של JSON Schema.
לדוגמה:
npm install ajv
const Ajv = require('ajv');const ajv = new Ajv();const userSchema = { type: 'object', required: ['id', 'name', 'username', 'email'], properties: { id: { type: 'integer' }, name: { type: 'string' }, username: { type: 'string' }, email: { type: 'string', format: 'email' } }, additionalProperties: true};test('Validate user JSON schema', async ({ request }) => { const response = await request.get('/users/1'); expect(response.status()).toBe(200); const user = await response.json(); const validate = ajv.compile(userSchema); expect(validate(user)).toBe(true);});
בדיקת Schema מאפשרת לזהות שינויים בלתי צפויים במבנה התגובה, גם כאשר השרת ממשיך להחזיר קוד 200.
בדיקות שליליות (Negative Testing)
בדיקות שליליות נועדו לבדוק כיצד המערכת מתנהגת כאשר היא מקבלת נתונים שגויים, בקשות לא תקינות או פעולות שאינן מורשות.
בדיקות אלה חשובות במיוחד משום שמערכות רבות מתפקדות היטב בתרחישים תקינים, אך נכשלות כאשר המשתמש אינו פועל לפי התהליך הצפוי.
דוגמאות לתרחישים:
| תרחיש | תוצאה צפויה |
|---|---|
| שליחת בקשה עם מזהה שאינו קיים | 404 |
| שליחת נתונים חסרים | 400 או 422 |
| שליחת Token לא תקף | 401 |
| ניסיון פעולה ללא הרשאה | 403 |
| שליחת Method שאינו נתמך | 405 |
| שליחת JSON בפורמט שגוי | 400 |
| שליחת בקשה גדולה מהמותר | 413, בהתאם להגדרות |
| חריגה ממגבלת בקשות | 429 |
חשוב לזכור שקודי התגובה המדויקים תלויים במימוש השירות ובחוזה ה-API. אין להניח שכל מערכת חייבת להחזיר את אותו קוד בכל תרחיש.
דוגמה לבדיקת משתמש שאינו קיים:
test('GET non existing user', async ({ request }) => { const response = await request.get('/users/999999'); expect(response.status()).toBe(404);});
בדיקות שליליות צריכות להיות חלק קבוע מתוכנית הבדיקות ולא תוספת שמבצעים רק בסוף הפרויקט.
בדיקות API ושילוב עם בדיקות UI
אחד היתרונות המשמעותיים ביותר של Playwright הוא האפשרות לשלב בדיקות API ובדיקות UI באותו פרויקט.
לדוגמה, נניח שקיימת מערכת לניהול לקוחות.
אפשר לבצע את התהליך הבא:
- ליצור לקוח חדש באמצעות API.
- לקבל את מזהה הלקוח שנוצר.
- לפתוח את מערכת המשתמש באמצעות דפדפן.
- להיכנס למסך הלקוחות.
- לחפש את הלקוח לפי המזהה.
- לוודא שהפרטים מוצגים בצורה תקינה.
כך אפשר לבדוק לא רק שה-API מחזיר תשובה תקינה, אלא שגם הממשק מציג את המידע שנוצר.
דוגמה לשילוב:
test('Create user through API and verify in UI', async ({ request, page}) => { const response = await request.post('/users', { data: { name: 'Guy Test', username: 'guyqa', email: 'guy@example.com' } }); expect(response.status()).toBe(201); const user = await response.json(); await page.goto('/users'); await expect( page.getByText('Guy Test') ).toBeVisible();});
הדוגמה ממחישה את הרעיון, אך בפרויקט אמיתי יש להגדיר גם כתובת בסיס לדפדפן, סביבת בדיקה מתאימה ונתוני בדיקה שניתן לנקות בסיום התרחיש.
השילוב הזה שימושי במיוחד בבדיקות End-to-End, כאשר רוצים לוודא שתהליך עסקי שלם עובד מהשרת ועד למשתמש.
ניהול נתוני בדיקה ויצירת Test Data
ניהול נתוני בדיקה הוא אחד האתגרים המרכזיים בפרויקטי אוטומציה.
כאשר מספר רב של בדיקות משתמש באותם נתונים, עלולות להיווצר התנגשויות.
לדוגמה:
- שתי בדיקות מנסות לעדכן את אותו משתמש.
- בדיקה אחת מוחקת נתונים שבדיקה אחרת עדיין צריכה.
- נתונים שנשארו מהרצה קודמת משפיעים על תוצאות הבדיקה.
- בדיקות מקבילות יוצרות כפילויות.
כדי להימנע מבעיות אלה מומלץ ליצור נתונים ייחודיים לכל בדיקה.
test('Create unique user', async ({ request }) => { const uniqueEmail = `user_${Date.now()}@example.com`; const response = await request.post('/users', { data: { name: 'QA Automation', email: uniqueEmail } }); expect(response.status()).toBe(201); const user = await response.json(); expect(user.email).toBe(uniqueEmail);});
במערכות אמיתיות כדאי גם להגדיר מנגנון Cleanup שימחק נתונים שנוצרו לצורך הבדיקה.
חשוב לבצע את המחיקה בזהירות, ורק בסביבת בדיקות שבה מותר לשנות נתונים.
בדיקות API באמצעות Fixtures
Fixtures הם מנגנון המאפשר להגדיר משאבים או פעולות שמשמשים כמה בדיקות.
לדוגמה, במקום להפיק Token מחדש בכל בדיקה, אפשר ליצור Fixture שמבצע התחברות ומספק את ה-Token לבדיקות.
דוגמה:
const { test: base, expect } = require('@playwright/test');const test = base.extend({ apiToken: async ({ request }, use) => { const response = await request.post( 'https://api.example.com/login', { data: { username: process.env.API_USER, password: process.env.API_PASSWORD } } ); expect(response.status()).toBe(200); const result = await response.json(); await use(result.accessToken); }});test('Access protected API', async ({ request, apiToken }) => { const response = await request.get( 'https://api.example.com/profile', { headers: { Authorization: `Bearer ${apiToken}` } } ); expect(response.status()).toBe(200);});
היתרון הוא הפרדה בין תהליך ההתחברות לבין הבדיקה העסקית.
בפרויקטים גדולים ניתן להגדיר Fixtures עבור משתמשים שונים, הרשאות, נתוני בדיקה ומשאבים נוספים.
בדיקות Timeout וזמני תגובה
בדיקות API אינן מתייחסות רק לתוכן התגובה אלא גם לזמן שלוקח לשרת להחזיר אותה.
לדוגמה, שירות שמחזיר נתונים לאחר 15 שניות עשוי להיות תקין מבחינת תוכן, אך לא לעמוד בדרישות הביצועים של המערכת.
אפשר למדוד זמן תגובה באמצעות JavaScript:
test('API response time', async ({ request }) => { const start = Date.now(); const response = await request.get('/users'); const duration = Date.now() - start; expect(response.status()).toBe(200); expect(duration).toBeLessThan(2000);});
בדוגמה זו הבדיקה מוודאת שזמן התגובה קטן משתי שניות.
חשוב להבחין בין בדיקת זמן תגובה של בקשה בודדת לבין בדיקת עומסים.
Playwright מתאים לבדיקות פונקציונליות ולאימות זמני תגובה בסיסיים, אך אינו תחליף לכלי ייעודי לבדיקות עומסים, Stress ו-Performance.
לבדיקות כאלה מומלץ להכיר גם כלים כמו JMeter ו-k6.
להעמקה בנושא ניתן לקרוא את המדריך בדיקות עומסים ובדיקות ביצועים.
הרצת בדיקות API באמצעות Playwright
לאחר כתיבת הבדיקות אפשר להריץ אותן באמצעות הפקודה:
npx playwright test
כדי להריץ קובץ מסוים:
npx playwright test tests/api.spec.js
כדי להציג את תוצאות הבדיקות בדוח HTML:
npx playwright show-report
ניתן גם להגדיר הרצה של בדיקה מסוימת לפי שם:
npx playwright test -g "GET users API"
אפשרויות הרצה נוספות:
npx playwright test --workers=4
פקודה זו מאפשרת להריץ בדיקות במקביל באמצעות ארבעה Workers.
חשוב להתאים את רמת המקביליות לסביבת הבדיקות ולוודא שהבדיקות אינן תלויות זו בזו.
שילוב Playwright בתהליכי CI/CD
אחד היתרונות של אוטומציה הוא האפשרות להריץ בדיקות באופן אוטומטי בכל שינוי בקוד.
אפשר לשלב Playwright בתהליך CI/CD כך שלאחר כל עדכון משמעותי במערכת יתבצעו בדיקות API אוטומטיות.
לדוגמה, בקובץ GitHub Actions:
name: Playwright API Testson: push: branches: [ main ] pull_request: branches: [ main ]jobs: test: runs-on: ubuntu-latest steps: - name: Checkout uses: actions/checkout@v4 - name: Setup Node.js uses: actions/setup-node@v4 with: node-version: 20 - name: Install dependencies run: npm ci - name: Install Playwright run: npx playwright install --with-deps - name: Run API tests run: npx playwright test
הדוגמה מריצה את הבדיקות בכל Push או Pull Request לענף main.
במערכת אמיתית יש להוסיף משתני סביבה, כתובות שרתים, Secrets והרשאות מתאימות.
שילוב זה מאפשר לזהות תקלות מוקדם יותר, עוד לפני שהגרסה מגיעה לסביבת הייצור.
איך כותבים Test Cases לבדיקות API עם Playwright?
כתיבת קוד אוטומציה אינה מחליפה את תהליך תכנון הבדיקות.
לפני כתיבת הבדיקה חשוב להבין את הדרישה העסקית, את מבנה השירות ואת התוצאות הצפויות.
לדוגמה, עבור API של יצירת משתמש, אפשר לבנות את תרחישי הבדיקה הבאים:
| מספר | תרחיש בדיקה | תוצאה צפויה |
|---|---|---|
| 1 | יצירת משתמש עם נתונים תקינים | 201 |
| 2 | יצירת משתמש ללא שם | 400 או 422 |
| 3 | יצירת משתמש ללא כתובת מייל | 400 או 422 |
| 4 | יצירת משתמש עם מייל לא תקין | 400 או 422 |
| 5 | יצירת משתמש עם מייל קיים | שגיאה עסקית מתאימה |
| 6 | ניסיון יצירה ללא הרשאה | 401 או 403 |
| 7 | יצירת משתמש עם שדות נוספים | בהתאם לחוזה השירות |
| 8 | יצירת משתמש עם ערכים ארוכים במיוחד | טיפול תקין בהתאם למגבלות |
לכל תרחיש צריך להגדיר:
- תנאים מקדימים.
- נתוני קלט.
- סוג הבקשה.
- כתובת Endpoint.
- Headers.
- קוד תגובה צפוי.
- מבנה התגובה.
- בדיקות תוכן.
- השפעה על הנתונים במערכת.
- תנאי ניקוי בסיום.
מומלץ לקרוא גם את המדריך איך כותבים Test Case לבדיקת API – מדריך מעשי עם דוגמאות.
טעויות נפוצות בבדיקות API עם Playwright
גם אנשי QA מנוסים עלולים לבצע טעויות כאשר הם מתחילים לעבוד עם Playwright.
1. בדיקת Status Code בלבד
קוד 200 אינו מבטיח שהנתונים נכונים. יש לבדוק גם את התוכן, המבנה והמשמעות העסקית.
2. שימוש בנתונים קבועים בכל הבדיקות
נתונים קבועים עלולים ליצור התנגשויות בהרצות מקבילות. עדיף ליצור נתונים ייחודיים.
3. שמירת סיסמאות ו-Tokens בקוד
מידע רגיש צריך להישמר במשתני סביבה או במנגנון Secrets מאובטח.
4. התעלמות מבדיקות שליליות
בדיקת API איכותית צריכה לבדוק גם התנהגות מול נתונים שגויים, הרשאות חסרות ומזהים שאינם קיימים.
5. תלות בין בדיקות
בדיקה אחת לא צריכה להיכשל רק משום שבדיקה אחרת לא רצה לפניה. יש לשאוף לעצמאות של תרחישי הבדיקה.
6. שימוש ב-Playwright לבדיקות עומס כבדות
Playwright אינו כלי ייעודי לבדיקות עומסים. לבדיקות עומס משמעותיות עדיף להשתמש ב-JMeter או k6.
7. התעלמות מניקוי נתונים
בדיקות שיוצרות נתונים צריכות לכלול תכנון של ניקוי, כדי למנוע הצטברות מידע מיותר בסביבת הבדיקות.
8. שימוש ב-Wait קבוע ללא צורך
אין צורך להוסיף השהיות קבועות בין בקשות API כאשר אפשר להמתין לתגובה עצמה באמצעות מנגנוני Promise ו-async/await.
יתרונות וחסרונות של Playwright לבדיקות API
יתרונות
- תמיכה מובנית בבקשות HTTP.
- עבודה נוחה עם JavaScript ו-TypeScript.
- שילוב בין בדיקות API לבדיקות UI.
- מנגנון Assertions מובנה.
- תמיכה בהרצות מקבילות.
- ניהול Fixtures ונתוני בדיקה.
- הפקת דוחות HTML.
- התאמה לתהליכי CI/CD.
- קהילה רחבה ותיעוד מפורט.
חסרונות
- דורש ידע בסיסי בתכנות.
- אינו מספק ממשק גרפי נוח כמו Postman לשליחת בקשות ידניות.
- דורש תחזוקה של קוד הבדיקות.
- אינו תחליף לכלים ייעודיים לבדיקות עומסים.
- בפרויקטים גדולים נדרשת ארכיטקטורת אוטומציה מסודרת כדי למנוע כפילות וקוד מורכב.
למי כדאי ללמוד בדיקות API עם Playwright?
Playwright מתאים למספר קבוצות של אנשי מקצוע:
בודקי תוכנה ידניים המעוניינים להתקדם לאוטומציה
מי שכבר מכיר HTTP, REST API, JSON ותרחישי בדיקה יכול להרחיב את הידע באמצעות JavaScript ולהתחיל לפתח בדיקות אוטומטיות.
אנשי QA Automation
מי שכבר עובד עם Selenium או כלי אוטומציה אחרים יכול להוסיף יכולות API לפרויקטים קיימים ולשפר את הכיסוי הבדיקתי.
מפתחי תוכנה
מפתחים יכולים להשתמש ב-Playwright כדי לבדוק שירותים ותהליכים עסקיים כחלק מתהליך הפיתוח.
ראשי צוותי QA ומנהלי בדיקות
מנהלים יכולים להשתמש ב-Playwright כדי לבנות תשתית בדיקות אחידה, לשפר את מהירות קבלת המשוב ולהקטין את התלות בבדיקות ידניות חוזרות.
למי שמעוניין להבין את התמונה הרחבה של בדיקות API, מומלץ לקרוא גם את המדריכים בדיקות REST API – מדריך לאנשי ה-QA ו-בדיקות API אוטומטיות ל-QA.
סיכום: האם כדאי להשתמש ב-Playwright לבדיקות API?
Playwright הוא כלי משמעותי עבור אנשי QA המעוניינים לפתח תשתית אוטומציה מודרנית ולשלב בדיקות API כחלק מתהליך בדיקות רחב.
הוא מאפשר לשלוח בקשות HTTP, לבדוק תגובות, לאמת מבני JSON, לבדוק הרשאות, לנהל נתוני בדיקה ולהריץ תרחישים אוטומטיים כחלק מתהליכי CI/CD.
היתרון הגדול ביותר שלו הוא השילוב בין בדיקות API לבדיקות UI באותו Framework. במקום לנהל מערכות אוטומציה נפרדות, ניתן ליצור תהליך בדיקה אחד שמכסה את השירותים ואת חוויית המשתמש.
עם זאת, חשוב לבחור את הכלי בהתאם לצורך. Postman מתאים מאוד לבדיקות API ידניות ולחקירת שירותים, Playwright מתאים לאוטומציה מבוססת קוד ולשילוב בדיקות API ו-UI, ואילו JMeter ו-k6 מתאימים יותר לבדיקות עומסים וביצועים.
עבור אנשי QA שרוצים להתקדם לתחום האוטומציה, לימוד Playwright לצד הבנה טובה של HTTP, REST API, JSON, JavaScript וכתיבת Test Cases הוא שילוב מקצועי שיכול לפתוח אפשרויות תעסוקה ולהרחיב את סל היכולות שלהם.
לקרוא מאמרים זה נחמד אבל לא יביא אותך לתוצאה שאתה רוצה, בדיוק בשביל זה הכנו עבורך את הקורס הדיגיטלי המהיר, תוך שעתיים וחצי תלמד את תחום הבדיקות ידניות, תוכל להתחיל לעבוד מהבית דרך FIVERR או ולהתכונן נכון לראיונות עבודה שיעזרו לך לצלוח אותם. כנס כאן הקורס ממוקד בבדיקות תוכנה ידניות הנותן בסיס חזק לתחום.
לעבוד מהבית כבודק תוכנה עם FIVERR >> לחץ כאן