Elég gyorsan érkeznek az új kiadások, és nem tudom, hogy sírjak, vagy nevessek.
A Playwright v1.65 hivatalosan is megjelent, és számos izgalmas fejlesztést, valamint tesztfuttatási változtatást hozott. Az alábbiakban a legfontosabb újdonságok összegzése látható, működő példákkal:
1. Tesztfuttatás Bun alatt (Run tests with Bun)
A Playwright tesztfuttatója mostantól hivatalosan is futtatható a Bun futtatókörnyezetben. Mivel a Bun saját maga végzi a TypeScript fájlok transzpilálását, a Playwright nem használja a Babelt vagy annak gyorsítótárát.
Használatához a --bun flaget kell megadni:
Bash
bunx--bunplaywrighttest
2. Új hibajelentő opciók (Reports with only failures)
Kényelmesebbé vált a CI/CD pipeline-ok logolása: az új failures reporter csak a hibás teszteket és a sikeres újrapróbálkozásokat nyomtatja ki, progress bar nélkül. Emellett az HTML, JSON és JUnit riportoknál is beállítható, hogy csak a problémás teszteket tartsák meg.
TypeScript
// playwright.config.tsimport {defineConfig} from '@playwright/test';export default defineConfig({ reporter:[['failures'],['html',{ onlyFailures:true}],],});
3. Exkluzív tesztzár (-exclusive- test lock)
Bevezetésre került egy új, beépített tesztzár mechanizmus, amellyel egy adott teszt kizárólagosan futtatható (azaz miközben ez fut, más tesztek nem futnak párhuzamosan vele, de a többi teszt egymás között igen).
TypeScript
import {test} from '@playwright/test';test('adatbázis migráció és szerver újraindítás',{ lock:'-exclusive-'},async()=>{// Amíg ez fut, semmilyen más teszt nem fut a workerben});
4. Egyszerűbb teszt annotációk
A test.skip(), test.fixme(), test.fail() és test.slow() metódusok mostantól közvetlenül is fogadnak egyetlen sztringként megadott leírást, ami rögzítésre kerül a teszt annotációi között:
TypeScript
import {test} from '@playwright/test';test('új funkció tesztelése',async({page})=>{test.skip('Még nem implementált backend végpont');});
5. Fontosabb Breaking Changes (Törő változtatások)
TypeScript class fields: A TypeScript osztálymezők mostantól szigorúan a tsconfig.json szerinti useDefineForClassFields viselkedést követik (hasonlóan a tsc-hez).
Inert elemek szigorúbb kezelése: Az akciók (pl. click(), fill()) automatikusan timeoutolnak, ha az elem inert attribútummal rendelkezik vagy egy inaktív réteg mögött rekedt.
A Playwright 1.64-es verziója számos olyan új funkciót és finomítást hozott, amelyek megkönnyítik az elemkeresést, a tesztek futtatását, valamint a videófelvételek testreszabását.
1. Új Locator API: locator.within()
A locator.within() segítségével két már létező locatort lehet természetes módon kombinálni, és a relatív pozicionálók (pl. .first(), .nth()) a szülő elemen belül értékelődnek ki.
TypeScript
// Összekapcsol két külön definíciótconstdialog=page.getByRole('dialog');constsaveButton=page.getByRole('button',{ name:'Mentés'});// Mentés gomb keresése kifejezetten a párbeszédablakon belülawaitsaveButton.within(dialog).click();
2. Véletlenszerű tesztfuttatás: --shuffle
Segít kiszűrni a tesztek közötti rejtett függőségeket a futtatási sorrend megkeverésével. A tesztfutás végén megadott seed kód segítségével pontosan reprodukálható a hibás futási sorrend.
Míg a 1.63-ban megjelent zárolások csak egyes tesztekre vonatkoztak, a 1.64-ben már egész fájlokra vagy tesztcsoportokra (describe) is alkalmazhatóak. Az azonos zárolási névvel rendelkező tesztek nem futnak párhuzamosan.
TypeScript
import {test} from '@playwright/test';// Az ebben a csoportban lévő tesztek nem futnak párhuzamosan más 'user-settings' zárral ellátott tesztekkeltest.describe.configure({ lock:'user-settings'});test('profil frissítése',async({page})=>{// ...});
4. default: false beállítás a projekt konfigurációban
A playwright.config.ts-ben megjelölhetők olyan böngészők vagy projektek, amelyeket alapértelmezetten ki szeretnél hagyni a sima npx playwright test futtatásból anélkül, meglévő konfigurációkat kellene törölni.
A Playwright kiegészült a böngésző alapú AI modellek eszközeinek (WebMCP) tesztelésére szolgáló felülettel (page.webmcp.tools() és page.webmcp.callTool()), amellyel ellenőrizhetők az oldalak által az AI-ágensek felé regisztrált eszközök.
Fontosabb breaking change-ek / Viselkedésbeli változások
Rejtett iframe-ek: A nem látható iframe-ben lévő elemeket (pl. visibility: hidden) a Playwright mostantól automatikusan rejtettként kezeli az akciók és a toBeVisible() ellenőrzések során.
Emulált képernyőméret: A devices['Desktop Chrome'] típusú eszközleírók átadják a screen tulajdonságot, így a window.screen felbontása és a media query-k az emulált kijelzőméretet tükrözik.
Snapshot frissítés: A --update-snapshots=missing opció használata esetén a hiányzó screenshotok létrehozása után a teszt sikeresként értékelődik.
Mennyi mindent használunk, de igazából lehet, hogy fogalmunk sincs róla, hogy mire is jó pontosan, és mikor is érdemes használni. A miértről nem is beszélve…
Mit mesél erről a Gemini?
A .NET-ben (C#) a yield kulcsszó pontosan ugyanazt a célt szolgálja, mint a Pythonban: IEnumerable<T> vagy IAsyncEnumerable<T> típusú adatfolyamokat hozhatsz vele létre úgy, hogy a kód lusta kiértékeléssel (lazy evaluation), elemenként adja vissza az eredményeket.
C#-ban két formája létezik:
yield return <érték>: Visszaad egy elemet, majd felfüggeszti a metódus futását a következő elem kéréséig.
yield break: Azonnal leállítja az iterációt (megszakítja a generálást).
Mire jó C#-ban?
1. Memóriatakarékosság nagy adathalmazoknál
Ha nem List<T>-et adsz vissza, nem kell a teljes gyűjteményt lefoglalni a RAM-ban.
C#
usingSystem;usingSystem.Collections.Generic;// PÉLDA 1: Hagyományos megközelítés (Memóriatakaréktalan)publicList<int>GetNumbersList(){varlist=newList<int>();for (inti=0;i<1_000_000;i++){list.Add(i);// Mind az 1 milló elem belekerül a RAM-ba}returnlist;}// PÉLDA 2: yield használata (Memóriatakarékos)publicIEnumerable<int>GetNumbersYield(){for (inti=0;i<1_000_000;i++){yieldreturni;// Mindig csak az aktuális számot generálja le}}
2. Szűrés és adatfeldolgozás yield break-kel
A yield break használatával feltételhez kötheted az adatfolyam végét anélkül, hogy bonyolult feltételkezelést kellene írnod a ciklus köré:
C#
publicIEnumerable<string>GetActiveUsers(List<string>users){foreach (varuserinusers){if (user=="ADMIN_STOP"){yieldbreak;// Azonnal leállítja az elemek kiadását}if (!string.IsNullOrEmpty(user)){yieldreturnuser;}}}
3. Óriási fájlok feldolgozása soronként
Nem kell a gigabájtos fájlokat egyszerre a memóriába tölteni (File.ReadAllLines helyett):
C#
usingSystem.IO;usingSystem.Collections.Generic;publicIEnumerable<string>ReadLargeFile(stringfilePath){using (StreamReaderreader=newStreamReader(filePath)){string?line;while ((line=reader.ReadLine()) !=null){ yield return line; // Mindig csak egyetlen sort tart a memóriában} }}// Használat:foreach (stringlineinReadLargeFile("huge_log.txt")){if(line.Contains("ERROR")){Console.WriteLine(line);}}
Modern .NET-ben hálózati kéréseknél vagy adatbázis-lekérdezéseknél aszinkron módon is használhatod:
C#
publicasyncIAsyncEnumerable<int>FetchDataAsync(){for (inti=1;i<=5;i++){awaitTask.Delay(1000);// Pl. hálózati várakozás szimulálásayieldreturni;}}// Használat:awaitforeach (variteminFetchDataAsync()){Console.WriteLine(item);// Másodpercenként jelenik meg egy elem}
Hagyományos visszatérés vs. yield C#-ban
Szempont
List<T> / Tömb
yield return (IEnumerable<T>)
Kiértékelés ideje
Azonnali (A metódus hívásakor lefut a teljes ciklus)
Lusta / Halasztott (Csak akkor fut, amikor a foreach kéri a következő elemet)
Igen, pontosan ugyanígy működik TypeScriptben és JavaScriptben is.
A TypeScript a JavaScript generátor függvényeit (Generator Functions) használja, amelyeket az function* (csillaggal jelölt) szintaxisról lehet felismerni.
A működési elv teljesen megegyezik a Python és a C# esetében látottakkal: a yield felfüggeszti a függvény futását, megőrzi a belső állapotot, és lusta kiértékeléssel (lazy evaluation) adja vissza az elemeket egy Generator objektumon keresztül.
Alapvető példa TypeScriptben
A generátor függvény visszatérési típusa Generator<T, TNext TReturn,>, ahol a T a yield-elt értékek típusa.
TypeScript
// A csillag (function*) jelzi, hogy ez egy generátor függvényfunction*szamGeneraltor():Generator<number>{yield1;yield2;yield3;}// Használat for...of ciklussal:for (constszamofszamGeneraltor()) {console.log(szam);// Kiírja egymás után: 1, 2, 3}
A TypeScriptben létezik a yield* utasítás is, amellyel átadhatod a vezérlést egy másik generátornak vagy tömbnek (bejárható objektumnak):
TypeScript
function*elsoResz():Generator<number>{yield1;yield2;}function*teljesSorozat():Generator<number>{yield*elsoResz();// Delegálja az elemeket az elsoResz-bőlyield* [3,4,5];// Tömb elemeit is ki tudja adni egymás után}console.log([...teljesSorozat()]);// [1, 2, 3, 4, 5]
3. Aszinkron generátorok (yield + async)
Ahogy C#-ban az IAsyncEnumerable, TypeScriptben és JS-ben is létezik az AsyncGenerator (async function*). Ez hálózati adatok, lapozott API-k vagy adatfolyamok (stream) feldolgozásánál nagyon hasznos:
TypeScript
asyncfunction*adatokLetolteseAPIrol():AsyncGenerator<string>{constoldalak= [1,2,3];for (constoldalofoldalak) {// Szimulált hálózati kérés (API hívás)constvalasz=awaitfetch(`https://api.example.com/data?page=${oldal}`);constadat=awaitvalasz.text();yieldadat;// Mindig csak az aktuális oldal adatait adja vissza}}// Használat for await...of ciklussal:asyncfunctionfeldolgozas(){forawait (constoldalAdatofadatokLetolteseAPIrol()) {console.log("Megérkezett egy oldal:",oldalAdat);}}