Playwright vs Cypress vs Selenium: Upřímné doporučení pro rok 2026

Playwright předstihl Cypress v týdenních stahováních z npm kolem poloviny roku 2024 a do začátku roku 2026 se tento rozdíl zvětšil na přibližně 30 milionů oproti 6,5 milionu týdenních stažení. K tomuto posunu nedošlo náhodou. Každé jiné srovnání na první stránce Google je napsáno dodavatelem QA nástrojů nebo společností poskytující SaaS pro testování. Toto srovnání pochází od týmu, který buduje produkční webové aplikace a vybírá framework pro automatizaci testů pro skutečné projekty, nikoliv za účelem propagace produktu.

Zde je místo, které zaujímá Selenium: stále jde o nejrozšířenější E2E framework globálně, zejména v týmech pracujících s Javou a Pythonem. Nikam nezmizí. Pro nové projekty v JavaScriptu/TypeScriptu v roce 2026 je však skutečnou otázkou volba mezi Playwrightem a Cypressem, přičemž Selenium slouží jako legacy záložní řešení.

Rychlý přehled na první pohled

Zvolte Playwright, pokud chcete nejlepší celkový testovací framework v roce 2026: nejrychlejší provádění, bezplatná paralelizace, podpora více jazyků a vynikající TypeScript DX. Zvolte Cypress, pokud si váš tým cení interaktivního ladění a komponentového testování nad všechno ostatní. Zvolte Selenium, pokud působíte v enterprise prostředí Java/Python s existující infrastrukturou pro Selenium.

To je shrnutí. Zbytek tohoto článku vysvětluje důkazy stojící za každým řádkem, včetně kódu, benchmarků a upřímných názorů.

Architektura: Jak každý nástroj komunikuje s prohlížečem

Architektura je hlavní příčinou téměř každého rozdílu, který v tomto srovnání uvidíte. Představte si to takto: Playwright komunikuje s prohlížečem jako režisér, který šeptá instrukce přímo hercům. Cypress sedí na jevišti s herci a běží ve stejné místnosti. Selenium posílá instrukce prostřednictvím prostředníka stojícího na chodbě.

Playwright: Přímé ovládání prohlížeče přes WebSocket

Playwright komunikuje s prohlížeči prostřednictvím připojení WebSocket pomocí protokolu Chrome DevTools Protocol (CDP) pro Chromium a ekvivalentních protokolů pro Firefox a WebKit. Neexistuje žádný prostředník, váš testovací kód posílá příkazy přímo do engine prohlížeče. To znamená nižší latenci, více možností (více karet, různé originy, zachytávání sítě) a méně pohyblivých částí, které se mohou pokazit.

Cypress: Provádění v rámci prohlížeče

Cypress používá zásadně odlišný přístup. Vstřikuje se do prohlížeče a spouští váš testovací kód ve stejné smyčce událostí JavaScriptu jako vaše aplikace. Proto se Cypress zdá být u jednoduchých testů tak rychlý – mezi vaším testem a aplikací není žádná síťová režie. Tato architektura však také vysvětluje omezení Cypressu: žádná podpora více karet, omezené cross-origin testování a pouze JavaScript/TypeScript (protože testy musí běžet v kontextu prohlížeče).

Selenium: Prostředník WebDriver

Selenium využívá protokol WebDriver. Váš testovací kód odesílá požadavky HTTP binárnímu souboru ovladače prohlížeče (chromedriver, geckodriver), který tyto požadavky převádí na příkazy prohlížeče. Každý příkaz je zpáteční cestou: test -> ovladač -> prohlížeč a zpět. Tato nepřímost přidává latenci a vytváří více bodů selhání. Selenium postupně přijímá BiDi protocol pro snížení této režie, ale ještě tam zcela není.

Verdikt: Playwright vítězí v architektuře. Přímá komunikace přes WebSocket znamená rychlejší provádění, více funkcí a méně nestabilních selhání. Model Cypressu v prohlížeči je skutečně chytrý pro jednoduché testy s jedním originem, ale vytváří pevné stropy, které Playwright nemá. Architektura Selenium ukazuje svůj věk.

Podpora jazyků a prohlížečů

To je často první filtr. Pokud váš tým nepíše v JavaScriptu, Cypress okamžitě vypadává ze hry.

Co to znamená v praxi? Pokud jste tým pracující s Javou s 20 QA inženýry, Cypress není možností, tečka. Pokud je pro vás důležité cross-browser testování včetně Safari (a mělo by být, Safari drží přibližně 18 % globálního podílu na trhu prohlížečů), Playwright to zvládne hned po instalaci na jakémkoli OS, zatímco Cypress stále označuje podporu WebKitu jako „experimentální“.

Selenium vítězí v čistém rozsahu. Podporuje více jazyků a více prohlížečů než obě alternativy. Ale pro jazyky a prohlížeče, které jsou v roce 2026 nejdůležitější – JavaScript/TypeScript, Python a trojice Chromium/Firefox/WebKit – pokrývá Playwright vše s nulovou konfigurací a zahrnutými binárními soubory prohlížečů.

Verdikt: Selenium vítězí v šíři (nejvíce jazyků, nejvíce prohlížečů, včetně IE). Playwright vítězí v praktickém pokrytí – prohlížeče a jazyky, které jsou v roce 2026 důležité, jsou zahrnuty a bez konfigurace. Cypress je nejužší možností.

Psaní testů: Srovnání kódu vedle sebe

Dost teorie. Zde je stejný test napsaný ve všech třech frameworcích. Právě zde pocítíte rozdíl v DX (developer experience).

Test přihlašovacího toku

Standardní test přihlášení: navigace na stránku, vyplnění údajů, odeslání a ověření přesměrování.

// Playwright
import { test, expect } from '@playwright/test';

test('user can log in', async ({ page }) => {
  await page.goto('/login');
  await page.locator('#email').fill('[email protected]');
  await page.locator('#password').fill('s3cureP@ss');
  await page.locator('button[type="submit"]').click();
  await expect(page).toHaveURL('/dashboard');
  await expect(page.locator('h1')).toContainText('Welcome');
});

// Cypress
describe('Login', () => {
  it('user can log in', () => {
    cy.visit('/login');
    cy.get('#email').type('[email protected]');
    cy.get('#password').type('s3cureP@ss');
    cy.get('button[type="submit"]').click();
    cy.url().should('include', '/dashboard');
    cy.get('h1').should('contain', 'Welcome');
  });
});

// Selenium (with WebDriver)
const { Builder, By, until } = require('selenium-webdriver');

describe('Login', function () {
  let driver;

  before(async () => {
    driver = await new Builder().forBrowser('chrome').build();
  });

  after(async () => {
    await driver.quit();
  });

  it('user can log in', async () => {
    await driver.get('http://localhost:3000/login');
    await driver.findElement(By.id('email')).sendKeys('[email protected]');
    await driver.findElement(By.id('password')).sendKeys('s3cureP@ss');
    await driver.findElement(By.css('button[type="submit"]')).click();
    await driver.wait(until.urlContains('/dashboard'), 5000);
    const heading = await driver.findElement(By.css('h1')).getText();
    expect(heading).to.include('Welcome');
  });
});

Všimněte si rozdílů. Playwrightovo async/await s page.locator() čitelně vypadá a automaticky čeká, až budou elementy akční, než s nimi interaguje. Chaining API Cypressu (cy.get().type().click()) je stručné a pro jednoduché toky skutečně příjemné. Selenium vyžaduje explicitní čekání (driver.wait(until.urlContains(...))), ruční správu životního cyklu prohlížeče a více boilerplate kódu.

Mockování API a zachytávání sítě

Tento scénář odhaluje mnohem větší propast. Zachyťte volání API, vraťte mockovaná data a ověřte, že se UI vykreslí správně.

// Playwright -- native network interception
test('shows mocked user list', async ({ page }) => {
  await page.route('**/api/users', (route) => {
    route.fulfill({
      status: 200,
      contentType: 'application/json',
      body: JSON.stringify([{ id: 1, name: 'Alice' }]),
    });
  });
  await page.goto('/users');
  await expect(page.locator('.user-card')).toHaveCount(1);
  await expect(page.locator('.user-card')).toContainText('Alice');
});

// Cypress -- native network interception
it('shows mocked user list', () => {
  cy.intercept('GET', '/api/users', {
    statusCode: 200,
    body: [{ id: 1, name: 'Alice' }],
  }).as('getUsers');
  cy.visit('/users');
  cy.wait('@getUsers');
  cy.get('.user-card').should('have.length', 1);
  cy.get('.user-card').should('contain', 'Alice');
});

// Selenium -- no native network interception
// You need a separate proxy tool like BrowserMob Proxy
// or mock your API server directly. There is no built-in
// equivalent to page.route() or cy.intercept().

// Typical workaround: start a mock server before the test
const mockServer = require('./helpers/mock-server');

before(async () => {
  await mockServer.start({ port: 4000 });
  mockServer.stub('GET', '/api/users', [{ id: 1, name: 'Alice' }]);
});

it('shows mocked user list', async () => {
  await driver.get('http://localhost:3000/users');
  // ... assert using findElement
});

To je velká věc. Mockování API je nezbytné pro spolehlivé E2E testy a jak Playwright, tak Cypress ho řeší nativně. Selenium vyžaduje samostatný mock server nebo proxy nástroj, což znamená více infrastruktury, více složitosti a více věcí, které se mohou pokazit.

Verdikt: Playwright vítězí v jasnosti kódu a schopnostech. Jeho syntaxe async/await je čistší než chaining Cypressu pro složité scénáře a nativně zpracovává mockování API, více karet a různé originy. Cypress vítězí v jednoduchosti pro přímočaré toky na jedné stránce, chaining API je skutečně příjemné. Selenium je nejukecanější a vyžaduje nejvíce boilerplate kódu.

Playwright vs Cypress vs Selenium: Benchmarky rychlosti

„Který je rychlejší?“ je jedna z nejvyhledávanějších otázek v tomto srovnání. Zde jsou skutečná čísla z benchmarkové studie Checkly a měření BetterStack, zkřížená pro konzistenci.

Playwright dokončí ekvivalentní testovací sady přibližně za 4,5 sekundy, ve srovnání s 9,4 sekundami pro Cypress a 14,5 sekundami pro Selenium. To není marginální rozdíl, je to dvojnásobný a trojnásobný gap.

Proč je Playwright rychlejší? Tři důvody: Komunikace přes WebSocket eliminuje HTTP režii, kterou nese Selenium. Model kontextu prohlížeče v Playwrightu vytváří izolovaná testovací prostředí bez nutnosti spouštět celé procesy prohlížeče. A jeho paralelní provádění probíhá na úrovni frameworku, nepotřebujete externí nástroje.

Rozdíl v rychlosti se zvětšuje u větších sad. Kontexty prohlížeče v Playwrightu škálují efektivně, protože sdílejí jeden proces prohlížeče. Selenium spawnuje nové instance prohlížeče pro každého paralelního pracovníka. Cypress spouští testy sériově ve své open-source verzi, takže rostoucí sada znamená lineárně rostoucí dobu provádění, pokud neplatíte za Cypress Cloud.

Jedna případová studie migrace dává číslům konkrétní podobu: BigBinary ohlásil 89% snížení doby provádění testů po přechodu z Cypressu na Playwright, jejich celá sada klesla z 2 hodin 27 minut na 16 minut díky shardingu v Playwrightu.

Verdikt: Playwright rozhodně vítězí v rychlosti. Spouští testovací sady 2x rychleji než Cypress a 3x rychleji než Selenium. Tento rozdíl se zvětšuje u větších sad, protože model kontextu prohlížeče v Playwrightu škáluje lépe než spawnování nových instancí prohlížeče.

Ladění a zkušenost vývojáře (DX)

Zde se věci stávají nuancovanými. Playwright je technicky superior, ale Cypress má skutečnou výhodu v DX, která udržuje týmy loajální.

Interaktivní ladění

Cypress Test Runner je stále zlatým standardem pro interaktivní ladění. Vidíte svůj test provádět v reálném čase ve skutečném prohlížeči, s laděním time-travel, kliknete na libovolný krok v logu příkazů a uvidíte přesný stav DOM v daném okamžiku. Pro frontendové vývojáře ladící vizuální regresy nebo problémy s layoutem je to těžké porazit. Upřímně, je to ta nejlepší funkce v celém toolkitu Cypressu.

Playwright Trace Viewer používá jiný přístup. Během spouštění testů zaznamenává stopy, screenshoty, snapshoty DOM, síťové požadavky a konzolové logy v každém kroku. Tyto stopy otevřete v prohlížečovém vieweru dodatečně. Pro ladění v CI (zjišťování, proč test selhal v headless pipeline), je Trace Viewer vlastně užitečnější než interaktivní runner Cypressu, protože získáte úplný kontext bez nutnosti reprodukce lokálně.

Režim --ui v Playwrightu přidal interaktivní zážitek bližší Test Runneru Cypressu v posledních verzích, ale není tak vyleštěný. Je funkční, nikoliv delightful.

Selenium IDE existuje, ale je omezené. Většina ladění v Selenium je console.log a screenshoty. Funguje to, ale připadá to jako rok 2012.

Vývoj s prioritou TypeScriptu

Playwright je TypeScript-first. Dodává se s automaticky generovanými typy, jeho konfigurační soubor je ve výchozím nastavení playwright.config.ts a autocomplete ve VS Code funguje bezchybně. Když napíšete page. a stisknete autocomplete, získáte každou metodu s plnými typovými signaturami.

Cypress podporuje TypeScript, ale existují body tření. Vlastní příkazy potřebují ruční deklarace typů (rozšíření rozhraní Cypress.Chainable) a chaining API někdy mate TypeScript inference. Soubor cypress.config.ts funguje, ale DX není tak hladké.

Podpora TypeScriptu v Selenium je komunitním úsilím a ve srovnání s nativním zážitkem z Playwrightu působí jako přilepená navíc.

Verdikt: Cypress vítězí v interaktivním DX, jeho Test Runner je skutečně delightful pro frontendové vývojáře ladící vizuální testy. Playwright vítězí v ladění CI a TypeScriptu, Trace Viewer je určen speciálně pro diagnostiku selhání v headless CI prostředích a jeho podpora TypeScriptu je nejlepší ve své třídě. Příběh ladění v Selenium je nejslabší.

Integrace CI/CD a paralelizace

Zde se guma dotýká silnice. Vaše testovací sada běží v CI stokrát denně, ne na vašem laptopu. Zde je copy-paste konfigurace GitHub Actions pro každý framework, něco, co žádný konkurent na první stránce Google neposkytuje.

Konfigurace GitHub Actions

# Playwright -- built-in parallelization, zero cost
name: Playwright Tests
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        shard: [1/4, 2/4, 3/4, 4/4]
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 22
      - run: npm ci
      - run: npx playwright install --with-deps
      - run: npx playwright test --shard=${{ matrix.shard }}
      - uses: actions/upload-artifact@v4
        if: failure()
        with:
          name: playwright-report-${{ matrix.shard }}
          path: playwright-report/

# Cypress -- parallel requires Cypress Cloud (paid)
name: Cypress Tests
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        containers: [1, 2, 3, 4]
    steps:
      - uses: actions/checkout@v4
      - uses: cypress-io/github-action@v6
        with:
          record: true
          parallel: true
          group: 'CI'
        env:
          CYPRESS_RECORD_KEY: ${{ secrets.CYPRESS_RECORD_KEY }}

# Selenium -- requires browser service container
name: Selenium Tests
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    services:
      selenium:
        image: selenium/standalone-chrome:latest
        ports:
          - 4444:4444
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 22
      - run: npm ci
      - run: npm test
        env:
          SELENIUM_REMOTE_URL: http://localhost:4444/wd/hub

Paralelizace: Zdarma vs placená

Výše uvedená konfigurace Playwrightu rozděluje vaši testovací sadu na 4 paralelní shardy pomocí --shard=1/4. Desetiminutová sada běží za 2,5 minuty. Nulové náklady. Není vyžadována žádná cloudová služba.

Bezplatný Starter plán Cypressu nyní zahrnuje paralelizaci, ale s limitem 500 výsledků testů měsíčně, který většina týmů vyčerpá během dne nebo dvou aktivního vývoje. Pro seriózní použití v CI budete potřebovat Cypress Cloud (začínající na $67/měsíc při ročním fakturaci pro Team plán s 120 tisíci výsledky/rok) nebo komunitní alternativy jako sorry-cypress. Vlajky record: true a parallel: true ve výše uvedeném YAML vyžadují připojení k Cypress Cloud.

Paralelizace v Selenium vyžaduje Selenium Grid (self-hosted, operační režie) nebo cloudového poskytovatele jako BrowserStack. Je to nejkomplexnější nastavení ze tří.

Verdikt: Playwright vítězí v CI/CD. Bezplatná, neomezená paralelizace s nulovou infrastrukturou je těžké porazit. Bezplatná úroveň Cypressu zahrnuje paralelizaci, ale je omezena na 500 výsledků měsíčně, skutečné týmy potřebují placený plán. Selenium vyžaduje nejvíce operační práce.

Analýza nákladů a cen

To je největší mezera v obsahu na celé SERP pro toto klíčové slovo. Každý konkurent to přeskočí, ale náklady záleží, zejména ve velkém měřítku.

Licence a cenové úrovně

Skutečné náklady podle velikosti týmu

Playwright je zdarma za vše, za co Cypress účtuje. Paralelizace, analytika testů prostřednictvím HTML reporteru, trace viewer pro ladění, codegen pro scaffolding testů, vše zahrnuto za nulovou cenu. Jediná věc, kterou Playwright nenabízí, je hostovaný cloudový dashboard s funkcemi pro týmovou spolupráci, a pro mnoho týmů stačí vestavěný HTML report a artefakty CI.

Selenium je také zdarma, ale náklady na infrastrukturu pro provozování Selenium Grid ve velkém měřítku nejsou triviální. Někdo ve vašem týmu musí udržovat tyto uzly Gridu, řešit aktualizace verzí prohlížečů a ladit selhání infrastruktury.

Verdikt: Playwright vítězí v nákladech, není to ani blízko. Každou funkci, kterou Cypress uzamyká za paywallem (paralelizace, analytika testů, detekce flakiness), Playwright zahrnuje zdarma. Selenium je zdarma na úrovni nástroje, ale účet za infrastrukturu narůstá.

Komponentové testování

Komponentové testování vám umožňuje mountnout jednotlivou komponentu React, Vue nebo Angular izolovaně a testovat ji bez spouštění celé aplikace. Cypress tuto approach pioneered a je to jeden z nejsilnějších důvodů, proč dnes zvolit Cypress.

Cypress má prvotřídní komponentové testování pro React (18-19), Vue 3, Angular (18-21) a Svelte 5. Používáte stejné API cy.mount() a stejný Test Runner, který již znáte z E2E testů. Dokumentace je zralá, ekosystém je solidní a funguje spolehlivě. Pro týmy, které chtějí jeden nástroj pro komponentové i E2E testování, je komponentové testování v Cypressu skutečným diferenciátorem.

Playwright přidal experimentální komponentové testování v posledních verzích, podporující React, Vue a Svelte. Je funkční, ale méně vyleštěné než implementace v Cypressu. Pokud je komponentové testování prioritou od prvního dne, Cypress má navrch. Ale rychlé tempo vydávání Playwrightu (měsíční) znamená, že se tato mezera zmenšuje.

Selenium nemá žádnou podporu pro komponentové testování. Operuje na úrovni prohlížeče, ne na úrovni komponent. Pokud potřebujete komponentové testování alongside Selenium E2E testy, použijete samostatný nástroj jako React Testing Library nebo Vitest.

Verdikt: Cypress vítězí v komponentovém testování, pioneered tento přístup, má nejzralejší implementaci a pokrývá nejširší škálu frameworků. Playwright je silný druhý. Selenium zde není konkurentem.

Komunita, ekosystém a trendy adopce

Čísla vyprávějí příběh. Playwright předstihl Cypress ve stahováních z npm kolem poloviny roku 2024 a do února 2026 je rozdíl značný: Playwright dosahuje přibližně 30 milionů týdenních stažení oproti 6,5 milionu u Cypressu a 1,8 milionu u Selenium WebDriver.

Hvězdičky na GitHubu následují podobný vzorec: Playwright má přibližně 82 800, Cypress 49 461 a Selenium 33 769 k únoru 2026. Průzkum State of JavaScript konzistentně řadí Playwright nejvýše v spokojenosti vývojářů a zájmu.

Ale npm vypráví pouze JavaScriptový příběh. Skutečná základna instalací Selenium sahá do ekosystémů Java, Python, C# a Ruby, kde se stahování z npm nepočítají. Ve světě enterprise Java je Selenium stále dominantním frameworkem s velkým náskokem.

Proč Playwright roste tak rychle? Podpora Microsoftu mu poskytuje konzistentní měsíční vydání a dlouhodobou stabilitu. Design zaměřený na TypeScript odpovídá směru, kterým se frontendový vývoj ubírá. Bezplatná paralelizace odstraňuje tření, které vytváří ceník Cypress Cloud. A podpora více jazyků znamená, že týmy Python a Java mohou migrovat ze Selenium bez změny jazyka.

Cypress neklesá v absolutních číslech, stahování se ustálila kolem 6–7 milionů týdně. Ale jeho relativní podíl se zmenšuje, jak Playwright absorbuje jak nové projekty, tak migrace z Cypressu/Selenium.

Verdikt: Playwright vítězí v momentum. Má nejrychlejší růst, nejvyšší spokojenost vývojářů a nejsilnější trajektorii. Selenium vítězí v nainstalované základně. Cypress si udržuje loajální komunitu, ale jeho růst se zastavil.

Průvodce migrací: Přepínání frameworků

Pokud zvažujete přepnutí, zde je praktický překladový průvodce.

Cypress na Playwright: Překlad API

// BEFORE: Cypress login test
describe('Login', () => {
  it('logs in successfully', () => {
    cy.visit('/login');
    cy.get('#email').type('[email protected]');
    cy.get('#password').type('password123');
    cy.get('form').submit();
    cy.url().should('include', '/dashboard');
  });
});

// AFTER: Same test in Playwright
import { test, expect } from '@playwright/test';

test('logs in successfully', async ({ page }) => {
  await page.goto('/login');
  await page.locator('#email').fill('[email protected]');
  await page.locator('#password').fill('password123');
  await page.locator('form').evaluate(form => form.submit());
  await expect(page).toHaveURL(/dashboard/);
});

Klíčové překlady: cy.visit() se stává page.goto(). cy.get() se stává page.locator(). cy.intercept() se stává page.route(). cy.wait('@alias') se stává page.waitForResponse(). Implicitní chaining Cypressu se stává explicitním async/await.

Selenium na Playwright: Překlad API

// BEFORE: Selenium login test
const { Builder, By, until } = require('selenium-webdriver');

async function loginTest() {
  const driver = await new Builder().forBrowser('chrome').build();
  try {
    await driver.get('http://localhost:3000/login');
    await driver.findElement(By.id('email')).sendKeys('[email protected]');
    await driver.findElement(By.id('password')).sendKeys('password123');
    await driver.findElement(By.css('form')).submit();
    await driver.wait(until.urlContains('/dashboard'), 10000);
  } finally {
    await driver.quit();
  }
}

// AFTER: Same test in Playwright
import { test, expect } from '@playwright/test';

test('logs in successfully', async ({ page }) => {
  await page.goto('/login');
  await page.locator('#email').fill('[email protected]');
  await page.locator('#password').fill('password123');
  await page.locator('form').evaluate(form => form.submit());
  await expect(page).toHaveURL(/dashboard/);
});

Největší rozdíl? Playwright se stará o životní cyklus prohlížeče a automatické čekání za vás. Žádné další driver.quit() v blocích finally. Žádné další driver.wait(until.urlContains(...), 10000), Playwright automaticky čeká na navigaci. Odstraňte všechna implicitní a explicitní čekání; automatické čekání Playwrightu je nahrazuje.

Kontrolní seznam migrace

1. Auditujte svou existující testovací sadu, spočítejte testy, identifikujte vlastní příkazy (Cypress) nebo komplexní logiku čekání (Selenium)
2. Nainstalujte Playwright alongside svého současného frameworku, spusťte oba v CI během přechodu
3. Překládejte testy inkrementálně, začněte s nejjednoduššími, nejcennějšími testy
4. Nahraďte vlastní příkazy page objekty nebo fixtures, vlastní příkazy Cypressu nemají 1:1 ekvivalent v Playwrightu
5. Aktualizujte svou konfiguraci CI, přidejte konfiguraci shardingu Playwrightu, odstraňte klíče Cypress Cloud, pokud jsou relevantní
6. Spusťte oba frameworky paralelně po dobu 1–2 sprintů pro zachycení regresí
7. Ukončete podporu starého frameworku, jakmile jsou všechny testy migrovány a stabilní

Typická sada 200 testů v Cypressu může být migrována jedním inženýrem za 1–2 sprints. Migrace ze Selenium na Playwright trvá o něco déle, protože testy v Selenium mají tendenci mít komplexnější logiku čekání, kterou je třeba přepracovat. Pokud migrujete, Playwright je cílem, který volí 90 % týmů v roce 2026. Samotná migrace je přímočará, nejtěžší částí bývají vlastní příkazy Cypressu nebo komplexní logika čekání v Selenium.

Doporučení pro specifické stacky: React, Next.js a další

Obecná rada „záleží na tom“ je k ničemu. Zde je to, co bychom vybrali pro specifické tech stacky, na základě budování produkčních aplikací s těmito frameworky.

Pokud váš tým buduje s Next.js a hodnotí frameworky, naše srovnání Next.js vs Remix pokrývá, jak architektura frameworku ovlivňuje vaši strategii testování. Schopnost Playwrightu nativně testovat API routy a serverové komponenty ho činí obzvláště мощným v ekosystému Next.js.

AI-asistované testování v roce 2026

AI-asistované testování již není hypotetické, nástroje jako GitHub Copilot, Cursor a Claude Code generují testovací kód denně pro tisíce vývojářů. Volba frameworku ovlivňuje, jak dobře tyto nástroje fungují.

Playwright má nejlepší kompatibilitu s AI. Jeho TypeScript-first API se silnými typovými definicemi znamená, že AI asistenti generují přesnější testovací kód. Strukturované vzorce async/await jsou pro LLM snazší k pochopení než chaining v Cypressu. A vlastní nástroj Playwrightu npx playwright codegen zaznamenává interakce s prohlížečem a generuje kompletní testovací soubory s inteligentním výběrem lokátorů, není potřeba žádná AI předplatné.

Cypress funguje s AI nástroji poměrně dobře. Jeho deklarativní chaining API je stručné a dobře reprezentované v trénovacích datech. Ale namespace cy. a vzorce vlastních příkazů mohou zmást generování kódu, produkuje testy, které vypadají správně, ale selhávají kvůli záludnostem specifickým pro Cypress.

Selenium je nejslabší shoda pro AI-asistované testování. Ukecaný boilerplate, více jazykových bindingů s různými API a nekonzistentní vzorce napříč Java/Python/JS znamenají, že AI-generovaný kód pro Selenium vyžaduje nejvíce manuálního čištění.

Nepřeceňujte zde roli AI, je to multiplikátor produktivity, nikoliv náhrada za návrh testů. Ale pokud váš tým používá AI coding asistenty (a většina ano v roce 2026), Playwright produkuje nejspolehlivější generované testy.

Verdikt: Playwright vítězí pro AI-asistovanou generaci testů. Jeho typované API a strukturované vzorce produkují nejlepší výsledky s moderními AI coding asistenty.

Rozhodovací framework: Který nástroj byste měli zvolit?

Zde je sekce, pro kterou jste přišli. Konkrétní scénáře, konkrétní doporučení.

Kdy NEpoužívat každý nástroj

• Nezvolte Playwright, pokud celý váš tým hluboce zná Cypress, má rozsáhlé vlastní příkazy a nemá žádné bolesti. Náklady na migraci existují a „novější“ neznamená „lepší pro vaši situaci“.
• Nezvolte Cypress, pokud potřebujete podporu více jazyků, testování více karet nebo bezplatné paralelní provádění ve velkém měřítku. To jsou architektonická omezení, ne funkce na roadmapě.
• Nezvolte Selenium pro nové projekty v JavaScriptu/TypeScriptu. Playwright i Cypress nabízejí dramaticky lepší DX, rychlost a spolehlivost pro JS týmy.

Jak Techsy přistupuje k automatizaci testů

V Techsy jsme implementovali E2E testování na desítkách produkčních webových aplikací. Zde je náš skutečný proces:

1. Ve výchozím nastavení zvolíme Playwright pro nové projekty. Jeho rychlost, bezplatná paralelizace a TypeScript-first DX odpovídají našemu stacku Next.js/React. Píšeme E2E testy alongside features, ne po sprintu, ne „když máme čas“, ale jako součást definice hotovo.

2. Používáme Cypress, když má klientský tým existující infrastrukturu Cypressu a migrace není opodstatněná. Netlačíme týmy k migraci jen tak pro nic za nic. Pokud Cypress funguje a tým je produktivní, pomáháme jim vytěžit z něj více.

3. Pomáháme týmům migrovat ze Selenium, když břemeno údržby překračuje náklady na migraci, což se stává častěji, než byste si mysleli. Sady Selenium mají tendenci hromadit komplexní logiku čekání a křehké selektory v průběhu let.

Naše typická testovací sada: Playwright pro E2E, React Testing Library pro testy na úrovni komponent a GitHub Actions pro CI. Tato kombinace pokrývá celou testovací pyramidu s minimální složitostí nástrojů.

Potřebujete pomoc s nastavením automatizovaného testování pro vaši webovou aplikaci? Naše tým implementuje testování Playwright a Cypress napříč projekty React, Next.js a Node.js. Získejte bezplatnou konzultaci k testování.

Finální verdikt

Pro většinu týmů začínajících nový projekt v roce 2026 je Playwright výchozí volbou. Je nejrychlejší, nejmocnější a zcela zdarma. Vítězí v 9 z 12 kategorií v tabulce výše.

Ale výchozí nastavení nejsou univerzální. Cypress zůstává správnou volbou pro frontendové týmy, které upřednostňují interaktivní ladění a komponentové testování a které mohou žít v rámci svých architektonických omezení. Selenium zůstává nezbytné pro enterprise prostředí Java/Python s existující testovací infrastrukturou a pro stále vzácnější případy, kdy záleží na podpoře IE.

Nejhorším rozhodnutím je analýza paralýzy. Zhodnoťte jazyk svého týmu, požadavky na prohlížeče, rozpočet na CI a preference ladění. Vyberte jeden. Začněte psát testy. Vždy můžete migrovat později a jak jsme ukázali výše, cesta migrace je dobře zdokumentovaná.

Zdroje

• Dokumentace Playwright
• Ceny Cypress Cloud
• npm Trends, Playwright vs Cypress vs Selenium
• Checkly, Benchmark srovnání rychlosti
• Next.js, Testování s Playwright
• State of JavaScript 2024 -- Testovací knihovny
• BigBinary, Proč jsme přešli z Cypressu na Playwright

Playwright vs Cypress vs Selenium: FAQ

Je Playwright lepší než Cypress?

Pro většinu týmů v roce 2026 ano. Playwright je rychlejší (2x v benchmarcích), podporuje více prohlížečů a jazyků, má bezplatnou paralelizaci a lepší podporu TypeScriptu. Cypress vítězí v DX interaktivního ladění a zralosti komponentového testování. Pokud jsou tyto dvě věci vaší nejvyšší prioritou, Cypress je stále silnou volbou.

Nahrazuje Playwright Selenium?

V ekosystému JavaScript/TypeScript, do velké míry ano. Stahování Playwrightu z npm jsou přibližně 4,5x vyšší než Cypress a 17x vyšší než Selenium WebDriver. Ale Selenium zůstává dominantní v enterprise prostředích Java a Python, kde je jeho podpora více jazyků a desetiletí ekosystémových nástrojů nezbytná. Selenium není mrtvé, zužuje se na svou niku.

Který je rychlejší, Playwright nebo Cypress?

Playwright spouští testovací sady přibližně 2x rychleji, 4,5 sekundy vs 9,4 sekundy v porovnatelných benchmarcích. Rozdíl se zvětšuje u větších sad, protože model kontextu prohlížeče v Playwrightu je efektivnější než procesní model Cypressu. Jeden tým ohlásil 89% snížení celkového času CI po migraci.

Podporuje Cypress Safari?

Cypress má experimentální podporu WebKitu, ale není považován za production-ready. Playwright zahrnuje WebKit (rendering engine Safari) jako prvotřídní, plně podporovaný prohlížeč, který běží na jakémkoli OS. Pokud je testování Safari kritické pro vaše uživatele, Playwright je bezpečnější volba.

Je Selenium v roce 2026 mrtvé?

Ne. Selenium zůstává nejrozšířenějším E2E frameworkem globálně, zejména v ekosystémech Java a Python. Je jedinou možností pro testování IE/legacy prohlížečů. Ale pro nové projekty v JavaScriptu/TypeScriptu jsou Playwright a Cypress lepšími volbami podle každého praktického metriky.

Může Playwright testovat mobilní aplikace?

Playwright může emulovat mobilní prohlížeče (Chrome pro Android, Safari pro iOS přes WebKit) s přesnou simulací viewportu, dotyku a user agenta. Nemůže automatizovat nativní mobilní aplikace. Pro testování nativních aplikací potřebujete Appium (které používá protokol WebDriver ze Selenium) nebo dedikovaný framework pro mobilní testování jako Detox.

Měl bych se nejprve naučit Playwright nebo Cypress?

Pokud jste noví v E2E testování v roce 2026, začněte s Playwrightem. Má nejsilnější růstovou trajektorii, nejkomplexnější sadu funkcí a dovednosti se přenášejí na jakýkoli projekt JavaScript/TypeScript. Cypress stojí za naučení, pokud jej váš tým již používá nebo pokud je interaktivní ladění vaší primární starostí.

Jaké jsou nevýhody Playwrightu?

Zážitek z interaktivního ladění v Playwrightu je méně vyleštěný než Test Runner v Cypressu (ačkoli UI mode v Playwrightu tuto mezeru zmenšuje). Jeho komponentové testování je méně zralé než v Cypressu. A jeho rychlé měsíční tempo vydávání znamená, že se API surface často mění, budete muset držet krok s aktualizacemi.

Kolik stojí Cypress Cloud?

Cypress Cloud začíná na $67/měsíc (fakturováno ročně) pro Team plán s 120 000 výsledky testů ročně a jde až na $267/měsíc pro Business s neomezenými výsledky. Enterprise ceny jsou custom. Playwright nabízí ekvivalentní funkce, paralelizaci, analytiku testů prostřednictvím HTML reporteru a detekci flakiness prostřednictvím opakování, zdarma.

Který E2E framework funguje nejlépe s GitHub Actions?

Všechny tři fungují s GitHub Actions, ale Playwright vyžaduje nejméně konfigurace. Oficiální Docker obrazy Playwrightu a vestavěné sharding (--shard=1/4) dělají z nastavení CI jediný YAML soubor. Cypress potřebuje svůj oficiální GitHub Action a předplatné Cypress Cloud pro paralelizaci. Selenium potřebuje service container pro driver prohlížeče.

Funguje Playwright s Javou nebo Pythonem?

Ano. Playwright má oficiální bindingy pro Java, Python, C# a JavaScript/TypeScript udržované Microsoftem. Cypress je pouze JavaScript/TypeScript. To činí z Playwrightu přesvědčivou alternativu k Selenium pro non-JS týmy, které chtějí moderní nástroje bez změny jazyka.

Jak migrovat ze Selenium na Playwright?

Začněte instalací Playwrightu alongside Selenium. Překládejte testy inkrementálně: page.locator() nahrazuje driver.findElement(), page.goto() nahrazuje driver.get() a můžete odstranit všechna explicitní čekání, protože Playwright automaticky čeká. Aktualizujte svou konfiguraci CI, spusťte oba frameworky paralelně během přechodu a poté ukončete podporu Selenium, jakmile jsou všechny testy zelené. Typická sada 200 testů zabere 1–2 sprints jednomu inženýrovi.