Vad är BDD-testning? Ramexempel

Vad är BDD-testning (Behavior Driven Development)?

BDD (Beteendedriven utveckling) Testning är en teknik för agil mjukvaruutveckling och är en förlängning av TDD, dvs Test Driven Development. I BDD är testfall skrivna på ett naturligt språk som även icke-programmerare kan läsa.

Hur fungerar BDD-testning?

Tänk på att du har fått i uppdrag att skapa en modul för överföring av pengar i en Net Banking-applikation.

Det finns flera sätt att testa det

Fondöverföring bör ske om det finns tillräckligt med saldo på källkontot
Fondöverföring bör ske om informationen om destinationens luftkonditionering är korrekt
Fondöverföring bör ske om transaktionslösenord / rsa-kod / säkerhetsautentisering för transaktionen som angetts av användaren är korrekt
Fondöverföring bör ske även om det är en helgdag
Fondöverföring bör ske på ett framtida datum som anges av kontoinnehavaren

Ocuco-landskapet Testscenario bli mer utarbetade och komplexa eftersom vi överväger ytterligare funktioner som överföringsbelopp X för ett intervall Y dagar/månader , stoppa schemaöverföring när det totala beloppet når Z och så vidare

Den allmänna tendensen hos utvecklare är att utveckla funktioner och skriva testkod senare. Som framgår av ovanstående fall, Testfall utvecklingen för detta fall är komplex och utvecklaren kommer att skjuta upp Testning till release, då kommer han att göra snabba men ineffektiva tester.

För att övervinna detta problem (beteendedriven utveckling) skapades BDD. Det gör hela testprocessen enkel för en utvecklare

I BDD måste vad du än skriver gå in på Givet-När-Då steg. Låt oss överväga samma exempel ovan i BDD

Given that a fund transfer module in net banking application has been developed
And I am accessing it with proper authentication

WhenI 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

Är det inte lätt att skriva och läsa och förstå? Den täcker alla möjliga testfall för fondöverföringsmodulen och kan enkelt modifieras för att rymma fler. Det är också mer som att skriva dokumentation för fondöverföringsmodulen.

Vad är REST API-testning?

Eftersom REST har blivit en ganska populär stil för att bygga API:er nuförtiden, har det blivit lika viktigt att automatisera REST API-testfall tillsammans med UI-testfall. Så i princip, dessa VILAR API-testning involverar testning av CRUD-åtgärder (Create-Read-Update-Delete) med metoderna POST, GET, PUT respektive DELETE.

Vad är Behave?

Behave är en av de populära Python BDD-testramar.

Låt oss se hur Behave fungerar:

Funktionsfiler är skrivna av din affärsanalytiker / sponsor / vem som helst med dina beteendescenarier i den. Den har ett naturligt språkformat som beskriver en funktion eller en del av en funktion med representativa exempel på förväntade resultat

Dessa scenariesteg mappas med stegimplementeringar inskrivna Python.

Och valfritt finns det vissa miljökontroller (kod som ska köras före och efter steg, scenarier, funktioner eller hela skjutmatchen).

Låt oss komma igång med installationen av vårt ramverk för automatiseringstest med Behave:

Ställa in BDD Testing Framework Behave on Windows

Installation:

Hämta och installera Python 3 från https://www.python.org/
Utför följande kommando på kommandotolken för att installera fungerar
pip-installationen beter sig
IDE: Jag har använt PyCharm Community Edition https://www.jetbrains.com/pycharm/download

Projektinställning:

Skapa ett nytt projekt
Skapa följande katalogstruktur:

Funktionsfiler:

Så låt oss bygga vår funktionsfil Sample_REST_API_Testing.feature har funktion som att utföra CRUD-operationer på "posts"-tjänsten.

I vårt exempel har jag använt http://jsonplaceholder.typicode.com/ inlägg exempel REST Service.

Exempel POST-scenario

Scenario: POST post example ->Here we are considering creating new post item using 'posts' service
Given: I set post posts API endpoint ->This is prerequisite for the test which is setting URL of posts service
When: I set HEADER param request content type as "application/json."
And set request body
And send POST HTTP request ->This is actual test step of sending a post request
Then: Then I receive valid HTPP response code 201 
And Response body "POST" is non-empty-> This is verification of response body

På samma sätt kan du skriva de återstående scenarierna enligt följande:

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."

Steg Implementering

Nu, för funktionssteg som används i ovanstående scenarier, kan du skriva implementeringar i Python filer i katalogen "steg".

Behave-ramverket identifierar Step-funktionen genom att dekoratörer matchar med funktionsfilpredikatet. Till exempel, Givet predikat i funktionsfilen Scenario söker efter stegfunktion med dekoratorn "given". Liknande matchning sker för När och Då. Men i fallet med 'Men', 'Och', tar stegfunktionen dekorator samma som det föregående steget. Till exempel, om 'And' kommer för Given, är matchande stegfunktionsdekorator @given.

Till exempel, när steg för POST kan implementeras enligt följande:

@when (u'I Set HEADER param request content type as "{header_conent_type}"')
Mapping of When, here notice “application/json” is been passed from feature file for "{header_conent_type}” . This is called as parameterization


def step_impl (context, header_conent_type):
This is step implementation method signature

request_headers['Content-Type'] = header_conent_type
Step implementation code, here you will be setting content type for request header

På liknande sätt kommer implementeringen av andra steg i step python-filen att se ut så här:

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 = 'http://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_conent_type}"')
def step_impl(context, header_conent_type):
    request_headers['Content-Type'] = header_conent_type

#You may also include "And" or "But" as a step - these are renamed by behave to take the name of their preceding step, so:
@when(u'Set request Body')
def step_impl(context):
    request_bodies['POST']={"title": "foo","body": "bar","userId": "1"}

#You may also include "And" or "But" as a step - these are renamed by behave to take the name of their preceding step, so:
@when(u'Send POST HTTP request')
def step_impl(context):
    # sending get request and saving response as response object
    response = requests.post(url=api_endpoints['POST_URL'], json=request_bodies['POST'], headers=request_headers)
    #response = requests.post(url=api_endpoints['POST_URL'], headers=request_headers) #https://jsonplaceholder.typicode.com/posts
    # extracting response text
    response_texts['POST']=response.text
    print("post response :"+response.text)
    # extracting response status_code
    statuscode = response.status_code
    response_codes['POST'] = statuscode

@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'] is 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'])

#You may also include "And" or "But" as a step - these are renamed by behave to take the name of their preceding step, so:
@when(u'Send GET HTTP request')
def step_impl(context):
    # sending get request and saving response as response object
    response = requests.get(url=api_endpoints['GET_URL'], headers=request_headers) #https://jsonplaceholder.typicode.com/posts
    # extracting response text
    response_texts['GET']=response.text
    # extracting response status_code
    statuscode = response.status_code
    response_codes['GET'] = statuscode

@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] is 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):
    # sending get request and saving response as response object  # response = requests.post(url=api_endpoints['POST_URL'], headers=request_headers) #https://jsonplaceholder.typicode.com/posts
    response = requests.put(url=api_endpoints['PUT_URL'], json=request_bodies['PUT'], headers=request_headers)
    # extracting response text
    response_texts['PUT'] = response.text
    print("update response :" + response.text)
    # extracting response status_code
    statuscode = response.status_code
    response_codes['PUT'] = statuscode
#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):
    # sending get request and saving response as response object
    response = requests.delete(url=api_endpoints['DELETE_URL'])
    # response = requests.post(url=api_endpoints['POST_URL'], headers=request_headers) #https://jsonplaceholder.typicode.com/posts
    # extracting response text
    response_texts['DELETE'] = response.text
    print("DELETE response :" + response.text)
    # extracting response status_code
    statuscode = response.status_code
    response_codes['DELETE'] = statuscode
#END DELETE

Kör testerna

Nu är vi klara med vår testskriptutvecklingsdel, så låt oss köra våra tester:

Kör följande kommando på kommandotolken för att köra vår funktionsfil

C: \Program\Python\Python37>bete sig -f snyggt C:\ \features\feature_files_folder\Sample_REST_API_Testing.feature

Detta kommer att visa testkörningsresultat enligt följande:

Rapportvisning på konsolen

Låt oss se en till cool sak här.

Eftersom användare alltid föredrar att se testresultat i ett mer läsbart och presentabelt format, låt oss ha rapporter i HTML-format med hjälp av Allure.

Rapport

Först måste du installera Allure Behave formatter [https://docs.qameta.io/allure-report/]:

Och kör nu följande kommando:

För rapporter

>bete sig -f json -o Sample_REST_API_Testing.feature

> lockande tjäna

Detta kommer att generera din testresultatrapport i ett presentabelt och informativt format så här:

Testrapport i HTML-format

Testrapport som visar individuella scenarieresultat

Sammanfattning

BDD är beteendedriven utveckling. Det är en av teknikerna för agil mjukvaruutveckling.
REST har blivit en ganska populär stil för att bygga API:er nuförtiden, det har blivit lika viktigt att automatisera REST API-testfall tillsammans med UI-testfall.
BDD har ett naturligt språkformat som beskriver en funktion eller en del av en funktion med representativa exempel på förväntade resultat
Behave-ramverket identifierar Step-funktionen genom att dekoratörer matchar med funktionsfilpredikatet
Exempel på ramverk för BDD-testning: 1) Cucumber 2) SpecFlow 3) Quantum 4) JBehave 5) Codeception

Du kanske gillar: