第一步:准备测试数据/编写测试用例
测试数据
第二步:准备公共文件放在Common文件夹下
1.配置文件操作
handle_config文件
```python
from configparser import ConfigParser
import os
from Commom.handle_path import conf_dir
class HandleConfig(ConfigParser):
def __init__(self,file_path):
super().__init__()
self.read(file_path, encoding="utf-8")
file_path = os.path.join(conf_dir,'nmb.ini')
conf = HandleConfig(file_path)
print(conf.get('log','name'))
2.excel文件操作
handle_excel
"""
excel类，你的需求是实现是什么?
1、读取表头
2、读取数据 - 读取表头以外的所有数据。 - 返回值：列表，成员是每一行数据
初始化工作？ 加载一个excel,打开一个表单。
"""
from openpyxl import load_workbook
import json
class HandleExcel:
def __init__(self,file_path,sheet_name):
self.wb = load_workbook(file_path)
self.sh = self.wb[sheet_name]
def __read_titles(self):
titles = []
for item in list(self.sh.rows)[0]: # 遍历第1行当中每一列
titles.append(item.value)
return titles
def read_all_datas(self):
all_datas = []
titles = self.__read_titles()
for item in list(self.sh.rows)[1:]: # 遍历数据行
values = []
for val in item: # 获取每一行的值
values.append(val.value)
res = dict(zip(titles, values)) # title和每一行数据，打包成字典
# 将请求数据从json字符串转换为字典对象
res['request_data'] = json.loads(res['request_data'])
all_datas.append(res)
return all_datas
def close_file(self):
self.wb.close()
if __name__ == '__main__':
import os
file_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "login_cases.xlsx")
exc = HandleExcel(file_path,"login")
cases = exc.read_all_datas()
exc.close_file()
for case in cases:
print(case)
3.requests请求操作
handle_requests
"""
基于项目做定制化封装
1、鉴权:token
2、项目通用的请求头:
{"X-Lemonban-Media-Type": "lemonban.v2"}
3、请求体格式：application/json
"""
import requests
from Commom.my_logger import logger
def __handle_header(token=None):
"""
处理请求头。加上项目当中必带的请求头。如果有token，加上token。
:param token: token值
:return: 处理之后headers字典
"""
headers = {"X-Lemonban-Media-Type": "lemonban.v2",
"Content-Type":"application/json"}
if token:
headers["Authorization"] = "Bearer {}".format(token)
return headers
#
def send_requests(method,url,data=None,token=None):
# 得到请求头
logger.info('发起一次HTTP请求')
headers = __handle_header(token)
logger.info('请求头为:{}'.format(headers))
logger.info('请求方法为:{}'.format(method))
logger.info('请求url为:{}'.format(url))
logger.info('请求数据为:{}'.format(data))
# 根据请求类型，调用请求方法
method = method.upper() # 大写处理
if method == "GET":
resp = requests.get(url,data,headers=headers)
else:
resp = requests.post(url,json=data,headers=headers)
logger.info('响应状态码为:{}'.format(resp.status_code))
logger.info('响应数据为:{}'.format(resp.json()))
return resp
if __name__ == '__main__':
login_url = "http://api.lemonban.com/futureloan/member/login"
login_datas = {"mobile_phone": "13845467789", "pwd": "1234567890"}
resp = send_requests("POST",login_url,login_datas)
token = resp.json()["data"]["token_info"]["token"]
recharge_url = "http://api.lemonban.com/futureloan/member/recharge"
recharge_data = {"member_id": 200119, "amount": 2000}
resp = send_requests("POST",recharge_url,recharge_data,token)
print(resp.json())
4.日志文件操作
my_logger
import logging
import os
from Commom.handle_config import conf
from Commom.handle_path import logs_dir
class MyLogger(logging.Logger):
def __init__(self,file=None):
# 设置输出级别、输出渠道、输出日志格式
# super().__init__(name,level)
super().__init__(conf.get("log","name"),conf.get("log","level"))
# 日志格式
fmt = '%(asctime)s %(name)s %(levelname)s %(filename)s-%(lineno)d line：%(message)s'
formatter = logging.Formatter(fmt)
# 控制台渠道
handle1 = logging.StreamHandler()
handle1.setFormatter(formatter)
self.addHandler(handle1)
if file:
# 文件渠道
handle2 = logging.FileHandler(file,encoding="utf-8")
handle2.setFormatter(formatter)
self.addHandler(handle2)
# 是否需要写入文件
if conf.getboolean("log","file_ok"):
file_name = os.path.join(logs_dir,conf.get("log","file_name"))
else:
file_name = None
# logger = MyLogger(conf.get("log","name"),conf.get("log","level"),file_name)
logger = MyLogger(file_name)
# logger.info('1111111111')
5.ddt操作
# -*- coding: utf-8 -*-
# This file is a part of DDT (https://github.com/txels/ddt)
# Copyright 2012-2015 Carles Barrobés and DDT contributors
# For the exact contribution history, see the git revision log.
# DDT is licensed under the MIT License, included in
# https://github.com/txels/ddt/blob/master/LICENSE.md
import inspect
import json
import os
import re
import codecs
from functools import wraps
try:
import yaml
except ImportError: # pragma: no cover
_have_yaml = False
else:
_have_yaml = True
__version__ = '1.2.1'
# These attributes will not conflict with any real python attribute
# They are added to the decorated test method and processed later
# by the `ddt` class decorator.
DATA_ATTR = '%values' # store the data the test must run with
FILE_ATTR = '%file_path' # store the path to JSON file
UNPACK_ATTR = '%unpack' # remember that we have to unpack values
index_len = 5 # default max length of case index
try:
trivial_types = (type(None), bool, int, float, basestring)
except NameError:
trivial_types = (type(None), bool, int, float, str)
def is_trivial(value):
if isinstance(value, trivial_types):
return True
elif isinstance(value, (list, tuple)):
return all(map(is_trivial, value))
return False
def unpack(func):
"""
Method decorator to add unpack feature.
"""
setattr(func, UNPACK_ATTR, True)
return func
def data(*values):
"""
Method decorator to add to your test methods.
Should be added to methods of instances of ``unittest.TestCase``.
"""
global index_len
index_len = len(str(len(values)))
return idata(values)
def idata(iterable):
"""
Method decorator to add to your test methods.
Should be added to methods of instances of ``unittest.TestCase``.
"""
def wrapper(func):
setattr(func, DATA_ATTR, iterable)
return func
return wrapper
def file_data(value):
"""
Method decorator to add to your test methods.
Should be added to methods of instances of ``unittest.TestCase``.
``value`` should be a path relative to the directory of the file
containing the decorated ``unittest.TestCase``. The file
should contain JSON encoded data, that can either be a list or a
dict.
In case of a list, each value in the list will correspond to one
test case, and the value will be concatenated to the test method
name.
In case of a dict, keys will be used as suffixes to the name of the
test case, and values will be fed as test data.
"""
def wrapper(func):
setattr(func, FILE_ATTR, value)
return func
return wrapper
def mk_test_name(name, value, index=0):
"""
Generate a new name for a test case.
It will take the original test name and append an ordinal index and a
string representation of the value, and convert the result into a valid
python identifier by replacing extraneous characters with ``_``.
We avoid doing str(value) if dealing with non-trivial values.
The problem is possible different names with different runs, e.g.
different order of dictionary keys (see PYTHONHASHSEED) or dealing
with mock objects.
Trivial scalar values are passed as is.
A "trivial" value is a plain scalar, or a tuple or list consisting
only of trivial values.
"""
# Add zeros before index to keep order
index = "{0:0{1}}".format(index + 1, index_len)
if not is_trivial(value):
return "{0}_{1}".format(name, index)
try:
value = str(value)
except UnicodeEncodeError:
# fallback for python2
value = value.encode('ascii', 'backslashreplace')
test_name = "{0}_{1}_{2}".format(name, index, value)
return re.sub(r'\W|^(?=\d)', '_', test_name)
def feed_data(func, new_name, test_data_docstring, *args, **kwargs):
"""
This internal method decorator feeds the test data item to the test.
"""
@wraps(func)
def wrapper(self):
return func(self, *args, **kwargs)
wrapper.__name__ = new_name
wrapper.__wrapped__ = func
# set docstring if exists
if test_data_docstring is not None:
wrapper.__doc__ = test_data_docstring
else:
# Try to call format on the docstring
if func.__doc__:
try:
wrapper.__doc__ = func.__doc__.format(*args, **kwargs)
except (IndexError, KeyError):
# Maybe the user has added some of the formating strings
# unintentionally in the docstring. Do not raise an exception
# as it could be that user is not aware of the
# formating feature.
pass
return wrapper
def add_test(cls, test_name, test_docstring, func, *args, **kwargs):
"""
Add a test case to this class.
The test will be based on an existing function but will give it a new
name.
"""
setattr(cls, test_name, feed_data(func, test_name, test_docstring,
*args, **kwargs))
def process_file_data(cls, name, func, file_attr):
"""
Process the parameter in the `file_data` decorator.
"""
cls_path = os.path.abspath(inspect.getsourcefile(cls))
data_file_path = os.path.join(os.path.dirname(cls_path), file_attr)
def create_error_func(message): # pylint: disable-msg=W0613
def func(*args):
raise ValueError(message % file_attr)
return func
# If file does not exist, provide an error function instead
if not os.path.exists(data_file_path):
test_name = mk_test_name(name, "error")
test_docstring = """Error!"""
add_test(cls, test_name, test_docstring,
create_error_func("%s does not exist"), None)
return
_is_yaml_file = data_file_path.endswith((".yml", ".yaml"))
# Don't have YAML but want to use YAML file.
if _is_yaml_file and not _have_yaml:
test_name = mk_test_name(name, "error")
test_docstring = """Error!"""
add_test(
cls,
test_name,
test_docstring,
create_error_func("%s is a YAML file, please install PyYAML"),
None
)
return
with codecs.open(data_file_path, 'r', 'utf-8') as f:
# Load the data from YAML or JSON
if _is_yaml_file:
data = yaml.safe_load(f)
else:
data = json.load(f)
_add_tests_from_data(cls, name, func, data)
def _add_tests_from_data(cls, name, func, data):
"""
Add tests from data loaded from the data file into the class
"""
for i, elem in enumerate(data):
if isinstance(data, dict):
key, value = elem, data[elem]
test_name = mk_test_name(name, key, i)
elif isinstance(data, list):
value = elem
test_name = mk_test_name(name, value, i)
if isinstance(value, dict):
add_test(cls, test_name, test_name, func, **value)
else:
add_test(cls, test_name, test_name, func, value)
def _is_primitive(obj):
"""Finds out if the obj is a "primitive". It is somewhat hacky but it works.
"""
return not hasattr(obj, '__dict__')
def _get_test_data_docstring(func, value):
"""Returns a docstring based on the following resolution strategy:
1. Passed value is not a "primitive" and has a docstring, then use it.
2. In all other cases return None, i.e the test name is used.
"""
if not _is_primitive(value) and value.__doc__:
return value.__doc__
else:
return None
def ddt(cls):
"""
Class decorator for subclasses of ``unittest.TestCase``.
Apply this decorator to the test case class, and then
decorate test methods with ``@data``.
For each method decorated with ``@data``, this will effectively create as
many methods as data items are passed as parameters to ``@data``.
The names of the test methods follow the pattern
``original_test_name_{ordinal}_{data}``. ``ordinal`` is the position of the
data argument, starting with 1.
For data we use a string representation of the data value converted into a
valid python identifier. If ``data.__name__`` exists, we use that instead.
For each method decorated with ``@file_data('test_data.json')``, the
decorator will try to load the test_data.json file located relative
to the python file containing the method that is decorated. It will,
for each ``test_name`` key create as many methods in the list of values
from the ``data`` key.
"""
for name, func in list(cls.__dict__.items()):
if hasattr(func, DATA_ATTR):
for i, v in enumerate(getattr(func, DATA_ATTR)):
test_name = mk_test_name(name, getattr(v, "__name__", v), i)
# 将用例的描述信息，改为用例数据的title字段
test_data_docstring = v["title"]
if hasattr(func, UNPACK_ATTR):
if isinstance(v, tuple) or isinstance(v, list):
add_test(
cls,
test_name,
test_data_docstring,
func,
*v
)
else:
# unpack dictionary
add_test(
cls,
test_name,
test_data_docstring,
func,
**v
)
else:
add_test(cls, test_name, test_data_docstring, func, v)
delattr(cls, name)
elif hasattr(func, FILE_ATTR):
file_attr = getattr(func, FILE_ATTR)
process_file_data(cls, name, func, file_attr)
delattr(cls, name)
return cls
6.路径操作
handle_path
import os
#获取项目的路径,向上两层
base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
print(base_dir)
#测试用例路径
cases_dir = os.path.join(base_dir,'TestCases')
#测试数据路径
datas_dir = os.path.join(base_dir,'TestDatas')
#测试报告路径
reports_dir = os.path.join(base_dir,'Outputs\\reports')
#日志路径
logs_dir = os.path.join(base_dir,'Outputs\\logs')
#配置文件路径
conf_dir = os.path.join(base_dir,'Conf')
第三步:将写好测试数据的excel放入TestData文件夹中
第四步:编写test_register文件,放入TestCases文件夹中
import unittest
import os
from Commom.handle_requests import send_requests
from Commom.handle_excel import HandleExcel
from Commom.myddt import ddt,data
from Commom.handle_path import datas_dir
from Commom.my_logger import logger
he = HandleExcel(datas_dir+"\\api_cases.xlsx",'注册')
cases = he.read_all_datas()
he.close_file()
@ddt
class TestRegister(unittest.TestCase):
@classmethod
def setUpClass(self) -> None:
logger.info('------注册模块用例 开始执行---------')
@classmethod
def tearDownClass(cls) -> None:
logger.info('------注册模块用例 执行结束---------')
@data(*cases)
def test_register_ok(self,case):
logger.info('***** 执行用例{}:{} *****'.format(case['id'],case['title']))
expected = eval(case['expected'])
#步骤 : 测试数据 发起请求
response = send_requests(case['method'],case['url'],case['request_data'])
logger.info('用例的期望结果为:{}'.format(case['expected']))
#断言 : code == 0 msg ==ok
try:
self.assertEqual(response.json()['code'],expected['code'])
self.assertEqual(response.json()['msg'], expected['msg'])
except AssertionError:
logger.exception('断言失败!')
第五步:创建Conf文件夹用于存放配置文件
第六步:创建Outputs文件夹存放输出文件
logs文件夹存放日志
reports文件夹存放报告
第七步:编写main文件用于执行文件
import unittest
import os
from BeautifulReport import BeautifulReport
from Commom.handle_path import cases_dir,reports_dir
#收集用例
s = unittest.TestLoader().discover(cases_dir)
#生成报告
br = BeautifulReport(s)
br.report('注册用例自动化','report.html',reports_dir)