מקריאה לפעולה: איך בודקים WebMCP עם Playwright

עודכן:
כ־10 דקות קריאה
תוכן העניינים

מבוא

ב־TestShift אנחנו מיישמים באתר שלנו שני שלבים של הנגשה לסוכני AI. לכל שלב יש שאלת איכות אחרת.

  1. אתר שסוכנים יכולים למצוא ולקרוא. הנגשנו את התוכן ובדקנו שהוא נגיש גם בלי להריץ JavaScript. דוח Is Agentic תיעד 100/100 עבור test-shift.com ב־7 בנובמבר 2026. במקרה הבוחן הראשון פירטתי מה בדקנו מעבר לציון.
  2. אתר שסוכנים יכולים גם לפעול בו. הטמענו בעמוד צור קשר שלושה כלים דרך WebMCP, פרוטוקול דפדפן חדש שנמצא עדיין בפיתוח. בחרנו לאמץ אותו מוקדם ולבנות את בדיקות Playwright כחלק מההטמעה, החל משתי פעולות כתיבה: שליחת פנייה וקביעת שיחה.

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

חושפים פעולות, לא הרשאות לספק

עמוד צור קשר מגדיר שלושה כלים דרך ממשק JavaScript של WebMCP. הם זמינים רק בדפדפן תומך; כלי הקביעה דורשים גם שרת מוגדר.

כלימה הוא עושהמה המבקר מאשר
send_contact_messageשולח ל־Formspree.כתובת לתשובה, נושא והודעה.
list_booking_timesמציג מועדים ב־UTC בלי לשמור מקום.אין מה לאשר.
book_consultationקובע פגישה דרך Calendly.מוזמן, שעה ואזור זמן.

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

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

תוצאהמה הסוכן עושה
cancelledמדווח שהפעולה לא המשיכה. ייתכן שהמבקר ביטל, וייתכן שהעמוד עצר את הפעולה. זו לא דחייה מצד הספק.
requires_manual או verification_failedמפנה את המבקר לטופס או לעמוד הקביעה כדי שישלים את האימות בעצמו. לא מנסה שוב אוטומטית.
unknownלא מדווח על הצלחה ולא חוזר על הפעולה. ייתכן שהספק כבר קיבל אותה. מבררים אם ההודעה התקבלה או בודקים את זימון Calendly לפני ניסיון נוסף.

הקונפיגורציה היא גבול אחריות, לא רק רשימת מפתחות

Astro ממשיך לבנות את האתר כעמודים סטטיים. WebMCP רץ בדפדפן בעמוד צור קשר; לא היה צורך להקים שרת סוכנים או לשכתב את האתר. לקביעת פגישות הוספנו מספר פונקציות Vercel. הן קוראות ל־API של Calendly עם ההרשאות הדרושות; הדפדפן והסוכן לא מקבלים אותן. פניות צור קשר ממשיכות להגיע לטופס הקיים ב־Formspree.

גבול במערכתמה הגדרנומה יכול להשתבשאיך בודקים
reCAPTCHA ו־FormspreeSite Key ציבורי בזמן בניית האתר, Secret תואם ב־Formspree ושם מארח מאושר.מפתחות לא תואמים, דחיית טוקן או סיווג הפנייה כספאם.בדיקה מדומה משווה את כל שדות הטופס, כולל טוקן סינתטי כשהוא מוגדר. בבדיקה חיה מחפשים את הרשומה אצל הספק, את הסיווג ואת המייל.
דגל הקביעה וכתובת המקורדגל הפעלה לפי סביבה וכתובת HTTPS מדויקת שהשרת מצפה לה.כתובת Preview שהועתקה לפרודקשן דוחה מבקרים אמיתיים; הפעלה לפני השלמת ההגדרות חושפת מסלול לא תקין.בדיקות קונפיגורציה ומקור בשרת, ואחריהן בדיקת שחרור מול הדומיין שנפרס.
Turnstile ובקשות קביעה ב־Redisאימות שמוגבל לשם המארח, מפתח חתימה בשרת, מצב משותף קצר חיים ומגבלות קצב.שימוש חוזר בבקשת קביעה, שינוי פרטים שאושרו, אימות שפג או שתי פונקציות שמבצעות אותה כתיבה.סביבת הדפדפן המדומה בודקת את מסלול האישור. בדיקות שרת בודקות קשירה לסשן ולפרטים, מימוש חד־פעמי ודחיות. ה־store בזיכרון של בדיקות E2E אינו בדיקה של Redis עצמו.
Calendlyטוקן עם ההרשאות הנדרשות, סוג אירוע שנבחר בצד השרת ומיקום פגישה שתואם להגדרת האירוע.פירוש זמינות כשריון, שימוש באירוע שגוי או קביעה בלי מיקום הפגישה הנדרש.בבדיקות המדומות משווים את בקשת הספק המלאה. בבדיקה חיה מאמתים בנפרד את הפגישה, הזימון וקישור ההצטרפות.

לפרודקשן מגדירים הרשאות וסודות נפרדים, מאמתים את כתובת המקור ואת הגדרות הספקים מול הדומיין הציבורי, ושומרים סודות אצל הספק או כ־Secret ב־Vercel. השינויים חלים על פריסות חדשות; שמירה בלוח הבקרה לא מוכיחה שהפריסה שמקבלת תעבורה כבר משתמשת בערכים האלה. את דגל הקביעה מפעילים רק אחרי בדיקות השחרור. בנפרד, בודקים גילוי כלים בדפדפן תומך גם בלי דגל הבדיקות של Playwright, לפי התיעוד העדכני של Chrome.

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

קודם בונים סביבת בדיקה, אחר כך assertions

Playwright 1.64 הוסיפה את page.webmcp ואת frame.webmcp. עכשיו אפשר לגלות ולהפעיל בבדיקה את אותו כלי שסוכן בדפדפן רואה, בלי להפעיל מודל שפה ובלי לנחש איזה כפתור מייצג את הפעולה. באותה בדיקה אפשר לעבור ל־locators הרגילים ולוודא מה המבקר רואה ומה הוא צריך לאשר. כך בודקים את חוזה הכלי מול הסוכן, את האישור האנושי ואת הבקשה שיוצאת לספק, באותו דפדפן.

ב־TestShift הבדיקות רצות עם Playwright 1.65.0 בפרויקט Chromium ייעודי עם --enable-features=WebMCP. הבדיקות הרגילות לא צריכות את הדגל.

פרויקט דפדפן ייעודי

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

import { defineConfig, devices } from "@playwright/test";

export default defineConfig({
  testDir: "./e2e",
  use: {
    baseURL: "http://127.0.0.1:4321",
    screenshot: "only-on-failure",
    trace: "on-first-retry",
  },
  projects: [
    {
      name: "chromium",
      testIgnore: "**/webmcp.spec.ts",
      use: { ...devices["Desktop Chrome"] },
    },
    {
      name: "webmcp-chromium",
      testMatch: "**/webmcp.spec.ts",
      use: {
        ...devices["Desktop Chrome"],
        launchOptions: { args: ["--enable-features=WebMCP"] },
      },
    },
  ],
  webServer: {
    command: "pnpm preview --host 127.0.0.1 --port 4321",
    url: "http://127.0.0.1:4321/",
    reuseExistingServer: !process.env.CI,
  },
});

פנייה: מיירטים לפני שפותחים את העמוד

מאחורי submissions יש יירוט של בקשות רשת. בתוך בדיקת הפנייה מתקינים את שני ה־routes לפני הניווט. מימוש CAPTCHA מדומה מחזיר טוקן ידוע, ו־Formspree כלל לא נקרא. כל ניסיון בקשה נרשם, גם אם assertion מאוחר יותר ייכשל.

const submissions: {
  method: string;
  fields: [string, FormDataEntryValue][];
}[] = [];

await page.route("https://www.google.com/recaptcha/**", route =>
  route.fulfill({
    contentType: "text/javascript",
    body: 'window.grecaptcha={ready(f){f()},execute(){return Promise.resolve("fixture-proof")}};',
  })
);

await page.route("https://formspree.io/**", async route => {
  const request = route.request();
  const fields = await new Response(request.postDataBuffer()?.toString("utf8"), {
    headers: { "content-type": request.headers()["content-type"] ?? "" },
  }).formData();

  submissions.push({
    method: request.method(),
    fields: [...fields].sort(([a], [b]) => a.localeCompare(b)),
  });
  await route.fulfill({ json: { next: "https://formspree.io/thanks" } });
});

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

קביעה: שרת האפליקציה האמיתי, תלויות נשלטות

סביבת הקביעה המדומה מפעילה שרת HTTP מקומי ב־Node. בקשות לעמודים ולנכסים מועברות לאתר הסטטי; בקשות לנתיבי הקביעה מועברות ל־createBookingHandler האמיתי. מחליפים רק את התלויות החיצוניות: תשובות Calendly, אימות המבקר והאחסון המשותף.

זה לב ה־fixture, כקטע קוד מתוך המימוש. origin הוא המקור של השרת המקומי הזמני ו־slot הוא מועד UTC סינתטי בעתיד. מתאם HTTP והעברת בקשות העמוד הושמטו. שתי פונקציות היצירה הן קוד אפליקטיבי, לא API של Playwright.

const writes: unknown[] = [];
const values = new Map<string, string>();
const eventType = "https://api.calendly.com/event_types/fixture";

const calendly = createCalendlyAccess(
  "fixture-token",
  eventType,
  async (input, init) => {
    const url = new URL(String(input));
    if (url.origin !== "https://api.calendly.com")
      throw new Error("Unexpected fixture destination");

    if (url.pathname === "/event_type_available_times")
      return Response.json({
        collection: [{ status: "available", start_time: slot }],
      });

    if (url.pathname !== "/invitees" || init?.method !== "POST")
      throw new Error("Unexpected fixture operation");

    writes.push(JSON.parse(String(init.body)));
    return Response.json(
      { resource: { uri: "https://api.calendly.com/scheduled_events/fixture/invitees/test" } },
      { status: 201 }
    );
  }
);

const handler = createBookingHandler({
  origin,
  siteKey: "fixture-site-key",
  hashKey: "fixture-only",
  verify: async proof => proof === "fixture-proof",
  ...calendly,
  store: {
    async put(key, value) {
      if (values.has(key)) return false;
      values.set(key, value);
      return true;
    },
    async take(key, value) {
      if (values.get(key) !== value) return false;
      return values.delete(key);
    },
    async limit() {
      return true;
    },
  },
});

הבקשה מהדפדפן עדיין עוברת את בדיקות המקור, העוגייה, בקשת הקביעה והפרטים. writes מתעד את הבקשה הסופית ל־Calendly אחרי הבדיקות האלה. זו בדיקה רחבה יותר מזיוף תשובת הקביעה בדפדפן, אבל צרה מבדיקת אינטגרציה חיה: limit() תמיד מאפשר פעולה, ה־Map אינו מממש TTL או תקלות רשת של Redis, והטוקן הסינתטי אינו בודק את Cloudflare.

בודקים את חוזה הכלי ואת החלטת המבקר

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

await page.goto("/contact/");
await expect.poll(async () =>
  (await page.webmcp.tools()).map(tool => tool.name)
).toContain("send_contact_message");

const pending = page.webmcp.callTool("send_contact_message", {
  email: "test@example.com",
  subject: "quality-gates",
  message: "Our CI tests need a reliable signal.",
});

const review = page.getByRole("dialog");
await expect(review).toContainText("test@example.com");
expect(submissions).toHaveLength(0);
await review.getByRole("button", { name: "Send message" }).click();
expect(await pending).toMatchObject({ status: "accepted" });
expect(submissions).toHaveLength(1);

הסוויטה מכסה שלושה מסלולי משתמש ועוד שני מקרי קצה של תשובת קביעה:

תרחישמה הבדיקה מאמתת בפועל
שליחת פנייהמגלה את הכלי, מפעילה אותו עם נתוני בדיקה ובודקת את חלון האישור. לפני האישור אין בקשה לספק. אירוע טעינה חוזר לא סוגר את החלון. אחרי אישור מפענחים את בקשת ה־multipart ומשווים את כל השדות: כתובת לתשובה, נושא, הודעה, שדה מלכודת ריק וטוקן CAPTCHA מדומה אם הוא מוגדר. נשלחת בקשת POST אחת בלבד. בניווט לעמוד אחר מוודאים שהכלי כבר לא רשום.
קביעת פגישהפותחת את עמוד צור קשר בעברית, מגלה את שני כלי הקביעה וקוראת מועד ידוע מראש. בודקת בחלון האישור את כתובת המוזמן, אזור הזמן ושעת ה־UTC המדויקת. לפני האישור אין כתיבה לספק. אחריו בודקים booked, חיווי הצלחה בעברית, ובקשת ספק אחת עם סוג האירוע, שעת ההתחלה ופרטי המוזמן הצפויים.
ביטול של כל אחת משתי הפעולותפותחת ומבטלת כל חלון בתורו. שני הכלים מחזירים cancelled והחלונות נסגרים. בקביעה מוצג שלא נשלחה בקשה. סופרים גם ניסיונות בקשה וגם כתיבות שנרשמו אצל הספק המדומה: אפס בקשות ל־Formspree ואפס בקשות POST לנתיבי הכתיבה של הקביעה.
הצלחה לכאורההצלחה מוצגת רק כשחוזרים יחד HTTP 201 ו־booked. תשובת 200 עם booked או 201 עם unknown לא מציגה הצלחה. במקום זאת, האתר מבקש לבדוק את הזימון או את היומן לפני שמנסים שוב.

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

הופכים הצלחה לכאורה לכישלון בבדיקה

סטטוס HTTP מוצלח אינו אישור לפגישה. הקטע הבא מותאם מהבדיקה שלנו: הוא משתמש בשרת הקביעה המקומי ובמימוש Turnstile סינתטי, ומחליף רק את תשובת הקביעה ב־HTTP 201 עם unknown. המקרה צריך להישאר שלילי, גם כשהתעבורה אומרת “נוצר.”

test("201 with unknown must not show success", async ({ page }) => {
  const fixture = await openBookingFixture();
  try {
    await page.route("https://challenges.cloudflare.com/turnstile/**", route =>
      route.fulfill({
        contentType: "text/javascript",
        body: 'window.turnstile={render(_el,o){queueMicrotask(()=>o.callback("fixture-proof"));return "fixture";},remove(){}};',
      })
    );
    await page.route("**/api/webmcp/book.json", route =>
      route.fulfill({ status: 201, json: { status: "unknown" } })
    );
    await page.goto(fixture.origin + "/contact/");
    await expect.poll(async () =>
      (await page.webmcp.tools()).map(tool => tool.name)
    ).toContain("book_consultation");

    const pending = page.webmcp.callTool("book_consultation", {
      startTime: fixture.slot,
      name: "Test Reader",
      email: "test@example.com",
      timeZone: "Asia/Jerusalem",
    });
    await page.getByRole("dialog")
      .getByRole("button", { name: "Book consultation" }).click();

    expect(await pending).toMatchObject({ status: "unknown" });
    await expect(page.getByLabel("Booking status")).toHaveText(
      "Calendly did not confirm the result. Check your invitation or calendar before trying again."
    );
  } finally {
    await fixture.close();
  }
});

המקרה הנוסף מחזיר HTTP 200 עם booked. יחד הם אוכפים תנאי משולב: חיווי הצלחה דורש גם 201 וגם booked. אלה לא בדיקות של תקלה חיה ב־Calendly; הן בודקות את פרשנות התשובה בצד הלקוח שלנו.

משחזרים את ה־race ומשאירים אותו מתוקן

בהרצה חיה ב־Preview הכלי החזיר cancelled אחרי האישור, בלי POST ל־Formspree. כדי לאבחן את התקלה היה צריך לראות את הרצף, לא רק את מחרוזת התוצאה:

  1. מודול צור קשר עלה ורשם את הכלים לפני שהעמוד סיים להיטען.
  2. המבקר אישר פעולה; היא התחילה לקבל טוקן אימות.
  3. אירוע astro:page-load מאוחר הפעיל שוב את האתחול.
  4. האתחול קרא לפעולת הניקוי, שביטלה את ההפעלה הפעילה. שום בקשה לא יצאה ל־Formspree.

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

await page.route("**/__webmcp_fixture_delay.gif", async route => {
  await new Promise(resolve => setTimeout(resolve, 1400));
  await route.fulfill({ status: 404, body: "" });
});
await page.addInitScript(() => {
  document.addEventListener("DOMContentLoaded", () => {
    const blocker = new Image();
    blocker.src = "/__webmcp_fixture_delay.gif";
    document.body.append(blocker);
  });
});
await page.route("https://www.google.com/recaptcha/**", route =>
  route.fulfill({
    contentType: "text/javascript",
    body: 'window.grecaptcha={ready(f){f()},execute(){return new Promise(r=>setTimeout(()=>r("fixture-proof"),2200))}};',
  })
);
await page.goto("/contact/", { waitUntil: "domcontentloaded" });

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

מאתחלים פעם אחת לעמוד, מנקים בניווט

הטעות הייתה לפרש כל אירוע אתחול כסיבה לפרק את הכלים שכבר פעילים. זה קטע ניהול החיים מעמוד צור קשר. initContactForm, initBookingCalendar ו־registerContactTools הן פונקציות עזר של האפליקציה שהמודול מייבא. תנאי הכניסה מונע מאתחול שני לבטל פעולה; מעבר לעמוד אחר עדיין מנקה את הכלים הישנים.

let cleanup: (() => void) | undefined;

function setupContact() {
  if (cleanup) return;
  const root = document.querySelector<HTMLElement>("[data-contact-form]");
  const widget = document.getElementById("calendly-widget");
  if (!root && !widget) return;

  const cleanForm = root ? initContactForm(root) : () => {};
  const cleanBooking = widget ? initBookingCalendar(widget) : () => {};
  const form = root?.querySelector("form");
  const dialog = document.querySelector<HTMLDialogElement>("[data-webmcp-review]");
  const cleanTools = form && dialog
    ? registerContactTools({
        document, form, dialog,
        locale: document.documentElement.lang === "he" ? "he" : "en",
      })
    : () => {};

  cleanup = () => {
    cleanTools();
    cleanForm();
    cleanBooking();
  };
}

document.addEventListener("astro:page-load", setupContact);
document.addEventListener("astro:before-swap", () => {
  cleanup?.();
  cleanup = undefined;
});
setupContact();

שומרים בדיקת רגרסיה שלא תלויה בהשהיות

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

const pending = page.webmcp.callTool("send_contact_message", contact);
const review = page.getByRole("dialog");
await expect(review).toContainText(contact.message);
expect(submissions).toHaveLength(0);

await page.evaluate(() => document.dispatchEvent(new Event("astro:page-load")));
await expect(review).toBeVisible();
await review.getByRole("button", { name: "Send message" }).click();

expect(await pending).toMatchObject({ status: "accepted" });
expect(submissions).toHaveLength(1);

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

בדיקה ירוקה וזימון שהתקבל הן ראיות שונות

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

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

אחרי תיקון האתחול, כלי צור קשר ביצע בקשת POST אחת ב־Preview. Formspree החזיר HTTP 200, והפנייה נמצאה בתיקיית Spam שלו. לא נמצאה הודעה תואמת בתיבת המייל. זה מוכיח שהפנייה הגיעה לספק, לא שהיא נכנסה לתיבת הפניות או נמסרה במייל. לא הסקנו מה גרם לסיווג.

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

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

מה למדנו

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


רוצים לדבר על ארכיטקטורת האיכות שלכם?

תפסיקו לדבג, תתחילו לשחרר גרסאות.

לתיאום שיחת אסטרטגיה