Əsas məzmuna keç
FrontDepth, Ana səhifə

Testləşdirmə

Playwright ilə end-to-end testlər

End-to-end test nəyi sübut edir və bunun qiyməti nədir, etibarlı qalan Playwright testlərini necə yazmalı: istifadəçiyə görünən locator-lar, auto-waiting və web-first assertion-lar, təcrid olunmuş context-lər və fixture-lar, storageState ilə bir dəfə daxil olmaq, page.route, project-lər və CI, trace-lərlə debug.

JuniorMiddleSeniorYenilənib: 16 noyabr 2026

Oxu səviyyəsi

Seçilmiş səviyyəyə qədər olan bölmələr göstərilir.

Bu mövzu Junior səviyyəsindən başlayır.

JuniorKonsepsiya

End-to-end test nəyi sübut edir

real tətbiqi real brauzerdə istifadəçi kimi idarə edir: URL açır, klikləyir, yazır və ekranda nə göründüyünü yoxlayır. Test ilə nəticə arasında istifadəçinin asılı olduğu hər şey dayanır: production build-i, router, CSS, brauzerin özü, cookie-lər və yönləndirmələr, API və onun arxasındakı verilənlər bazası.

E2E testləri dəyərli edən məhz budur. Onlar jsdom-da işləyən unit və görə bilmədiyi problemləri tutur:

  • sticky banerin örtdüyü və ya CSS-in gizlətdiyi düymə, ona görə klik ona heç vaxt çatmır;
  • sınmış route, çatışmayan mühit dəyişəni, chunk-lardan birini daxil etməyən build;
  • sahə adı fərqləndiyi üçün backend-in sorğusunu rədd etdiyi form;
  • SameSite və ya Secure atributuna görə brauzerin göndərmədiyi sessiya cookie-si;
  • Chromium-da işləyən, Safari-nin arxasındakı engine olan WebKit-də isə sınan funksionallıq.

Onları baha edən də budur:

  • Yavaşdır. Brauzer açılır, tətbiq yüklənir, real sorğular gedib-gəlir. Bir test millisaniyələr yox, saniyələr çəkir, yüzlərlə testdən ibarət dəst isə paralel işləsə belə dəqiqələr çəkir.
  • Hərəkət edən hissələr çoxdur. Bazadakı data, şəbəkə vaxtları, animasiyalar və üçüncü tərəf skriptləri testi dəyişikliklə əlaqəsi olmayan səbəblərdən sındıra bilər. çoxu buradan gəlir.
  • Uğursuzluqlar qeyri-müəyyəndir. "Checkout testi sındı" UI-da, API-də, datada və ya testin özündə bug demək ola bilər.
  • Hazırlıq. Tətbiq lokal və CI-da backend və test datası ilə işləməlidir.

Ona görə E2E testlər hər halı yox, istifadəçi ssenarilərini əhatə edir: daxil olmaq, istifadəçilərin gəldiyi əsas axınlar (yaratmaq, redaktə etmək, ödəmək, dərc etmək) və bir neçə sistemdən keçən yollar. Hər ssenariyə bir test hissələrin bir-birinə düzgün bağlandığını sübut edir. Validasiya, formatlama və xəta kodlarının kənar halları daha sürətli testlərə aiddir. Martin Fowler-in təsvir etdiyi test piramidası və Kent C. Dodds-un testing trophy-si orta qatlar barədə razılaşmır, amma hər ikisi E2E testləri zirvəyə qoyur: onlar azdır və hər biri bahadır.

E2E test nadir hallarda və real səbəbdən sınanda ən dəyərlidir. Bu mövzunun qalan hissəsi buna necə çatmaq barədədir: istifadəçinin gördüyünü tapan locator-lar, təxmin etməyən gözləmə və bir-birinə sızmayan testlər.

JuniorFramework

Playwright Test ilə ilk test

Shell
npm init playwright@latest

Komanda @playwright/test-i, playwright.config.ts-i, nümunə testi və istəsən, GitHub Actions workflow-unu əlavə edir. npx playwright test testləri işə salır, default olaraq headless və Chromium, Firefox və WebKit-də paralel; npx playwright show-report HTML hesabatını açır.

TypeScript
// tests/tasks.spec.ts
import { test, expect } from "@playwright/test";

test("adds a task", async ({ page }) => {
  await page.goto("/tasks");

  await page.getByLabel("New task").fill("Write the release notes");
  await page.getByRole("button", { name: "Add task" }).click();

  await expect(page.getByRole("listitem").filter({ hasText: "Write the release notes" })).toBeVisible();
  await expect(page.getByRole("status")).toHaveText("1 task left");
});
  • page fixture-dir: Playwright-in bu test üçün yaratdığı təzə səhifə.
  • Config-də use.baseURL təyin olunanda (məsələn, "http://localhost:3000") page.goto("/tasks") path qəbul edir; webServer seçimi isə testlərdən əvvəl tətbiqi işə sala bilər.
  • Locator-lar elementi istifadəçinin tapacağı kimi tapmağı təsvir edir. Playwright getByRole-u (rol və üzrə), form sahələri üçün getByLabel-i, getByText, getByPlaceholder, getByAltText, getByTitle-ı, istifadəçiyə görünən heç nə uyğun gəlməyəndə isə getByTestId-ni (data-testid atributu) tövsiyə edir.
  • getByRole("button", { name: "Add task" }) adı default olaraq böyük-kiçik hərfə həssas olmayan alt sətir kimi uyğunlaşdırır; exact: true tam və hərfə həssas uyğunluq tələb edir.
  • Locator-lar tənbəldir: action və ya assertion onu işlədənə qədər heç nə axtarılmır, hər istifadədə isə element yenidən tapılır, ona görə arada baş verən yenidən render zərər vermir.
  • Locator-lar sərtdir (strict): birdən çox elementə uyğun gələn locator üzərində action xəta atır. first()-ə əl atmaq əvəzinə onu filter({ hasText }) ilə və ya zəncirləməklə daralt (row.getByRole("button", { name: "Delete" })).
  • Action-lar locator-un metodlarıdır: click(), fill(), check(), selectOption(), press(), hover(), setInputFiles().

Niyə CSS selector-lar yox, rollar və label-lər: class-lar və DOM strukturu hər redizaynda dəyişir, rollar, adlar və label-lər isə yalnız istifadəçinin gördüyü UI dəyişəndə dəyişir. Kontrolun accessible name-i olmayanda rol sorğusu da sınır, bu isə real bug-dır. npx playwright codegen <url> kliklərini rol, mətn və test id locator-ları ilə test koduna yazır; onun nəticəsinə qaralama kimi bax.

JuniorKonsepsiya

Auto-waiting və web-first assertion-lar

Səhifələr asinxron dəyişir: sorğu bitir, komponent render olunur, animasiya sona çatır. Playwright sabit müddət yox, düzgün şərt gözləyir.

Action-lardan əvvəl . click()-dən əvvəl Playwright locator-un dəqiq bir elementə uyğun gəldiyini və həmin elementin:

  • görünən olduğunu: boş olmayan bounding box-u var və visibility: hidden yoxdur;
  • stabil olduğunu: ən azı ardıcıl iki animasiya kadrı ərzində eyni bounding box, yəni animasiyanın ortasında deyil;
  • event-ləri qəbul etdiyini: klikin həqiqətən dəyəcəyi elementdir, overlay-in altındakı nəsə deyil;
  • aktiv olduğunu: disabled deyil

yoxlayır. fill() daha az şey yoxlayır: görünən, aktiv və redaktə oluna bilən (read-only olmayan). Yoxlamalar vaxtında keçməsə, action TimeoutError ilə uğursuz olur. force: true seçimi vacib olmayan yoxlamaları ötürür; onu nadir hallarda işlət, çünki real istifadəçini dayandıracaq overlay-in içindən klikləyə bilər.

Web-first assertion-lar. await expect(locator).toBeVisible() bir dəfə yoxlamır: şərt ödənənə və ya expect timeout-u, default olaraq 5 saniyə, bitənə qədər təkrar yoxlayır. toHaveText, toContainText, toHaveValue, toHaveCount, toBeChecked, toHaveURL, toHaveTitle və digər locator və səhifə assertion-ları da belədir.

TypeScript
// Mesaj görünənə və ya 5 saniyə keçənə qədər təkrar yoxlayır
await expect(page.getByRole("status")).toHaveText("Task saved");

// Bir dəfə, elə indi yoxlayır: flaky
expect(await page.getByRole("status").isVisible()).toBe(true);

İkinci sətir vəziyyəti bir anda oxuyur və heç vaxt təkrar yoxlamayan adi boolean-ı müqayisə edir. Playwright-in best practices səhifəsi məhz bu sətri yazılmamalı nümunə kimi göstərir.

Sabit gözləmələr pis əlamətdir. await page.waitForTimeout(2000) yavaş CI maşınında azdır, başqa hər yerdə isə boş itən vaxtdır. Playwright-in API sənədləri onun yalnız debug üçün işlədilməli olduğunu deyir, çünki vaxt gözləyən testlər mahiyyətcə flaky-dir. Əvəzinə mənalı bir şey gözlə: element, mətn, URL (await expect(page).toHaveURL(/\/tasks\/\d+/)) və ya cavab.

Hər Playwright çağırışını await et. Unudulmuş await testin action və ya assertion işləməmiş bitməsinə imkan verir, ona görə test heç nəyi yoxlamadan keçə bilər. Playwright-in best practices səhifəsi bunu tutmaq üçün @typescript-eslint/no-floating-promises lint qaydasını tövsiyə edir.

Bilməli olduğun timeout-lar: testə default olaraq 30 saniyə, assertion-a 5 saniyə verilir, action-ın isə öz timeout-u yoxdur, ona görə onu testin timeout-u məhdudlaşdırır.

MiddleFramework

Testlərin təcridi, browser context-lər və fixture-lar

Hər test yeni browser context alır; Playwright onu öz cookie-ləri və storage-i olan tamamilə yeni brauzer profilinə bənzədir. Resurslara qənaət üçün brauzer prosesi ortaqdır, context isə yox. Ona görə testlər bir-birinin sessiyalarını görmür və istənilən sırada, paralel işləyə bilir. Test faylları ayrı worker proseslərində paralel işləyir (default olaraq məntiqi CPU nüvələrinin yarısı qədər); fullyParallel aktiv deyilsə, bir faylın içindəki testlər ardıcıl işləyir. Worker-lər bir-biri ilə əlaqə saxlaya bilmir.

Context backend-i yox, brauzeri təcrid edir. İki test eyni bazada eyni qeydi redaktə edirsə, context-lərin sayından asılı olmayaraq bir-birinə mane olur. Hər test ehtiyac duyduğu datanı unikal adlarla özü yaratmalı və başqa testin qoyub getdiyi heç nəyə arxalanmamalıdır.

Fixture-lar testə lazım olanı verir. Daxili olanlar page, context (səhifənin təcrid olunmuş context-i), browser (ortaq), browserName və HTTP çağırışları üçün təcrid olunmuş API client-i olan request-dir. test.extend ilə yaratdığın fixture-lar setup və teardown-u bir yerdə saxlayır, yalnız onları istəyən testlər üçün işləyir və başqa fixture-lardan asılı ola bilir:

TypeScript
// tests/fixtures.ts
import { test as base, expect } from "@playwright/test";

type Project = { id: string; name: string };

export const test = base.extend<{ project: Project }>({
  project: async ({ request }, use) => {
    // Setup: datanı UI ilə yox, API ilə yarat
    const response = await request.post("/api/projects", {
      data: { name: `Release ${crypto.randomUUID()}` },
    });
    expect(response.ok()).toBe(true);
    const project = (await response.json()) as Project;

    await use(project);

    // Teardown: test bitəndən sonra, uğursuz olsa belə işləyir
    await request.delete(`/api/projects/${project.id}`);
  },
});

export { expect };
TypeScript
// tests/project.spec.ts
import { test, expect } from "./fixtures";

test("renames a project", async ({ page, project }) => {
  await page.goto(`/projects/${project.id}`);
  await page.getByRole("button", { name: "Rename" }).click();
  await page.getByLabel("Project name").fill("Q4 launch");
  await page.getByRole("button", { name: "Save" }).click();

  await expect(page.getByRole("heading", { level: 1 })).toHaveText("Q4 launch");
});

await use(...)-dan əvvəlki kod setup-dır, sonrakı isə teardown. request fixture-u da page.goto kimi path-ları baseURL-ə görə resolve edir. Datanı API ilə yaratmaq onlarla klik əvəzinə millisaniyələr çəkir, layihə yaradan ekranın isə öz testi olur.

MiddleNümunə

storageState ilə bir dəfə daxil olmaq

Hər testdə form vasitəsilə daxil olmaq yavaşdır və login formunu bütün test dəsti üçün tək sınma nöqtəsinə çevirir. Playwright-in tövsiyə etdiyi yanaşma setup project-də bir dəfə daxil olmaq, brauzerin vəziyyətini fayla saxlamaq və hər testi ondan başlatmaqdır:

TypeScript
// tests/auth.setup.ts
import path from "node:path";
import { test as setup, expect } from "@playwright/test";

const authFile = path.join(__dirname, "../playwright/.auth/user.json");

setup("sign in", async ({ page }) => {
  await page.goto("/login");
  await page.getByLabel("Email").fill(process.env.E2E_EMAIL!);
  await page.getByLabel("Password").fill(process.env.E2E_PASSWORD!);
  await page.getByRole("button", { name: "Sign in" }).click();

  await expect(page).toHaveURL("/tasks");
  await expect(page.getByRole("button", { name: "Account" })).toBeVisible();

  await page.context().storageState({ path: authFile });
});
TypeScript
// playwright.config.ts
import { defineConfig, devices } from "@playwright/test";

export default defineConfig({
  use: { baseURL: "http://localhost:3000" },
  projects: [
    { name: "setup", testMatch: /.*\.setup\.ts/ },
    {
      name: "chromium",
      use: { ...devices["Desktop Chrome"], storageState: "playwright/.auth/user.json" },
      dependencies: ["setup"],
    },
  ],
});
  • chromium ondan asılı olduğu üçün setup project birinci işləyir. Sonra hər test saxlanmış vəziyyətdən yaradılan yeni context alır, ona görə daxil olmuş halda başlayır və yenə təcrid olunmuş qalır.
  • storageState() cookie-ləri və local storage-i, indexedDB: true ötürəndə isə IndexedDB-ni də saxlayır. Session storage saxlanmır; Playwright-də onu saxlamaq üçün API yoxdur.
  • Faylda test hesabının adından iş görmək üçün istifadə oluna biləcək real sessiya cookie-ləri var: playwright/.auth-u .gitignore-a əlavə et, sessiyanın vaxtı bitəndə isə faylı sil.
  • Daxil olmamış istifadəçi təcrübəsinin testləri öz faylı üçün vəziyyəti sıfırlayır: test.use({ storageState: { cookies: [], origins: [] } }).
  • Bir neçə rol: setup project-də hər rol üçün bir dəfə daxil ol (admin.json, user.json) və fayl üzrə test.use({ storageState: ... }) ilə seç. Eyni anda iki istifadəçiyə ehtiyacı olan test, məsələn, admin-in istifadəçinin göndərdiyini təsdiqləməsi, browser.newContext({ storageState }) ilə iki context yaradır.
  • Hər worker-ə bir hesab. Testlər başqalarının oxuduğu server tərəfi state-i dəyişmirsə, ortaq hesab yaxşıdır. Dəyişirsə, Playwright hər worker üçün ayrıca hesabla daxil olan və test.info().parallelIndex ilə açarlanan worker-scoped fixture tövsiyə edir.

Tətbiq API sorğusu ilə daxil olmağa imkan verirsə, setup formun əvəzinə request işlədə bilər; o zaman login formunun özünə ayrıca adi bir test yazılır.

MiddleFramework

page.route ilə şəbəkəni mock etmək, ya etməmək

E2E test real inteqrasiyanı yoxlamaq üçündür, ona görə default olaraq öz backend-ini mock etmə: API-ni saxtalaşdıran test daha yavaş komponent testidir və istənilən mock kimi real API-dən uzaqlaşa bilər. Playwright-in best practices səhifəsi sərhədi sənin idarə etmədiyin şeydə çəkir: üçüncü tərəf asılılıqlarını test etmə və onların cavablarını page.route ilə mock et. Bu hallarda mock et:

  • asılılıq başqasınındır: ödəniş provayderi, xəritələr, chat və ya analitika skripti; onun dayanması sənin test dəstini sındırmamalıdır;
  • vəziyyəti real backend ilə yaratmaq çətindir: 503, qırılmış bağlantı, yavaş cavab.
TypeScript
test("shows a banner when the tasks API fails", async ({ page }) => {
  await page.route("**/api/tasks", (route) =>
    route.fulfill({ status: 503, json: { message: "Maintenance" } }),
  );

  await page.goto("/tasks");

  await expect(page.getByRole("alert")).toHaveText("Tasks are unavailable. Try again later.");
});

Route-u page.goto()-dan əvvəl qeydiyyata al; ondan əvvəl göndərilən sorğular tutulmur. Handler nə edə bilər:

  • route.fulfill({ status, json, headers, body }) şəbəkəsiz cavab verir; json content type-ı da təyin edir, status isə default olaraq 200-dür;
  • route.abort(errorCode) sorğunu şəbəkə xətası kimi uğursuz edir (default "failed", ya da "timedout" və "internetdisconnected" kimi kodlar);
  • route.continue() sorğunu şəbəkəyə göndərir, istəsən header-ləri, metodu və ya URL-i dəyişərək;
  • route.fetch() real sorğunu icra edir, ona görə real cavabı dəyişib route.fulfill({ response, json }) ilə ötürə bilərsən.

Bir neçə route uyğun gələndə sonuncu qeydiyyata alınan birinci işləyir. route.fallback() sorğunu növbəti uyğun route-a ötürür, route.continue() isə qalanlarını ötürüb onu birbaşa şəbəkəyə göndərir. Səhifə route-ları context route-larından üstündür, { times: 1 } isə route-un bir dəfə işləməsini təmin edir. Qeydə alınmış cavabların bütöv dəsti üçün page.routeFromHAR() HAR faylını təkrar oynadır.

API sənədlərindən iki xəbərdarlıq. Routing-i aktiv etmək HTTP keşini söndürür, ona görə keşləmə davranışının testi həmin sorğuları route etməməlidir. Və page.route Service Worker-in tutduğu sorğuları görmür; interception-a güvənəndə Playwright use-da serviceWorkers: "block" tövsiyə edir. Bu, tətbiq öz Service Worker-ini qeydiyyata alanda və ya test olunan build-də MSW-ninki kimi mock worker-i aktiv qalanda vacibdir.

Tətbiqin API-sinin çoxunu route etdiyini görürsənsə, test artıq end-to-end deyil. Həmin halı şəbəkə mock-ları olan komponent testinə köçür, E2E testi isə real backend-də saxla.

SeniorVeb platforma

Project-lər, paralellik və CI

Project-lər eyni testləri fərqli parametrlərlə işə salır: brauzerlər, emulyasiya olunan cihazlar və ya əvvəlcə setup addımı. Playwright sənədlərinin göstərdiyi CI parametrləri ilə tipik config:

TypeScript
// playwright.config.ts
import { defineConfig, devices } from "@playwright/test";

export default defineConfig({
  testDir: "tests",
  fullyParallel: true,
  forbidOnly: !!process.env.CI,
  retries: process.env.CI ? 2 : 0,
  workers: process.env.CI ? 1 : undefined,
  reporter: process.env.CI ? "blob" : "html",
  use: {
    baseURL: "http://localhost:3000",
    trace: "on-first-retry",
  },
  projects: [
    { name: "chromium", use: { ...devices["Desktop Chrome"] } },
    { name: "webkit", use: { ...devices["Desktop Safari"] } },
    { name: "mobile-safari", use: { ...devices["iPhone 12"] } },
  ],
  webServer: {
    command: "npm run start",
    url: "http://localhost:3000",
    reuseExistingServer: !process.env.CI,
  },
});

npx playwright test --project=webkit bir project-i işə salır. Cihaz qeydi həmin cihazın brauzerini, viewport-unu və user agent-ini təyin edir; bu, real telefon yox, emulyasiyadır.

  • forbidOnly təsadüfən commit olunmuş test.only olanda run-ı uğursuz edir.
  • retries: default olaraq uğursuz testlər təkrarlanmır. Retry-larla əvvəlcə sınan, sonra keçən test uğurlu (passed) kimi yox, flaky kimi göstərilir, uğursuzluq isə worker prosesini və onun brauzerini atıb yenisini başladır. "Flaky"-ni bug hesabatı kimi oxu: retry-lar pipeline-ı hərəkətdə saxlayır, heç nəyi düzəltmir.
  • CI-da workers: 1: Playwright-in CI bələdçisi stabillik və təkrarlana bilənliyə üstünlük vermək üçün bunu tövsiyə edir. Güclü CI maşınları olan komandalar daha çox worker işlədir.
  • Sharding test dəstini maşınlar arasında bölür: npx playwright test --shard=1/4-dən --shard=4/4-ə qədər, hər biri öz CI job-unda. fullyParallel: true ilə testlər tək-tək, onsuz isə bütöv fayllar paylanır. Hər shard blob hesabatı yazır, npx playwright merge-reports --reporter html ./all-blob-reports isə onları bir HTML hesabatına çevirir.
  • webServer testlərdən əvvəl tətbiqi işə salır; reuseExistingServer: !process.env.CI lokalda işləyən serverini təkrar istifadə edir, CI-da isə həmişə yenisini başladır.
  • CI job-unda brauzerləri npx playwright install --with-deps ilə (və ya yalnız test etdiklərini, npx playwright install chromium --with-deps) quraşdır və playwright-report/-u artifact kimi yüklə ki, hesabat və onun trace-ləri job-dan sonra da qalsın.

Hər pull request-də hansı brauzerlərin işləyəcəyi xərc qərarıdır: çox vaxt hər pull request-də biri, tam matris isə gecə. WebKit-i harasa daxil et: o, Safari-nin engine-idir və hamı Chromium-da işləyəndə onun bug-larını gözdən qaçırmaq asandır.

SeniorFramework

Uğursuzluqların debug-ı: trace-lər, screenshot-lar və UI mode

CI-da qırmızı E2E test adətən "Timed out 5000ms waiting for expect(locator).toBeVisible()" kimi bir şey deyir. Sual elementin niyə heç vaxt görünmədiyidir, cavab isə adətən trace-dədir.

Trace-lər hər action-ı ondan əvvəlki, onun anındakı və ondan sonrakı DOM snapshot-ları ilə, üstəlik şəbəkə sorğuları, konsol mesajları, xətalar və kod sətri ilə qeydə alır. use-dakı trace seçimi:

  • "on-first-retry": uğursuz test ilk dəfə təkrarlananda qeydə al; Playwright nümunələrindəki parametr, testlər keçdikcə heç nəyə başa gəlmir;
  • "on-all-retries": hər retry-ı qeydə al;
  • "retain-on-failure": hər testi qeydə al, trace-i yalnız uğursuz olanda saxla;
  • "on": hər test; sənədlər bunu performans üçün ağır adlandırır.

HTML hesabatını aç (npx playwright show-report) və trace ikonuna kliklə, ya da npx playwright show-trace path/to/trace.zip işə sal. trace.playwright.dev trace-i brauzerdə açır; faylı lokal yükləyir və heç yerə data göndərmir.

Bu ardıcıllıqla nəyə baxmalı:

  1. Uğursuz action və onun snapshot-ları. Element orada idimi? Dialoq onu örtmüşdü? Spinner-in arxasında idi? Hələ köhnə mətni göstərirdi?
  2. Network tab-ı. 500, yavaş API çağırışı və ya heç göndərilməmiş sorğu görünməyən elementlərin çoxunu izah edir.
  3. Console tab-ı. Render-i dayandırmış JavaScript xətası.
  4. Locator. Actions tab-ı hər action-ın işlətdiyi locator-u göstərir; başqa şeyə uyğun gəlmiş locator tez-tez rast gəlinən səbəbdir.

screenshot: "only-on-failure" və video: "retain-on-failure" hesabata şəkil əlavə edir, amma Playwright-in best practices səhifəsi CI uğursuzluqları üçün trace viewer-ə üstünlük verir: o, yalnız pikselləri yox, DOM-u, şəbəkəni və kodu göstərir.

Flaky uğursuzluqlara başqa trace lazımdır. "on-first-retry" ilə trace retry-dan gəlir; retry keçibsə, uğurlu run-a baxırsan. Testi "retain-on-failure"-a keçir və trace ilə uğursuz olana qədər dəfələrlə işə sal: lokalda npx playwright test --repeat-each=20 ilə və ya CI-da. Uğursuz trace-i keçənlə müqayisə et: fərq adətən gec gələn cavab, yenidən render olunan element və ya başqa testin dəyişdiyi datadır.

Lokalda:

  • npx playwright test --ui UI mode-u açır: testləri işə salmaq və filtrləmək, watch mode, hər addımda zamanda səyahət, kursoru snapshot üzərinə gətirməklə locator seçmək, Network və Console panelləri.
  • npx playwright test --debug Playwright Inspector ilə işləyir, ona görə action-lar arasında addım-addım keçə bilərsən.
SeniorKonsepsiya

E2E test dəstini kiçik və etibarlı saxlamaq

E2E test dəsti öz məqsədinə iki yolla çatmır: hər dəyişiklikdə işə salmaq üçün çox yavaşlayır, ya da o qədər flaky olur ki, qırmızı nəticəyə məhəl qoyulmur. Hər ikisi bəxtsizlik yox, dizayn qərarıdır.

Kənarda qalanlar. Hər validasiya mesajı, hər formatlama qaydası, hər API xəta kodu və hər icazə kombinasiyası şəbəkə mock-ları olan komponent testlərinə və ya hər halın millisaniyələrlə işlədiyi unit testlərə aiddir. Formun E2E testi düzgün göndərişin bütün stack-dən keçdiyini və bir yanlış dəyərin xəta göstərdiyini yoxlayır; qalan qaydalar aşağıda test olunur. Üçüncü tərəf servisləri, kitabxanaların daxili işləri və piksel səviyyəsində üslub (ayrıca vizual testlər işlətmirsənsə) da kənarda qalır.

Sənə aid data. Qeydləri paylaşan testlər paralel işləyəndə bir-birinə mane olur, sıra dəyişəndə sınır. Hər testə lazım olanı fixture-da, API ilə, unikal adlarla yarat və teardown-da sil. İnsanların əllə dəyişdiyi ortaq staging serveri yox, idarə etdiyin mühit işlət, məsələn, lokal stack və ya ayrıca test bazası. Testləri test.describe.configure({ mode: "serial" }) ilə zəncirləmə: bir test sınanda qrupun qalanı ötürülür, bütün qrup isə birlikdə təkrarlanır.

Flakiness bug-dır. Flaky kimi göstərilən test sənə race barədə xəbər verir: cavab üçün çatışmayan gözləmə, animasiya, ortaq data, saatdan və ya testlərin sırasından asılılıq. Onu trace-də tap və testi və ya tətbiqi düzəlt. İndi düzəldə bilmədiyin testi açıq şəkildə karantinə al, məsələn, test.fixme və tiketlə; hamı nəticələri oxumağı dayandırana qədər onu təsadüfi sınmağa buraxma.

Sürət də vacib xüsusiyyətdir. storageState ilə bir dəfə daxil ol, datanı UI yox, request ilə yarat, fullyParallel ilə işə sal və CI-da shard et. Dəst komandanın pull request üçün gözləməyə hazır olduğundan uzun çəkirsə, insanlar onu ötürməyə başlayır və o zaman o, heç nəyi qorumur.

Hər ssenaridə əsas niyyəti yoxla. Yol boyu on beş şeyi yoxlayan testi oxumaq çətindir və on beş səbəbdən sınır. Ssenarinin nə üçün olduğunu yoxla (sifariş verildi, dəvət gəldi), üstəlik istifadəçinin oraya çatmaq üçün yolda görməli olduğunu.

Sağlam dəstin əlamətləri: qırmızı nəticəyə inanılır, uğursuzluq bir ssenariyə işarə edir, yeni funksionallıq isə on yox, bir-iki E2E test əlavə edir.

SeniorMüsahibə məsləhətləri

Müsahibə üçün məsləhətlər

30 saniyəlik cavab. "E2E test real tətbiqi real brauzerdə işə salır, ona görə hissələrin birlikdə işlədiyini sübut edir: build, routing, CSS, cookie-lər, API. O, yavaşdır və sınmağın daha çox yolu var, ona görə E2E testləri kritik ssenarilər üçün saxlayıram, kənar halları isə aşağı səviyyədə test edirəm. Playwright-də rol və label locator-ları işlədirəm, sabit gözləmələr əvəzinə auto-waiting və web-first assertion-lara güvənirəm, hər testə API fixture-ları ilə təzə data verirəm, storageState ilə bir dəfə daxil oluram, page.route ilə isə yalnız üçüncü tərəfləri və ya yaradılması çətin uğursuzluqları mock edirəm. CI-da ilk retry-da trace qeydə alıram və hər flaky nəticəyə bug kimi baxıram."

Gözlənilən suallar

  • Niyə hər şeyi end-to-end test etməyək? Xərc: test başına saniyələr, flakiness üçün daha çox səbəb, qeyri-müəyyən uğursuzluqlar. Ssenarilər E2E-də, hallar daha sürətli testlərdə.
  • Playwright vaxt problemlərindən necə qaçır? Hər action-dan əvvəl actionability yoxlamaları (görünən, stabil, event qəbul edən, aktiv, redaktə oluna bilən) və expect timeout-una qədər, default olaraq 5 saniyə, təkrar yoxlayan assertion-lar. waitForTimeout yalnız debug üçündür.
  • Testləri necə müstəqil saxlayırsan? Hər testə yeni browser context; fixture-larda API ilə yaradılan unikal data; testlərin sırasına və ortaq qeydlərə arxalanmamaq.
  • Login-i necə həll edirsən? Daxil olub storageState saxlayan setup project; project-lər ondan asılıdır; fayl git-ə düşmür; testlər server tərəfi state-i dəyişəndə hər worker-ə ayrı hesab.
  • E2E-də şəbəkəni mock edirsən? Default olaraq öz backend-ini yox; üçüncü tərəf servislərini və yaradılması çətin uğursuzluqları page.route ilə, naviqasiyadan əvvəl qeydiyyata alaraq.
  • Yalnız CI-da sınan testi necə debug edirsən? Trace ilə: snapshot-lar, şəbəkə, konsol, işlədilən locator. Flaky testlər üçün retain-on-failure ilə qeydə al və sınana qədər təkrarla.

Bal itirməyə səbəb olan səhvlər

  • Nümunələrdə waitForTimeout və ya expect(await locator.isVisible()).toBe(true).
  • Rol və ya label olduğu halda CSS və ya XPath selector-ları.
  • Retry-ları flakiness üçün düzəliş adlandırmaq.
  • Hər testdə UI ilə login olmaq və ya paralel worker-lər arasında dəyişkən bir hesabı paylaşmaq.

Senior səviyyəni göstərən məqamlar

Yalnız testdən yox, test dəstindən danış: hansı ssenarilər E2E əhatəsinə layiqdir, hansılar yox; test datası necə yaradılır və təmizlənir; hansı brauzerlər hər pull request-də, hansılar gecə işləyir; insanlar onu gözləməyi dayandırmamışdan əvvəl dəst nə qədər çəkə bilər; flaky test düzələnə qədər necə izlənir.

JuniorYoxlama siyahısı

End-to-end testləri review edərkən nəyi yoxlamalı

Yazmadığın Playwright testlərini — komanda yoldaşının pull request-ini, kitabxananın nümunəsini, AI assistentin təklifini — review edəndə bu siyahını işlət. Zəif E2E test nadir hallarda dərhal sınır; o, sonra, təsadüfi, CI-da sınır və qənaət etdiyindən çox vaxt aparır.

  • Sabit gözləmələr və ya birdəfəlik yoxlamalar varmı? waitForTimeout-u, expect(...)-ın içindəki isVisible()-ı və əllə yazılmış polling dövrlərini axtar; onları await expect(locator).toBeVisible() və ya toHaveURL kimi, expect timeout-una qədər təkrar yoxlayan web-first assertion-larla əvəz et.
  • Hər Playwright çağırışı await olunubmu? Çatışmayan await testin action və ya assertion işləməmiş bitməsinə imkan verir; @typescript-eslint/no-floating-promises qaydası və CI-dakı tsc bunu tutur.
  • Locator-lar istifadəçinin gördüyünü təsvir edirmi? CSS class-ları, XPath və ya nth() əvəzinə adla getByRole-a, getByLabel-ə və getByText-ə üstünlük ver; zərərsiz markup dəyişikliyindən sonra testi fikrən işə sal: elementi yenə tapardımı?
  • Hər test öz datasını yaradırmı? Testlər arasında paylaşılan qeydləri, testlərin sırasına arxalanmanı və ya mode: "serial"-ı axtar; data unikal adlarla fixture-dan və ya API çağırışından gəlməli və teardown-da silinməlidir.
  • Test hər dəfə UI ilə daxil olurmu? Login-in yeri storageState olan setup project-dir; playwright/.auth-un .gitignore-da olduğunu yoxla, çünki faylda sessiya cookie-ləri var.
  • Şəbəkə yalnız lazım olan yerdə mock olunubmu? Öz API-nin üzərində page.route testi yavaş komponent testinə çevirir; onun yeri üçüncü tərəf servisləri və yaradılması çətin uğursuzluqlardır və page.goto()-dan əvvəl qeydiyyata alınmalıdır.
  • Test hər kənar halı yox, ssenarini yoxlayırmı? Validasiya qaydaları və xəta kodları daha sürətli testlərə aiddir; E2E test istifadəçinin gəldiyi nəticəni yoxlamalıdır.

Özünü yoxla

  • Məşq

    Kodun nəticəsini təxmin et, açıq müsahibə suallarına cavab ver və özünü qiymətləndir.

    3 nəticə sualı · 4 açıq sual

  • Quiz

    İzahlı test sualları və yekun nəticə.

    7 sual