{"canonical_url":"https://engineer.company/da/glossary/end-to-end-test/","content_markdown":"# End-to-end-test\n\n## Hvad det er\n\nEn end-to-end-test kontrollerer et helt, kørende system, sådan som brugeren\nmøder det. Den starter applikationen med dens rigtige frontend, backend,\ndatabase og konfiguration, gennemfører et forløb, for eksempel at oprette en\nkonto eller betale for en ordre, og kontrollerer til sidst det, brugeren ville\nse på skærmen. I daglig tale forkortes den ofte til E2E-test, og selve\npraksissen kaldes end-to-end-testning.\n\nI _Software Engineering at Google_ sorterer Adam Bender tests langs to akser.\nStørrelse handler om ressourcer: små tests kører i én proces, mellemstore på én\nmaskine, og store tests kører, hvor de vil. Omfang handler om, hvor meget kode\nen test sætter i gang, og tests med stort omfang går under flere navne, blandt\nandet funktionelle tests, end-to-end-tests og systemtests. Joseph Graves\ntilføjer i bogens kapitel om større tests, at tests med det største omfang\ntypisk har flere rigtige afhængigheder og færre test doubles.\n\nDet, de rigtige afhængigheder giver, er det, Graves kalder fidelity: hvor godt\nen test afspejler den virkelige adfærd i det system, der bliver testet. En\nenhedstest af en checkout-formular beviser, at formularens kode er rigtig i en\nsandkasse; en end-to-end-test af den samme formular beviser, at den udrullede\nside, ruten bag den, prisreglerne og databasen er enige med hinanden. Prisen\nbetales i isolation: jo mere et miljø ligner produktion, desto sværere er det at\nforsegle det hermetisk mod alt andet, og Graves bemærker, at de to egenskaber\nofte er i direkte konflikt.\n\nFor en webapplikation er brugerens grænseflade browseren, så det er dér, en\nend-to-end-test står. Graves siger det ligeud: for slutbrugerne er »det\noffentlige API selve applikationen«. Playwright Test, som eksemplet nedenfor\nbruger, beskriver sig selv som et end-to-end-testframework til moderne webapps.\nDet samler testkøreren, assertions, isolation og parallel kørsel og styrer\nChromium, Firefox og WebKit, enten headless eller med synligt vindue.\n\n## Hvorfor det betyder noget\n\nMindre tests efterlader huller, som kun en test af det samlede system kan lukke,\nog Graves opregner de almindeligste. En test double kan glide væk fra det, den\nerstatter, og intet fortæller testen, at den rigtige implementering har ændret\nsig. En enhedstest dækker koden inde i én kørbar fil, mens\nudrulningskonfigurationen, opstartsscripts og indstillingerne for\nproduktionsinstanserne ligger uden for den. Problemer, der kun viser sig under\nbelastning, er det tredje hul, og det fjerde er adfærd, ingen havde forudset, og\ndet er netop sådan, de fleste problemer når frem til brugerne. Bender skriver,\nat Google for det meste forbeholder store tests til end-to-end-tests af hele\nsystemet, som handler mere om at validere konfiguration end om enkelte stykker\nkode.\n\nDe kontrollerer også brugerfladen i det system, brugeren møder. En formular,\nder sender til en rute, som backenden lige har omdøbt, eller en release, hvis\nkonfiguration peger på den forkerte tjeneste, består hver eneste enhedstest på\nbegge sider og fejler, første gang et rigtigt menneske prøver den.\n\nPrisen er hastighed og pålidelighed. Graves bemærker, at Googles store tests har\nen standard-timeout på 15 minutter eller en time, og at de kan være\nikke-hermetiske, fordi de deler ressourcer med andre tests og med trafik, og\ndermed ikke-deterministiske. Bender nævner de sædvanlige kilder til den\nikke-determinisme: urets tid, trådplanlægning, netværkslatens og, længere nede,\nhardwareafbrydelser og browserens renderingsmotor. Derfor er bogens grove\nrettesnor en pyramide: omkring 80 % snævre enhedstests, 15 % integrationstests\nog 5 % end-to-end-tests, der validerer hele systemet. Større tests fungerer\nifølge Bender som fornuftstjek, efterhånden som produktet udvikler sig, og bør\nikke være holdets vigtigste måde at fange fejl på, og hold hos Google kører dem\nofte kun under build- og releaseprocessen, så de ikke sinker den daglige\nudvikling.\n\n## Sådan ser det ud i praksis\n\nTag en webshop, der sælger en tekande og spørger et fragtfirmas API om\nleveringstiden. En Playwright-spec for en gæsts første køb læser næsten som\nselve forløbet:\n\n```ts\n// e2e/checkout.spec.ts\nimport { test, expect } from \"@playwright/test\";\n\ntest.beforeEach(async ({ page }) =\u003e {\n    // Fragtfirmaets API ejes af andre: svar på dets vegne her.\n    await page.route(\"https://api.carrier.example/**\", (route) =\u003e\n        route.fulfill({ status: 200, body: '{\"days\": 2}' }),\n    );\n});\n\ntest(\"en gæst kan købe en tekande\", async ({ page }) =\u003e {\n    await page.goto(\"/shop/teapot\");\n    await page.getByRole(\"button\", { name: \"Læg i kurven\" }).click();\n    await page.getByRole(\"link\", { name: \"Kurv\" }).click();\n    await expect(page.getByText(\"Levering om 2 dage\")).toBeVisible();\n    await page.getByLabel(\"E-mail\").fill(\"buyer@example.com\");\n    await page.getByRole(\"button\", { name: \"Afgiv ordre\" }).click();\n    const thanks = page.getByRole(\"heading\", { name: \"Tak for din ordre\" });\n    await expect(thanks).toBeVisible();\n    await page.getByRole(\"link\", { name: \"Se din ordre\" }).click();\n    await expect(page.getByText(\"Tekande\")).toBeVisible();\n});\n```\n\nHver locator navngiver det, brugeren ser: en knap, der hedder Læg i kurven, et\nfelt med etiketten E-mail og en overskrift, der siger Tak for din ordre.\nPlaywright anbefaler at finde elementer efter rolle først, og dets locators er\nstrikse: matcher mere end ét element, kaster handlingen en fejl i stedet for at\ngætte. Før hvert klik og hver udfyldning venter Playwright på, at elementet kan\nbetjenes, og en assertion som `toBeVisible()` prøver igen, indtil betingelsen\nholder, så spec'en indeholder ingen faste ventepauser. Kaldet til `page.route` besvarer\nbrowserens forespørgsler til fragtfirmaet med et fast svar, så testen aldrig\nafhænger af en server, holdet ikke selv driver; mønstret skal matche hele\nURL'en, og `**` matcher på tværs af skråstreger. Routing når kun de\nforespørgsler, siden selv sender: spørger butikkens server i stedet\nfragtfirmaet, ser browseren aldrig den forespørgsel, og så må en test double\ntage over på serverens side. Hver test får desuden en frisk browserkontekst, som\nPlaywright sammenligner med en helt ny browserprofil, så den ene tests cookies\nog indkøbskurv ikke kan sive over i den næste.\n\nKonfigurationen starter applikationen og fortæller Playwright, hvor den bor:\n\n```ts\n// playwright.config.ts\nimport { defineConfig } from \"@playwright/test\";\n\nexport default defineConfig({\n    testDir: \"e2e\",\n    retries: process.env.CI ? 2 : 0,\n    use: {\n        baseURL: \"http://localhost:3000\",\n        trace: \"on-first-retry\",\n    },\n    webServer: {\n        command: \"npm run start\",\n        url: \"http://localhost:3000\",\n        reuseExistingServer: !process.env.CI,\n    },\n});\n```\n\nBlokken `webServer` kører `npm run start` og venter, til URL'en svarer, før den\nførste test går i gang; på en bærbar genbruger den en server, der allerede\nkører, og på CI starter den altid sin egen. Med `baseURL` kan spec'en skrive\n`/shop/teapot` i stedet for en fuld adresse. `npx playwright test` kører suiten\nheadless, `--headed` viser browservinduet, og `npx playwright show-report` åbner\nHTML-rapporten. Som standard prøver Playwright ikke en fejlet test igen; her\ntillader CI to forsøg mere, en test, der fejler og derefter består, bliver\nrapporteret som flaky og ikke som bestået, og ved første genforsøg optages et\ntrace, der viser, hvad der var anderledes.\n\nI større skala er browserlaget den mindste del af arbejdet. Den\n[testsuite, der er bygget til Go, SQL og browseren](/da/portfolio/built-a-test-suite-across-go-sql-and-browser/),\nfra 2025, har 981 testfunktioner i Go fordelt på 310 filer, 543 Vitest- og\nPlaywright-specs, heraf 48 end-to-end-filer og 30 browser-specs, og 494\nadfærdstestfiler i SQL. Opgaven var at kontrollere hvert lags adfærd dér, hvor\nadfærden hører hjemme, frem for at kontrollere alt udefra gennem en browser, så\nen stored function bliver testet i selve databasen i stedet for gennem de tre\napplikationslag, der ligger over den. Siden lægger ikke skjul på prisen: suiten\ner langsom, den lægger en ekstra byrde på hver ændring, og i den størrelse\nkræver den selv vedligeholdelse.\n\n## Hvor det går galt\n\n**Suiten er en isvaffel.** Sådan kalder Bender en suite med mange\nend-to-end-tests og få integrations- eller enhedstests. Den slags suiter er\ntypisk langsomme, upålidelige og svære at arbejde med, og mønstret opstår ofte i\nprojekter, der er hastet fra prototype til produktion. Graves tilføjer, at når\nkoden er svær at enhedsteste, er end-to-end-tests de eneste, nogen kan skrive,\nog så har projektet skabt legacy-kode på få dage. Hver ny tjeneste ganger\ndesuden antallet af veje gennem systemet, så en end-to-end-suite aldrig kan\ndække dem alle. Skub hvert tilfælde ned til den mindste test, der kan fange det,\ngem browseren til de forløb, kun hele systemet kan vise, og byg hen imod\npyramiden fra projektets første dage.\n\n**Selektorerne følger markuppen.** En locator som\n`button.buttonIcon.episode-actions-later`, Playwrights eget eksempel på noget,\nman bør undgå, går i stykker, næste gang nogen omdøber en klasse, selvom\nbrugeren ikke ser nogen forskel. Graves advarer om, at UI-tests har ry for at\nvære upålidelige og dyre, blandt andet fordi ændringer i udseendet får dem til\nat fejle, mens adfærden er den samme. Find elementer efter rolle, etiket eller\ntekst, sådan som en bruger finder dem, eller efter et test-id, holdet selv ejer.\nHar backenden et offentligt API, så del forløbet ved grænsen mellem UI og API,\nog kør resten af end-to-end-testen gennem API'et.\n\n**Testen sover.** En fast pause er for kort på en langsom dag og for lang alle\nandre dage. Graves bemærker, at tests, der bygger på sleeps og timeouts, alle\nbegynder at fejle, når maskinerne, der kører dem, bliver overbelastede, og\ngenkørslerne lægger endnu mere last på. Playwrights best practices viser en mere\nsnedig udgave af den samme fejl:\n`expect(await page.getByText(\"welcome\").isVisible()).toBe(true)` kontrollerer\nén gang og går videre, mens\n`await expect(page.getByText(\"welcome\")).toBeVisible()` venter på betingelsen.\nBrug web-first assertions, og når en test venter på backenden, så spørg efter\ntilstandsændringen med jævne mellemrum og med en timeout.\n\n**Testene deler data.** Én test opretter en konto, som den næste forventer,\neller to parallelle workers køber den sidste tekande på lager. Suiten består i\nén rækkefølge og fejler i en anden, eller kun når den kører parallelt.\nPlaywrights råd er at holde hver test fuldstændig isoleret, med sin egen\nlagring, session, data og cookies, og at styre dataene i enhver database,\ntestene bruger. Opret det, hver test har brug for, med unikke navne, og byg\naldrig på det, en tidligere test efterlod.\n\n**En andens server er med i testen.** En rigtig betalingsudbyder, et fragtfirma\neller en tjeneste til kort og ruter gør suiten afhængig af et system, holdet\nikke kan styre, og trafik dertil kan koste penge. Graves skriver, at det ikke\nanbefales at lade automatiske tests bruge et rigtigt tredjeparts-API, og at\nsådan en afhængighed er et vigtigt sted at dele testene; Playwrights eget råd er\nkun at teste det, man selv har kontrol over. Svar på tredjepartens vegne med\n`page.route`, når browseren sender kaldet, som spec'en ovenfor gør, eller med en\ntest double, som serveren er sat op til at kalde, når serveren selv sender det,\nog lad testen slutte ved den afhængighed.\n\n**Genforsøg skjuler ustabiliteten.** Genforsøg på CI gør en rød build grøn, og\nomkostningen vokser. Bender regner det igennem: ved 10.000 tests om dagen giver\nen risiko på 0,1 % for en falsk fejl i hver test 10 ustabile fejl om dagen, der\nskal undersøges, og når ustabiliteten nærmer sig 1 %, begynder testene at miste\nderes værdi. At køre testen igen bytter maskintid for udviklertid og udskyder\nkun den egentlige årsag. Dokumentationen til pytest siger det samme fra en anden\nvinkel: tests på et højere niveau er mere tilbøjelige til at være flaky, fordi\nde afhænger af mere tilstand. Behandl enhver test, Playwright melder som flaky,\nsom en fejl, åbn tracet fra genforsøget, og ret testen, eller slet den.\n\n## Læs mere\n\n- [Testing Overview](https://abseil.io/resources/swe-book/html/ch11.html)\n  — Adam Benders kapitel i _Software Engineering at Google_: testers størrelse\n  og omfang, pyramiden, isvaflen og prisen for ustabile tests.\n- [Larger Testing](https://abseil.io/resources/swe-book/html/ch14.html)\n  — Joseph Graves om fidelity, de huller, enhedstests efterlader, grænserne ved\n  UI og tredjeparter, og om at drive ustabiliteten ud.\n- [Installation](https://playwright.dev/docs/intro)\n  — Playwrights egen introduktion: installation af Playwright Test, kørsel af\n  eksempeltesten, headed-tilstand og HTML-rapporten.\n- [Best Practices](https://playwright.dev/docs/best-practices)\n  — test af synlig adfærd, isolerede tests, tredjepartsservere holdt udenfor,\n  locators og web-first assertions.\n- [Retries](https://playwright.dev/docs/test-retries)\n  — hvordan Playwright prøver fejlede tests igen og mærker hver test som passed,\n  flaky eller failed.\n- [Flaky tests](https://docs.pytest.org/en/stable/explanation/flaky.html)\n  — pytests forklaring af, hvorfor tests bliver ustabile, fra ukontrolleret\n  systemtilstand og testrækkefølge til trådsikkerhed, og hvad man kan gøre ved\n  det.\n\n\u003chttps://engineer.company/da/glossary/end-to-end-test/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hvor en end-to-end-test hører hjemme ved siden af enhedstests, et gennemgået Playwright-eksempel med konfiguration og de vaner, der gør suiten ustabil.","formats":{"gemtext":"https://engineer.company/da/glossary/end-to-end-test/index.gmi","gopher":"https://engineer.company/da/glossary/end-to-end-test/gophermap","html":"https://engineer.company/da/glossary/end-to-end-test/","json":"https://engineer.company/da/glossary/end-to-end-test/index.json","markdown":"https://engineer.company/da/glossary/end-to-end-test/index.md","pdf":"https://engineer.company/da/glossary/end-to-end-test/index.pdf"},"kind":"page","language":"da","title":"Hvad er en end-to-end-test?","url":"https://engineer.company/da/glossary/end-to-end-test/","version":1}