Kategória: Typescript

  • Playwright 1.65 újdonságok

    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 --bun playwright test
    

    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.ts
    import { 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.
  • Playwright 1.64 újdonságok

    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ót
    const dialog = page.getByRole('dialog');
    const saveButton = page.getByRole('button', { name: 'Mentés' });
    
    // Mentés gomb keresése kifejezetten a párbeszédablakon belül
    await saveButton.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.

    Bash

    # Tesztek véletlenszerű sorrendben történő futtatása
    npx playwright test --shuffle
    
    # Pontos futási sorrend újrajátszása a kapott seed alapján
    npx playwright test --shuffle 271828182
    

    3. Tesztzárolások (Test Locks) csoportszinten

    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 tesztekkel
    test.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.

    TypeScript

    // playwright.config.ts
    export default {
      projects: [
        { name: 'chromium', use: { ...devices['Desktop Chrome'] } },
        { name: 'firefox', use: { ...devices['Desktop Firefox'] }, default: false },
        { name: 'webkit', use: { ...devices['Desktop Safari'] }, default: false },
      ],
    };
    
    • Futtatás csak chromium-on: npx playwright test
    • Kifejezett futtatás firefox-on: npx playwright test --project=firefox

    5. Videófelvételek fejlesztése (VP9, CSS stílusok, FPS)

    A videók rögzítése hatékonyabbá és jobban testreszabhatóvá vált:

    • VP9 kódolás: Kisebb fájlméret és alacsonyabb CPU-használat.
    • Egyedi képkockasebesség (FPS): Testreszabható fps opció.
    • CSS stílusok a műveletjelzőkhöz: A korábbi fontSize opció helyett CSS szabályok adhatók meg a mutatók és kiemelések testreszabására.

    TypeScript

    // playwright.config.ts
    export default {
      use: {
        video: {
          mode: 'on',
          fps: 60,
          style: {
            pointMarker: 'background-color: red;',
            targetHighlight: 'border: 2px solid blue;',
          },
        },
      },
    };
    

    6. Kísérleti WebMCP támogatás (page.webmcp)

    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.
  • Tipikus interjú kérdés: yield

    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#

    using System;
    using System.Collections.Generic;
    
    // PÉLDA 1: Hagyományos megközelítés (Memóriatakaréktalan)
    public List<int> GetNumbersList()
    {
        var list = new List<int>();
        for (int i = 0; i < 1_000_000; i++)
        {
            list.Add(i); // Mind az 1 milló elem belekerül a RAM-ba
        }
        return list;
    }
    
    // PÉLDA 2: yield használata (Memóriatakarékos)
    public IEnumerable<int> GetNumbersYield()
    {
        for (int i = 0; i < 1_000_000; i++)
        {
            yield return i; // 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#

    public IEnumerable<string> GetActiveUsers(List<string> users)
    {
        foreach (var user in users)
        {
            if (user == "ADMIN_STOP")
            {
                yield break; // Azonnal leállítja az elemek kiadását
            }
    
            if (!string.IsNullOrEmpty(user))
            {
                yield return user;
            }
        }
    }
    

    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#

    using System.IO;
    using System.Collections.Generic;
    
    public IEnumerable<string> ReadLargeFile(string filePath)
    {
        using (StreamReader reader = new StreamReader(filePath))
        {
            string? line;
            while ((line = reader.ReadLine()) != null)
            {
                yield return line; // Mindig csak egyetlen sort tart a memóriában
            }
        }
    }
    
    // Használat:
    foreach (string line in ReadLargeFile("huge_log.txt"))
    {
        if (line.Contains("ERROR"))
        {
            Console.WriteLine(line);
        }
    }
    

    4. Aszinkron adatfolyamok (C# 8.0+: IAsyncEnumerable<T>)

    Modern .NET-ben hálózati kéréseknél vagy adatbázis-lekérdezéseknél aszinkron módon is használhatod:

    C#

    public async IAsyncEnumerable<int> FetchDataAsync()
    {
        for (int i = 1; i <= 5; i++)
        {
            await Task.Delay(1000); // Pl. hálózati várakozás szimulálása
            yield return i;
        }
    }
    
    // Használat:
    await foreach (var item in FetchDataAsync())
    {
        Console.WriteLine(item); // Másodpercenként jelenik meg egy elem
    }
    

    Hagyományos visszatérés vs. yield C#-ban

    SzempontList<T> / Tömbyield return (IEnumerable<T>)
    Kiértékelés idejeAzonnali (A metódus hívásakor lefut a teljes ciklus)Lusta / Halasztott (Csak akkor fut, amikor a foreach kéri a következő elemet)
    MemóriahasználatMagas ($O(N)$ méretű lista a RAM-ban)Minimális ($O(1)$ állandó memóriagény)
    Sebesség (első elem)Lassú (meg kell várni a teljes lista felépítését)Azonnali (az első elem kérésére rögtön visszatér)

    Gondoltam, megkérdezem ugyanezt Typescript esetén.

    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ény
    function* szamGeneraltor(): Generator<number> {
      yield 1;
      yield 2;
      yield 3;
    }
    
    // Használat for...of ciklussal:
    for (const szam of szamGeneraltor()) {
      console.log(szam); // Kiírja egymás után: 1, 2, 3
    }
    

    Mire jó TypeScriptben?

    1. Memóriatakarékos és végtelen sorozatok

    Nem kell előre tömbbe gyűjteni az elemeket:

    TypeScript

    function* vegtelenAzonositoGeneral(): Generator<string> {
      let id = 1;
      while (true) {
        yield `ID_${id++}`;
      }
    }
    
    const idGen = vegtelenAzonositoGeneral();
    
    console.log(idGen.next().value); // "ID_1"
    console.log(idGen.next().value); // "ID_2"
    console.log(idGen.next().value); // "ID_3"
    

    2. Adatfolyamok delegálása (yield*)

    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> {
      yield 1;
      yield 2;
    }
    
    function* teljesSorozat(): Generator<number> {
      yield* elsoResz(); // Delegálja az elemeket az elsoResz-ből
      yield* [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

    async function* adatokLetolteseAPIrol(): AsyncGenerator<string> {
      const oldalak = [1, 2, 3];
      
      for (const oldal of oldalak) {
        // Szimulált hálózati kérés (API hívás)
        const valasz = await fetch(`https://api.example.com/data?page=${oldal}`);
        const adat = await valasz.text();
        
        yield adat; // Mindig csak az aktuális oldal adatait adja vissza
      }
    }
    
    // Használat for await...of ciklussal:
    async function feldolgozas() {
      for await (const oldalAdat of adatokLetolteseAPIrol()) {
        console.log("Megérkezett egy oldal:", oldalAdat);
      }
    }
    

    Összehasonlítás

    NyelvFüggvény jelöléseKulcsszóBejárási felület
    C#IEnumerable<T> Get()yield returnforeach / LINQ
    Pythondef get():yieldfor item in gen
    TypeScriptfunction* get(): Generator<T>yieldfor...of / next()