Czym jest testowanie BDD? Framework programowania sterowanego zachowaniem
⚡ Inteligentne podsumowanie
Testowanie BDD opisuje zachowanie aplikacji prostym językiem „Given-When-Then”, dzięki czemu analitycy, programiści i testerzy korzystają z jednej specyfikacji. Niniejszy przewodnik stosuje to podejście do testowania interfejsu API REST z użyciem Behave, Python framework obejmujący konfigurację, pliki funkcji, implementację kroków, wykonywanie i raportowanie.
Co to jest test BDD (rozwój zorientowany na zachowanie)?
Testowanie BDD (rozwój zorientowany na zachowanie). to technika zwinnego wytwarzania oprogramowania, będąca rozwinięciem metodyki TDD, czyli Test Driven Development. W BDD przypadki testowe są pisane w języku naturalnym, zrozumiałym nawet dla osób niebędących programistami.
Jak działa testowanie BDD?
Załóżmy, że Twoim zadaniem jest utworzenie modułu przelewu środków w aplikacji bankowości internetowej.
Istnieje wiele sposobów, aby to sprawdzić:
- Przelew środków powinien nastąpić, jeżeli na koncie źródłowym znajduje się wystarczająca ilość środków
- Przelew środków powinien zostać zrealizowany, jeśli dane rachunku docelowego są prawidłowe
- Przelew środków powinien nastąpić, jeśli hasło transakcji / kod RSA / uwierzytelnienie bezpieczeństwa wprowadzone przez użytkownika jest prawidłowe
- Przelew środków powinien zostać zrealizowany nawet w dzień wolny od pracy
- Transfer środków powinien nastąpić w przyszłym terminie określonym przez posiadacza rachunku
Scenariusz testowy staje się bardziej rozbudowany i złożony, gdy weźmiemy pod uwagę dodatkowe funkcje, takie jak przelewanie kwoty X na okres Y dni lub miesięcy, zatrzymanieping zaplanowany przelew, gdy suma osiągnie Z, itd.
Ogólną tendencją programistów jest późniejsze rozwijanie funkcji i pisanie kodu testowego. Jak widać w powyższym przykładzie, Przypadek testowy rozwój tutaj jest złożony, więc deweloper będzie odkładał Testy do czasu wydania, w którym to momencie przeprowadzane są szybkie, ale nieskuteczne testy.
Aby rozwiązać ten problem, opracowano metodę Behavior Driven Development (BDD). Ułatwia ona programistom cały proces testowania.
W BDD wszystko, co napiszesz, musi zostać uwzględnione Biorąc pod uwagę-Kiedy-Wtedy Kroki. Rozważmy ten sam przykład powyżej w BDD:
Given that a fund transfer module in net banking application has been developed And I am accessing it with proper authentication When I shall transfer with enough balance in my source account Or I shall transfer on a Bank Holiday Or I shall transfer on a future date And destination a/c details are correct And transaction password / rsa code / security authentication for the transaction is correct And press or click send button Then amount must be transferred And the event will be logged in log file
Ten formularz jest łatwy w pisaniu, czytaniu i zrozumieniu. Obejmuje każdy możliwy przypadek testowy dla modułu transferu funduszy i można go szybko modyfikować, aby uwzględnić więcej przypadków. Czyta się go jak żywą dokumentację modułu. Ponieważ BDD wywodzi się z TDD, warto ustalić różnicę między nimi, zanim przejdziemy do narzędzi.
BDD vs TDD: kluczowe różnice
Obie praktyki opierają się na testowaniu i obie skracają pętle sprzężenia zwrotnego. Różnią się tym, kto pisze testy, jakim językiem się posługują i którą warstwę aplikacji opisują.
| WYGLĄD | TDD (Test Driven Development) | BDD (Rozwój oparty na zachowaniu) |
|---|---|---|
| Skupiać | Jak jednostka kodu działa wewnętrznie | Jak system zachowuje się z perspektywy użytkownika |
| Wybierz język | Asercje języka programowania | Scenariusze języka naturalnego „Gdzie-Kiedy-Wtedy” |
| Główny autor | Deweloper | Analityk biznesowy, właściciel produktu, tester i programista razem |
| Readable przez nieprogramistów | Nie | Tak |
| Typowy zakres | Poziom jednostki | Funkcja, API i poziom akceptacji |
| Typowe narzędzia | JUnit, pytest, NUnit | Zachowywać się, Cucumber, SpecFlow, JBehave |
Te dwa elementy raczej się uzupełniają, niż konkurują. Zespoły zazwyczaj utrzymują TDD do projektowania na poziomie jednostki i dodawania scenariuszy BDD, aby opisać zachowanie, które interesariusze faktycznie akceptują. Ponieważ punkty końcowe REST znajdują się dokładnie na tym poziomie akceptacji, idealnie pasują do BDD.
Co to jest testowanie API REST?
Wraz ze wzrostem popularności REST w tworzeniu interfejsów API, automatyzacja przypadków testowych interfejsu API REST i interfejsu użytkownika stała się równie ważna. Testowanie API obejmuje testowanie działań CRUD (Create-Read-Update-Delete) odpowiednio za pomocą metod POST, GET, PUT i DELETE.
Co to jest Zachowaj się?
Zachowaj się jest jednym z popularnych Python Frameworki testowe BDD. Oto jak działają funkcje Behave:
- Pliki funkcji są tworzone przez analityka biznesowego, sponsora lub osobę odpowiedzialną za scenariusze zachowań. Plik funkcji wykorzystuje format języka naturalnego, opisujący funkcję lub jej część, wraz z reprezentatywnymi przykładami oczekiwanych rezultatów.
- Te kroki scenariusza są mapowane na implementacje kroków zapisane w Python.
- Opcjonalnie, sterowanie środowiskowe uruchamia kod przed i po krokach, scenariuszach, funkcjach lub całym przebiegu.
Po ustaleniu ról poszczególnych plików można zainstalować framework.
Konfigurowanie środowiska testowego BDD Zachowaj włączone Windows
Instalacja:
- Pobierz i zainstaluj Python 3 od https://www.python.org/
- Aby zainstalować Behave, wykonaj następujące polecenie w wierszu poleceń
pip install behave- SDI: PyCharm Tutaj użyto wersji Community Edition — https://www.jetbrains.com/pycharm/download/
Konfiguracja projektu:
- Utwórz nowy projekt
- Utwórz następującą strukturę katalogów
Zrzut ekranu powyżej pokazuje układ, którego oczekuje Behave: cechy katalog zawierający pliki funkcji i zagnieżdżony kroki katalog zawierający Python implementacje. Behawior wykrywa oba foldery według nazwy, więc nazwy folderów muszą się dokładnie zgadzać.
Pliki funkcji:
Teraz zbudujmy plik funkcji Sample_REST_API_Testing.feature, przy czym funkcją tą są operacje CRUD w usłudze „posty”.
W tym przykładzie użyto https://jsonplaceholder.typicode.com/ publikuje przykładową usługę REST, darmowe, fałszywe API, które akceptuje żądania zapisu i zwraca realistyczne odpowiedzi bez zapisywania zmian.
Przykładowy scenariusz POST
Scenario: POST post example -> creating a new post item using the 'posts' service Given I set post posts API endpoint -> prerequisite: sets the URL of the posts service When I set HEADER param request content type as "application/json" And set request body And send POST HTTP request -> the actual test step Then I receive valid HTTP response code 201 And Response body "POST" is non-empty -> verification of the response body
Podobnie możesz zapisać pozostałe scenariusze w następujący sposób:
Sample_REST_API_Testing.feature
Feature: Test CRUD methods in Sample REST API testing framework Background: Given I set sample REST API url Scenario: POST post example Given I Set POST posts api endpoint When I Set HEADER param request content type as "application/json" And Set request Body And Send a POST HTTP request Then I receive valid HTTP response code 201 And Response BODY "POST" is non-empty Scenario: GET posts example Given I Set GET posts api endpoint "1" When I Set HEADER param request content type as "application/json" And Send GET HTTP request Then I receive valid HTTP response code 200 for "GET" And Response BODY "GET" is non-empty Scenario: UPDATE posts example Given I Set PUT posts api endpoint for "1" When I Set Update request Body And Send PUT HTTP request Then I receive valid HTTP response code 200 for "PUT" And Response BODY "PUT" is non-empty Scenario: DELETE posts example Given I Set DELETE posts api endpoint for "1" When I Send DELETE HTTP request Then I receive valid HTTP response code 200 for "DELETE"
Wdrożenie kroków
Teraz, w przypadku kroków funkcji użytych w powyższych scenariuszach, możesz napisać implementacje w Python pliki w katalogu „steps”.
Struktura Behave identyfikuje funkcję skokową poprzez dopasowanie dekoratorów do predykatu pliku funkcji. Na przykład, Biorąc pod uwagę, predykat w scenariuszu pliku funkcji wyszukuje funkcję skokową niosącą @given dekorator. To samo dopasowanie ma miejsce dla Kiedy oraz NastępnieW przypadku „But” i „And” funkcja kroku przyjmuje ten sam dekorator, co poprzedni krok. Na przykład, jeśli „And” następuje po funkcji Given, pasującym dekoratorem funkcji kroku jest @given.
Na przykład krok When dla POST można zaimplementować w następujący sposób. Zwróć uwagę, jak "application/json" jest przekazywany z pliku funkcji do symbolu zastępczego w nawiasach klamrowych — nazywa się to parametryzacją.
# Decorator: the braced name captures a value from the feature file @when(u'I Set HEADER param request content type as "{header_content_type}"') def step_impl(context, header_content_type): # Step implementation: set the content type on the request header request_headers['Content-Type'] = header_content_type
Podobnie jest z realizacją pozostałych kroków w kroku Python plik będzie wyglądał następująco:
sample_step_implementation.py
from behave import given, when, then, step import requests api_endpoints = {} request_headers = {} response_codes = {} response_texts = {} request_bodies = {} api_url = None @given(u'I set sample REST API url') def step_impl(context): global api_url api_url = 'https://jsonplaceholder.typicode.com' # START POST Scenario @given(u'I Set POST posts api endpoint') def step_impl(context): api_endpoints['POST_URL'] = api_url + '/posts' print('url :' + api_endpoints['POST_URL']) @when(u'I Set HEADER param request content type as "{header_content_type}"') def step_impl(context, header_content_type): request_headers['Content-Type'] = header_content_type # "And" or "But" steps are renamed by behave to match their preceding step @when(u'Set request Body') def step_impl(context): request_bodies['POST'] = {"title": "foo", "body": "bar", "userId": "1"} @when(u'Send POST HTTP request') def step_impl(context): # send the request and save the response object response = requests.post(url=api_endpoints['POST_URL'], json=request_bodies['POST'], headers=request_headers) response_texts['POST'] = response.text print("post response :" + response.text) response_codes['POST'] = response.status_code @then(u'I receive valid HTTP response code 201') def step_impl(context): print('Post rep code ;' + str(response_codes['POST'])) assert response_codes['POST'] == 201 # END POST Scenario # START GET Scenario @given(u'I Set GET posts api endpoint "{id}"') def step_impl(context, id): api_endpoints['GET_URL'] = api_url + '/posts/' + id print('url :' + api_endpoints['GET_URL']) @when(u'Send GET HTTP request') def step_impl(context): response = requests.get(url=api_endpoints['GET_URL'], headers=request_headers) response_texts['GET'] = response.text response_codes['GET'] = response.status_code @then(u'I receive valid HTTP response code 200 for "{request_name}"') def step_impl(context, request_name): print('Get rep code for ' + request_name + ':' + str(response_codes[request_name])) assert response_codes[request_name] == 200 @then(u'Response BODY "{request_name}" is non-empty') def step_impl(context, request_name): print('request_name: ' + request_name) print(response_texts) assert response_texts[request_name] is not None # END GET Scenario # START PUT/UPDATE @given(u'I Set PUT posts api endpoint for "{id}"') def step_impl(context, id): api_endpoints['PUT_URL'] = api_url + '/posts/' + id print('url :' + api_endpoints['PUT_URL']) @when(u'I Set Update request Body') def step_impl(context): request_bodies['PUT'] = {"title": "foo", "body": "bar", "userId": "1", "id": "1"} @when(u'Send PUT HTTP request') def step_impl(context): response = requests.put(url=api_endpoints['PUT_URL'], json=request_bodies['PUT'], headers=request_headers) response_texts['PUT'] = response.text print("update response :" + response.text) response_codes['PUT'] = response.status_code # END PUT/UPDATE # START DELETE @given(u'I Set DELETE posts api endpoint for "{id}"') def step_impl(context, id): api_endpoints['DELETE_URL'] = api_url + '/posts/' + id print('url :' + api_endpoints['DELETE_URL']) @when(u'I Send DELETE HTTP request') def step_impl(context): response = requests.delete(url=api_endpoints['DELETE_URL']) response_texts['DELETE'] = response.text print("DELETE response :" + response.text) response_codes['DELETE'] = response.status_code # END DELETE
⚠️ Uwaga: Porównywanie kodów statusu z == zamiast is sprawy. is operator testuje tożsamość obiektu, a nie jego równość, Python 3.8 i późniejsze podnoszą Ostrzeżenie składni: „jest” z dosłownym dla tego wzorca. Każde stwierdzenie zapisane jako assert code is 201 powinno zostać zapisane jako assert code == 201.
Uruchamianie testów
Skrypt testowy został ukończony, więc uruchommy testy. Wykonaj poniższe polecenie w wierszu poleceń, aby uruchomić plik funkcji:
:: Run a single feature file with the pretty formatter behave -f pretty features\feature_files_folder\Sample_REST_API_Testing.feature :: Run every feature in the project behave
Wyniki wykonania testu są wyświetlane w następujący sposób:
Wyświetlanie raportu na konsoli
Dane wyjściowe w postaci konsoli są wygodne w trakcie tworzenia oprogramowania, jednak interesariusze zazwyczaj wolą czytelny raport, który zapewnia Allure.
Raporty
Najpierw zainstaluj formater Allure Behave i narzędzie wiersza poleceń Allure. Formater to Python pakiet; narzędzie wiersza poleceń to osobny plik do pobrania opisany w Dokumentacja raportu Allure.
:: 1. Install the formatter pip install allure-behave :: 2. Run the tests and write raw results to a folder behave -f allure_behave.formatter:AllureFormatter -o reports/allure-results features/ :: 3. Render and open the HTML report allure serve reports/allure-results
Generuje to raport z wynikami testów w czytelnym i informacyjnym formacie, jak ten:
Raport z testu w formacie HTML
Raport z testu wyświetlający wynik indywidualnego scenariusza
Działający zestaw narzędzi będzie przydatny tylko wtedy, gdy będzie czytelny w miarę rozrastania się interfejsu API. Właśnie wtedy dyscyplina w zakresie plików funkcji się opłaca.
Najlepsze praktyki dotyczące pisania plików funkcji Behave
Pakiet Behave szybko ulega degradacji, gdy scenariusze opisują kliknięcia i ładunki zamiast zachowań. Poniższe praktyki zapewniają czytelność plików funkcji dla interesariuszy biznesowych, jednocześnie zachowującping dotychczasowy Python warstwa łatwa w utrzymaniu dla inżynierów.
- Opisz zachowanie, nie implementację. Wpisz „Zakładając, że klient ma wystarczające saldo”, a nie „Zakładając, że saldo w kolumnie wynosi 500”. Plik funkcji opisuje działanie systemu; plik kroków opisuje sposób jego sprawdzania.
- Zachowaj jedno zachowanie na scenariusz. Scenariusz, który potwierdza kod statusu, treść odpowiedzi i wiersz bazy danych, to w rzeczywistości trzy scenariusze. Ich rozdzielenie sprawia, że błędy wskazują bezpośrednio na przyczynę.
- Przenieś współdzielone ustawienia do tła. Powyższy przykład wykorzystuje
Background: Given I set sample REST API urltak, aby każdy scenariusz odziedziczył bazę URL bez powtarzania. - Parametryzuj zamiast duplikować. Zabezpieczone symbole zastępcze, takie jak
"{request_name}"niech jedna funkcja krokowa obsługuje potwierdzenia GET, PUT i DELETE, dlatego przykład wymaga znacznie mniejszej liczby definicji kroków niż scenariusze. - Użyj Zarysu scenariusza dla wariantów danych. Gdy to samo zachowanie musi zostać udowodnione dla kilku danych wejściowych,
Examples:tabela jest bardziej przejrzysta niż skopiowane scenariusze. - Unikaj zależności między scenariuszami. Behave nie gwarantuje, że scenariusz POST zostanie uruchomiony przed scenariuszem GET w każdej konfiguracji. Każdy scenariusz powinien utworzyć potrzebny mu stan.
- Zastąp zmienne globalne na poziomie modułu kontekstem. W przykładzie punkty końcowe i odpowiedzi są przechowywane w słownikach modułów dla zwięzłości. W pakietach produkcyjnych należy je przechowywać w Behave.
contextobiekt, więc stan resetuje się czysto pomiędzy scenariuszami. - Oznaczaj scenariusze dla wybranych przebiegów. Tagi takie jak
@smokeor@regressiondopuszczaćbehave --tags=@smoke, co zapewnia szybką informację zwrotną na temat rurociągu.
Zastosowanie tych nawyków od pierwszego pliku funkcji sprawia, że pakiet BDD jest cenny znacznie dłużej niż początkowe przykłady CRUD. Zespoły rozwijające to podejście często łączą je z Cucumber dla projektów JVM lub Postman do eksploracyjnych kontroli API.







