Easy to understand --- build httprunner+pymysql+allure+jenkins+git interface automation test framework

The author of httprunner is debugtalk. He is a senior developer. At present, there are five versions of httprunner
The usage of Httprunner is relatively simple and conforms to a variety of scenarios in work:
1. After completing the interface automation, it is required to continue the performance test of this interface (hrun has a built-in locust module, which can directly conduct pressure test)
2. There are too many interfaces to do, and only some parameters need to be replaced, and the work of interface automation will be completed (charles records and exports the. har file, and converts it into a. py file through the hrun command)
3. Every step of the interface response of the request library needs to add assertions, and hrun will automatically generate assertion methods
4. Third party libraries integrated by hrun: loguru and jmespath

Current version of hrun:

Environment preparation: install python, Httprunner, allure pytest:

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple httprunner
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple allure-pytest

Environment verification, check the httprunner version:

httprunner -V   


httprunner --help  

Generate scaffolding (quickly generate a hrun framework):

httprunner startproject  PartsService

Convert the yml file in the scaffold into pytest file (execute in the root directory):

 cd  PartsService
 hmake testcases

Run httprunner and a single file (enter the root directory of the file to be run)

Mode 1:		pytest [filename]
Mode 2:		hrun [filename]
Mode 3:		httprunner run  [filename]

Run httprunner in batch to run all use cases under the file set

Mode 1:				pytest [dirname]
Mode 2:				hrun [dirname]
Mode 3:				 httprunner run  [dirname]

see. har generate script help

har2case -h  

The above is the basic usage of hrun, and the following is the secondary encapsulation of hrun

Allure: store the report result set of allure
api_data: store the request data of the interface (can be json file, xlsx file, yaml file)
api_testing: store API test cases
api_util: encapsulation method for API testing
common: public methods, such as reading database files
config: store global configuration files
databases: store database files
login: login

config file content:

# the url domain you wants to use in UI testing
backend_url =https://wwww.baidu.cn/

###  pytest xxxx --alluredir ./report
###  allure serve report

###   hrun test_post_api.yml --alluredir=allure
###   allure generate ./allure/ -o ./reports --clean

backend_url is the project address. If there are multiple sets of environments, you can put multiple URLs to switch

common file content:

import configparser  
import os

class ConfigReader:
    def __init__(self, file_name):
        self.config = configparser.ConfigParser()
        config_path = os.path.split(os.path.realpath(__file__))[0] + os.sep + file_name
        self.config.read(config_path, "utf-8")

    def get_config(self, config_item):
        sections = self.config.sections()
        for section in sections:
            if self.config.has_option(section, config_item):
                return self.config.get(section, config_item)

    def get_config_by_section(self, config_item, section_name):
        return self.config.get(section_name, config_item)

Only one method of reading Config file is written here, which is convenient for switching multiple sets of database environments. It can be supplemented later if necessary

login file content:

from httprunner import HttpRunner, Config, Step, RunRequest, RunTestCase  # todo: import httprunner module
def get_base_url():  # todo: encapsulate project_host method, which is the global API path of the project
    from common import config_reader  # todo:  config_reader reference config_reader method
    return config_reader.ConfigReader('../config/base_config.cfg').get_config('backend_url')

class TestCaseLogin(HttpRunner): # todo: define that the class name should start with Test

    config = Config("testcase description")\
        .verify(False)\   # todo: ignore Https certificates
            "Accept":"application/json, text/plain, */*",
            "Cookie":"SIAM_IMAGE_CODE=762410696575033344; SIAMTGT=TGT-892-4xraUmB3mrsA0MtWv11ENoZmq1t4CiBYgSGPJjG9NQrHpTqczc-SIAM; LtpaToken=AAECAzYxRjBCN0Y5NjFGMTYwQjlDTj1iaWVzb25nbGluL089Zm90b25UaDZzgyb50ZEjaw/jBYfTHXONKQ==",
            "userName": " xxxx",   
            "password": "xxxx",  
            "validCode": "xxx",
    })  # TODO: set global variables. The following Step methods can be used. Accept, Cookie, userName, password, validCode and brandId are set here

    teststeps = [
            RunRequest("Sign in")
                .post(get_base_url()+"API route")  #todo: switch your own api path
                .with_cookies(**{"aaf875be9aad4feca52ccece8eade2df": "WyIzMTE4NjIwNDQ3Il0"}) # todo: API cookies
                .with_json({"userName": "$userName", "password": "$password", "validCode": "$validCode"}) # todo: reference the defined global variable
                .with_jmespath('body.data.token', 'token') # todo: get the response value from the response. The outermost layer is a fixed body
                .with_jmespath('headers.Server', 'cookies')  # todo: take the token under the data of the body for the variable name later, so the body is specified earlier. Similarly, you can also take the data of the header (if necessary)
                .assert_equal("status_code", 200)
                .assert_equal('headers."Content-Type"', "application/json")
                .assert_equal("body.code", 200)
                .assert_equal("body.message", "success")

if __name__ == "__main__":

Write the login case to facilitate the subsequent hrun file call and realize login decoupling

api_util file contents:

import time
from httprunner import HttpRunner,Config,Step,RunTestCase,RunRequest
from login.get_token import TestCaseLogin as GetToken  # todo: import login file
def get_base_url():
    from common import config_reader
    return config_reader.ConfigReader('../config/base_config.cfg').get_config('backend_url')

class APIRequestConstructor(HttpRunner):  # todo: create a basic class to clear and read the token information of hrun later
    config = (
        Config("API Test execution")
    teststeps = [
            RunTestCase("By login API obtain token")
def reset_request_step(token=GetToken): # todo: encapsulates the method based on the class. If it is not passed by default, GetToken is used
    APIRequestConstructor.teststeps.clear() # todo: teardown, which belongs to the unit test framework, gives each use case a clean execution environment
    APIRequestConstructor.teststeps.append(  # todo: add step action
            RunTestCase("By login API obtain token")

headers = {        # todo: write header data according to the needs of the project
    "Host": "xxx",
    "Accept": "application/json, text/plain, */*",
    "Content-Type": "application/json;charset=utf-8",
    "brandId": "3",
    "Authorization": "${token}",
    "Cookie": "xxxx",
cookies = {"aaf875be9aad4feca52ccece8eade2df": "WyIxNjUxMTM1OTE1Il0"} # todo: write cookie data according to the needs of the project

def create_run_request(request_name, url, request_json, body="body.data", headers=headers, cookies=cookies):  # todo: encapsulate the use case steps and place the API name, request address and request parameters
    if request_json is not None: # todo: if the json format of the request parameter is not empty, execute the post request
        return RunRequest(request_name).post(url).with_headers(**headers).with_cookies(**cookies).with_json(
        ).extract().with_jmespath(body, "res_data")
    else: # todo: if the request parameter json is empty, the post request will be executed
        return RunRequest(request_name).get(url).with_headers(**headers).with_cookies(**cookies) \
            .extract().with_jmespath(body, "res_data")

def contruct_request_step(run_request_obj):
    return Step(

def perform_requests_and_get_last_response(steps):  # todo: the execution step of putting into use case
    APIRequestConstructor.teststeps.extend(steps)  # todo: steps to read teststeps
    obj = APIRequestConstructor()  # todo: instantiating objects
    res = obj.with_export(["res_data", "token"]).get_export_variables()
    return res

Secondary encapsulation of httprunner to reduce redundant code

Contents of databases file:

import copy
import configparser
import os
class ConfigReader:
    def __init__(self, file_name):
        self.config = configparser.ConfigParser()
        config_path = os.path.split(os.path.realpath(__file__))[0] + os.sep + file_name
        self.config.read(config_path, "utf-8")

    def get_config(self, config_item):
        sections = self.config.sections()
        for section in sections:
            if self.config.has_option(section, config_item):
                return self.config.get(section, config_item)
class DB():
    def __init__(self, database_name):
        cf = ConfigReader("database_config_dev.cfg")  # todo: which database is connected? If there are multiple environments, remember to switch the database configuration here
        self.host = cf.get_config(database_name + "_host")
        self.port = cf.get_config(database_name + "_port")
        self.user = cf.get_config(database_name + "_user")
        self.password = cf.get_config(database_name + "_password")
        self.database_name = database_name
    def connect(self):  # todo: create database connection method
        import pymysql
        # Create database connection
        self.db = pymysql.connect(host=self.host, user=self.user, password=
        self.password, database=self.database_name)
        # Create cursor
        self.cursor = self.db.cursor()

    def get_one(self, sql):  # todo: return a piece of data
        result = 0
            result = self.cursor.fetchone()
        except Exception as e:
            print('select error', e)
        return result

    def get_all(self, sql):  # todo: return all qualified query results
        result = 0
            result = self.cursor.fetchall()
        except Exception as e:
            print("select error", e)
        return result

    def __edit(self, sql):  # Create main function
        result = 1  # Set the result set for judgment when calling
        try:  # Here is the try statement used to try the operation
            self.db.commit()  # Note that if you modify, delete, or add a database, you must commit. You do not need to commit to query or create tables
        except Exception as e:  # If the operation fails, an operation exception is reported and the cursor is rolled back
            print('error :', e)
            result = 0
        return result

    def insert(self, sql):
        # The following three insert statements are the same, but we look clearer when calling
        return self.__edit(sql)  # Execute sql statements through the processing of the main function

    def delete(self, sql):  # Delete statement
        return self.__edit(sql)

    def update(self, sql):  # Modify statement
        return self.__edit(sql)

    def close(self):  # Closing method
        self.cursor.close()  # Close cursor
        self.db.close()  # close database

For example, there are two sets of database environments here. It is easier to encapsulate them with this method

api_ Content of testing file:

import allure,pytest
from loguru import logger
from api_util.util import *

@allure.feature("Parts information management query")
class TestSearChParts():
    @pytest.fixture(scope="class", autouse=True)
    @allure.feature("data dump")
    def teardown_(self):
        logger.debug("Implementation of the use case will end.")
    @allure.story("Branch: parts information management query")
    def test_Search_Parts_GetToken(self):
        reset_request_step()  # todo: login file reference. GetToken is not passed by default
        # todo: create request method create_search_parts can be named by user. Call create_run_request method, passing in API name, API address and request body
        create_search_parts = \
                "Accessory information management", "api/common/partsInfo/sparepart/v1/getSparePartByPage", {"status":1,"pageSize":10,"pageNum":1,"loading":"false"}) \
                .with_jmespath("body.data.list[0].id","ids") \
                .validate() \
                .assert_equal("status_code", 200).assert_equal("body.message", "success")
        # todo:   contruct_request_step is put into the execution step. If there are multiple steps, they need to be separated by commas
        create_out_of_warranty_payment_step = contruct_request_step(
        # todo:   perform_ requests_ and_ get_ last_ Put the response into the use case that needs to be executed. Similarly, if there are multiple, they need to be separated by commas
        res = perform_requests_and_get_last_response(
        id = res['res_data']['list'][0]['id'] # todo: take out the response value of the interface response and get it to the dependent interface for use. Because of the encapsulated method, the external body of response is res_data, so you need to add
    @allure.story("Service station: parts information management query")
    def test_Search_Parts_Service_Station(self):
        create_out_of_warranty_payment_run_request = \
                "Accessory information management", "api/common/partsInfo/sparepart/v1/getSparePartByPage",
                {"status": 1, "pageSize": 10, "pageNum": 1, "loading": "false"}) \
                .validate() \
                .assert_equal("status_code", 200).assert_equal("body.message", "success")
        create_out_of_warranty_payment_step = contruct_request_step(
        res = perform_requests_and_get_last_response(

Last run file method:
1. Right click the file to run

2. Click the green triangle on the left side of the method to execute a single use case

3. Run with command:

pytest [filename]

You can also use hrun [filename]

If you want to run all the use cases under the whole file set, you can directly pytest [dirname]

Locally generated allure Report

pytest xxxx --alluredir ./report     # todo: xxx is the name of the hrun file or the name of the folder. Generate allure result set

allure serve report    # todo: view the allure report locally (the console will give the url address)

allure generate ./report/ -o ./reports --clean  # todo: clear the historical allure result set and add an allure report under the reports folder

jenkins configuring pytest+httprunner

1. To install the allure plug-in on jenkins:
Jenkins system management - global tool configuration - Allure Commandline add configuration
Check automatic installation, select from maven central, and select the latest version, which is currently 2.7

2. Configure job
New task: free style software project

2. Enter job configuration

Configure git
Repository URL: git address. Remember to add it after it git
Credentials: pull git code credentials

Click the [add] button to enter the jenkins add voucher pop-up window

**Branches to build: * * for branches, fill in * / master, master branch. If necessary, fill in other branches

cron timing configuration

Just click the question mark and see the help. It is set here to build a job at 6 a.m. every day

shell build
Select Execute shell here and execute with shell command. This is because Jenkins pulls the code in a fixed In the jenkins/workspace directory, the ${WORKSPACE} variable points to this address.
Finally save it!

Post build actions: after the action is built, click the add post build action option and select allow. The name filled in the path of Results should be the same as the name after ${WORKSPACE}, otherwise the report content is empty.

Run Jenkins

You can view the new task on the home page and click the small icon on the far right to build it. You can also click name to enter the task and click start construction. Click Allure Report to view the test results of this run.

Detailed Jenkins configuration: https://blog.csdn.net/weixin_42923777/article/details/102551493?ops_request_misc=&request_id=&biz_id=102&utm_term=jenkins%E9%85%8D%E7%BD%AEpytest +allure&utm_ medium=distribute. pc_ search_ result. none-task-blog-2allsobaiduweb~default-2-102551493. pc_ search_ result_ positive&spm=1018.2226.3001.4187

Keywords: Python software testing API testing

Added by HoangLong on Thu, 17 Feb 2022 14:59:52 +0200