Airtest一：批量运行脚本、汇总报告、导出报告

 

 

一、项目目录

二、各文件说明

1、air_case。需要执行的脚本air文件，例如login.air。后续直接添加该文件即可，其他的文件都不用动

 

2、export_log。该文件夹自动生成，是自动导出的日志，发给其他人的时候，直接发送该包，日志中的路径用的相对路径。可以直接找到文件

 

3、log。该文件夹自动生成，是运行中产生的log.txt文件

 

4、my_runner.py。运行case的启动器，整个demo的入口文件。【一般报错的都是这个文件】已经将这个文件改成使用导出模板的方式

 

5、report.py。生成报告入口，但是my_runner.py已经运行完case，生成了报告，无需再执行此文件

 

6、summary_template.html。汇总报告的模版，执行完case汇总的报告是根据该文件的样式产生的。

 

7、util.py。工具

 

三、运行方式

python3 my_runner.py

 

四、 说明

我的demo是基于图像识别的浏览器case，没有连接设备，执行手机的在my_runner.py将devices添加进去即可

 

五、各文件源码

 

my_runner.py文件

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2020-02-23 13:33
# @Author  : zhangxue
# @File    : my_runner.py
# @Desc    :
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from airtest.cli.runner import AirtestCase, run_script
from argparse import *
import airtest.report.report as report
import jinja2
import shutil
import os
import io


class CustomAirtestCase(AirtestCase):
    # @classmethod
    # def setUpClass(cls):
    #     super(CustomAirtestCase,cls).setUpClass()


    def setUp(self):
        print("custom setup")
        super(CustomAirtestCase, self).setUp()

    def tearDown(self):
        print("custom tearDown")
        super(CustomAirtestCase, self).setUp()

    def run_air(self, root_dir='', device=[], scriptname='air_case'):
        # 用例目录
        script_path = root_dir + "/" + scriptname
        # 聚合结果
        results = []
        # 创建log文件
        root_log = root_dir + '/' + 'log'
        if os.path.isdir(root_log):
            shutil.rmtree(root_log)
        else:
            os.makedirs(root_log)
            print(str(root_log) + '  is created')

        # 创建export_log文件
        export_log = root_dir + '/' + 'export_log'
        if os.path.isdir(export_log):
            shutil.rmtree(export_log)
        else:
            os.makedirs(export_log)
            print(str(export_log) + '  is created')

        for f in os.listdir(script_path):
            if f.endswith(".air"):
                # f为.air案例名称：login.air
                airName = f
                script = os.path.join(script_path, f)
                # airName_path为.air的全路径/Users/zhangxue/Documents/study/airtest_fppui/air_case/login.air
                print("当前运行脚本路径：" + str(script))
                # 日志存放路径和名称：/Users/zhangxue/Documents/study/airtest_fppui/log/login/log.html
                log = os.path.join(root_dir, 'log' + '/' + airName.replace('.air', ''))
                print("log路径：" + str(log))
                if os.path.isdir(log):
                    shutil.rmtree(log)
                else:
                    os.makedirs(log)
                    print(str(log) + '  is created')
                # global args
                args = Namespace(device=device, log=log, recording=None, script=script, compress=1)
                try:
                    run_script(args, AirtestCase)
                except:
                    pass
                finally:
                    export_output_file = os.path.join(export_log + "/" + airName.replace('.air', '.log') + '/log.html')
                    rpt = report.LogToHtml(script_root=script, log_root=log, export_dir=export_log)
                    rpt.report("log_template.html", output_file=export_output_file)
                    result = {}
                    result["name"] = airName.replace('.air', '')
                    result["result"] = rpt.test_result
                    results.append(result)

        # 生成聚合报告
        env = jinja2.Environment(
            loader=jinja2.FileSystemLoader(root_dir),
            extensions=(),
            autoescape=True
        )
        template = env.get_template("summary_template.html", root_dir)
        html = template.render({"results": results})
        output_file = os.path.join(export_log, "summary.html")
        with io.open(output_file, 'w', encoding="utf-8") as f:
            f.write(html)
        print(output_file)


if __name__ == '__main__':
    test = CustomAirtestCase()
    root = os.path.abspath(".")
    print("root_path路径：  " + root)

    device = ['']

    test.run_air(root)

my_runner.py文件

report.py文件

# -*- coding: utf-8 -*-

import os
import io
import types
import shutil
import json
import jinja2
from airtest.utils.compat import decode_path
import airtest.report.report as R

HTML_FILE = "log.html"
HTML_TPL = "log_template.html"
STATIC_DIR = os.path.dirname(R.__file__)

def get_parger(ap):
    ap.add_argument("script", help="script filepath")
    ap.add_argument("--outfile", help="output html filepath, default to be log.html")
    ap.add_argument("--static_root", help="static files root dir")
    ap.add_argument("--log_root", help="log & screen data root dir, logfile should be log_root/log.txt")
    ap.add_argument("--record", help="custom screen record file path", nargs="+")
    ap.add_argument("--export", help="export a portable report dir containing all resources")
    ap.add_argument("--lang", help="report language", default="en")
    ap.add_argument("--plugins", help="load reporter plugins", nargs="+")
    return ap


def get_script_info(script_path):
    script_name = os.path.basename(script_path)
    result_json = {"name": script_name, "author": None, "title": script_name, "desc": None}
    return json.dumps(result_json)


def _make_export_dir(self):
    dirpath = self.script_root
    logpath = self.script_root
    # copy static files
    for subdir in ["css", "fonts", "image", "js"]:
        dist = os.path.join(dirpath, "static", subdir)
        shutil.rmtree(dist, ignore_errors=True)
        self.copy_tree(os.path.join(STATIC_DIR, subdir), dist)

    return dirpath, logpath


def report(self, template_name, output_file=None, record_list=None):
    """替换LogToHtml中的report方法"""
    self._load()
    steps = self._analyse()
    # 修改info获取方式
    info = json.loads(get_script_info(self.script_root))

    if self.export_dir:
        self.script_root, self.log_root = self._make_export_dir()
        output_file = os.path.join(self.script_root, HTML_FILE)
        self.static_root = "static/"

    if not record_list:
        record_list = [f for f in os.listdir(self.log_root) if f.endswith(".mp4")]
    records = [os.path.join(self.log_root, f) for f in record_list]

    if not self.static_root.endswith(os.path.sep):
        self.static_root = self.static_root.replace("\", "/")
        self.static_root += "/"

    data = {}
    data['steps'] = steps
    data['name'] = os.path.basename(self.script_root)
    data['scale'] = self.scale
    data['test_result'] = self.test_result
    data['run_end'] = self.run_end
    data['run_start'] = self.run_start
    data['static_root'] = self.static_root
    data['lang'] = self.lang
    data['records'] = records
    data['info'] = info

    return self._render(template_name, output_file, **data)


def get_result(self):
    return self.test_result


def main(args):
    # script filepath
    path = decode_path(args.script)
    record_list = args.record or []
    log_root = decode_path(args.log_root) or path
    static_root = args.static_root or STATIC_DIR
    static_root = decode_path(static_root)
    export = decode_path(args.export) if args.export else None
    lang = args.lang if args.lang in ['zh', 'en'] else 'zh'
    plugins = args.plugins

    # gen html report
    rpt = R.LogToHtml(path, log_root, static_root, export_dir=export, lang=lang, plugins=plugins)
    # override methods
    rpt._make_export_dir = types.MethodType(_make_export_dir, rpt)
    rpt.report = types.MethodType(report, rpt)
    rpt.get_result = types.MethodType(get_result, rpt)

    rpt.report(HTML_TPL, output_file=args.outfile, record_list=record_list)

    return rpt.get_result()


if __name__ == "__main__":
    import argparse
    ap = argparse.ArgumentParser()
    args = get_parger(ap).parse_args()
    print(str(args) + "     111111111111111")
    basedir = os.path.dirname(os.path.realpath(__file__))
    print(basedir)
    logdir = os.path.realpath(args.script)
    print(logdir + "2222222")

    # 聚合结果
    results = []

    # 遍历所有日志
    for subdir in os.listdir(logdir):
        if os.path.isfile(os.path.join(logdir, subdir)):
            continue
        args.script = os.path.join(logdir, subdir)
        args.outfile = os.path.join(args.script, HTML_FILE)
        result = {}
        result["name"] = subdir
        result["result"] = main(args)
        results.append(result)

    # 生成聚合报告
    env = jinja2.Environment(
        loader=jinja2.FileSystemLoader(basedir),
        extensions=(),
        autoescape=True
    )
    template = env.get_template("summary_template.html")
    html = template.render({"results": results})

    output_file = os.path.join(logdir, "summary.html")
    with io.open(output_file, 'w', encoding="utf-8") as f:
        f.write(html)
    print(output_file)

summary_template.html文件

<!DOCTYPE html>
<html>
<head>
    <title>测试结果汇总</title>
    <meta charset="UTF-8">
    <style>
        .fail {
            color: red;
          7emem;
         text-align: center;
        }
        .success {
            color: green;
          7emem;
         text-align: center;
        }
      .details-col-elapsed {
          7em;
         text-align: center;
      }
      .details-col-msg {
          7em;
         text-align: center;
         background-color:#ccc;
      }

    </style>
</head>
<body>
<div>
<div><h2>Test Statistics</h2></div>

    <table width="800" border="thin" cellspacing="0" cellpadding="0">
        <tr  width="600">
            <th width="300" class='details-col-msg'>案例名称</th>
            <th class='details-col-msg'>执行结果</th>
        </tr>
        {% for r in results %}
        <tr width="600">
            <td class='details-col-elapsed'><a href="{{r.name}}.log/log.html" target="view_window">{{r.name}}</a></td>
            <td class="{{'success' if r.result else 'fail'}}">{{"成功" if r.result else "失败"}}</td>
        </tr>
        {% endfor %}
    </table>
</div>
</body>
</html>