Gatling. Nagrywanie skryptów. Część 3.

Skrypty symulacyjne, które wykorzystuje Gatling są pisane w języku Scala z użyciem składni DSL. Z językiem tym można zapoznać się tutaj: http://www.scala-lang.org/. Jego znajomość nie jest jednak konieczna, przynajmniej na początku, gdyż Gatling umożliwia nagranie kroków jakie wykonuje użytkownik w przeglądarce w testowanej aplikacji.

Jak już zostało wspomniane w poprzednim artykule do nagrywania skryptów dla narzędzia Gatling służy aplikacja Recorder, która jest dostarczana w pakiecie razem z naszym narzędziem. Aby uruchomić aplikację Recorder należy przejść do katalogu %GATLING_HOME%in (gdzie zmienna %GATLING_HOME% wskazuje na katalog domowy z narzędziem Gatling). Jeśli pracujemy na systemie Windows to uruchamiamy plik ‘recorder.bat’, osoby pracujące na systemach linuxowych lub MacOS uruchamiają plik ‘recorder.sh’. Uruchamianie zostało omówione w poprzednim artykule.

Recorder – konfiguracja

Po uruchomieniu pliku ‘recorder.bat’ (lub ‘recorder.sh’ na systemach z rodziny Linux) zaprezentuje się okno ‘Gatling Recorder – Configuration’, które umożliwia konfigurację narzędzia.

Zrzut ekranu 01. Gatling Recorder – Configuration.

Domyślne opcje z jakimi uruchamia się Recorder można zmienić edytując plik ‘recorder.conf’ z katalogu %GATLING_HOME%conf.

Recorder – konfiguracja – Recorder mode

Z pomocą Recordera można szybko wygenerować skrypt scenariusza poprzez podłączenie się jako pośrednik (http proxy) pomiędzy przeglądarką a serwerem http lub przez wczytanie i konwersje zapisanej sesji z przeglądarki w postaci pliku HAR (Http Archive file).

Wybór jednego z trybów nagrywania dokonuje się w sekcji ‘Recorder mode’, gdzie dostępne są odpowiednio opcje ‘HTTP Proxy’ oraz ‘HAR Converter’.

Domyślnie jest wybrany tryb ‘HTTP Proxy’, w którym na oknie konfiguracji prezentowana jest sekcja ‘Network’ z ustawionym portem nasłuchiwania ‘8000’. Numer portu można zmienić zależnie od własnych potrzeb, ale trzeba pamiętać, aby w ustawieniach przeglądarki w konfiguracji serwera proxy użyć tego samego portu.

Pola z wiersza ‘Outgoing proxy’ czyli ‘host’, ‘HTTP’, ‘HTTPS’, ‘username’ i ‘password’ należy uzupełnić, jeśli dostęp do aplikacji internetowej jest możliwy tylko za pomocą serwera proxy.

Opcja ‘HTTPS Mode’ służy do informowania przeglądarki o stanie połączenia w przypadku przekierowywania połączenia przez omawiane narzędzie, gdyż takie połączenie powoduje odszyfrowanie ruchu HTTPS pomiędzy przeglądarką a serwerem aplikacji. W HTTPS Mode dostępne są trzy opcje:

‘Self-signed certificate’ (opcja domyślna) – w której Recorder używa tego samego certyfikatu do wszystkich domen i który powoduje wystąpienie alertu zabezpieczeń dla testowanej domeny. Aby umożliwić nagrywanie konieczne jest zaakceptowanie wyjątków bezpieczeństwa dla odwiedzanych domen.

Zrzut ekranu 02. Gatling Recorder – Configuration – HTTPS mode – Self-signed certificate.

‘Provided KeyStore’ – opcja w której można przekazać pełny pakiet kluczy Java (format JKS lub PKCS#12) zawierający certyfikat, który ma być używany wraz z hasłem. Ten tryb jest użyteczny, jeśli już utworzono własne klucze oraz certyfikaty dla swojej aplikacji i chcesz je użyć do nagrywania.

Zrzut ekranu 03. Gatling Recorder – Configuration – HTTPS mode – Provided Keystore.

‘On-the-fly certificate generation’ – opcja pozwala na wygenerowanie certyfikatu w formacie PEM lub też umożliwia dostarczenie certyfikatu i klucza prywatnego z dysku.

Zrzut ekranu 04. Gatling Recorder – Configuration – HTTPS mode – Certificate Authority.

W przypadku wybrania trybu ‘HAR Converter’ zamiast sekcji Network pojawi się sekcja ‘Http Archive (HAR) import’ z polem ‘HAR File’, w którym wybiera się zapisany wcześniej w przeglądarce plik HAR.

Zrzut ekranu 05. Gatling Recorder – Configuration – HAR Converter.

Recorder – konfiguracja – Simulation information

W sekcji ‘Simulation information’ Recordera znajdują się opcje:

• ‘Follow Redirects?’ – opcja domyślnie zaznaczona powoduje automatyczne śledzenie przekierowań w przypadku statusów odpowiedzi 301, 302, 303 lub 307. Opcja ta musi być włączona jeżeli testujemy aplikacje internetowe z dynamicznie generowaną zawartością.
• ‘Infer html resources?’ – włączenie tej opcji powoduje, że Recorder pobiera wbudowane zasoby HTML dodając wpis ‘inferHtmlResources’ z odpowiednimi parametrami w definicji protokołu HTTP w skrypcie, parsuje odpowiedź HTML, aby pobrać wbudowane zasoby, a następnie przefiltrować je wg scenariusza.
• ‘Remove cache headers’ – określa czy cache ma być dostępny dla wszystkich aktorów.
• ‘Automatic Referers’ – opcja powoduje, że wartość w polu Referer w nagłówku zapytania HTTP jest obliczana automatycznie. Opcja jest domyślnie włączona. Po wyłączeniu tej opcji w nagranym skrypcie w definicji protokołu HTTP pojawi się opcja “.disableAutoReferer“.
• ‘Save & check response bodies?’ – włączenie opcji powoduje, że całe ciało (body) odpowiedzi na zapytanie jest zapisywane w pliku tekstowym, a w przypadku pliku z symulacją zostanie dopisane dodatkowe sprawdzenie (check – “.check(bodyBytes.is(RawFileBody(„RecordedSimulation_0001_response.txt”))))” ) ciała odpowiedzi z zapisanym ciałem w pliku.

Zrzut ekranu 06. Gatling Recorder – Configuration – Simulation information.png.

Recorder – konfiguracja – Output

Sekcja ‘Output’ pozwala na wybranie katalogu, w którym nagrany skrypt zostanie zapisany oraz umożliwia zmianę kodowania zapisanego pliku. Domyślnie skrypty są zapisywane w katalogu ‘%GATLING_HOME%user-filessimulations’ z kodowaniem ‘UTF-8’. Jeśli zmienimy kodowanie dla skryptu przy jego nagrywaniu to będziemy musieli także zmienić kodowanie przy jego odtwarzaniu co będzie wymagało edycji pliku ‘gatling.conf’.

Zrzut ekranu 07. Gatling Recorder – Configuration – Output.png.

Recorder – konfiguracja – Filters

Sekcja ‘Filters’ pozwala na przefiltrowanie żądań wysyłanych do serwera wg wyrażeń regularnych określonych w listach ‘Whitelist’ i ‘Blacklist’.

Zrzut ekranu 08. Gatling Recorder – Configuration – Filters.

Jeśli chcemy pominąć nagrywanie zapytań o statyczne elementy strony, np. pliki graficzne ‘*.jpg’ to do blacklisty dodajemy pozycję z wyrażeniem  “.*.jpg”.

Kolejność z jaką wpisy w listach będą brane pod uwagę określa opcja z listy ‘Strategy’, która zawiera trzy opcje: ‘Whitelist first’, ‘Blacklist first’ i ‘Disabled’, które pozwalają najpierw oceniać odpowiednio białą, czarną listę lub wyłączyć filtrowanie.

Przycisk ‘No static resources’ dodaje do Blacklisty listę predefiniowanych wyrażeń, które wykluczą z nagrywania zapytania o statyczne zasoby aplikacji. Dodanie do czarnej listy wyrażeń regularnych odpowiadających statycznej zawartości strony zwiększy czytelność nagranego skryptu pomijając nagrywanie zapytań o te elementy.

Na poniższym zrzucie ekranu prezentowana jest sekcja Filters po wybraniu akcji ‘No static resources’ i rozwiniętą listą ‘Strategy’.

Zrzut ekranu 09. Gatling Recorder – Configuration – Filters.

Na dole okna ‘Gatling Recorder – Configuration’ jest dostępny checkbox ‘Save preferences’, który pozwala na zapis własnych ustawień aplikacji, aby przy kolejnym jej uruchomieniu nie trzeba było wprowadzać zmian w konfiguracji Recordera. Aby zmiany zostały zapamiętane po zaznaczeniu chcekboxa należy wybrać przycisk ‘Start!’, który uruchomi proxy i rozpocznie nagrywanie ruchu z przeglądarki z odpowiednio skonfigurowanym proxy.

Zrzut ekranu 10. Gatling Recorder – Configuration – Start.

Istnieje również możliwość uruchomienia narzędzia Recorder z poziomu wiersza poleceń, w przypadku dodania parametrów nadpisują one opcje domyślne. Dostępne opcje i parametry można sprawdzić wykonując polecenie

> recorder.bat --help

z linii komend.

Przygotowanie scenariusza do nagrywania

Aby wykonać testy wydajnościowe w narzędziu Gatling potrzebny jest nam scenariusz, który odzwierciedla działania użytkownika w testowanej aplikacji. Aplikacją na której będziemy nagrywać scenariusz jest TestArena – darmowe narzędzie do zarządzania testami (przypadkami testowymi). Więcej informacji o tej aplikacji można znaleźć na stronie http://testarena.pl/.

Warunki wstępne do rozpoczęcia nagrywania skryptów dla aplikacji TestArena:

• aplikacja została zainstalowana i skonfigurowana na serwerze lokalnym i udostępniona pod adresem http://testarena.com,
• w aplikacji zostały dodane projekty, wydania, środowiska oraz zadania i testy,
• po zalogowaniu jako administrator, dodano użytkownika z rolą lidera oraz drugiego z rolą testera, użytkownicy zostali dodani do projektu,
• po zalogowaniu na utworzonego wcześniej usera został wybrany domyślny projekt.

Aby zbytnio nie komplikować scenariusza nagramy jedną z podstawowych czynności w aplikacji czyli dodawanie zadań w projekcie. Zakładamy, że użytkownik wykona następujące kroki w aplikacji:

1. Otworzy stronę aplikacji www.testarena.com.
2. Na stronie logowania wprowadzi dane użytkownika (login i hasło).
3. Zaloguje się.
4. Przejdzie do zakładki ‘Zadania’.
5. Wybierze akcję ‘Dodaj zadanie’.
6. W pole ‘Tytuł’ wpisze tekst.
7. W pole ‘Opis’ wpisze tekst.
8. W polu ‘Środowisko’ wpisze tekst i wybierze dostępną opcję.
9. W polu ‘Wersja’ wpisze tekst i wybierze dostępną opcję.
10. Z listy ‘Priorytet’ wybierze priorytet.
11. W polu ‘Termin realizacji’ wskaże datę.
12. W polu ‘Przypisz do’ wpisze tekst i wybierze dostępną opcję.
13. Zapisze zadanie.
14. Wróci do listy zadań.
15. Wyloguje się.

Uruchomienie nagrywania

Wiemy już ogólnie jak wygląda okno konfiguracji narzędzia Recorder i jakimi opcjami dysponuje, więc przed rozpoczęciem nagrywania wprowadzamy w tym oknie ustawienia pod naszą aplikację:

• pozostawiamy ‘Recorder mode’ na ‘Http proxy’,
• w polu ‘Package’ wpisujemy ‘testarena’,
• w polu ‘Class name’ wprowadzamy ‘RecordedSimulation01’,
• checkboxy ‘Follow Redirects?’, ‘Remove cache headers?’ i  ‘Automatic Referers?’ pozostawiamy zaznaczone,
• checkbox ‘Infer html resources?’ odznaczamy,
• checkbox ‘Save & check response bodies?‘ pozostawiamy odznaczony,
• ‘Output folder’ pozostawiamy ustawiony domyślnie na katalog ‘user-filessimulations’,
• ‘Encoding’ pozostawiamy z domyślną opcją ‘Unicode (UTF-8)’,
• w ‘Filters’ pozostawiamy opcję ‘Strategy’  z wartością ‘Disabled’.

Zrzut ekranu 11. Gatling Recorder – Configuration – ustawienie do nagrywania scenariusza.

Mając ustawione parametry przed wybraniem przycisku ‘Start!’ trzeba zmienić ustawienia sieciowe na przeglądarce, aby cały ruch sieciowy przechodził przez HTTP proxy Recorder i mógł być przez niego zarejestrowany.

W tym celu, w przeglądarce Firefox należy wejść w ustawienia proxy wybierając ‘Menu’ > ‘Opcje’ > ‘Ogólne’, dalej w sekcji ‘Proxy sieciowe’ wybrać ‘Ustawienia…‘ ( w starszych wersjach FF będzie to ‘Menu’ > ‘Opcje’ > ‘Zaawansowane’ > ‘Sieć’)  i w ‘Ustawieniach połączenia’ oznaczyć opcję ‘Ręczna konfiguracja serwerów proxy’. Jako Server proxy HTTP należy wpisać ‘localhost’ i podać numer portu ‘8000’ (nr portu musi być zgodnym z ustawionym portem w konfiguracji narzędzia Recorder) oraz zaznaczyć checkbox ‘Użyj tego serwera proxy dla wszystkich protokołów’.

Zrzut ekranu 12. Firefox – ustawienie połączenia proxy.

Aby zmienić ustawienia proxy w przeglądarce Chrome należy rozwinąć menu ‘Dostosowywanie i kontrolowanie Google Chrome‘ i wybrać opcję ‘Ustawienia’, następnie rozwinąć opcję ‘Zaawansowane’ i przejść do sekcji ‘System‘. Dostęp do tych ustawień możliwy jest również poprzez wpisanie adresu ‘chrome://settings/system’. Następnie należy wybrać opcję ‘Otwórz ustawienia serwera proxy’ i w zakładce ‘Połączenia’ kliknąć w ‘Ustawienia sieci LAN’. W wyświetlonym oknie w sekcji ‘Serwer proxy’ zaznaczamy checkbox: ‘Użyj serwera proxy dla sieci LAN’. W pole adres należy wpisać ‘localhost’, a w pole port: ‘8000’ (nr portu musi być zgodnym z ustawionym portem w konfiguracji narzędzia Recorder). Wybrać przycisk ‘Zaawansowane’ i sprawdzić czy na oknie ‘Ustawienia serwera proxy’ checkbox ‘Użyj tego serwera proxy dla wszystkich protokołów’ jest oznaczony. Przyciskiem ‘OK’ akceptuje się wprowadzone ustawienia.

Okno ustawień proxy dla przeglądarki Chrome dostępne jest również z poziomu ustawień systemu operacyjnego (Windows) ponieważ przeglądarka Chrome bazuje na ustawieniach systemowych.

Zrzut ekranu 13. Chrome ustawienia serwera proxy.

Zrzut ekranu 14. Chrome ustawienia serwera proxy.

W innych przeglądarkach zmiana ustawień jest analogiczna do powyższych przykładów.

Po wprowadzeniu zmian w oknie konfiguracji narzędzia Recorder oraz ustawieniu proxy dla przeglądarki można rozpocząć nagrywanie skryptu klikając ‘Start!’, spowoduje to zamknięcie okna konfiguracji i otwarcie okna ‘Gatling Recorder – Running …’.

Zrzut ekranu 15. Gatling Recorder – Running… – okno w trakcie nagrywania.

W sekcji ‘Controls’ można dodawać tagi do skryptu, wyczyścić dotychczas nagrane zdarzenia przyciskiem ‘Clear’, anulować nagrywanie lub zamknąć okno przyciskiem ‘Cancel’. Przyciskiem ‘Stop & Save’ zapisujemy nagrane akcje z realizacji scenariusza do pliku.

W momencie rejestrowania, wszystkie akcje które wykonujemy w testowanej aplikacji są przechwytywane i prezentowane w oknie narzędzia. W sekcji ‘Executed Events’ będą prezentowane zarejestrowane zdarzenia, takie jak:

• żądania HTTP (Requesty): czyli zapytania wysyłane przez przeglądarkę na serwer,
• pauzy (Pause): czyli czasy pomiędzy kolejnymi żądaniami (requestami),
• tagi (Tags): czyli znaczniki wprowadzone przez użytkownika do oznaczenia wykonywanych zdarzeń w nagrywanym skrypcie.

W sekcji ‘Request Information’ oraz ‘Response Information’ zostaną zaprezentowane szczegóły żądania i odpowiedzi HTTP dla wybranego w polu ‘Executed Events’ zapytania.

Zrzut ekranu 16. Gatling Recorder – Running… – przykład zdarzeń, szczegóły żądania i odpowiedzi.

W sekcji ‘Secured hosts requiring accepting a certificate’ mogą pojawić się błędy związane z brakiem akceptacji certyfikatów.

Zrzut ekranu 17. Gatling Recorder – Running… – przykład komunikatu w Secured hosts requiring accepting a certificate.

Przy pierwszej próbie połączenia się z aplikacją przez proxy może pojawić się strona z błędem ‘Połączenie nie jest bezpieczne’, co może wymagać dodania wyjątku bezpieczeństwa, aby móc załadować stronę i rozpocząć nagrywanie.

Nagrywanie kroków będziemy realizować wg wcześniej zaproponowanego scenariusza, a w celu poprawy przejrzystości późniejszego skryptu scenariusza i wykonanych akcji dodamy tagi jako komentarze opisujące kolejne zdarzenia.

Dodajemy tag „Otwarcie strony”,

– otwieramy stronę aplikacji www.testarena.com.

Dodajemy tag „Logowanie”,

– na stronie logowania wprowadzamy dane użytkownika (login i hasło) i wybieramy „Zaloguj”.

Dodajemy tag „Zadania”,

– przechodzimy do zakładki „Zadania”.

Dodajemy tag „Dodanie zadania”,

– wybieramy akcję „Dodaj zadanie”.

Dodajemy tag „Wypełnianie formularza”,

– w pole „Tytuł” wpisujemy tekst,

– w pole „Opis” wpisujemy tekst,

– w polu „Środowisko” wpisujemy tekst i wybieramy dostępną opcję,

– w polu „Wersja” wpisujemy tekst i wybieramy dostępną opcję,

– z listy „Priorytet” wybieramy priorytet,

– w polu „Termin realizacji” wskazujemy datę,

– w polu „Przypisz do” wpisujemy tekst i wybieramy dostępną opcję.

Dodajemy tag „Zapis formularza”,

– zapisujemy zadanie wybierając „Zapisz”.

 Dodajemy tag „Powrót do listy Zadania”,

– wracamy do listy zadań wybierając „Powrót”.

Dodajemy tag „Wylogowanie”,

– wylogowujemy się wybierając „Wyloguj”.

Patrząc na okno narzędzia można zauważyć, że w zarejestrowanych akcjach obok wysyłanych requestów i wprowadzonych tagów są także wpisy ‘PAUSE 321ms’. Oznacza to, że Recorder rejestruje także przerwy jakie robimy w wykonywanych krokach na stronie. Daje to możliwość nagrania scenariusza, który jak najbardziej odzwierciedla naturalne zachowanie użytkownika na stronie.

Zrzut ekranu 18. Gatling Recorder – running… – dodany tag ‘Zadania’.

Kiedy wszystkie kroki mamy już wykonane i zarejestrowane można zakończyć nagrywanie poprzez ‘Stop & Save’, okno do nagrywania zostanie zamknięte, a pojawi się znowu okno konfiguracyjne narzędzia Recorder. Plik z symulacją jest zapisywany we wskazanej w ustawieniach ścieżce.

Nagrany skrypt scenariusza można otworzyć w dowolnym edytorze tekstu. Jest to plik w takiej postaci jaka została zapisana przez Recorder z wykonanych przez nas akcji. Jeżeli dodaliśmy tagi to skrypt jest bardziej czytelny, jednak jest w nim jeszcze sporo nadmiarowego (zbędnego) kodu oraz brakuje refaktoryzacji, którą zajmiemy się w przyszłości.

W wygenerowanym kodzie dane prywatne takie jak adresy e-mail oraz hasła zostały zamienione na ciągi znaków ‘x’.

package testarena

import scala.concurrent.duration._

import io.gatling.core.Predef._

import io.gatling.http.Predef._

import io.gatling.jdbc.Predef._

class RecordedSimulation01 extends Simulation {

val httpProtocol = http

.baseURL("http://testarena.com")

.acceptHeader("*/*")

.acceptEncodingHeader("gzip, deflate")

.acceptLanguageHeader("pl,en-US;q=0.7,en;q=0.3")

.userAgentHeader("Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:56.0) Gecko/20100101 Firefox/56.0")

val headers_0 = Map(

"Accept" -> "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",

"Upgrade-Insecure-Requests" -> "1")

val headers_3 = Map("Pragma" -> "no-cache")

val headers_6 = Map(

"Content-Type" -> "application/x-www-form-urlencoded; charset=UTF-8",

"X-Requested-With" -> "XMLHttpRequest")

val headers_9 = Map(

"Accept" -> "application/json, text/javascript, */*; q=0.01",

"X-Requested-With" -> "XMLHttpRequest")

val headers_18 = Map("X-Requested-With" -> "XMLHttpRequest")

val uri2 = "http://ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js"

   val uri3 = "http://detectportal.firefox.com/success.txt"

   val uri4 = "https://www.google.com"

   val uri5 = "http://fonts.googleapis.com/css"

val scn = scenario("RecordedSimulation01")

// Otwarcie strony

.exec(http("request_0")

.get("/")

.headers(headers_0))

.pause(32)

// Logowanie

.exec(http("request_1")

.post("/logowanie")

.headers(headers_0)

.formParam("email", "xxxxxxxx@xxxxxxxx")

.formParam("password", "xxxxxxxx")

.formParam("login", "Zaloguj")

.formParam("remember", "0")

.formParam("csrf", "4eb7b43335d196fb3ff740a0da91fec9"))

.exec(http("request_2")

.get("/upload/avatars/user/mini/default.jpg?1507905764"))

.pause(2)

.exec(http("request_3")

.get(uri3 + "")

.headers(headers_3))

.pause(37)

// Zadania

.exec(http("request_4")

.get("/PP1/tasks")

.headers(headers_0))

.pause(100 milliseconds)

.exec(http("request_5")

.get("/upload/avatars/user/mini/default.jpg?1507905804"))

.pause(244 milliseconds)

.exec(http("request_6")

.post("/multi_select_load_ajax")

.headers(headers_6)

.formParam("name", "task167"))

.pause(10)

// Dodanie zadania

.exec(http("request_7")

.get("/PP1/task_add")

.headers(headers_0))

.exec(http("request_8")

.get("/upload/avatars/user/mini/default.jpg?1507905815"))

.pause(45)

// Wypełnianie formularza

.exec(http("request_9")

.get("/PP1/environment_list_ajax?q=S")

.headers(headers_9))

.pause(3)

.exec(http("request_10")

.get("/PP1/version_list_ajax?q=")

.headers(headers_9))

.pause(228 milliseconds)

.exec(http("request_11")

.get("/PP1/version_list_ajax?q=W")

.headers(headers_9))

.pause(20)

.exec(http("request_12")

.post("/PP1/project_user_list_ajax")

.headers(headers_6)

.formParam("q", "xxxxxxxxx@xxxxxxxx"))

.pause(35)

// Zapis formularza

.exec(http("request_13")

.post("/PP1/task_add_process")

.headers(headers_0)

.formParam("backUrl", "http://testarena.com/PP1/tasks")

.formParam("title", "Zadanie z001")

.formParam("description", "Opis zadania z001")

.formParam("releaseName", "Wydanie 01")

.formParam("releaseId", "132")

.formParam("environments", "75")

.formParam("versions", "98")

.formParam("priority", "2")

.formParam("dueDate", "2017-10-31 23:59")

.formParam("assigneeName", "Tester Testowy (xxxxxxxxx@xxxxxxxx)")

.formParam("assigneeId", "3")

.formParam("tags", "")

.formParam("save", "Zapisz")

.formParam("csrf", "3caaff352b3d8790c1f9c8ca95955a10"))

.pause(101 milliseconds)

.exec(http("request_14")

.get("/upload/avatars/user/mini/default.jpg?1507905921"))

.exec(http("request_15")

.get("/img/is_busy.gif"))

.exec(http("request_16")

.get("/img/arrow_down_icon.png"))

.exec(http("request_17")

.get("/img/info_close_button.png"))

.exec(http("request_18")

.post("/PP1/comment_list_by_task_ajax/357")

.headers(headers_18))

.pause(22)

// Powrót do listy Zadania

.exec(http("request_19")

.get("/PP1/tasks")

.headers(headers_0))

.exec(http("request_20")

.get("/upload/avatars/user/mini/default.jpg?1507905943"))

.pause(308 milliseconds)

.exec(http("request_21")

.post("/multi_select_load_ajax")

.headers(headers_6)

.formParam("name", "task167"))

.pause(28)

// Wylogowanie

.exec(http("request_22")

.get("/wyloguj")

.headers(headers_0))

.pause(286 milliseconds)

.exec(http("request_23")

.get(uri3 + "")

.headers(headers_3))

setUp(scn.inject(atOnceUsers(1))).protocols(httpProtocol)

}

Listing 1.  Kod skryptu po zakończeniu nagrywania.

Objaśnienie kodu nagranego skryptu

Poniżej przedstawię fragmenty kodu wygenerowanego skryptu z ich opisem.

Na początku mamy nazwę opcjonalnej paczki:

package testarena

Następnie wymagane importy:

import scala.concurrent.duration._

import io.gatling.core.Predef._

import io.gatling.http.Predef._

import io.gatling.jdbc.Predef._

Dalej jest deklaracja klasy, która dziedziczy po klasie Simulation:

class RecordedSimulation01 extends Simulation

Następnie ogólna konfiguracja dla wszystkich żądań HTTP:

val httpProtocol = http

Ustawienie podstawowego adresu baseURL, który będzie wstępnie dodawany do wszystkich względnych adresów URL:

.baseURL("http://testarena.com")

Ustawienie kolejnych elementów nagłówka HTTP, które będą przesyłane we wszystkich zapytaniach:

.acceptHeader("*/*")

.acceptEncodingHeader("gzip, deflate")

.acceptLanguageHeader("pl,en-US;q=0.7,en;q=0.3")

.userAgentHeader("Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:56.0) Gecko/20100101 Firefox/56.0")

Definiowanie mapy nagłówków przed scenariuszem pozwala na ponowne użycie ich w kilku żądaniach w skrypcie:

val headers_0 = Map(

"Accept" -> "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",

"Upgrade-Insecure-Requests" -> "1")

val headers_3 = Map("Pragma" -> "no-cache")

val headers_6 = Map(

"Content-Type" -> "application/x-www-form-urlencoded; charset=UTF-8",

"X-Requested-With" -> "XMLHttpRequest")

val headers_9 = Map(

"Accept" -> "application/json, text/javascript, */*; q=0.01",

"X-Requested-With" -> "XMLHttpRequest")

val headers_18 = Map("X-Requested-With" -> "XMLHttpRequest")

Definicje zmiennych, które były wykorzystywane w żądaniach podczas nagrywania:

val uri2 = "http://ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js"

val uri3 = "http://detectportal.firefox.com/success.txt"

val uri4 = "https://www.google.com"

val uri5 = "http://fonts.googleapis.com/css"

Definicja scenariusza zaczyna się od wiersza:

val scn = scenario("RecordedSimulation01")

Kolejne kroki scenariusza składają się z kilku powtarzających się elementów, każdy tag dodany podczas nagrywania skryptu prezentowany jest jako komentarz:

// Otwarcie strony

Wywołanie akcji – żądania HTTP – o nazwie ‘request_0’, nazwa będzie też prezentowana w raporcie:

.exec(http("request_0")

Dla poprawy czytelności skryptu i raportu nazwę ‘request_0’ można zmienić w kodzie.

Ustawienie metody GET z adresem ‘/’ dla żądania http:

.get("/")

Ustawienie części nagłówka żądania HTTP, która nie jest wspólna:

.headers(headers_0))

Polecenie pauzy czyli czas podawany domyślnie w sekundach pomiędzy kolejnym krokiem użytkownika:

.pause(32)

Wartości czasu oczekiwania można także uzupełnić w milisekundach dopisując ‘milliseconds’ do podanego czasu np. .pause(100 milliseconds).

Tag w postaci komentarza:

// Logowanie

Wywołanie akcji żądania http o nazwie ‘request_1’ metodą POST z adresem ‘/logowanie’ z przesłanymi parametrami formularza:

.exec(http("request_1")

.post("/logowanie")

.headers(headers_0)

.formParam("email", "xxxxxxxx@xxxxxxxx")

.formParam("password", "xxxxxxxx")

.formParam("login", "Zaloguj")

.formParam("remember", "0")

.formParam("csrf", "4eb7b43335d196fb3ff740a0da91fec9"))

W dalszej części skryptu elementy kodu (żądania) będą się powtarzać, jednak mając dodane tagi w postaci komentarzy wiemy jakich żądań dotyczą. Pomijamy więc następne żądania i przechodzimy do następnych elementów.

Ostatnim elementem nagranego skryptu jest definicja symulacji, czyli ustawienie konfiguracji i wywołanie scenariuszy (w tym przypadku tylko ‘scn‘), które zostaną uruchomione jako symulacja:

setUp(scn.inject(atOnceUsers(1))).protocols(httpProtocol)

setUp – zawiera całą konfigurację, razem z nazwami scenariuszy, które zostaną uruchomione,

scn – nazwa  scenariusza, w naszym skrypcie jest tylko jeden taki scenariusz,

scn.inject(atOnceUsers(1))) – deklaracja uruchomienia scenariusza z jednym użytkownikiem,

protocols(httpProtocol) – podłączenie konfiguracji HTTP zadeklarowanej na początku skryptu.

Podsumowanie

W artykule tym opisaliśmy możliwe sposoby nagrywania skryptów symulacyjnych w narzędziu Gatling Recorder. Czyszczeniem skryptu z nadmiarowego kodu, parametryzacją zmiennych, kontrolą czy kroki scenariusza wykonują się poprawnie oraz uruchamianiem nagranego skryptu zajmiemy się w kolejnych artykułach poświęconym narzędziu.

Temat nie jest wyczerpany dlatego zachęcam do sięgnięcia po więcej szczegółowych informacji do dokumentacji https://gatling.io/docs/current/.

SPRAWDŹ TAKŻE
Przygotowanie środowiska do testów wydajności w Gatlingu. Część 2.
Gatling. Testy wydajności w innej formie. Część 1.