Wszystko o TestRun – od konfiguracji po to, co dzieje się pod spodem

01Pierwsze kroki

TestRun nagrywa to, co klikasz na swojej stronie, zamienia to w scenariusz testu i odtwarza go na serwerze w prawdziwej przeglądarce (Playwright + Chromium) – ręcznie, w kolejce albo według harmonogramu.

Szybki start

1. Załóż konto i potwierdź adres e-mail

   Bez potwierdzenia panel się nie otworzy. Niepotwierdzone konta są usuwane po 7 dniach.

2. Utwórz projekt

   Podaj nazwę i pełny adres strony, np. https://uat.twoj-sklep.pl. Powstanie środowisko domyślne i wpis domeny do weryfikacji. Chcesz najpierw tylko spróbować? Wpisz adres sklepu demo https://testrun.pl/demo – nie wymaga weryfikacji.

3. Zweryfikuj domenę

   Ustawienia › Weryfikacja domeny: dodaj meta tag, plik albo rekord TXT i kliknij Sprawdź teraz. Szczegóły.

4. Jeśli strona jest za zaporą – wpuść IP TestRun

   Adres serwera znajdziesz w Ustawienia › Środowiska. Szczegóły.

5. Nagraj test

   Kliknij ● Nagraj test, wybierz W przeglądarce TestRun i przejdź ścieżkę jak użytkownik. Dane (e-mail, PESEL, hasło) wstawiaj przyciskiem Wstaw dane, a na końcu dodaj sprawdzenie przyciskiem Sprawdź. Zakończ przyciskiem Zakończ.

6. Uruchom i ustaw harmonogram

   W scenariuszu kliknij Uruchom. Gdy przechodzi – w zakładce Harmonogram dodaj np. „W dni robocze o 6:00”.

Najważniejsze pojęcia

Mapa panelu

Po wybraniu projektu w menu po lewej masz zakładki:

W stopce menu widać zużycie planu, np. Darmowy: 42/300 przebiegów.

02Konfiguracja projektu

Konfigurację robi się raz na projekt. Wszystko jest w zakładce Ustawienia.

Projekt i plan

Projekt należy do organizacji. Tworząc go, podajesz nazwę i adres strony – adres staje się pierwszym środowiskiem (domyślne). Limity zależą od planu:

Środowiska

Adres strony nie jest zapisany w scenariuszu – pochodzi ze środowiska. Dzięki temu test nagrany na UAT uruchomisz bez zmian na stagingu i produkcji.

• Dodawanie: Ustawienia › Środowiska → nazwa (np. produkcja) + adres → Dodaj środowisko. Domena nowego adresu trafia automatycznie do weryfikacji.
• Domyślne: Ustaw domyślne – używane, gdy nie wybierzesz innego (np. szybkie Uruchom na liście scenariuszy, dane testowe bez wskazanego środowiska).
• Usuwanie: projekt musi mieć co najmniej jedno środowisko.

Weryfikacja domeny

Testy (i nagrywanie w przeglądarce TestRun) działają tylko na domenach, których jesteś właścicielem. To chroni przed użyciem TestRun do automatycznego zakładania kont w cudzych serwisach. Wystarczy jedna z trzech metod:

Token i gotowe do skopiowania wartości są przy domenie w panelu. Po wdrożeniu kliknij Sprawdź teraz – przy niepowodzeniu panel pokaże, co sprawdził i dlaczego się nie udało.

Dostęp z IP serwera TestRun

Przebiegi i przeglądarka nagrywania łączą się z Twoją stroną z adresu IP serwera TestRun – znajdziesz go w Ustawienia › Środowiska (przycisk Kopiuj IP). Jeśli środowisko jest chronione (zapora, lista dozwolonych IP, panel hostingu, Cloudflare lub inna ochrona przed botami), dodaj ten adres do dozwolonych, a potem zaznacz to przy środowisku.

Zaznaczenie to punkt listy kontrolnej – niczego nie blokuje, ale bez niego okno nagrywania ostrzega, że strona może nie wpuścić TestRun. Zmiana adresu środowiska kasuje potwierdzenie (nowy adres to zwykle inny serwer).

Sekrety

Hasła do kont testowych, klucze bramek płatności, tokeny API. Dodajesz je w Ustawienia › Sekrety: nazwa WIELKIE_LITERY_I_CYFRY, wartość i zakres – wszystkie środowiska albo jedno konkretne.

W scenariuszu sekret to zmienna typu secret:

"haslo": { "type": "secret", "name": "ADMIN_PASSWORD" }

• Wartość per środowisko wygrywa z wartością dla wszystkich środowisk – np. inne hasło na produkcji.
• Brak sekretu = przebieg kończy się błędem „Brak sekretu ADMIN_PASSWORD”. Wyjątek: "required": false (w edytorze: odznacz wymagany) – wtedy w każdym przebiegu powstaje nowe, losowe hasło. Idealne przy rejestracji.
• Panel nigdy nie pokazuje wartości – można ją tylko nadpisać lub usunąć.

Atrybut identyfikatorów testowych

Jeśli Twoja aplikacja ma atrybuty typu data-testid="register-submit", nagrywanie użyje ich jako najstabilniejszego sposobu wskazania elementu. Domyślnie data-testid; inną nazwę (np. data-qa, data-cy) ustawisz w Ustawienia › Projekt.

Powiadomienia e-mail

Gdy przebieg kończy się statusem failed, error albo timeout, TestRun wysyła maila z nazwą testu, środowiskiem, krokiem, komunikatem błędu i linkiem do wyników.

• Dostają go członkowie organizacji z prawem edycji (nie viewer).
• Nie dostaje go osoba, która sama uruchomiła przebieg z panelu – i tak patrzy na wynik. Przebiegi z harmonogramu i kolejek powiadamiają wszystkich.
• Każdy wyłącza je dla siebie: Ustawienia › Powiadomienia e-mail albo linkiem w stopce maila.
• Jeden mail na przebieg – ponowienie go nie zdubluje.

Role i uprawnienia

Usunięcie projektu wymaga wpisania jego nazwy. Projekt jest archiwizowany, a jego harmonogramy – wyłączane.

03Nagrywanie testów

Nagrywasz, klikając po stronie. TestRun zapisuje zdarzenia (kliknięcia, wpisy, przejścia), a po zakończeniu zamienia je w czytelne kroki scenariusza.

Dwa tryby nagrywania

Kliknij ● Nagraj test, wybierz środowisko (gdy jest ich kilka) i tryb:

Przeglądarka TestRun i pasek nagrywania

Po Rozpocznij otwiera się nowa karta z obrazem strony na całe okno. Klikasz i piszesz normalnie – mysz i klawiatura trafiają do przeglądarki na serwerze. Nad stroną jest pasek:

Natywne okna alert, confirm i prompt pokazują się nad podglądem – Twoja odpowiedź zostanie nagrana. Pole z nazwą testu możesz uzupełnić w trakcie nagrywania.

Wstaw dane

Najpierw kliknij pole formularza na stronie, potem otwórz Wstaw dane ▾. Menu ma trzy części:

• Wygeneruj nowe – E-mail (nowa skrzynka testowa), Imię, Nazwisko, PESEL, NIP, REGON, Nr konta (NRB), Nr dowodu, Telefon, Kod pocztowy, Miasto, Ulica, Nazwa firmy, Hasło. Obok e-maila możesz wpisać własny adres skrzynki – wtedy w każdym przebiegu będzie ten sam.
• Użyte w tym nagraniu – ponowne wpisanie wartości, która już padła (np. hasło w polu „Powtórz hasło”).
• Zapisane dane – wartości z danych testowych, np. e-mail z wcześniejszej rejestracji – do testu logowania.

Wartości wstawione paskiem są oznaczane do zapisu (save: true): trafiają do danych testowych od razu po zakończeniu nagrania i po każdym udanym przebiegu.

Poczta w nagraniu

1. Wstaw adres skrzynki

   W polu e-mail formularza: Wstaw dane → E-mail.

2. Wyślij formularz

   Np. rejestracji albo „Nie pamiętam hasła”.

3. Otwórz Poczta

   Po kilku sekundach pojawi się mail (licznik przy przycisku). Kliknij Otwórz: <link>.

W scenariuszu powstaną dwa kroki: Czekaj na e-mail (z filtrem tematu i wyciągnięciem linku) i Otwórz link z e-maila. W przebiegu TestRun poczeka na świeży mail w nowej skrzynce i otworzy aktualny link – nie ten z nagrania. Kod z maila (np. 2FA) dodasz ręcznie w edytorze – patrz czekanie na maila.

Sprawdzenia i zrzuty

Test bez sprawdzeń mówi tylko, że dało się kliknąć. Dodaj na końcu (i w ważnych miejscach) asercję:

• Sprawdź → Element na stronie… → kliknij element → Jest widoczny albo Zawiera tekst (podpowiada obecny tekst – skróć go do stałej części).
• Adres strony – czy adres zawiera obecną ścieżkę (np. /panel).
• Tytuł strony – czy tytuł karty jest taki jak teraz.

📷 dodaje krok zrzutu: Widoczny ekran albo Cała strona, z opcjonalnym opisem „co sprawdzić”. Zrzut trafi do wyników każdego przebiegu, także zaliczonego – do oceny wizualnej przez człowieka.

Następny test – kilka testów w jednej sesji

Następny test zapisuje bieżący test jako scenariusz i od razu nagrywa kolejny – w tej samej przeglądarce: zalogowanie, ciasteczka i skrzynki zostają. Za pierwszym razem powstaje kolejka testów, a każdy kolejny test trafia na jej koniec. Wartości wygenerowane we wcześniejszych testach kolejne odczytują jako zapisane dane. Tak nagrasz np. 1. Rejestracja → 2. Logowanie → 3. Zakup, gotowe do uruchamiania jako całość.

Snippet – nagrywanie we własnej przeglądarce

Dla stron niedostępnych z internetu. Wklej kod z Ustawienia › Snippet w części wspólnej wszystkich podstron (np. przed </head>):

<script src="https://testrun.pl/r.js" data-key="pk_…" async></script>

Dla zwykłych odwiedzających skrypt nic nie robi. Aktywuje się dopiero, gdy tester otworzy link nagrywania z panelu.

1. Wybierz „We własnej przeglądarce” i Rozpocznij

   Panel pokaże link do nagrywania (ważny 2 godziny) i listę otwartych kart, w których już nagrywano.

2. Otwórz link

   Także w innej przeglądarce lub na telefonie. Albo przy znanej karcie kliknij Nagrywaj tę kartę.

3. Potwierdź kod

   Sprawdź, czy strona pokazuje ten sam kod co panel, i kliknij Akceptuj i nagrywaj.

4. Nagrywaj

   Na stronie pojawi się pływający pasek (w Shadow DOM, nie koliduje ze stylami strony) z tymi samymi narzędziami co w przeglądarce TestRun (wstawianie danych, poczta, sprawdzenia). Przejście na kolejne podstrony nie przerywa nagrania.

Jak nagranie staje się testem

Surowe zdarzenia są „sprzątane” w kroki, które da się czytać i edytować:

Jeśli scenariusz wymaga uzupełnienia (np. sekretu dla hasła wpisanego ręcznie), notatka wersji 1 zawiera „Do uzupełnienia: …”, a edytor pokaże ostrzeżenie o brakujących sekretach.

Dobre praktyki nagrywania

• Jeden test = jedna ścieżka (rejestracja, logowanie, zakup). Łącz je w kolejki, a nie w jeden długi test.
• Zawsze wstawiaj dane paskiem, nie wpisuj na sztywno – inaczej drugi przebieg trafi na „konto już istnieje”.
• Kończ asercją – „widać Witaj, …”, „adres zawiera /zamowienie/dziekujemy”.
• Zamykaj banery cookies kliknięciem, a potem w edytorze oznacz ten krok jako optional – gdy baner się nie pojawi, test pójdzie dalej.
• Nie czekaj „na oko” – kroki i asercje same czekają na elementy. Krok wait z czasem to ostateczność.

04Scenariusze i ręczna edycja

Każdy scenariusz – nagrany albo pusty – możesz zmienić w panelu: krok po kroku albo jako dokument JSON.

Edytor scenariusza

• Nazwa – edytowalna na górze strony.
• Kroki – przeciągaj za uchwyt z numerem, by zmienić kolejność (działa też klawiaturą). Ołówek otwiera krok jako JSON, kosz go usuwa.
• + Dodaj krok… – wstawia gotowy szablon: Otwórz stronę, Kliknij, Wpisz, Naciśnij klawisz, Wybierz z listy, Zaznacz, Czekaj na e-mail, Sprawdź, Czekaj na adres, Czekaj, Zrób zrzut ekranu, Podmień odpowiedź usługi, Wyślij żądanie HTTP, Czekaj na webhook, Oblicz skrót / podpis. Szablon od razu otwiera się do edycji.
• Symulacja bramki płatności… – kreator kroków płatności (opis).
• Zmienne – lista z opisem; przy sekretach przełącznik wymagany, przy generatorach i skrzynkach zapisuj w danych testowych. Edytuj otwiera wszystkie zmienne jako JSON.
• Edytuj jako JSON – cały scenariusz naraz: najszybszy sposób na hurtowe zmiany, kopiowanie kroków między scenariuszami czy dodanie include.
• Zapisz / Zapisz i uruchom – zapis tworzy nową wersję. Przy kilku środowiskach obok wybierasz, gdzie uruchomić.

Struktura scenariusza

{
  "schemaVersion": 1,
  "name": "Rejestracja i logowanie",
  "description": "Nowe konto z potwierdzeniem mailowym",
  "settings": {
    "viewport": { "width": 1366, "height": 768 },
    "locale": "pl-PL",
    "timezone": "Europe/Warsaw",
    "defaultTimeoutMs": 10000,
    "screenshots": "onFailure"
  },
  "variables": { … },
  "steps": [ … ]
}

Scenariusz może mieć do 500 kroków. Identyfikatory kroków (id) muszą być unikalne i nie zmieniają się przy zmianie kolejności.

Zmienne

W krokach używasz ich przez {{nazwa}}. Nazwa: litery, cyfry i _, nie zaczyna się od cyfry; run i env są zarezerwowane. Wartości są tworzone na nowo przy każdym przebiegu.

mailbox i generate z "save": true zapisują wartość w danych testowych po udanym przebiegu. Zmienne powstają też w trakcie testu – przez saveAs w krokach (extract, waitForEmail, mock, request, hash, waitForWebhook) i krok setVariable.

Wbudowane zmienne i składnia

Generatory danych

Polskie identyfikatory mają poprawne sumy kontrolne, więc walidacja formularza ich nie odrzuci.

"pesel": { "type": "generate", "generator": "pesel", "options": { "gender": "female", "minAge": 18 } },
"urodziny": { "type": "generate", "generator": "date", "options": { "from": "1960-01-01", "to": "2000-12-31", "format": "DD.MM.YYYY" } }

Lokatory i self-healing

Krok działający na elemencie ma pole target z kilkoma strategiami wskazania, od najbardziej do najmniej stabilnej. Nagrywanie zapisuje je wszystkie.

"target": {
  "strategies": [
    { "type": "testId", "value": "register-submit" },
    { "type": "role", "role": "button", "name": "Załóż konto" },
    { "type": "text", "value": "Załóż konto", "exact": true },
    { "type": "css", "value": "form#register button[type=submit]" }
  ],
  "frame": null,
  "nth": null
}

• frame – selektor CSS ramki iframe, gdy element jest w niej (działa też dla ramek z innej domeny).
• nth – numer elementu (od 0), gdy strategia celowo wskazuje kilka.

Kroki – pełna lista

Wspólne pola każdego kroku:

Nawigacja

Interakcje

Oczekiwanie, dane, zrzuty

{ "id": "s17", "action": "extract", "target": { "strategies": [{ "type": "css", "value": ".order-number" }] },
  "property": "text", "regex": "Nr zamówienia: (\\d+)", "saveAs": "nrZamowienia" }

Kroki e-mail, webhooków i mocków są opisane w osobnych rozdziałach: waitForEmail, waitForWebhook, request, hash, mock.

Asercje

Operatory op: equals, notEquals, contains, notContains, matches (regex), gt, gte, lt, lte.

{ "id": "a1", "action": "assert", "check": "text", "target": { … }, "op": "contains", "expected": "Witaj, {{imie}}" }
{ "id": "a2", "action": "assert", "check": "count", "target": { … }, "op": "gte", "expected": 1 }
{ "id": "a3", "action": "assert", "check": "variable", "variable": "mail.attachmentNames", "op": "contains", "expected": "faktura" }

Wspólne fragmenty (include)

Krok include wstawia inny scenariusz projektu – np. wspólne „Logowanie” używane w dziesięciu testach. Zmienne przekazujesz w inputs; zmienne scenariusza wstawianego, których nie przekażesz, tworzą się normalnie.

{ "id": "s2", "action": "include", "scenarioId": "8f0c…", "inputs": { "login": "{{email}}", "haslo": "{{haslo}}" } }

Identyfikator scenariusza znajdziesz w adresie jego strony (/s/<id>). Maksymalne zagnieżdżenie: 3 poziomy. Kroki wstawionego scenariusza widać w wynikach przebiegu.

Wersje

Każdy zapis tworzy nową, niezmienną wersję. Przebieg zapamiętuje dokładnie tę wersję, którą wykonał – nawet po zmianach wiesz, co było testowane. W Historii wersji kliknij Pokaż, a potem Przywróć tę wersję (przywrócenie też jest nowym zapisem).

05Uruchamianie i wyniki

Uruchamianie

• Ręcznie: Uruchom na liście scenariuszy (środowisko domyślne) albo w scenariuszu (z wyborem środowiska). Panel przejdzie od razu do wyników.
• Kolejka: Uruchom przy kolejce – rozdział 06.
• Harmonogram: automatycznie albo Teraz – rozdział 07.
• Ponownie: Uruchom ponownie na stronie przebiegu.

Przebieg, który jeszcze czeka w kolejce, można anulować.

Statusy

Statusy kroków: passed, failed, warning (nieudany krok opcjonalny), skipped (pominięty po wcześniejszym błędzie).

Wyniki przebiegu

• Kroki – status, czas, liczba prób, komunikat błędu i szczegóły (np. oczekiwany i faktyczny tekst, kod HTTP, odebrany mail).
• Zrzuty ekranu – przy nieudanym kroku (domyślnie) i z kroków screenshot; Pełny rozmiar otwiera oryginał.
• Pliki z przebiegu – pliki pobrane na stronie (np. faktura PDF) przy kroku, który je pobrał, załączniki maili i zrzuty do oceny wizualnej. PDF, obrazy i tekst mają podgląd; reszta jest do zapisu.
• Dane użyte w przebiegu – wartości zmiennych (adresy e-mail, PESEL-e…), z sekretami zamaskowanymi. Pozwala odtworzyć błąd ręcznie.
• Nagranie przebiegu (trace) – przy nieudanym przebiegu.

Trace Playwrighta

Trace to pełny zapis przebiegu: każdy krok z wyglądem strony przed i po, drzewo DOM, żądania sieciowe i konsola. Pobierz trace.zip ze strony przebiegu i przeciągnij go na trace.playwright.dev – plik jest otwierany lokalnie w Twojej przeglądarce, nigdzie nie jest wysyłany.

Trace jest zapisywany tylko przy przebiegach, które nie przeszły – zaliczone go nie potrzebują.

Jak wykonywany jest przebieg

06Kolejki testów

Kolejka uruchamia scenariusze po kolei, a każdy kolejny korzysta z danych (i opcjonalnie sesji przeglądarki) poprzednich. Typowo: 1. Rejestracja → 2. Logowanie → 3. Zakup.

Tworzenie kolejki

1. Kolejki testów → + Nowa kolejka

   Albo nagraj kilka testów przyciskiem Następny test – kolejka powstanie sama.

2. Dodaj scenariusze w kolejności wykonywania

   Strzałkami zmieniasz kolejność. Ten sam scenariusz może wystąpić kilka razy (np. logowanie przed i po zmianie hasła).

3. Ustaw opcje i zapisz

   Patrz niżej. Potem Uruchom i wybierz środowisko.

Wspólna sesja i zatrzymanie po błędzie

Przepływ danych

Strona kolejki pokazuje, co każdy scenariusz zapisuje (→ email) i czego potrzebuje – oraz skąd to dostanie: od wcześniejszego scenariusza w kolejce, z danych testowych projektu, albo znikąd (ostrzeżenie – przebieg skończy się błędem).

Po uruchomieniu strona przebiegu kolejki pokazuje postęp, wynik każdego scenariusza i sekcję Dane przekazane dalej.

Pod spodem

07Harmonogramy

Harmonogram działa na serwerze TestRun – nie potrzebujesz CI ani nikogo, kto pamięta, żeby kliknąć „uruchom”.

Nowy harmonogram

Harmonogram › + Dodaj:

• Co uruchamiać – jeden lub więcej scenariuszy i kolejek (do 30 pozycji), w ustalonej kolejności: + Dodaj kolejny test lub kolejkę, strzałki ↑↓, ✕.
• Środowisko – na którym uruchamiać.
• Jak często – Co godzinę, Codziennie o…, W dni robocze o…, Co tydzień (poniedziałek) o…, albo Własne wyrażenie cron.
• Nazwa – opcjonalna; bez niej powstanie z pozycji i częstotliwości.

Na liście: termin następnego uruchomienia, ostatni wynik, Teraz (uruchamia od razu, nie zmieniając następnego terminu), włączanie/wyłączanie, edycja i usuwanie.

Wyrażenia cron

Pięć pól: minuta godzina dzień-miesiąca miesiąc dzień-tygodnia, czas polski (Europe/Warsaw, ze zmianą czasu letniego).

Seria a kolejka

Harmonogram z kilkoma pozycjami uruchamia je jako serię. To co innego niż kolejka:

Kolejka może być pozycją serii – wewnątrz działa według własnych ustawień. Pozycje serii nie startują równocześnie, więc nie obciążą testowanego środowiska.

Pod spodem

08Dane testowe

Mechanizm przekazywania wartości między scenariuszami: rejestracja zapisuje e-mail i hasło, a logowanie używa zawsze konta z ostatniej udanej rejestracji.

Zapis i odczyt

• Zapis automatyczny: zmienne mailbox i generate z "save": true – po każdym udanym przebiegu i od razu po zakończeniu nagrania. Nagrywanie ustawia to samo dla wartości z „Wstaw dane”.
• Zapis ręczny: zakładka Dane testowe – dodaj, edytuj, usuń (np. login konta testowego założonego ręcznie).
• Odczyt: zmienna {"type":"stored","key":"email"}, a w nagraniu Wstaw dane → Zapisane dane.
• Osobno dla każdego środowiska – konto z UAT nie trafi do testu produkcji.
• Kolumna Źródło pokazuje, który scenariusz (lub nagranie, lub wpis ręczny) zapisał wartość ostatnio.

Przykład: rejestracja → logowanie

"variables": {
  "email": { "type": "mailbox", "save": true },
  "haslo": { "type": "generate", "generator": "password", "save": true }
}

"variables": {
  "email": { "type": "stored", "key": "email" },
  "haslo": { "type": "stored", "key": "haslo" }
}

Uruchamiane osobno – logowanie użyje ostatniego zapisanego konta. W kolejce – konta z rejestracji z tego samego uruchomienia.

09Skrzynki e-mail

Prawdziwe skrzynki w domenie inbox.testrun.pl – Twoja aplikacja wysyła maile normalnie, a TestRun je odbiera, otwiera linki, przepisuje kody i sprawdza załączniki.

Adresy i ważność

• Zmienna {"type":"mailbox"} lub „Wstaw dane → E-mail” daje w każdym przebiegu nowy adres w postaci <nazwa-zmiennej>-<8 znaków>@inbox.testrun.pl, np. email-3fa91c2d@inbox.testrun.pl.
• Zwykła skrzynka działa 7 dni, potem jest usuwana razem z mailami i załącznikami. Skrzynki zapisane w danych testowych i z własnym adresem nie wygasają.
• Zakładka Skrzynki e-mail pokazuje wszystkie skrzynki projektu (📌 = zapisana w danych testowych), skąd pochodzą (przebieg, scenariusz) i odebrane maile. Skrzynce możesz nadać własną nazwę.

Własny adres

Gdy potrzebujesz stałego adresu – np. konto testowe zapisane do newslettera albo adres wpisany na sztywno w konfiguracji systemu:

• Skrzynki e-mail › + Nowa skrzynka → Własny adres (albo Losowy adres), opcjonalna nazwa.
• albo w nagraniu: „Wstaw dane → E-mail” i wpisz adres,
• albo w scenariuszu: {"type":"mailbox","address":"subskrypcje"}.

Zasady: 1–40 znaków, małe litery, cyfry, kropka, myślnik i podkreślenie, bez polskich znaków. Zarezerwowane są adresy techniczne (postmaster, admin, noreply…) i wzór adresów losowych. Adres zajęty przez inny projekt jest niedostępny.

Czekanie na maila (waitForEmail)

{
  "id": "s8", "action": "waitForEmail",
  "mailbox": "{{email}}",
  "filter": { "subjectContains": "Potwierdź", "from": "no-reply@sklep.pl" },
  "since": "run",
  "timeoutMs": 60000,
  "saveAs": "mail",
  "extract": [
    { "kind": "link", "contains": "/aktywuj/", "saveAs": "linkAktywacyjny" },
    { "kind": "code", "saveAs": "kod" },
    { "kind": "regex", "pattern": "Nr klienta: (\\d+)", "saveAs": "nrKlienta" }
  ]
}

Typowe zakończenie: { "action": "navigate", "url": "{{linkAktywacyjny}}" } albo { "action": "fill", "target": …, "value": "{{kod}}" }.

Załączniki

Do 20 załączników na mail, każdy do 50 MB. Do asercji użyj {{mail.attachmentNames}} (nazwy po przecinku):

{ "id": "a4", "action": "assert", "check": "variable", "variable": "mail.attachmentNames", "op": "contains", "expected": "faktura" }

Same pliki obejrzysz w wynikach przebiegu i w zakładce skrzynek (podgląd PDF, obrazów, tekstu).

10Webhooki

Dwa kierunki: Twoja aplikacja wysyła webhook (TestRun go odbiera i sprawdza) albo inny system wysyła webhook do Twojej aplikacji (TestRun go wysyła zamiast niego).

Odbieranie webhooków

Każdy projekt ma adres w zakładce Webhooki i mocki:

https://testrun.pl/hook/<token>/<dowolna-ścieżka>

1. Wpisz adres w testowanej aplikacji

   Np. jako adres powiadomień o zamówieniach: https://testrun.pl/hook/<token>/zamowienia. Ścieżkę po tokenie wybierasz dowolnie.

2. Sprawdź, czy dochodzi

   Wyślij testowe żądanie – pojawi się w Odebrane żądania (lista odświeża się sama, każde można rozwinąć):

3. Dodaj krok waitForWebhook

   Po akcji, która wyzwala webhook.

curl -X POST -H 'Content-Type: application/json' -d '{"test":1}' https://testrun.pl/hook/<token>/test

{ "id": "w1", "action": "waitForWebhook", "path": "/zamowienia", "method": "POST",
  "bodyContains": "{{email}}", "since": "run", "saveAs": "hook" },
{ "id": "w2", "action": "assert", "check": "variable", "variable": "hook.json.status", "op": "equals", "expected": "paid" }

Osobny adres na każdy przebieg

Gdy testowana aplikacja pozwala wpisać adres webhooka w formularzu (np. integracja w panelu klienta), użyj zmiennej {"type":"webhook"}. Każdy przebieg dostanie unikalny adres …/hook/<token>/r/<nazwa>-<losowe> – wpisz go krokiem fill i czekaj na niego: "path": "{{hook}}".

Wysyłanie żądań (request)

Symuluje system zewnętrzny wysyłający żądanie do Twojej aplikacji – np. bramkę płatności potwierdzającą zapłatę albo integrację z CRM.

{
  "id": "r1", "action": "request", "method": "POST",
  "url": "/api/platnosci/powiadomienie",
  "headers": { "X-Source": "testrun" },
  "body": "{\"orderId\":\"{{nrZamowienia}}\",\"status\":\"PAID\"}",
  "sign": { "secret": "{{kluczBramki}}", "header": "X-Signature", "algorithm": "sha256", "prefix": "sha256=" },
  "expectStatus": 200,
  "saveAs": "odp"
}

• Adres: ścieżka względna = adres środowiska. Pełny adres musi należeć do zweryfikowanej domeny projektu.
• Content-Type jest ustawiany sam: application/json, gdy treść zaczyna się od { lub [, w przeciwnym razie application/x-www-form-urlencoded. Własny nagłówek go nadpisuje.
• sign – podpis HMAC treści (sha1/sha256/sha384/sha512, hex lub base64, opcjonalny prefix) w podanym nagłówku.
• Wynik: bez expectStatus krok nie przechodzi przy kodzie ≥ 400. {{odp.status}}, {{odp.headers.…}}, {{odp.body}}, {{odp.json.…}}.

Podpisy i skróty (hash)

Gdy podpis ma być w treści (np. pole sign w Przelewy24), a nie w nagłówku, wylicz go wcześniej krokiem hash:

{ "id": "h1", "action": "hash", "algorithm": "sha256",
  "input": "{{nrZamowienia}}|{{kwota}}", "key": "{{kluczBramki}}", "encoding": "hex", "saveAs": "podpis" }

Algorytmy: md5, sha1, sha256, sha384, sha512. Z key – HMAC, bez – zwykły skrót. Potem użyj {{podpis}} w treści kroku request.

11Mocki

Gdy strona w przeglądarce pyta zewnętrzne API (kurier, GUS, płatności, mapy), TestRun może odpowiedzieć zamiast niego. Test przestaje zależeć od cudzej usługi, a Ty możesz sprawdzić scenariusze trudne do wywołania, np. awarię.

Podmiana odpowiedzi

{ "id": "m1", "action": "mock", "url": "api.kurier.pl/wycena", "method": "POST",
  "status": 200, "body": "{\"cena\": 14.99, \"termin\": \"jutro\"}", "saveAs": "wycena" }

Mock działa od swojego kroku do końca przebiegu – umieść go przed akcją, która wywołuje usługę. Typowy wzorzec: mock na początku, akcja, potem asercja, że strona została wywołana poprawnie:

{ "id": "a5", "action": "assert", "check": "variable", "variable": "wycena.json.waga", "op": "equals", "expected": "2.5" }

Dopasowanie adresu

CORS, przekierowania, awarie

12Płatności

Dwie drogi testowania zakupów bez prawdziwych pieniędzy. Wybierz pierwszą, gdy bramka ma sandbox dostępny z internetu; drugą – gdy nie ma albo chcesz testu niezależnego od bramki.

Droga 1: przez sandbox bramki

Środowisko testowe sklepu łączy się z sandboksem bramki (BLIK, Przelewy24, PayU, Tpay…). Nagraj zakup w przeglądarce TestRun – kroki na stronie bramki (np. wybór „płatność pozytywna”) też się nagrają. W przebiegu runner przejdzie przez prawdziwy sandbox, a bramka sama wyśle powiadomienie do sklepu. Nic nie trzeba symulować.

Droga 2: symulacja bramki

W edytorze scenariusza: Symulacja bramki płatności… (podpowiadane też automatycznie, gdy nagranie snippetem „przeskoczyło” stronę bramki). Gotowe ustawienia: DemoPay (sklep demo TestRun), Przelewy24, PayU, Tpay i własna bramka.

1. Adres bramki (fragment)

   Przejście pod adres zawierający ten tekst zostanie przechwycone mockiem. Dane, które sklep przekazał bramce, będą w {{bramka.url}}, {{bramka.query.…}}, {{bramka.json.…}}.

2. Adres powiadomień w sklepie

   Endpoint, na który bramka wysyła potwierdzenie – ścieżka względna lub pełny adres w zweryfikowanej domenie.

3. Strona powrotu

   Gdzie bramka odsyła klienta po płatności.

4. Klucz do podpisu

   Nazwa sekretu w projekcie (np. P24_CRC) – ustaw go w Sekretach.

5. Wstaw do scenariusza

   Kreator doda kroki: mock (na początku), hash (podpis), request (powiadomienie) i navigate (powrót). Dla niektórych bramek poprosi o uzupełnienie zmiennych, np. ID sprzedawcy, kwoty, sessionId.

{ "action": "mock", "url": "przelewy24.pl", "saveAs": "bramka" },
// … kroki sklepu aż do „Zapłać” …
{ "action": "hash", "algorithm": "sha384", "input": "{…,\"crc\":\"{{kluczBramki}}\"}", "saveAs": "podpis" },
{ "action": "request", "method": "POST", "url": "/platnosci/przelewy24/status", "body": "{…,\"sign\":\"{{podpis}}\"}" },
{ "action": "navigate", "url": "/zamowienie/dziekujemy" }

13Zasady działania

Architektura

Scenariusz to kontrakt między trzema częściami: nagrywanie go tworzy, panel pozwala go edytować, a runner wykonuje 1:1. Dlatego wszystko, co nagrasz, możesz też poprawić ręcznie – i odwrotnie.

Bezpieczeństwo

• Weryfikacja domen – testy, nagrywanie w przeglądarce TestRun i kroki request działają tylko na domenach, których własność potwierdziłeś.
• Ochrona sieci wewnętrznej (SSRF) – przeglądarka przebiegu i nagrywania nie połączy się z adresami prywatnymi (10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16, 127.0.0.0/8, 169.254.0.0/16, 100.64.0.0/10, prywatne IPv6, localhost, *.internal) – także gdy publiczna nazwa domeny wskazuje na taki adres.
• Sekrety – AES-256-GCM, maskowane w wynikach, nigdy nie wracają do przeglądarki.
• Izolacja przebiegów – każdy przebieg ma osobny kontekst przeglądarki; ciasteczka jednego testu nie trafią do drugiego (poza świadomie włączoną wspólną sesją kolejki).
• Pliki z testowanych stron – podgląd w panelu tylko dla PDF, obrazów i tekstu, w piaskownicy bez skryptów; HTML, SVG i inne typy zawsze idą do zapisu na dysk.
• Konto – hasła haszowane scrypt, ochrona przed CSRF (zmiany stanu tylko z domeny panelu, ciasteczko sesji SameSite).

Przechowywanie danych

Sprzątanie uruchamia się automatycznie co godzinę. Serwery i dane znajdują się w Unii Europejskiej.

Limity techniczne

Strony na localhost

Środowisko z adresem localhost / 127.0.0.1 działa tylko na komputerze testera – serwer TestRun go nie otworzy. Możesz takie środowisko dodać i nagrywać snippetem we własnej przeglądarce (bez weryfikacji domeny), ale przebiegi i harmonogramy wymagają środowiska dostępnego z internetu – np. UAT lub stagingu. Najprościej: nagraj na localhost, a uruchamiaj na stagingu (adres pochodzi ze środowiska, więc scenariusz się nie zmienia).

14Gdy coś nie działa

Najczęstsze komunikaty i co z nimi zrobić.