移动端测试的学习

一.移动端测试知识概览

1.移动端测试是什么?

移动端测试是指对移动应用进行的测试,即实体的特性满足需求的程度.

2.移动端测试分类

        app功能测试

                1.业务逻辑正确性测试

                        产品文档

                2.兼容性测试

                          1.系统版本
                          2.分辨率
                          3.网络情况

                3.异常测试

                         1.热启动应用
                          2.网络切换&中断恢复
                          3.电话&信息中断恢复

                4.升级&安装卸载测试

                5.健壮性测试

                          1.手机资源消耗
                          2.流量消耗
                          3.崩溃恢复等测试

app自动化测试

        通过场景和数据的预设，把以人为驱动的测试行为转化为机器执行的一种过程

         并不是所有功能都能进行自动化

app安全测试

        通过安全测试技术，保证app尽可能的不存在安全漏洞.

市场招聘如何？

        互联网移动场景下业务的爆发，导致移动端开发和测试人员需求量增大，市场很缺移动端的人才。

二.第一阶段移动端测试环境搭建

        移动端自动化测试的基础环境配置

1.1 安装Java环境
  Android应用为例讲解，需要安装java环境
1.2 SDK环境
  Android依赖SDK的环境
1.3 模拟器环境
  考虑大家连接真机不方便，所以采用模拟器替代

三.主流的移动端自动化工具

Robotium
    1.支持语言：Java

    2.仅支持Android系统

    3.不支持跨应用
Macaca
    1.支持语言：Java，Python，Node.js

    2.支持Android和iOS系统

    3.支持跨应用
Appium
    1.支持语言：Java，C#，Python，php，perl，ruby，Node.js

    2.支持Android和iOS系统

    3.支持跨应用
自动化工具选择的关注点
    1.是否支持native，webview

    2.是否支持获取toast

    3.是否支持跨应用

四.Appium环境搭建

        Appium客户端安装

  Appium背景介绍                  

 1.官网：www.appium.io,由SauceLab公司开发

  2.Appium是由nodejs的express框架写的Http Server,Appium使用WebDriver的json wire协议，
    来驱动Apple系统的UIAutomation库、Android系统的UIAutomator框架
2.2.1.2 Appium桌面客户端安装方式

  1. 运行appium-desktop-Setup-1.2.7.exe，默认安装即可
  2. 启动客户端，按图片步骤 1 -> 2 -> 3 -> 4 设置

 启动appium界面

3. 启动成功展示如下图

 Appium-python库安装

命令行安装(需要联网)

  pip install Appium-Python-Client
安装包安装

  前提：python已安装setuptools包
  安装setuptools:
      1.解压setuptools-38.2.4.zip
      2.进入解压后文件夹执行命令: python setup.py install
      3.等待安装完成，无错误信息即可

  安装Appium-Python-Client:
      1.解压Appium-Python-Client-0.25.tar.gz
      2.进入解压后文件夹执行命令: python setup.py install
      3.等待安装完成，无错误信息即可

五.Appium入门的第一个例子

第一个例子

手机驱动对象

  驱动对象会帮助我们完成手机和脚本之间交互.
导入driver对象

  from appium import webdriver
声明手机驱动对象

    只有声明驱动对象我们才可以让手机完成脚本的操作,声明的方法如下:

    driver = webdriver.Remote('http://127.0.0.1:4723/wd/hub', desired_caps)  # 声明对象后会直接启动参数中的应用

    desired_caps: ？？？
手机启动参数
    desired_caps：负责启动服务端时的参数设置，appium server 与手机端建立会话关系时，根据这些参数服务端可以做出相应的处理
    desired_caps常用参数:
    platformName         平台的名称：iOS, Android, or FirefoxOS
    platformVersion      设备系统版本号
    deviceName           设备号 IOS：instruments -s devices，Android: adb devices
    app                  安装文件路径：/abs/path/to/my.apk or http://myapp.com/app
    appActivity          启动的Activity
    appPackage           启动的包
    unicodeKeyboard      unicode设置(允许中文输入)
    resetKeyboard        键盘设置(允许中文输入)
    # server 启动参数
    desired_caps = {}
    desired_caps['platformName'] = 'Android' 
    desired_caps['platformVersion'] = '5.1'
    desired_caps['deviceName'] = '192.168.56.101:5555'
    desired_caps['appPackage'] = 'com.android.settings'
    desired_caps['appActivity'] = '.Settings'
    desired_caps['unicodeKeyboard'] = True
    desired_caps['resetKeyboard'] = True
脚本内启动其他app
    driver.start_activity(appPackage,appActivity)
关闭app

  driver.close_app()  # 关闭当前操作的app，不会关闭驱动对象
关闭驱动对象

    driver.quit()   # 关闭驱动对象，同时关闭所有关联的app
实例代码

  from appium import webdriver

  import time

  # server 启动参数
  desired_caps = {}
  # 设备信息
  desired_caps['platformName'] = 'Android'
  desired_caps['platformVersion'] = '5.1'
  desired_caps['deviceName'] = '192.168.56.101:5555'
  # app信息
  desired_caps['appPackage'] = 'com.android.settings'
  desired_caps['appActivity'] = '.Settings'

  driver = webdriver.Remote('http://localhost:4723/wd/hub', desired_caps)

  time.sleep(5)

  driver.quit()

六.App基础操作API

完成app自动化需要一些基础条件的支持，本节将讲解APP初始化API.
1.1前置代码

  # server 启动参数

  desired_caps = {}
  desired_caps['platformName'] = 'Android' 
  desired_caps['platformVersion'] = '5.1'
  desired_caps['deviceName'] = '192.168.56.101:5555'
  desired_caps['appPackage'] = 'com.android.settings'
  desired_caps['appActivity'] = '.Settings'
  desired_caps['unicodeKeyboard'] = True
  desired_caps['resetKeyboard'] = True

  # 声明driver对象
  driver = webdriver.Remote('http://127.0.0.1:4723/wd/hub', desired_caps)
1.2安装APK到手机
    driver.install_app(app_path) 
    参数：
        app_path：脚本机器中APK文件路径
1.3手机中移除APP
  driver.remove_app(app_id) 
  参数：
      app_id：需要卸载的app包名
1.4判断APP是否已安装
  driver.is_app_installed(bundle_id) 
  参数：
      bundle_id: 可以传入app包名,返回结果为True(已安装) / False(未安装)
1.5发送文件到手机
  import base64
  data = str(base64.b64encode(data.encode('utf-8')),'utf-8')
  driver.push_file(path,data)
  参数：
      path：手机设备上的路径(例如：/sdcard/a.txt)
      data：文件内数据,要求base64编码
      Python3.x中字符都为unicode编码，而b64encode函数的参数为byte类型，需要先转码；
       生成的数据为byte类型，需要将byte转换回去。
1.6从手机中拉取文件
  import base64
  data = driver.pull_file(path) # 返回数据为base64编码
  print(str(base64.b64decode(data),'utf-8')) # base64解码
  参数：
      path: 手机设备上的路径
1.7获取当前屏幕内元素结构
  driver.page_source  
  作用：
      返回当前页面的文档结构，判断特定的元素是否存在

七.手机控件查看工具uiautomatorviewer

工具简介

  用来扫描和分析Android应用程序的UI控件的工具.
如何使用

    1.进入SDK目录下的tools目录，打开uiautomatorviewer

    2.电脑连接真机或打开android模拟器

    3.启动待测试app

    4.点击uiautomatorviewer的左上角Device Screenshot,会生成app当前页面的UI控件截图
android_appium

    5.选择截图上需要查看的控件，即可浏览该控件的id,class,text,坐标等信息
android_appium

八.APP元素定位操作

手工测试主要通过可见按钮操作，而自动化是通过元素进行交互操作.
    元素的基本定位基于当前屏幕范围内展示的可见元素。
3.3.1Appium常用元素定位方式
name    value
id    id属性值    
class    class属性值    
xpath    xpath表达式    
3.3.2.前置代码

    from appium import webdriver
    # server 启动参数
    desired_caps = {}
    # 设备信息
    desired_caps['platformName'] = 'Android'
    desired_caps['platformVersion'] = '5.1'
    desired_caps['deviceName'] = '192.168.56.101:5555'
    # app的信息
    desired_caps['appPackage'] = 'com.android.settings'
    desired_caps['appActivity'] = '.Settings'

    # 声明我们的driver对象
    driver = webdriver.Remote('http://127.0.0.1:4723/wd/hub', desired_caps)
3.3.3.通过id定位

  方法：find_element_by_id(id_value) # id_value:为元素的id属性值
  业务场景:
      1.进入设置页面
      2.通过ID定位方式点击搜索按钮
  代码实现：
      driver.find_element_by_id("com.android.settings:id/search").click()
      driver.quit()
3.3.4.通过class定位

  方法：find_element_by_class_name(class_value) # class_value:为元素的class属性值
    业务场景:
        1.进入设置页面
        2.点击搜索按钮
        3.通过class定位方式点击输入框的返回按钮
    代码实现：
        # id 点击搜索按钮
        driver.find_element_by_id("com.android.settings:id/search").click()
        # class 点击输入框返回按钮
        driver.find_element_by_class_name('android.widget.ImageButton').click()
        driver.quit()
3.3.5.通过xpath定位

  方法：find_element_by_xpath(xpath_value) # xpath_value:为可以定位到元素的xpath语句
  *** android端xptah常用属性定位：
      1. id ://*[contains(@resource-id,'com.android.settings:id/search')] 
      2. class ://*[contains(@class,'android.widget.ImageButton')]
      3. text ://*[contains(@text,'WLA')]

  *** 模糊定位 contains(@key,value): value可以是部分值
    业务场景:
        1.进入设置页面
        2.点击WLAN菜单栏
    代码实现：
        # xpath 点击WLAN按钮
        driver.find_element_by_xpath("//*[contains(@text,'WLA')]").click()
3.3.6.定位一组元素,注意element -> elements
    应用场景为元素值重复，无法通过元素属性直接定位到某个元素，只能通过elements方式来选择，返回一个定位对象的列表.
3.3.7.通过id方式定位一组元素
    方法： find_elements_by_id(id_value) # id_value:为元素的id属性值
    业务场景:
        1.进入设置页面
        2.点击WLAN菜单栏(id定位对象列表中第1个)
    代码实现：
        # 定位到一组元素
        title = driver.find_elements_by_id("com.android.settings:id/title")
        # 打印title类型，预期为list
        print(type(title))
        # 取title返回列表中的第一个定位对象，执行点击操作
        title[0].click()
3.3.8.通过class方式定位一组元素
    方法：find_elements_by_class_name(class_value) # class_value:为元素的class属性值
    业务场景:
        1.进入设置页面
        2.点击WLAN菜单栏(class定位对象列表中第3个)
    代码实现：
        # 定位到一组元素
        title = driver.find_elements_by_class_name("android.widget.TextView")
        # 打印title类型，预期为list
        print(type(title))
        # 取title返回列表中的第一个定位对象，执行点击操作
        title[3].click()
3.3.9.通过xpath方式定位一组元素
    方法:find_elements_by_xpath(xpath_value) # xpath_value:为可以定位到元素的xpath语句
    业务场景:
        1.进入设置页面
        2.点击WLAN菜单栏(xpath中class属性定位对象列表中第3个)
    代码实现：
        # 定位到一组元素
        title = driver.find_elements_by_xpath("//*[contains(@class,'widget.TextView')]")
        # 打印title类型，预期为list
        print(type(title))
        # 取title返回列表中的第一个定位对象，执行点击操作
        title[3].click()
WebDriverWait 显示等待操作
    在一个超时时间范围内，每隔一段时间去搜索一次元素是否存在，
    如果存在返回定位对象，如果不存在直到超时时间到达，报超时异常错误。
    方法:WebDriverWait(driver, timeout, poll_frequency).until(method)
    参数：
        1.driver：手机驱动对象
        2.timeout：搜索超时时间
        3.poll_frequency：每次搜索间隔时间，默认时间为0.5s
        4.method：定位方法(匿名函数)
    匿名函数: 
        lambda x: x
    等价于python函数：
        def test(x):
            return x
    使用示例：
        WebDriverWait(driver, timeout, poll_frequency).until(lambda x: x.find_elements_by_id(id_value))
    解释：
        1.x传入值为：driver，所以才可以使用定位方法.
    函数运行过程：
        1.实例化WebDriverWait类，传入driver对象，之后driver对象被赋值给WebDriverWait的一个类变量：self._driver
        2.until为WebDriverWait类的方法，until传入method方法(即匿名函数)，之后method方法会被传入self._driver
        3.搜索到元素后until返回定位对象，没有搜索到函数until返回超时异常错误.
    业务场景:
        1.进入设置页面
        2.通过ID定位方式点击搜索按钮
    代码实现：
        from selenium.webdriver.support.wait import WebDriverWait # 导入WebDriverWait类
        # 超时时间为30s，每隔1秒搜索一次元素是否存在，如果元素存在返回定位对象并退出
        search_button = WebDriverWait(driver, 30, 1).until(lambda driver: driver.find_element_by_id("com.android.settings:id/search"))
        search_button.click()
        driver.quit()

九.APP元素信息操作API

本节讲介绍手机端元素信息的获取以及基本的输入操作。
前置代码

    from appium import webdriver
    # server 启动参数
    desired_caps = {}
    # 设备信息
    desired_caps['platformName'] = 'Android'
    desired_caps['platformVersion'] = '5.1'
    desired_caps['deviceName'] = '192.168.56.101:5555'
    # app的信息
    desired_caps['appPackage'] = 'com.android.settings'
    desired_caps['appActivity'] = '.Settings'

    # 声明我们的driver对象
    driver = webdriver.Remote('http://127.0.0.1:4723/wd/hub', desired_caps)
3.4.1.点击元素

3.4.2.发送数据到输入框

  方法：send_keys(vaue) # value：需要发送到输入框内的文本
  业务场景:
      1.打开设置
      2.点击搜索按钮
      3.输入内容abc
    代码实现：
        # 点击搜索按钮
        driver.find_element_by_id("com.android.settings:id/search").click()
        # 定位到输入框并输入abc
        driver.find_element_by_id("android:id/search_src_text").send_keys("abc")

    重点:
        大家可以将输入的abc 改成 输入中文，得到的结果:输入框无任何值输入且程序不会抱错
    解决输入中文问题：

        1.server 启动参数增加两个参数配置
            desired_caps['unicodeKeyboard'] = True
            desired_caps['resetKeyboard'] = True

        2.再次运行会发现运行成功
            # 点击搜索按钮
            driver.find_element_by_id("com.android.settings:id/search").click()
            # 定位到输入框并输入abc
            driver.find_element_by_id("android:id/search_src_text").send_keys("传智播客")
3.4.3.清空输入框内容

  方法：clear()
  业务场景:
      1.打开设置
      2.点击搜索按钮
      3.输入内容abc
      4.删除已输入abc
  代码实现：
      # 点击搜索按钮
      driver.find_element_by_id("com.android.settings:id/search").click()
      # 定位到输入框并输入abc
      input_text = driver.find_element_by_id("android:id/search_src_text")
      # 输入abc
      input_text.send_keys("abc")
      time.sleep(1)
      # 删除abc
      input_text.clear()
3.4.4.获取元素的文本内容

  方法: text
  业务场景：
      1.进入设置
      2.获取所有元素class属性为“android.widget.TextView”的文本内容
  代码实现：
      text_vlaue = driver.find_elements_by_class_name("android.widget.TextView")
      for i in text_vlaue:
          print(i.text)
  执行结果：
      设置

      无线和网络
      WLAN
      更多
      设备
      显示
      提示音和通知
      存储
3.4.5.获取元素的属性值
  方法: get_attribute(value) # value:元素的属性
  value='name' 返回content-desc / text属性值
   value='text' 返回text的属性值
   value='className' 返回 class属性值，只有 API=>18 才能支持
   value='resourceId' 返回 resource-id属性值，只有 API=>18 才能支持
  业务场景：
      1.进入设置
      2.获取搜索按钮的content-desc属性值
搜索属性
  代码实现：
      # 定位到搜索按钮
      get_value = driver.find_element_by_id("com.android.settings:id/search")
      print(get_value.get_attribute("content-desc"))
  执行结果：
      搜索
3.4.6.获取元素在屏幕上的坐标
  方法:location
  业务场景：
      1.进入设置页面
      2.获取搜索按钮在屏幕的坐标位置
  代码实现:
      # 定位到搜索按钮
      get_value = driver.find_element_by_id("com.android.settings:id/search")
      # 打印搜索按钮在屏幕上的坐标
      print(get_value.location)
  执行结果:
      {'y': 44, 'x': 408}
3.4.7.获取app包名和启动名
  获取包名方法：current_package
  获取启动名：current_activity
  业务场景：
      1.启动设置
      2.获取包名和启动名
  代码实现：
      print(driver.current_package)
      print(driver.current_activity)
  执行结果：
      com.tencent.news
      .activity.SplashActivity

十.APP元素事件操作API

3.5.1.前置代码

    from appium import webdriver
    # server 启动参数
    desired_caps = {}
    # 设备信息
    desired_caps['platformName'] = 'Android'
    desired_caps['platformVersion'] = '5.1'
    desired_caps['deviceName'] = '192.168.56.101:5555'
    # app的信息
    desired_caps['appPackage'] = 'com.android.settings'
    desired_caps['appActivity'] = '.Settings'

    # 声明我们的driver对象
    driver = webdriver.Remote('http://127.0.0.1:4723/wd/hub', desired_caps)
3.5.2.swip滑动事件

  从一个坐标位置滑动到另一个坐标位置,只能是两个点之间的滑动
  方法：swipe(start_x, start_y, end_x, end_y, duration=None)
  参数：
      1.start_x：起点X轴坐标
      2.start_y：起点Y轴坐标
      3.end_x：  终点X轴坐标
      4.end_y,： 终点Y轴坐标
      5.duration： 滑动这个操作一共持续的时间长度，单位：ms
  业务场景：
      1.进入设置
      2.从坐标(148,659)滑动到坐标(148,248)
  代码实现：
      # 滑动没有持续时间
      driver.swipe(188,659,148,248)
      # 滑动持续5秒的时间
      driver.swipe(188,659,148,248,5000)
3.5.3.scroll滑动事件

  从一个元素滑动到另一个元素，直到页面自动停止
  方法：scroll(origin_el, destination_el)
  参数：
      1.origin_el：滑动开始的元素
      2.destination_el：滑动结束的元素
  业务场景：
      1.进入设置页
      2.模拟手指从存储菜单位置 到 WLAN菜单位置的上滑操作
  代码实现：
      # 定位到存储菜单栏
      el1 = driver.find_element_by_xpath("//*[contains(@text,'存储')]")
      # 定位到WLAN菜单栏
      el2 = driver.find_element_by_xpath("//*[contains(@text,'WLAN')]")
      # 执行滑动操作
      driver.scroll(el1,el2)
3.5.4.drag拖拽事件
   从一个元素滑动到另一个元素,第二个元素替代第一个元素原本屏幕上的位置
  方法：drag_and_drop(origin_el, destination_el)
  参数：
      1.origin_el：滑动开始的元素
      2.destination_el：滑动结束的元素
  业务场景：
      1.进入设置页
      2.模拟手指将存储菜单 滑动到 WLAN菜单栏位置
  代码实现：
      # 定位到存储菜单栏
      el1 = driver.find_element_by_xpath("//*[contains(@text,'存储')]")
      # 定位到WLAN菜单栏
      el2 = driver.find_element_by_xpath("//*[contains(@text,'WLAN')]")
      # 执行滑动操作
      driver.drag_and_drop(el1,el2)
3.5.5.应用置于后台事件
  APP放置后台，模拟热启动
  方法：background_app(seconds)
  参数：
      1.seconds:停留在后台的时间，单位：秒
  业务场景：
      1.进入设置页
      2.将APP置于后台5s
  代码实现：
      driver.background_app(5)
  效果：
      app置于后台5s后，再次展示当前页面
十一.APP模拟手势高级操作

TouchAction是AppiumDriver的辅助类，主要针对手势操作，比如滑动、长按、拖动等，
    原理是将一系列的动作放在一个链条中发送到服务器，服务器接受到该链条后，解析各个动作，逐个执行。
3.6.1.前置代码

    from appium import webdriver
    # server 启动参数
    desired_caps = {}
    # 设备信息
    desired_caps['platformName'] = 'Android'
    desired_caps['platformVersion'] = '5.1'
    desired_caps['deviceName'] = '192.168.56.101:5555'
    # app的信息
    desired_caps['appPackage'] = 'com.android.settings'
    desired_caps['appActivity'] = '.Settings'

    # 声明我们的driver对象
    driver = webdriver.Remote('http://127.0.0.1:4723/wd/hub', desired_caps)
所有手势都要通过执行函数才会运行.

3.6.2.手指轻敲操作

  模拟手指轻敲一下屏幕操作
  方法：tap(element=None, x=None, y=None)
  方法：perform() # 发送命令到服务器执行操作
  参数：
      1.element：被定位到的元素
      2.x：相对于元素左上角的坐标，通常会使用元素的X轴坐标
      3.y：通常会使用元素的Y轴坐标
  业务场景：
      1.进入设置
      2.点击WLAN选项
  代码实现：
      # 通过元素定位方式敲击屏幕
      el = driver.find_element_by_xpath("//*[contains(@text,'WLAN')]")
      TouchAction(driver).tap(el).perform()

      # 通过坐标方式敲击屏幕，WLAN坐标:x=155,y=250
      # TouchAction(driver).tap(x=155,y=250).perform()
3.6.3.手指按操作

  模拟手指按下屏幕,按就要对应着离开.
  方法:press(el=None, x=None, y=None)
  方法：release() # 结束动作，手指离开屏幕
  参数：
      1.element：被定位到的元素
      2.x：通常会使用元素的X轴坐标
      3.y：通常会使用元素的Y轴坐标
  业务场景:
      1.进入设置
      2.点击WLAN选项
  代码实现：
      # 通过元素定位方式按下屏幕
      el = driver.find_element_by_xpath("//*[contains(@text,'WLAN')]")
      TouchAction(driver).press(el).release().perform()

      # 通过坐标方式按下屏幕，WLAN坐标:x=155,y=250
      # TouchAction(driver).press(x=155,y=250).release().perform()
3.6.4.等待操作

  方法：wait(ms=0)
  参数：
      ms：暂停的毫秒数
  业务场景:
      1.进入设置
      2.点击WLAN选项
      3.长按WiredSSID选项5秒
  代码实现：
      # 点击WLAN
      driver.find_element_by_xpath("//*[contains(@text,'WLAN')]").click()
      # 定位到WiredSSID
      el =driver.find_element_by_id("android:id/title")
      # 通过元素定位方式长按元素
      TouchAction(driver).press(el).wait(5000).perform()

      # 通过坐标方式模拟长按元素
      # 添加等待(有长按)／不添加等待(无长按效果)
      # TouchAction(driver).press(x=770,y=667).wait(5000).release().perform()
3.6.5.手指长按操作

  模拟手机按下屏幕一段时间,按就要对应着离开.
  方法：long_press(el=None, x=None, y=None, duration=1000)
  参数：
      1.element：被定位到的元素
      2.x：通常会使用元素的X轴坐标
      3.y：通常会使用元素的Y轴坐标
      4.duration：持续时间，默认为1000ms
  业务场景:
      1.进入设置
      2.点击WLAN选项
      3.长按WiredSSID选项5秒
  代码实现：
      # 点击WLAN
      driver.find_element_by_xpath("//*[contains(@text,'WLAN')]").click()
      # 定位到WiredSSID
      el =driver.find_element_by_id("android:id/title")
      # 通过元素定位方式长按元素
      TouchAction(driver).long_press(el,duration=5000).release().perform()

      # 通过坐标方式长按元素，WiredSSID坐标:x=770,y=667
      # 添加等待(有长按)／不添加等待(无长按效果)
      # TouchAction(driver).long_press(x=770,y=667).perform()
3.6.6.手指移动操作
  模拟手机的滑动操作
  方法：move_to(el=None, x=None, y=None)
  参数:
      1.el:定位的元素
      2.x:相对于前一个元素的X轴偏移量
      3.y:相对于前一个元素的Y轴偏移量
  业务场景1：
      1.进入设置
      2.向上滑动屏幕
    代码实现：
        # 定位到存储
        el = driver.find_element_by_xpath("//*[contains(@text,'存储')]")
        # 定位到更多
        el1 = driver.find_element_by_xpath("//*[contains(@text,'更多')]")
        # 元素方式滑动
        TouchAction(driver).press(el).move_to(el1).release().perform()
        # 坐标的方式滑动
        # TouchAction(driver).press(x=240,y=600).wait(100).move_to(x=240,y=100).release().perform()
        # 注意press连接一个move_to实际调用的是swip方法，可在log中查询，不要给相对坐标。
    业务场景2：
        1.进入设置
        2.向上滑动屏幕到可见"安全"选项
        3.进入到安全
        4.点击屏幕锁定方式
        5.点击图案
        6.绘制图案
    代码实现：
        # 定位到WLAN
        el1 = driver.find_element_by_xpath("//*[contains(@text,'WLAN')]")
        # 定位到存储
        el2 = driver.find_element_by_xpath("//*[contains(@text,'存储')]")
        # 存储上滑到WLAN
        driver.drag_and_drop(el2,el1)
        # 定位到用户
        el3 = driver.find_element_by_xpath("//*[contains(@text,'用户')]")
        # 注意 这次使用drag_and_drop方法，传入的"存储定位"仍使用其原始在屏幕上的位置，所以是由存储滑动到用户才可以上滑，否则需要重新"定位存储"
        # 存储上滑倒用户位置
        driver.drag_and_drop(el2,el3)
        # 点击安全按钮
        driver.find_element_by_xpath("//*[contains(@text,'安全')]").click()
        # 点击屏幕锁定方式按钮
        driver.find_element_by_xpath("//*[contains(@text,'屏幕锁定')]").click()
        # 点击图案按钮
        driver.find_element_by_xpath("//*[contains(@text,'图案')]").click()
        # 绘制图案四个坐标 1:(244,967) 2:(723,967) 3:(723,1442) 4:(244,1916)
        TouchAction(driver).press(x=244,y=967).wait(100).move_to(x=479,y=0).wait(100)\
            .move_to(x=0,y=475).wait(100).move_to(x=-479,y=474).release().perform()

十二.手机操作API

针对手机的一些常用设置功能进行操作.
3.7.1.前置代码

    from appium import webdriver
    # server 启动参数
    desired_caps = {}
    # 设备信息
    desired_caps['platformName'] = 'Android'
    desired_caps['platformVersion'] = '5.1'
    desired_caps['deviceName'] = '192.168.56.101:5555'
    # app的信息
    desired_caps['appPackage'] = 'com.android.settings'
    desired_caps['appActivity'] = '.Settings'

    # 声明我们的driver对象
    driver = webdriver.Remote('http://127.0.0.1:4723/wd/hub', desired_caps)
3.7.2.获取手机时间
  方法：device_time
  代码实现：
      # 获取当前手机的时间
      print(driver.device_time)
  执行结果：
      Wed Dec 27 08:52:45 EST 2017
3.7.3.获取手机的宽高
  获取手机的宽高，可以根据宽高做一些坐标的操作
  方法：get_window_size()
  代码实现：
      print(driver.get_window_size())
  执行结果：
      {'height': 800, 'width': 480}
3.7.4.发送键到设备
  模拟系统键值的操作，比如操作honme键，音量键,返回键等。
  方法：keyevent(keycode, metastate=None):
  参数：
      keycode：发送给设备的关键代码
      metastate：关于被发送的关键代码的元信息，一般为默认值
  业务场景:
      1.打开设置
      2.按多次音量增加键
  代码实现：
      for i in range(3):
          driver.keyevent(24)

3.7.5.操作手机通知栏
  打开手机的通知栏，可以获取通知栏的相关信息和元素操作
  方法：open_notifications()
  业务场景: 
      1.启动设置
      2.打开通知栏
  代码实现：
      driver.open_notifications()

3.7.6.获取手机当前网络
  获取手机当前连接的网络
  方法：network_connection
  业务场景:
      获取手机当前网络模式
  代码实现：
      print(driver.network_connection)
  执行结果：
      6

3.7.7.设置手机网络
  更改手机的网络模式，模拟特殊网络情况下的测试用例
  方法：set_network_connection(connectionType)
  参数：
      connectionType：需要被设置成为的网络类型
  业务场景：
      1.启动设置
      2.设置手机网络为飞行模式
  代码实现：
      driver.set_network_connection(1)

3.7.8.手机截图
  截取手机当前屏幕，保存指定格式图片到设定位置
  方法：get_screenshot_as_file(filename)
  参数：
      filename：指定路径下，指定格式的图片.
  业务场景：
      1.打开设置页面
      2.截图当前页面保存到当前目录，命名为screen.png
  代码实现：
      import os
      driver.get_screenshot_as_file(os.getcwd() + os.sep + './screen.png')
  执行结果：
      当前目录下会生成screen.png文件

十三.Pytest安装和介绍

当前使用python3.x版本
4.1.1.Pytest介绍
    pytest是python的一种单元测试框架，同自带的Unittest测试框架类似，相比于Unittest框架使用起来更简洁，效率更高。
4.1.2.主要有以下特点:
  1.非常容易上手，入门简单，文档丰富，文档中有很多实例可以参考
  2.支持简单的单元测试和复杂的功能测试
  3.支持参数化
  4.执行测试过程中可以将某些测试跳过，或者对某些预期失败的Case标记成失败
  5.支持重复执行失败的Case
  6.支持运行由Nose , Unittest编写的测试Case
  7.具有很多第三方插件，并且可以自定义扩展
  8.方便的和持续集成工具集成
4.1.3.Pytest安装(pytest官网)

4.1.3.1.安装包安装

  1.进入下载包路径
  2.python setup install 
  3.安装出现权限问题：
      3.1.mac/linux 添加sudo，运行：sudo python setup install
      3.2.windows 管理员方式运行cmd窗口，运行：python setup install
4.1.3.2.命令行安装

  1.mac／linux：sudo pip3 install -U pytest # -U:可以理解为--upgrade，表示已安装就升级为最新版本
  2.管理员方式运行cmd：pip3 install -U pytest
4.1.3.3.安装成功校验：

  1.进入命令行
  2.运行：pytest --version # 会展示当前已安装版本
4.1.4.Pytest运行的第一个例子

    # file_name: test_abc.py
    import pytest # 引入pytest包
    def test_a(): # test开头的测试函数
        print("------->test_a")
        assert 1 # 断言成功
    def test_b():
        print("------->test_b")
        assert 0 # 断言失败
    if __name__ == '__main__':
        pytest.main("-s  test_abc.py") # 调用pytest的main函数执行测试
    执行结果：
        test_abc.py 
        ------->test_a
        . # .(代表成功)
        ------->test_b
        F # F(代表失败)
4.1.5.Pytest运行方式

1.测试类主函数模式

  pytest.main("-s  test_abc.py")
2.命令行模式

  pytest 文件路径／测试文件名
  例如：
      pytest ./test_abc.py

十四.Pytest的setup和teardown函数

4.2.1。概述
  1.setup和teardown主要分为：模块级,类级，功能级，函数级。
  2.存在于测试类内部
4.2.2.函数级别setup()／teardown()

      运行于测试方法的始末，即:运行一次测试函数会运行一次setup和teardown
      代码示例：
          import pytest
          class Test_ABC:
              # 函数级开始
              def setup(self):
                  print("------->setup_method")
              # 函数级结束
              def teardown(self):
                  print("------->teardown_method")
              def test_a(self):
                  print("------->test_a")
                  assert 1
              def test_b(self):
                  print("------->test_b")
          if __name__ == '__main__':
              pytest.main("-s  test_abc.py")
      执行结果：
          test_abc.py 
          ------->setup_method # 第一次 setup()
          ------->test_a
          .
          ------->teardown_method # 第一次 teardown()
          ------->setup_method # 第二次 setup()
          ------->test_b
          .
          ------->teardown_method # 第二次 teardown()
4.2.3.类级别

      运行于测试类的始末，即:在一个测试内只运行一次setup_class和teardown_class，不关心测试类内有多少个测试函数。
      代码示例：
          import pytest
          class Test_ABC:
              # 测试类级开始
              def setup_class(self):
                  print("------->setup_class")
              # 测试类级结束
              def teardown_class(self):
                  print("------->teardown_class")
              def test_a(self):
                  print("------->test_a")
                  assert 1
              def test_b(self):
                  print("------->test_b")
          if __name__ == '__main__':
              pytest.main("-s  test_abc.py")
      执行结果：
          test_abc.py 
          ------->setup_class # 第一次 setup_class()
          ------->test_a
          .
          ------->test_b
          F 
          ------->teardown_class # 第一次 teardown_class()

十五.Pytest配置文件

pytest的配置文件通常放在测试目录下，名称为pytest.ini，命令行运行时会使用该配置文件中的配置.
配置pytest命令行运行参数
    [pytest]
    addopts = -s ... # 空格分隔，可添加多个命令行参数 -所有参数均为插件包的参数
配置测试搜索的路径
    [pytest]
    testpaths = ./scripts  # 当前目录下的scripts文件夹 -可自定义
配置测试搜索的文件名
    [pytest]
    python_files = test_*.py  
    # 当前目录下的scripts文件夹下，以test_开头，以.py结尾的所有文件 -可自定义
配置测试搜索的测试类名
    [pytest]
    python_classes = Test_*  
    # 当前目录下的scripts文件夹下，以test_开头，以.py结尾的所有文件中，以Test_开头的类 -可自定义
配置测试搜索的测试函数名
    [pytest]
    python_functions = test_*  
    # 当前目录下的scripts文件夹下，以test_开头，以.py结尾的所有文件中，以Test_开头的类内，以test_开头的方法 -可自定义
十六.Pytest常用插件

插件列表网址：https://plugincompat.herokuapp.com
    包含很多插件包，大家可依据工作的需求选择使用。
    前置条件：
        1.文件路径：
            - Test_App
            - - test_abc.py
            - - pytest.ini
        2.pyetst.ini配置文件内容：
            [pytest]
            # 命令行参数
            addopts = -s
            # 搜索文件名
            python_files = test_*.py
            # 搜索的类名
            python_classes = Test_*
            # 搜索的函数名
            python_functions = test_*
4.4.1.Pytest测试报告
  通过命令行方式，生成xml/html格式的测试报告，存储于用户指定路径。
    插件名称：pytest-html
    安装方式：
        1.安装包方式 python setup.py install 
        2.命令行 pip3 install pytest-html
    使用方法：
        命令行格式：pytest --html=用户路径/report.html
    示例：
        import pytest
        class Test_ABC:
            def setup_class(self):
                print("------->setup_class")
            def teardown_class(self):
                print("------->teardown_class")
            def test_a(self):
                print("------->test_a")
                assert 1
            def test_b(self):
                print("------->test_b")
                assert 0 # 断言失败
    运行方式：
        1.修改Test_App/pytest.ini文件，添加报告参数，即：addopts = -s --html=./report.html 
            # -s:输出程序运行信息
            # --html=./report.html 在当前目录下生成report.html文件
            ⚠️ 若要生成xml文件，可将--html=./report.html 改成 --html=./report.xml
        2.命令行进入Test_App目录
        3.执行命令： pytest
    执行结果：
        1.在当前目录会生成assets文件夹和report.html文件
报告截图

4.4.2.Pytest控制函数执行顺序
    函数修饰符的方式标记被测试函数执行的顺序.
    插件名称：pytest-ordering
    安装方式：
        1.安装包方式 python setup.py install 
        2.命令行 pip3 install pytest-ordering
    使用方法：
        1.标记于被测试函数，@pytest.mark.run(order=x)
        2.根据order传入的参数来解决运行顺序
        3.order值全为正数或全为负数时，运行顺序：值越小，优先级越高
        4.正数和负数同时存在：正数优先级高
    默认情况下，pytest是根据测试方法名由小到大执行的,可以通过第三方插件包改变其运行顺序。
    默认执行方式
    示例：
        import pytest
        class Test_ABC:
            def setup_class(self):
                print("------->setup_class")
            def teardown_class(self):
                print("------->teardown_class")
            def test_a(self):
                print("------->test_a")
                assert 1
            def test_b(self):
                print("------->test_b")
                assert 0
        if __name__ == '__main__':
            pytest.main("-s  test_abc.py")
    执行结果：
        test_abc.py 
        ------->setup_class
        ------->test_a # 默认第一个运行
        .
        ------->test_b # 默认第二个运行
        F
        ------->teardown_class
    示例：
        import pytest
        class Test_ABC:
            def setup_class(self):
                print("------->setup_class")

            def teardown_class(self):
                print("------->teardown_class")
            @pytest.mark.run(order=2)
            def test_a(self):
                print("------->test_a")
                assert 1

            @pytest.mark.run(order=1)
            def test_b(self):
                print("------->test_b")
                assert 0
        if __name__ == '__main__':
                pytest.main("-s  test_abc.py")
    执行结果：
        test_abc.py
        ------->setup_class
        ------->test_b # order=1 优先运行
        F
        ------->test_a # order=2 晚于 order=1 运行
        .
        ------->teardown_class
4.4.3.Pytest失败重试
    通过命令行方式，控制失败函数的重试次数。
    插件名称：pytest-rerunfailures
    安装方式：
        1.安装包方式 python setup.py install 
        2.命令行 pip3 install pytest-rerunfailures
    使用方法：
        命令行格式：pytest --reruns n # n：为重试的次数
    示例：
    import pytest
    class Test_ABC:
        def setup_class(self):
            print("------->setup_class")
        def teardown_class(self):
            print("------->teardown_class")
        def test_a(self):
            print("------->test_a")
            assert 1
        def test_b(self):
            print("------->test_b")
            assert 0 # 断言失败
    运行方式：
        1.修改Test_App/pytest.ini文件，添加失败重试参数，即：addopts = -s  --reruns 2 --html=./report.html 
            # -s:输出程序运行信息
            # --reruns 2 ：失败测试函数重试两次
            # --html=./report.html 在当前目录下生成report.html文件
        2.命令行进入Test_App目录
        3.执行命令： pytest
    执行结果：
        1.在测试报告中可以看到两次重试记录