Macaca实战之二：自动化框架基础，超详细

首先，我先安装依赖，并介绍下大体框架。

其次，我进行框架模块的详细介绍。

再次，我介绍编写代码的流程。

最后，我介绍整体的框架运行。

一、安装依赖和打包

1、安装依赖

pip3 install nnlog

pip3 install pymysql

pip3 install redis

pip3 install faker

pip3 install yagmail

pip3 install macaca

pip3 install retrying

安装BeautifulReport（用于生成报告用的）

下载BeautifulReport.zip，把解压后的二级BeautifulReport文件夹放在python3 site_packages下面

2、打包

设置开发者账户和Bundle ID

编辑规划

 打包之前把之前的包删除掉，当然没有的话，就不用删除了

app_name:

3、配置IOS真机驱动

安装真机驱动

DEVELOPMENT_TEAM_ID=R6B565DTM npm i macaca-ios -g

 按照配置app-inspector时的步骤对macaca-ios下的XCTestWD.xcodeproj进行操作。

注意：修改Bundle Identifier和app_name 要区别于app-inspector，避免安装在同一手机出现冲突。

完成后，关闭XCODE就可以了。

 

二、大体框架：

 app：安装的放置路径

common：公共使用的文件夹

common.logger.py：日志模块

common.run_server.py：运行Macaca的模块

common.settings.py：变量和配置模块

files：放置log，报告，截图的文件夹

model：公共的模式/模板/方法的文件夹

model.appunit：编写公共测试类文件，它会调用公共驱动文件来初始化WebDriver服务器

model.base.py：编写基础类文件，它接收页面UI对象中的定位字典，再根据字典内容返回查找到的元素

model.driver.py：编写公共驱动文件，它可以根据platform参数去调用对应平台的驱动

page：页面文件夹

page.page_ui_object：放置页面元素的文件夹，把每一个页面定位到的元素，写成一个.py文件，有多少个页面，就写多少个.py

page.page_object：：放置对页面元素操作的文件夹，对页面的每个元素的动作，写成一个.py文件，和page_ui_object一一对应

test_case：测试用例的文件夹

venv：虚拟环境，也可以不用，使用的化，可以百度搜索下，很简单

globalver.py：配置IOS和Android的参数，由于经常修改，单独拿出来

run_all_test.py：运行测试用例的文件

 

二、框架模块的详细介绍

1、common模块（共用模块）

1.1、common.logger.py（日志模块）

import logging, time
import os

cur_path = os.path.dirname(os.path.realpath(__file__))# 执行的.py对应的当前文件夹的路径
log_path = os.path.join(os.path.dirname(cur_path), 'files/logs')# log_path是存放日志的路径，os.path.dirname()上一级文件夹的路径
if not os.path.exists(log_path): os.mkdir(log_path)# 如果不存在这个logs文件夹，就自动创建一个

class Log():
    def __init__(self):#初始化类自己的变量
        self.logname = os.path.join(log_path, '%s.log' % time.strftime('%Y-%m-%d %H_%M_%S'))# 文件的命名
        self.logger = logging.getLogger()#每个logger对象都有一个名称，比如创建一个test的logger，logging.getLogger('test')
        self.logger.setLevel(logging.DEBUG)#设置logger的等级
        # 日志输出格式
        # 日志格式:                             时间             python文件       级别            日志信息
        self.formatter = logging.Formatter('[%(asctime)s] - %(filename)s] - %(levelname)s: %(message)s')

    def __console(self, level, message):
        # 处理器handles,可以指定日志输出到控制台，还是输出到文件
        # 创建一个FileHandler，用于写到本地文件
        # fh = logging.FileHandler(self.logname, 'a')  #追加模式,这个是python2的
        fh = logging.FileHandler(self.logname, 'a', encoding='utf-8')  #这个是python3的
        fh.setLevel(logging.DEBUG)  #设置级别，可以收集DEBUG级别以上的日志
        fh.setFormatter(self.formatter)    #设置格式
        self.logger.addHandler(fh)    #加入到处理器执行

        # 创建一个StreamHandler,用于输出到控制台
        ch = logging.StreamHandler()
        ch.setLevel(logging.DEBUG)
        ch.setFormatter(self.formatter)
        self.logger.addHandler(ch)

        if level == 'info':
            self.logger.info(message)
        elif level == 'debug':
            self.logger.debug(message)
        elif level == 'warning':
            self.logger.warning(message)
        elif level == 'error':
            self.logger.error(message)
        # 这两行代码是为了避免日志输出重复问题
        self.logger.removeHandler(ch)
        self.logger.removeHandler(fh)
        # 关闭打开的文件
        fh.close()

    def debug(self, message):
        self.__console('debug', message)

    def info(self, message):
        self.__console('info', message)

    def warning(self, message):
        self.__console('warning', message)

    def error(self, message):
        self.__console('error', message)

# 打开下面的注释可以测试下
# if __name__ == "__main__":
#     log = Log()
#     log.info("---测试开始----")
#     log.info("操作步骤1,2,3")
#     log.warning("----测试结束----")

1.2、BeautifulReport.py（报告模块）

此模块在python的site-packages中，报告和日志不分家，所以放在一起说了。

import os
import sys
from io import StringIO as StringIO
import time
import json
import unittest
import platform
import base64
from distutils.sysconfig import get_python_lib
import traceback
from functools import wraps

__all__ = ['BeautifulReport']

#图片显示模板
HTML_IMG_TEMPLATE = """
    < a href=" ">
    < img src="data:image/png;base64, {}" width="800px" height="500px"/>
    
    


"""


class OutputRedirector(object):
    """ Wrapper to redirect stdout or stderr """
    
    def __init__(self, fp):
        self.fp = fp
    
    def write(self, s):
        self.fp.write(s)    #把str写到文件中
    
    def writelines(self, lines):
        self.fp.writelines(lines)    #内容全部写到文件中(多行一次性写入)
    
    def flush(self):
        self.fp.flush()    #把缓冲区的内容写入硬盘


stdout_redirector = OutputRedirector(sys.stdout)    #标准输出
stderr_redirector = OutputRedirector(sys.stderr)    #错误输出

SYSSTR = platform.system()    #返回当前操作系统的名字
SITE_PAKAGE_PATH = get_python_lib()    #查看python的site-packages路径

FIELDS = {
    "testPass": 0,
    "testResult": [
    ],
    "testName": "",
    "testAll": 0,
    "testFail": 0,
    "beginTime": "",
    "totalTime": "",
    "testSkip": 0
}


class PATH:
    """ all file PATH meta """
    config_tmp_path = SITE_PAKAGE_PATH + '/BeautifulReport/template/template' #报告html模版


class MakeResultJson:
    """ make html table tags 制作HTML表格标记"""
    
    def __init__(self, datas: tuple):
        """
        init self object
        :param datas: 拿到所有返回数据结构
        """
        self.datas = datas
        self.result_schema = {}

    
    def __setitem__(self, key, value):
        """
        
        :param key: self[key]
        :param value: value
        :return:
        """
        self[key] = value
    
    def __repr__(self) -> str:
        """
            返回对象的html结构体
        :rtype: dict
        :return: self的repr对象, 返回一个构造完成的tr表单
        """
        keys = (
            'className',
            'methodName',
            'description',
            'spendTime',
            'status',
            'log',
        )
        for key, data in zip(keys, self.datas):#zip()打包为元组的列表

            self.result_schema.setdefault(key, data)

        print (keys)
        print (self.datas)
        print (json.dumps(self.result_schema))
        #上面三行打印的结果如下
        '''
        ('className', 'methodName', 'description', 'spendTime', 'status', 'log')
        ('Test_SNB_Regression', 'test_00_enter_jlc', '进入到App的未登陆页面', '25.2
        {"className": "Test_SNB_Regression", "methodName": "test_00_enter_jlc", ".....
        '''
        #由上面可以看出，我们的理解思路上先找出self.datas怎么生成的，然后keys和self.datas再组      合成字典
        return json.dumps(self.result_schema)


class ReportTestResult(unittest.TestResult):
    """ override"""
    
    def __init__(self, suite, stream=sys.stdout):
        """ pass """
        super(ReportTestResult, self).__init__()
        self.begin_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
        self.start_time = 0
        self.stream = stream
        self.end_time = 0
        self.failure_count = 0
        self.error_count = 0
        self.success_count = 0
        self.skipped = 0
        self.verbosity = 1
        self.success_case_info = []
        self.skipped_case_info = []
        self.failures_case_info = []
        self.errors_case_info = []
        self.all_case_counter = 0
        self.suite = suite
        self.status = ''
        self.result_list = []
        self.case_log = ''
        self.default_report_name = '自动化测试报告'
        self.FIELDS = None
        self.sys_stdout = None
        self.sys_stderr = None
        self.outputBuffer = None
    
    @property
    def success_counter(self) -> int:
        """ set success counter """
        return self.success_count
    
    @success_counter.setter
    def success_counter(self, value) -> None:
        """
            success_counter函数的setter方法, 用于改变成功的case数量
        :param value: 当前传递进来的成功次数的int数值
        :return:
        """
        self.success_count = value
    
    def startTest(self, test) -> None:
        """
            当测试用例测试即将运行时调用
        :return:
        """
        unittest.TestResult.startTest(self, test)
        self.outputBuffer = StringIO()
        stdout_redirector.fp = self.outputBuffer
        stderr_redirector.fp = self.outputBuffer
        self.sys_stdout = sys.stdout
        self.sys_stdout = sys.stderr
        sys.stdout = stdout_redirector
        sys.stderr = stderr_redirector
        self.start_time = time.time()
    
    def stopTest(self, test) -> None:
        """
            当测试用力执行完成后进行调用
        :return:
        """
        self.end_time = '{0:.3} s'.format((time.time() - self.start_time))
        self.result_list.append(self.get_all_result_info_tuple(test))
        self.complete_output()
    
    def complete_output(self):
        """
        Disconnect output redirection and return buffer.
        Safe to call multiple times.
        """
        if self.sys_stdout:
            sys.stdout = self.sys_stdout
            sys.stderr = self.sys_stdout
            self.sys_stdout = None
            self.sys_stdout = None
        return self.outputBuffer.getvalue()
    
    def stopTestRun(self, title=None) -> dict:
        """
            所有测试执行完成后, 执行该方法
        :param title:
        :return:
        """
        FIELDS['testPass'] = self.success_counter
        for item in self.result_list:
            item = json.loads(str(MakeResultJson(item)))
            FIELDS.get('testResult').append(item)
        FIELDS['testAll'] = len(self.result_list)
        FIELDS['testName'] = title if title else self.default_report_name
        FIELDS['testFail'] = self.failure_count
        FIELDS['beginTime'] = self.begin_time
        end_time = int(time.time())
        start_time = int(time.mktime(time.strptime(self.begin_time, '%Y-%m-%d %H:%M:%S')))
        FIELDS['totalTime'] = str(end_time - start_time) + 's'
        FIELDS['testError'] = self.error_count
        FIELDS['testSkip'] = self.skipped
        self.FIELDS = FIELDS
        return FIELDS
    
    def get_all_result_info_tuple(self, test) -> tuple:
        """
            接受test 相关信息, 并拼接成一个完成的tuple结构返回
        :param test:
        :return:
        """
        return tuple([*self.get_testcase_property(test), self.end_time, self.status, self.case_log])
    
    @staticmethod
    def error_or_failure_text(err) -> str:
        """
            获取sys.exc_info()的参数并返回字符串类型的数据, 去掉t6 error
        :param err:
        :return:
        """
        return traceback.format_exception(*err)
    
    def addSuccess(self, test) -> None:
        """
            pass
        :param test:
        :return:
        """
        logs = []
        output = self.complete_output()
        logs.append(output)
        if self.verbosity > 1:
            sys.stderr.write('ok ')
            sys.stderr.write(str(test))
            sys.stderr.write('\n')
        else:
            sys.stderr.write('.')
        self.success_counter += 1
        self.status = '成功'
        self.case_log = output.split('\n')
        self._mirrorOutput = True  # print(class_name, method_name, method_doc)



    
    def addError(self, test, err):
        """
            add Some Error Result and infos
        :param test:
        :param err:
        :return:
        """
        logs = []
        output = self.complete_output()
        logs.append(output)
        logs.extend(self.error_or_failure_text(err))
        self.failure_count += 1
        self.add_test_type('失败', logs)
        if self.verbosity > 1:
            sys.stderr.write('F  ')
            sys.stderr.write(str(test))
            sys.stderr.write('\n')
        else:
            sys.stderr.write('F')
        
        self._mirrorOutput = True
    
    def addFailure(self, test, err):
        """
            add Some Failures Result and infos
        :param test:
        :param err:
        :return:
        """
        logs = []
        output = self.complete_output()
        logs.append(output)
        logs.extend(self.error_or_failure_text(err))
        self.failure_count += 1
        self.add_test_type('失败', logs)
        if self.verbosity > 1:
            sys.stderr.write('F  ')
            sys.stderr.write(str(test))
            sys.stderr.write('\n')
        else:
            sys.stderr.write('F')
        
        self._mirrorOutput = True
    
    def addSkip(self, test, reason) -> None:
        """
            获取全部的跳过的case信息
        :param test:
        :param reason:
        :return: None
        """
        logs = [reason]
        self.complete_output()
        self.skipped += 1
        self.add_test_type('跳过', logs)
        
        if self.verbosity > 1:
            sys.stderr.write('S  ')
            sys.stderr.write(str(test))
            sys.stderr.write('\n')
        else:
            sys.stderr.write('S')
        self._mirrorOutput = True
    
    def add_test_type(self, status: str, case_log: list) -> None:
        """
            abstruct add test type and return tuple
        :param status:
        :param case_log:
        :return:
        """
        self.status = status
        self.case_log = case_log
    
    @staticmethod
    def get_testcase_property(test) -> tuple:
        """
            接受一个test, 并返回一个test的class_name, method_name, method_doc属性
        :param test:
        :return: (class_name, method_name, method_doc) -> tuple
        """
        class_name = test.__class__.__qualname__
        method_name = test.__dict__['_testMethodName']
        method_doc = test.__dict__['_testMethodDoc']
        return class_name, method_name, method_doc


class BeautifulReport(ReportTestResult, PATH):
    img_path = 'img/' if platform.system() != 'Windows' else 'img\\'
    
    def __init__(self, suites):
        super(BeautifulReport, self).__init__(suites)
        self.suites = suites
        self.log_path = None
        self.title = '自动化测试报告'
        self.filename = 'report.html'

    def report(self, description, filename: str = None, log_path='.'):
        """
            生成测试报告,并放在当前运行路径下
        :param log_path: 生成report的文件存储路径
        :param filename: 生成文件的filename
        :param description: 生成文件的注释
        :return:
        """
        if filename:
            self.filename = filename if filename.endswith('.html') else filename + '.html'
        
        if description:
            self.title = description
        
        self.log_path = os.path.abspath(log_path)
        self.suites.run(result=self)
        self.stopTestRun(self.title)
        self.output_report()
        text = '\n测试已全部完成, 可前往{}查询测试报告'.format(self.log_path)
        print(text)
    
    def output_report(self):
        """
            生成测试报告到指定路径下
        :return:
        """
        template_path = self.config_tmp_path
        override_path = os.path.abspath(self.log_path) if \
            os.path.abspath(self.log_path).endswith('/') else \
            os.path.abspath(self.log_path) + '/'
        
        with open(template_path, 'rb') as file:
            body = file.readlines()
        with open(override_path + self.filename, 'wb') as write_file:
            for item in body:
                if item.strip().startswith(b'var resultData'):
                    head = '    var resultData = '
                    item = item.decode().split(head)
                    item[1] = head + json.dumps(self.FIELDS, ensure_ascii=False, indent=4)
                    item = ''.join(item).encode()
                    item = bytes(item) + b';\n'
                write_file.write(item)
    
    @staticmethod
    def img2base(img_path: str, file_name: str) -> str:
        """
            接受传递进函数的filename 并找到文件转换为base64格式
        :param img_path: 通过文件名及默认路径找到的img绝对路径
        :param file_name: 用户在装饰器中传递进来的问价匿名
        :return:
        """
        pattern = '/' if platform != 'Windows' else '\\'

        with open(img_path + pattern + file_name, 'rb') as file:
            data = file.read()
        return base64.b64encode(data).decode()

    def add_test_img(*pargs):
        """
            接受若干个图片元素, 并展示在测试报告中
        :param pargs:
        :return:
        """

        def _wrap(func):
            @wraps(func)
            def __wrap(*args, **kwargs):
                img_path = os.path.abspath('{}'.format(BeautifulReport.img_path))
                try:
                    result = func(*args, **kwargs)
                except Exception:
                    if 'save_img' in dir(args[0]):
                        save_img = getattr(args[0], 'save_img')
                        save_img(func.__name__)
                        data = BeautifulReport.img2base(img_path, pargs[0] + '.png')
                        print(HTML_IMG_TEMPLATE.format(data, data))
                    sys.exit(0)
                print('

')

                if len(pargs) > 1:
                    for parg in pargs:
                        print(parg + ':')
                        data = BeautifulReport.img2base(img_path, parg + '.png')
                        print(HTML_IMG_TEMPLATE.format(data, data))
                    return result
                if not os.path.exists(img_path + pargs[0] + '.png'):
                    return result
                data = BeautifulReport.img2base(img_path, pargs[0] + '.png')
                print(HTML_IMG_TEMPLATE.format(data, data))
                return result
            return __wrap
        return _wrap

上面代码返回的信息

对应代码中的：（取值）

 

对应的html报告中值为：

BeautifulReport.py具体的详细的代码，有兴趣的可以自己研究下。

 

1.3、screenshot截图存放路径

 另外：

BeautifulReport.add_test_img这个方法，只有在用例出错的情况下才会截图

 

1.4、common.run_server.py（启动macaca）

import threading #多线程模块
import os
from common import settings
#启动macaca 服务
class RunServer(threading.Thread):#继承多线程类

    def __init__(self, port):#定义构造函数
        threading.Thread.__init__(self)
        self.cmd = 'macaca server -p %s --verbose' % port

    def run(self):
        os.system(self.cmd) #相当于在cmd中执行self.cmd的命令

if __name__ == '__main__':
    runServer = RunServer(settings.MACACA_PORT)
    runServer.run() #启动服务

1.5、common.settings.py（全局变量）

import  os
import nnlog  #写日志的模块

#redis的参数信息
REDIS_INFO={
        'host':'10.103.27.209',
        'port':'6379',
        'password':'123456',
        'db':'0',
        'decode_response':'True'
}


#数据库的连接信息
MY_SQL_INFO  = {
    'host':'10.103.27.58',
    'port':3306,
    'password':"123123",
    'db':'test3_product',
    'user':'',
    'charset':'utf8',
    'autocommit':True
}

SNB_MY_SQL_INFO  = {
    'host':'10.103.27.58',
    'port':3306,
    'password':"123123",
    'db':'snb_test1_live',
    'user':'root',
    'charset':'utf8',
    'autocommit':True
}

#__file__ 代表的就是当前这个python文件
BASE_PATH = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) #取到程序的主目录
LOG_FILE = os.path.join(BASE_PATH,'files/logs','server.log')  #写日志的路径
ADB_LOGS=os.path.join(BASE_PATH,'files/android_perfor_data','abd.log')#存放abb logcat的日志
PERFOR_DATA=os.path.join(BASE_PATH,'files/android_perfor_data','status.csv')#存放内存和cpu的数据

'''
log = nnlog.Logger(file_name='my1.log', level='debug', when='D', backCount=5, interval=1)
# file_name是日志文件名
# level是日志级别，如果不传的话默认是debug级别
# when是日志文件多久生成一个，默认是按天，S 秒、M 分、 H 小时、 D 天、 W 每星期
# backCount是备份几个日志文件，默认保留5天的
# interval是间隔多久生成一个日志文件，默认是1天
'''
log = nnlog.Logger(LOG_FILE,when='S') #调用写日志的方法

#保存截图的路径
SCREENSHOT_FILE = os.path.join(BASE_PATH,'files/screenshot')

#macaca服务的端口号
MACACA_PORT=3456

#老用户手机号
OLD_PHONE=13514725830

REPORT_PATH = os.path.join(BASE_PATH, 'files/report')  # 获取测试报告存放的路径

CASE_PATH= os.path.join(BASE_PATH, 'test_case')  # 获取测试用例的路径
APP_PATH=os.path.join(BASE_PATH,'app').replace('/','//') #包的存放路径



mail_info={
    'user':'[email protected]',
    'password':'rbjzatqxcabk',
    'host':'smtp.qq.com'
}
TO=['[email protected]'] #发送给谁
CC=['[email protected]'] #抄送给谁

command = 'adb logcat -c && adb logcat | grep  \"com.laijin.simplefinance\"' #筛选简理财包的日志,清除缓存的日志，从当前运行开始打印日志

2、model模块

2.1、appunit.py（公共测试类文件,它会调用公共驱动文件来初始化WebDriver）

class AppTest(unittest.TestCase):
    """
    测试类，父类为unittest.TestCase,所有测试用例类继承的基本类
    继承unittest.TestCase的方法与各种断言
    """

    '''
    @classmethod修饰的方法setUpClass()需要通过cls参数传递当前类对象
    self和cls的区别不是强制的，只是PEP8中一种编程风格，
    slef通常用作实例方法的第一参数，cls通常用作类方法的第一参数。
    即通常用self来传递当前类对象的实例，cls传递当前类对象,比如传递cls.initDriver()。
    '''

    @classmethod
    def setUpClass(cls):
        """
        在所有测试用例运行前运行一次
        """
        cls.driver = drivers()#选择driver,并启动
        cls.initDriver()#初始化driver

    @classmethod
    def tearDownClass(cls):
        """
        在所有测试用例运行完后运行一次
        """
        cls.driver.quit()#关闭driver

    @classmethod
    @retry(stop_max_attempt_number=10, wait_random_min=1000, wait_random_max=2000)
    #需要多次重试请求的装饰器,stop_max_attempt_number重试最大次数，wait_random_max在两次调用方法停留最长时长，单位毫秒
    def initDriver(cls):
        """
        在运行测试用例前初始化
        """
        print("尝试连接服务器...")
        # 初始化WebDriver服务器
        cls.driver.init()

2.2、base.py（app元素的查找和操作）

     找到元素的基本方法是element()，例如查找id为“login”的元素：
     driver.element('id', 'login')
     但是在大多数情况下，不需要使用这个基本的方法，为了方便起见，有很多扩展方法。
     例如，查找页面上name属性为“Login failed!”的元素：
     driver.element_by_name('Login failed!')
     详细参考地址：https://blog.csdn.net/hekaiyou/article/details/79067803  
     return: WebElement对象， 此时与行为有关，比如点击元素、获取标签名或元素的内部文本

 

2.3、driver.py（不同平台的webdriver的实例化）

from macaca import WebDriver #启动macaca测试用例需要导入webdriver
import globalvar
import ui_auto_platform



def drivers(): #定义一个driver的方法
    """
    根据全局平台参数返回对应的驱动
    :return: WebDriver对象
    """
    desired_caps = {} #定义一个空字典
    if ui_auto_platform.platform == 'ios':
        # 把iOS字典的键/值对更新到desired_caps里
        desired_caps.update(globalvar.ios_capabilities)  #如果平台是ios，就把ios的配置更新到字典中
    elif ui_auto_platform.platform == 'android':
        # 把Android字典的键/值对更新到desired_caps里
        desired_caps.update(globalvar.android_capabilities)
    else:
        pass
    driver = WebDriver(desired_caps, globalvar.server_url) #初始化webdriver服务器,创建一个实例
    return driver  #driver是WebDriver的一个实例化

2.4、utils（各种小工具函数）

比如数据哭链接成功和失败的判断，数据库的增删改查，生成身份证号，生成银行卡号，生成姓名，等等

3、Page&Test_case

例子一、下面以从APP启动到首页为例子，讲解：

这时页面的流程：

流程文字描述：

启动APP后，启动页需要滑动四张图片，然后点击立即进入，APP弹出升级弹层，我们需要忽略，点击‘稍后提醒我’，APP弹出开启消息通知，我们点击‘以后再说’，APP弹出活动弹层，我们点击‘×’，这时APP进入到未登录的首页。

有了流程，那我们来设计UI自动化的处理流程。

3.1、page_ui_object

我们起个名字就叫‘进入APP首页’，going_unlogin_page_ui.py，然后把元素都记录下来。

from model.base import Base

class GoingUnloginPageUi(Base):
    """
        进入app的UI对象（PUO）
    """

    def dianjijinru_button_loc(self):
        '''
        滑动启动屏后，'点击进入'按钮
        :return:
        '''
        return self.selector({
            'ios_by': 'xpath',
            'ios_value': '//XCUIElementTypeApplication[1]/XCUIElementTypeWindow[2]/XCUIElementTypeOther[2]/XCUIElementTypeScrollView[1]/XCUIElementTypeImage[1]/XCUIElementTypeButton[1]',
            'android_by': '',
            'android_value': '',
        })

    def update_page_button_loc(self):
        '''
         升级页面弹层,'或稍后提醒我'的按钮
        :return:
        '''
        return self.selector({
            'ios_by': 'xpath',
            'ios_value': '//XCUIElementTypeApplication[1]/XCUIElementTypeWindow[2]/XCUIElementTypeOther[2]/XCUIElementTypeOther[2]/XCUIElementTypeOther[3]/XCUIElementTypeOther[1]/XCUIElementTypeButton[1]',
            'android_by': '',
            'android_value': '',
        })

    def update_page_text_loc(self):
        '''
         升级页面弹层,'或稍后提醒我'的文本，用于判断是否出现升级弹层
        :return:
        '''
        return self.selector({
            'ios_by': 'name',
            'ios_value': '或稍后提醒我',
            'android_by': '',
            'android_value': '',
        })

    def update_page_button_loc1(self):
        '''
         升级页面弹层,'立即体验'按钮
        :return:
        '''
        return self.selector({
            'ios_by': 'name',
            'ios_value': 'versionupdate button normal',
            'android_by': '',
            'android_value': '',
        })

    def message_page_loc(self):
        '''
         开启消息通知,'以后再说'按钮
        :return:
        '''
        return self.selector({
            'ios_by': 'name',
            'ios_value': '以后再说',
            'android_by': '',
            'android_value': '',
        })

    def activity_page_loc(self):
        '''
         活动弹层的关闭按钮
        :return:
        '''
        return self.selector({
            'ios_by': 'name',
            'ios_value': 'icon notification close',
            'android_by': '',
            'android_value': '',
        })

 

3.2、 page_object

上面我们把页面的元素都写清楚了，接下来是对页面元素的操作。新建py文件：going_unlogin_page.py

from page.page_ui_object.going_unlogin_page_ui import GoingUnloginPageUi

class GoingUnloginPage(GoingUnloginPageUi):

    def click_dianjijinru_page(self):
        '''
        滑动启动屏后，点击'点击进入'按钮
        :return:
        '''
        self.dianjijinru_button_loc().click()

    def click_update_page(self):
        '''
        点击升级弹层的'或稍后提醒我'按钮
        :return:
        '''
        self.update_page_button_loc().click()

    def get_update_page(self):
        '''
        获取升级弹层的'或稍后提醒我'文字
        :return:
        '''
        return self.update_page_text_loc().text

    def click_update_page1(self):
        '''
        点击升级弹层的'立即体验'按钮
        :return:
        '''
        self.update_page_loc1().click()

    def click_message_page(self):
        '''
        点击开启消息通知的'以后再说'按钮
        :return:
        '''
        self.message_page_loc().click()

    def get_message_page(self):
        '''
        获取开启消息通知的'以后再说'文字
        :return:
        '''
        return self.message_page_loc().text


    def click_activity_page(self):
        '''
        点击活动弹层的关闭按钮
        :return:
        '''
        self.activity_page_loc().click()

    def get_activity_page(self):
        '''
        获取活动弹层的文字
        :return:
        '''
        return self.activity_page_loc().text

 

3.3、Test_case

上面把页面元素和对元素的操作都写完了，下面就是要编写用例了。按照流程看下面的代码，一目了然。

from BeautifulReport import BeautifulReport
from model.appunit import AppTest
from common.logger import Log
import os,time
from page.page_object.going_unlogin_page import GoingUnloginPage


class Test_SNB_Regression(AppTest):
    '''拾年宝UI自动化ios测试'''
    log = Log()
    def save_img(self, img_name):
        """
            传入一个img_name, 并存储到默认的文件路径下
        :param img_name:
        :return:
        """
        self.driver.save_screenshot('{}/{}'.format(os.path.abspath(BeautifulReport.img_path), img_name))
    @BeautifulReport.add_test_img('enter_jlc_iOS.png')
    def test_00_enter_jlc(self):
        '''进入到简理财App的未登陆页面'''

        self.log.info('----进入到简理财App的未登陆页面测试 ： start！----')
        Going_Unlogin_Page_Po = PageLayer(self.driver)
        self.log.info('开始进入到App')
        time.sleep(10)
        expected='通过'#判断用例是否通过

        # 向左滑动四次屏幕
        try:
            self.log.info('向左滑动四次屏幕')
            for i in range(4):
                Going_Unlogin_Page_Po.swipe_left_android(duration=1)
                time.sleep(1)
            time.sleep(2)
        except Exception as msg:
            self.log.info('向左滑动四次屏幕时出现异常：%s'%str(msg).strip())
            self.log.info('FAIL')
            expected = '失败'
        else:
            self.log.info('向左滑动四次屏幕进入到立即进入的页面  PASS')


        time.sleep(5)

        try:
            self.log.info('屏幕滑动完，点击立即进入')
            Going_Unlogin_Page_Po.click_dianjijinru_page()
            time.sleep(5)
        except Exception as msg:
            self.log.info('屏幕滑动完，点击立即进入：%s' % str(msg).strip())
            self.log.info('FAIL')
            expected = '失败'
        else:
            self.log.info('屏幕滑动完，点击立即进入  PASS')


        if self.driver.element_if_exists('name','或稍后提醒我'):

            try:
                self.log.info('检测升级弹层,点击或稍后提醒我')
                Going_Unlogin_Page_Po.click_update_page()
                time.sleep(5)
            except Exception as msg:
                self.log.info('检测升级弹层,点击或稍后提醒我：%s' % str(msg).strip())
                self.log.info('FAIL')
                expected = '失败'
            else:
                self.log.info('检测升级弹层,点击或稍后提醒我  PASS')

        if self.driver.element_if_exists('name','以后再说'):

            try:
                self.log.info('检测开启消息通知弹层,点击以后再说')
                Going_Unlogin_Page_Po.click_message_page()
                time.sleep(5)
            except Exception as msg:
                self.log.info('检测开启消息通知弹层,点击以后再说：%s' % str(msg).strip())
                self.log.info('FAIL')
                expected = '失败'
            else:
                self.log.info('检测开启消息通知弹层,点击以后再说  PASS')

        if self.driver.element_if_exists('name','icon notification close'):

            try:
                self.log.info('检测活动弹层,点击关闭按钮')
                Going_Unlogin_Page_Po.click_activity_page()
                time.sleep(5)
            except Exception as msg:
                self.log.info('检测活动弹层,点击关闭按钮：%s' % str(msg).strip())
                self.log.info('FAIL')
                expected = '失败'
            else:
                self.log.info('检测活动弹层,点击关闭按钮  PASS')


        self.assertEqual(expected,'通过')

至此，一条进入APP的测试用例写完了。

4、run_test.py（启动测试用例）

import os
import sys
import unittest
import time
from common.settings import REPORT_PATH,CASE_PATH
from model.utils import send_mail
from ui_auto_platform import platform

import BeautifulReport

sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))  #把当前的文件目录加入到sys.path中，在别的机器上可以正常执行

timestr=time.strftime('%Y-%m-%d %H-%M-%S')




def run(timestr=None):
    # 如果是Android的平台就执行snb文件
    if platform=='android':

        tests = unittest.defaultTestLoader.discover(CASE_PATH,'snb.py')#自动查找CASE_PATH路径下的.py文件
    else:
        tests = unittest.defaultTestLoader.discover(CASE_PATH, 'snb_ios.py')

    runner = BeautifulReport.BeautifulReport(tests)
    today = time.strftime('%Y-%m-%d %H-%M-%S')
    if timestr:
        file_name='uiauto_report' + timestr + '.html'
    else:
        file_name = 'uiauto_report' + timestr + '.html'
    runner.report('ui自动化测试报告-%s'%today,filename=file_name,log_path=REPORT_PATH)
    #发邮件的内容
    count_info = {
        'pass_count':runner.success_count,
        'fail_count':runner.failure_count,
        'all_count':runner.success_count+runner.failure_count
    }
    abs_file_path = os.path.join(REPORT_PATH,file_name)
    send_mail(count_info,abs_file_path)#发邮件



if __name__ == '__main__':
    run(timestr=timestr)