{"canonical_url":"https://engineer.company/sv/glossary/end-to-end-test/","content_markdown":"# End-to-end-test\n\n## Vad det är\n\nEtt end-to-end-test kontrollerar ett helt körande system så som användaren möter\ndet. Det startar applikationen med riktig frontend, backend, databas och\nkonfiguration, går igenom en hel resa, till exempel en registrering eller\nbetalningen av en beställning, och kontrollerar till sist det som användaren\nskulle se. I vardagligt tal förkortas det ofta till E2E-test, och arbetssättet\nkallas end-to-end-testning.\n\nI boken _Software Engineering at Google_ sorterar Adam Bender tester längs två\naxlar. Storlek handlar om resurser: små tester körs i en enda process,\nmedelstora på en enda maskin och stora var som helst. Omfattning handlar om hur\nmycket kod ett test berör, och tester med stor omfattning går under flera namn,\nbland dem funktionstester, end-to-end-tester och systemtester. Joseph Graves\ntillägger i bokens kapitel om större tester att testerna med störst omfattning\nvanligtvis involverar flera riktiga beroenden och färre testdubblar.\n\nDet som de riktiga beroendena ger är verklighetstrohet, som Graves definierar\nsom hur väl ett test återspeglar det verkliga beteendet hos systemet som testas.\nEtt enhetstest av ett kassaformulär bevisar att formulärets kod är rätt i en\navgränsad miljö; ett end-to-end-test av samma formulär bevisar att den\ndriftsatta sidan, routen bakom den, prisreglerna och databasen stämmer överens\nmed varandra. Priset betalas i isolering: ju mer en miljö liknar produktion,\ndesto svårare är det att försegla den mot allt annat, och Graves påpekar att\nverklighetstrohet och hermetiska tester ofta står i direkt konflikt.\n\nFör en webbapplikation är användarens gränssnitt webbläsaren, och det är där ett\nend-to-end-test står. Graves säger det rakt ut: för slutanvändare är ”det\npublika API:et själva applikationen”. Playwright Test, som exemplet nedan\nanvänder, beskriver sig själv som ett ramverk för end-to-end-testning av moderna\nwebbappar. Det samlar testkörare, assertions, isolering och parallell körning,\noch styr Chromium, Firefox och WebKit, med eller utan synligt fönster.\n\n## Varför det spelar roll\n\nMindre tester lämnar luckor som bara ett test av det sammansatta systemet kan\ntäppa till, och Graves räknar upp de vanligaste. En testdubbel kan glida ifrån\ndet den ersätter, utan att testet får veta att den riktiga implementationen har\nändrats. Ett enhetstest täcker koden inuti en enda binärfil, medan\ndriftsättningens konfiguration, startskripten och inställningarna för\nproduktionsinstanserna ligger utanför. Problem som bara visar sig under last är\nden tredje luckan. Den fjärde är beteende som ingen förutsåg, och det är så de\nflesta problem når användarna. Bender skriver att Google mest reserverar stora\ntester för end-to-end-tester av hela systemet, som validerar konfiguration mer\nän enskilda kodbitar.\n\nDe kontrollerar också gränssnittet i det system som användaren möter. Ett formulär\nsom skickar data till en route som backend just har döpt om, eller en release\nvars konfiguration pekar på fel tjänst, klarar alla enhetstester på båda sidor\noch fallerar första gången en riktig människa provar.\n\nPriset är hastighet och tillförlitlighet. Graves skriver att Googles stora\ntester har en standardtimeout på 15 minuter eller en timme, och att de kan vara\nicke-hermetiska, alltså dela resurser med andra tester och trafik, och därmed\nicke-deterministiska. Bender nämner de vanliga källorna till sådan\nicke-determinism: klocktid, trådschemaläggning, latens i nätverket och, längre\nned, hårdvaruavbrott och webbläsarnas renderingsmotorer. Därför är bokens\ntumregel en pyramid: ungefär 80 % enhetstester med smal omfattning, 15 %\nintegrationstester och 5 % end-to-end-tester som validerar hela systemet. Större\ntester, skriver Bender, fungerar som rimlighetskontroller allteftersom produkten\nutvecklas och bör inte vara teamets främsta sätt att hitta buggar; team på\nGoogle kör dem ofta bara under bygge och release, så att de inte bromsar det\ndagliga utvecklingsarbetet.\n\n## Så ser det ut i praktiken\n\nTa en webbutik som säljer en tekanna och frågar ett fraktbolags API om beräknad\nleveranstid. En Playwright-specifikation för en gästs första köp läses som\nsjälva resan:\n\n```ts\n// e2e/checkout.spec.ts\nimport { test, expect } from \"@playwright/test\";\n\ntest.beforeEach(async ({ page }) =\u003e {\n    // Fraktbolagets API ägs av andra: svara å dess vägnar här.\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öpa en tekanna\", async ({ page }) =\u003e {\n    await page.goto(\"/shop/teapot\");\n    await page.getByRole(\"button\", { name: \"Lägg i varukorgen\" }).click();\n    await page.getByRole(\"link\", { name: \"Varukorg\" }).click();\n    await expect(page.getByText(\"Leverans om 2 dagar\")).toBeVisible();\n    await page.getByLabel(\"E-post\").fill(\"buyer@example.com\");\n    await page.getByRole(\"button\", { name: \"Slutför beställningen\" }).click();\n    const thanks = page.getByRole(\"heading\", { name: \"Tack för ditt köp\" });\n    await expect(thanks).toBeVisible();\n    await page.getByRole(\"link\", { name: \"Visa din beställning\" }).click();\n    await expect(page.getByText(\"Tekanna\")).toBeVisible();\n});\n```\n\nVarje locator namnger det som användaren ser: en knapp som heter ”Lägg i\nvarukorgen”, ett fält märkt ”E-post”, en rubrik som säger ”Tack för ditt köp”.\nPlaywright rekommenderar rollbaserade locatorer i första hand, och locatorerna\när strikta: matchar de mer än ett element kastar åtgärden ett fel i stället för\natt gissa. Före varje klick och varje ifyllning väntar Playwright tills\nelementet är redo för åtgärden, och en assertion som `toBeVisible()` försöker\nigen tills villkoret är uppfyllt, så specifikationen klarar sig utan fasta väntetider.\nAnropet `page.route` besvarar webbläsarens förfrågningar till fraktbolaget med\nett fast svar, så att testet aldrig beror på en server som teamet inte själv\ndriver; mönstret måste matcha hela URL:en, och `**` matchar över snedstreck.\nRoutningen når bara de förfrågningar som sidan själv skickar: frågar butikens\nserver fraktbolaget i stället, ser webbläsaren aldrig den förfrågan, och då\nmåste en testdubbel ta över på serverns sida. Varje test får dessutom en ny\nwebbläsarkontext, som Playwright liknar vid en helt ny webbläsarprofil, så\nkakorna och varukorgen från ett test inte kan läcka in i nästa.\n\nKonfigurationen startar applikationen och talar om för Playwright var den finns:\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\nBlocket `webServer` kör `npm run start` och väntar tills URL:en svarar innan\ndet första testet startar; på en bärbar dator återanvänder det en server som\nredan körs, och i CI startar det alltid sin egen. Med `baseURL` kan\nspecifikationen skriva `/shop/teapot` i stället för en fullständig adress.\n`npx playwright test` kör sviten utan fönster, `--headed` visar\nwebbläsarfönstret och `npx playwright show-report` öppnar HTML-rapporten. Som\nstandard körs ett test som fallerar inte om; här tillåter CI två omförsök, ett\ntest som fallerar och sedan går igenom rapporteras som instabilt (flaky) och\ninte som godkänt, och ett spår (trace) spelas in vid första omförsöket för att\nvisa vad som skilde sig.\n\nI större skala är webbläsarlagret den minsta delen av arbetet.\n[Testsviten för Go, SQL och webbläsaren](/sv/portfolio/built-a-test-suite-across-go-sql-and-browser/),\nfrån 2025, har 981 testfunktioner i Go fördelade på 310 filer, 543\ntestspecifikationer i Vitest och Playwright, däribland 48 end-to-end-filer och\n30 webbläsarspecifikationer, och 494 beteendetestfiler i SQL. Målet var att\npröva varje lager där dess beteende finns, inte allt utifrån via en webbläsare,\nså en lagrad funktion testas direkt i databasen och inte genom tre\napplikationslager ovanför. Sidan sticker inte under stol med kostnaden: sviten tar\ntid, varje ändring får betala för den, och vid den storleken kräver den ett eget\nunderhåll.\n\n## Var det går fel\n\n**Sviten är en glasstrut.** Bender kallar det en glasstrut när en svit har många\nend-to-end-tester och få integrations- eller enhetstester; sådana sviter blir\nofta långsamma, opålitliga och svåra att arbeta med, och mönstret dyker gärna\nupp i projekt som har forcerats från prototyp till produktion. Graves tillägger\natt när koden är svår att enhetstesta blir end-to-end-tester de enda som någon\nkan skriva, och då har projektet producerat legacy-kod inom några dagar. Varje\nny tjänst mångdubblar dessutom vägarna genom systemet, så en end-to-end-svit kan\naldrig täcka dem alla. Skjut ned varje fall till det minsta test som kan fånga\ndet, spara webbläsaren till de resor som bara hela systemet kan visa, och bygg\nmot pyramiden från projektets första dagar.\n\n**Selektorerna följer markupen.** En locator som\n`button.buttonIcon.episode-actions-later`, Playwrights eget exempel på vad man\nbör undvika, går sönder nästa gång någon byter namn på en klass, fast användaren\ninte ser någon skillnad. Graves varnar för att UI-tester har rykte om sig att\nvara opålitliga och dyra, delvis för att ändringar i utseendet får dem att\nfallera medan beteendet är detsamma. Hitta element efter roll, etikett eller\ntext, så som en användare hittar dem, eller efter ett test-id som teamet äger.\nDär backend har ett publikt API delar du resan vid gränsen mellan UI och API och\nkör resten av end-to-end-testet genom API:et.\n\n**Testet sover.** En fast väntetid är för kort en långsam dag och för lång alla\nandra dagar. Graves påpekar att tester som förlitar sig på pauser och timeouter\nalla börjar fallera när maskinerna som kör dem är överbelastade, och\nomkörningarna lägger på ytterligare last. Playwrights bästa praxis visar en\nsubtilare variant av samma misstag:\n`expect(await page.getByText(\"welcome\").isVisible()).toBe(true)` kontrollerar en\ngång och går vidare, medan\n`await expect(page.getByText(\"welcome\")).toBeVisible()` väntar på villkoret.\nAnvänd web-first-assertions, och när ett test väntar på backend, fråga efter\ntillståndsändringen gång på gång, med en timeout.\n\n**Testerna delar data.** Ett test skapar ett konto som nästa test räknar med,\neller två parallella arbetare köper den sista tekannan i lager. Sviten går\nigenom i en ordning och fallerar i en annan, eller bara när den körs parallellt.\nPlaywright rekommenderar att varje test hålls helt isolerat, med egen lagring,\nsession, data och egna kakor, och att man kontrollerar datan i alla databaser\nsom testerna använder. Skapa det som varje test behöver, med unika namn, och\nlita aldrig på det som ett tidigare test lämnat efter sig.\n\n**Någon annans server är med i testet.** En riktig betalleverantör, ett\nfraktbolag eller en karttjänst gör sviten beroende av ett system som teamet inte\nkontrollerar, och trafiken dit kan kosta pengar. Graves skriver att det inte\nrekommenderas att automatiska tester använder ett riktigt tredjeparts-API, och\natt ett sådant beroende är en viktig söm där testerna kan delas; Playwrights\neget råd är att bara testa det man kontrollerar. Svara å tredjepartens vägnar\nmed `page.route` när webbläsaren gör anropet, så som specifikationen ovan gör,\neller med en testdubbel som servern är konfigurerad att anropa när servern gör\nanropet själv, och låt det beroendet vara där testet slutar.\n\n**Omförsök döljer instabiliteten.** Att köra om i CI gör ett rött bygge grönt,\noch kostnaden växer. Bender räknar på det: med 10 000 tester om dagen och 0,1 %\nrisk för ett falskt fel i vart och ett får teamet 10 instabila fel om dagen att\nutreda, och när instabiliteten närmar sig 1 % börjar testerna förlora sitt\nvärde. Omkörningar byter maskintid mot ingenjörstid och skjuter bara upp\ngrundorsaken. Dokumentationen för pytest säger samma sak från ett annat håll:\ntester på högre nivå är oftare instabila eftersom de beror på mer tillstånd.\nBehandla varje test som Playwright rapporterar som instabilt som en bugg, öppna\nspåret från omförsöket, och rätta testet eller ta bort det.\n\n## Läs mer\n\n- [Testing Overview](https://abseil.io/resources/swe-book/html/ch11.html)\n  — Adam Benders kapitel i _Software Engineering at Google_: teststorlek och\n  omfattning, pyramiden, glasstruten och vad instabila tester kostar.\n- [Larger Testing](https://abseil.io/resources/swe-book/html/ch14.html)\n  — Joseph Graves om verklighetstrohet, luckorna som enhetstester lämnar,\n  gränserna mot UI och tredje part, och hur man får bukt med instabilitet.\n- [Installation](https://playwright.dev/docs/intro)\n  — Playwrights egen introduktion: installera Playwright Test, köra\n  exempeltestet, köra med synligt fönster och HTML-rapporten.\n- [Best Practices](https://playwright.dev/docs/best-practices)\n  — testa beteende som användaren ser, isolera tester, hålla\n  tredjepartsservrar utanför, locatorer och web-first-assertions.\n- [Retries](https://playwright.dev/docs/test-retries)\n  — hur Playwright kör om fallerande tester och märker vart och ett som\n  passed, flaky eller failed.\n- [Flaky tests](https://docs.pytest.org/en/stable/explanation/flaky.html)\n  — pytests förklaring till varför tester blir instabila, från okontrollerat\n  systemtillstånd och testordning till trådsäkerhet, och vad man gör åt det.\n\n\u003chttps://engineer.company/sv/glossary/end-to-end-test/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Var ett end-to-end-test hör hemma bland enhetstesterna, ett Playwright-exempel med konfiguration och de vanor som gör en testsvit långsam och instabil.","formats":{"gemtext":"https://engineer.company/sv/glossary/end-to-end-test/index.gmi","gopher":"https://engineer.company/sv/glossary/end-to-end-test/gophermap","html":"https://engineer.company/sv/glossary/end-to-end-test/","json":"https://engineer.company/sv/glossary/end-to-end-test/index.json","markdown":"https://engineer.company/sv/glossary/end-to-end-test/index.md","pdf":"https://engineer.company/sv/glossary/end-to-end-test/index.pdf"},"kind":"page","language":"sv","title":"Vad är ett end-to-end-test?","url":"https://engineer.company/sv/glossary/end-to-end-test/","version":1}