Time will tell.
前边讲解的 Monkey 都是随机事件流，Monkey 在手机里像个无头苍蝇一样乱蹦乱跳，那么本章节就教你如何让 Monkey 按指令在手机里闹腾 —— Monkey 自定义脚本。
1、monkey 隐藏命令
–pck-blacklist-file
–pck-whitelist-file
–f:可以指定monkey的自定义脚本
一般 Monkey 测试都是随机的测试事件，假如我们需要测试某一个特定的场景，普通的命令很难办到，这是就是需要自定义脚本这个命令了。
它的使用方式也是很简单方便的，只要我们按照 Monkey 的脚本规范写好脚本，之后将它保存到手机中，然后运行 Monkey 的时候使用-f命令指定脚本就行。
2、monkey 自定义脚本格式
虽然，Google 官方并没有提供对 MS 详细讲解的 API 文档，但是我们是可以通过源码来分析出 MS 支持的 API 的。
MS 的源码文件是：MonkeySourceScript.java
Monkey 的源码 MonkeySourceScript.java类中有一段关于 Monkey 脚本规则的描述MonkeySourceScript.java有兴趣的同学可以去看一下这个源码，这里以 5.1.1 为例子，进行讲解，其实这一块的代码变动非常的少，找一个版本了解即可。我们看一下源码对脚本规则描述。
脚本规则的描述
/**
* monkey event queue. It takes a script to produce events sample script format:
*
* 
* type= raw events
* count= 10
* speed= 1.0
* start data >>
* captureDispatchPointer(5109520,5109520,0,230.75429,458.1814,0.20784314,0.06666667,0,0.0,0.0,65539,0)
* captureDispatchKey(5113146,5113146,0,20,0,0,0,0)
* captureDispatchFlip(true)
* ...
* 
*/
解释意思
#声明脚本的类型
type= raw events
#脚本的执行次数，由于monkey运行次数在命令设置的，这里的设置是无效的
count= 10
#事件执行时间间隔，这个也是通过命令来设置，这里不起作用
speed= 1.0
#脚本的入口，说明脚本从下面开始执行
start data >>
#下全是monkey命令
captureDispatchPointer(5109520,5109520,0,230.75429,458.1814,0.20784314,0.06666667,0,0.0,0.0,65539,0)
captureDispatchKey(5113146,5113146,0,20,0,0,0,0)
captureDispatchFlip(true)
知道 Monkey 脚本书写的基本格式，在来看一眼 Monkey 常见脚本 API 。
1.LaunchActivity(包名，Activity名称)
启动被测应用的某个Activity
2.Tap(x,y,TapDuration)
一次单击事件
x,y：是坐标
TapDuration:持续的时间，单位毫秒
3.DispatchPress(keyName)
模拟一个按键
keyName:按键的名称
4.RotateScreen(RotationDegree,peresist)
旋转屏幕
RotationDegree：0~3分别表示顺时针的四个方向
peresist：是否存留
5.DispatchFiip(true/false)
打开或关闭软键盘
6.LongPress()长按2秒
7.PressAndHold(x,y,PressDuration)
模拟长按事件
x,y:点击的坐标
PressDuration:持续时常，单位毫秒
8.DispatchString(input)
输入字符串
input:输入的内容
9.Drag(xStart,yStart,xEnd,yEnd,pCount)
模拟拖动操作
xStart,yStart:开始的坐标值
xEnd,yEnd:结束的坐标值
pCount:滑动事件的次数
10.PinchZoom(pt1xStart,pt1yStart,pt1xEnd,pt1yEnd,pt2xStart,pt2ystart,pt2xEnd,pt2yEnd)
手势缩放事件
pt1xStart,pt1yStart:第一个手指起始的坐标位置
pt1xEnd,pt1yEnd：第一个手指结束的坐标位置
pt2xStart,pt2ystart：第二个手指开始的坐标位置
pt2xEnd,pt2yEnd：第二个手指结束的坐标位置
11.UserWait(sleepTime)
设置睡眠时间
sleepTime：等待时间，单位毫秒
12.DeviceWake()
唤醒设备屏幕
在源码中，所有我们上面介绍的 API 都是以一个static final的形式被声明。这里简单就LaunchActivity 的方法的源码进行讲解，其他的 API 其实也大同小异。
LaunchActivity的方法的源码讲解：
1、浏览器输入源码地址，找到静态字符串LaunchActivity，如图：
2、将鼠标定位到静态字符串LaunchActivity通过ctrl(command)+?️左键我们可以定位到方法的位置。大约在597行，如图：
3、将鼠标定位到LaunchActivity的方法通过ctrl(command)+?️左键我们可以进入到方法代码。大约在597行，如图：
4、如上边LaunchActiviity方法源码所示，LaunchActiviity会以数组的形式接收两个参数，分别表示 PackageName和Activity 的ClassName，下面具体对应的实现，我们就不细看了。再参照上面介绍的 API ，就可以很清晰的定位出方法和参数的含义了。
有兴趣的小伙伴们可以通过以上步骤一一查看那些方法的 API 。
3、Monkey 脚本的实例
1、Monkey 脚本主要包含两部分，一部分是头文件信息，一部分是具体的 Monkey 命令。
2、按照2.1的脚本描述规则我们来编辑monkeyscript，如下：
type = user
count = 1
speed = 500
start data >>
#启动应用程序
LaunchActivity(com.michael.words,com.michael.words.activity.SplashActivity)
UserWait(5000)
#点击下步按钮
Tap(615,609)
UserWait(1000)
#点击编辑框
Tap(200,85,1000)
#输入sg
DispatchString(sg)
注意这里分别使用了DispatchPress 和DispatchString来分别使用，就是为了做演示，实际你可以依赖场景选择使用的 API 。而其中涉及到坐标点的问题，这个在后面会讲解如何获取控件的坐标点。
3、执行脚本
编写好脚本，保存为monkey.script文件。
通过 adb push将其上传到待测试的设备中。要push到sdcard文件夹中(这里一夜神模拟器为例)，如图：
adb push C:/Users/DELL/Desktop/monkey.script /sdcard/
查看有没有push到设备中，从下图可以看到成功的push进去了。如图：
有兴趣或者不相信的可以查看文件内容，如图：
然后通过 monkey -f执行此脚本，例如下面执行 1次。
adb shell monkey -f /sdcard/monkey.script -v 1
效果截图
image
执行完成之后，可以在控制台，看到输出的 Log 信息。
image
4、总结
1、通过adb pull和adb push手机与电脑之间传输文件
(1)将手机卡中的某个文件复制到电脑
手机连接电脑后，在命令行输入 adb devices，获取到设备序列号后说明手机已经和电脑连接成功。
输入: adb pull 手机存储路径 电脑路径 　　　adb pull /sdcard/xxx /Users/xxxx/xxx.tx
(2)从电脑端向手机复制文件
输入: adb pull 电脑路径 手机存储路径 　　　adb push /Users/xxxx/xxx.txt /sdcard/xxx
2、注意事项(此处有坑！)
头文件代码书写注意 “=” 两边预留空格，否则会出现如下报错。
java.lang.NumberFormatException: Invalid int: ""
以上就分享到这里，最近正好有时间做自动化测试方面的资料整理。如果你对Python自动化测试、面试题，感兴趣可以加入我们扣裙一起学习175317069，有各项测试资料，面试题资料。
欢迎【点赞】、【评论】、【关注】~
Time will tell.(时间会证明一切)

序言
首先介绍一下python和uiautomator
1、UIAutomator是Android官方推出的安卓应用界面自动化测试工具，是最理想的针对APK进行自动化功能回归测试的利器，使用UIAutomator基本可以满足常规测试需求。
2、Python是一种解释型、面向对象、动态数据类型的高级程序设计语言，通过Python与uiautomator结合可以写出你想的自动化测试
环境配置
1、首先ubuntu一般都自带python，这里笔者用的ubuntu自带的python2.7版本。
2、然后进入pypi.python.org/pypi网站，利用站内搜索下载uiautomator支持模块
3、下载完成后，进入uiautomator文件夹，执行完成安装python setup.py install
4、检测环境是否配置好,直接进入python
android@ubuntu:~$ python
Python 2.7.6 (default, Mar 22 2014, 22:59:56)
[GCC 4.8.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import uiautomator
>>>
没有报错就代表环境配置好了。
5、uiautomator安装好后，还可以在终端直接启动uiautomatorviewer，通过该工具可以分析出UI控件的id,text，focusable等等各种属性，甚至布局上的层次关系。下面是网上下载的一个截图
20151023205142537.png
模拟拨打电话
关于uiautomator的API本文不做详述，读者可以直接参考# 快学UiAutomator UiDevice API 详解或者另行搜索，语法很简单
下面是拨打电话的过程
GIF.gif
直接附上call.py的代码
#!/usr/bin/env python
# -*- coding: utf-8 -*-
########################################################################################################
#
# 传入:手机id(adb devices显示的手机id)
# e.g:python call.py 4650150b
#
# V1.0
# 2018/03/02
# yink.liu
########################################################################################################
import sys
import time
from uiautomator import Device
class Call(object):
def __init__(self):
# 初始化拨号键盘坐标，根据手机不同需要修改，顺序为0123456789*#
self.cellphone_key = [            (360, 1140),
(160, 780), (360, 780),  (560, 780),
(160, 900), (360, 900),  (560, 900),
(160, 1020),(360, 1020), (560, 1020),
(160, 1140),             (560, 1140),]
# 功能键 依次为,拨号、挂断
self.function_key = [(360, 1275),(360, 1230)]
# 运营商电话号码
self.operator = '10010'
# 处理传入的参数
self.gpus = sys.argv[1]
self.gpus = (self.gpus.split(','))
self.cellphone_id = self.gpus[0]
# 指定操作的手机
self.d=Device(self.cellphone_id)
print '手机id:',self.cellphone_id
def call(self):
self.send_operator_call()
# 拨打运营商电话
def send_operator_call(self):
# 进入拨号
self.d.screen.on()
self.d.press.home()
self.d(text="Phone").click()
time.sleep(2)
# 拨打运营商固定号码
for num in self.operator:
print num
self.choice_cellphone_click_key(num)
# 拨号
self.choice_function_click_key('call')
time.sleep(3)
# 挂断
self.choice_function_click_key('hang_up')
def choice_function_click_key(self, key):
if key == 'call':
self.d.click(self.function_key[0][0],self.function_key[0][1])
elif key == 'hang_up':
self.d.click(self.function_key[1][0],self.function_key[1][1])
time.sleep(0.15)
def choice_cellphone_click_key(self, key):
if key == '*':
self.d.click(self.cellphone_key[10][0],self.cellphone_key[10][1])
elif key == '#':
self.d.click(self.cellphone_key[11][0],self.cellphone_key[11][1])
else:
self.d.click(self.cellphone_key[int(key)][0],self.cellphone_key[int(key)][1])
time.sleep(0.15)
if __name__ == "__main__":
c = Call()
c.call()
结束语
通过UIAutomator写一些测试用例，可避免需要大量的重复测试工作。也是PC控制手机的一种手段

3.     Appium安装配置
3.1.  限制
如果你在windows上安装appium，你没法使用预编译专用于OS X的.app文件，你也将不能测试IOS apps，因为appium依赖OS X专用的库来支持IOS测试。这意味着你只能通过在mac上来运行IOS的app测试。这点限制挺大。
3.2.  傻瓜式安装node.js
3.2.1. 查看是否安装成功
nodejs安装完毕后，需要配置环境变量
在PATH中添加：D:\Program Files\nodejs;
3.3.  傻瓜式安装Appium
3.3.1. 成功界面
3.4.  配置appium环境变量
C:\Program Files (x86)\Appium\node_modules\.bin
3.5.  打开控制台，查看appium环境
3.5.1. appium-doctor
3.6.  配置Android— 环境变量
F:\adt-bundle-windows-x86_64_20140101\sdk
3.7.  Python中配置appium环境(联网)
进入：D:\python\Scripts
打开控制台：
pip  install  Appium-Python-client
3.8.  总结：
1) android sdk安装完毕后，需要配置环境变量
新建ANDROID_HOME
在PATH中添加：%ANDROID_HOME%:\.....
2)  nodejs安装完毕后，需要配置环境变量
在PATH中添加：D:\Program Files\nodejs;
3) appium安装完毕后，需要配置环境变量
D:\Program Files (x86)\Appium\node_modules\.bin;
4) 配置好后，启动cmd，
输入node -v，查看node安装版本
输入appium-doctor检查appium的安装环境是否成功，
5) 安装Python,配置环境变量，
4.   第一个脚本示例
4.1.  首先通过eclpse启动android模拟器
4.2. 启动Appium
4.3.  点击左上角有“机器人”的按钮：
选择你的android版本
4.4. 点击右上角的“三角”按钮启动Appium。
4.5.  通过Python编写自动化测试脚本。
desired_caps是一个字典，用于在appium server 与手机端建立会话关系时，手机端需要告诉服务端设备相关的一些参数，根据这些参数服务端可以做出相应的处理。
#coding:utf-8
from appium import
webdriver
#desired_caps是一个字典,负责启动服务端时的参数设置，启动session的时候是必须提供的。
# Desired Capabilities本质上是key value的对象，它告诉appium server这样一些事情，比如：
# 本次测试是启动浏览器还是启动移动设备？
# 是启动andorid还是启动ios？
# 启动android时，app的package是什么？
# 启动android时，app的activity是什么
desired_caps = {}
#你要测试的手机操作系统
desired_caps['platformName']
= 'Android'
#手机操作系统的版本
desired_caps['platformVersion']
= '4.2'
#使用的手机类型或模拟器类型
desired_caps['deviceName']
= 'Android'
#deviceName你的模拟器名字，就是在下载AVD的时候，你填写的，忘了的回头去找，或者在模拟器顶部会显示
#所运行的app包名
desired_caps['appPackage']
= 'com.android.calculator2'
#app运行的事件
desired_caps['appActivity']
= '.Calculator'
#启动打开app
driver =
webdriver.Remote('http://127.0.0.1:4723/wd/hub', desired_caps)
#根据元素定位，执行点击操作
driver.find_element_by_name("6").click()
driver.find_element_by_name("5").click()
driver.find_element_by_name("9").click()
driver.find_element_by_name("1").click()
driver.find_element_by_name("5").click()
driver.find_element_by_name("+").click()
driver.find_element_by_name("6").click()
driver.find_element_by_name("=").click()
driver.quit()
报错
解决方案
会话已存在错误--解决方案，关掉appium，重启
4.6.  画出来的这三个，是需要在脚本中正确填写的
4.7.  执行效果
5.     Appium界面内容解析
5.1.  整体介绍
主页面顶部从左到右依次是：
1、AndroidSettings:android相关的设置
2、　GeneralSettings：全局设置，设置appium相关的内容
3、 DeveloperSettings：开发者设置，一般不用需要关心
4、About：appium相关信息，不需要关心
5、Inspector：查找元素用的，windows无法使用，MAC可以使用，windows可以不用关心。
6、LaunchAppium：启动appium按钮
7、右下角清除日志按钮。
5.2.  Android Settings
此页面分为Application、Launch Device、Capabilities、Advanced四部分，先看图之后分析分别有什么作用
5.2.1. 1、Application
本模块设置被测试app信息，如安装包路径、包名、activity等
ApplicationPath：选择要测试的apk，选择他后与全局设置中的Pre-LaunchApplication配合，启动appium时会先把apk安装到手机(或模拟器)再启动app。
Package：根据apk生成的app包名，之前提到过的，我们这个包的身份证，我们需要通过这个去找到包，不然我们安装后我们通过什么去辨别这些包呢？
Waitfor
Package：等待包名。
LaunchActivity：启动的activity，我们可以把手机当做一个浏览器，而Activity就是其中的一个个网页，我们启动app时需要去运行的activity，这里我们填写首次启动页面的activity。我们选择第一启动的activity与aapt命令生成的launchable-activity:name一致
备注：这里需要注意一个问题在我们每次通过Choose选择apk后，appium会自动把这个包进行重新签名，那么在package以及activity里面会自动把包名和activity的名称列进去，但是这里会出现一个问题，每次选择apk后列表中会有一个缓存的原因，即使你更改了apk，但是package还是没有变，这样启动的时候就一直报错，遇见这样的情况不要着急，重新启动两次就好。
Waitfor
Activity：和上面的差不多，意思是等待某个Activity打开，用的时间不是很多，做了解。
UseBrowser：测试浏览器选择这项，与前五项互逆。及选择了他前五个就不可以选择。
FullReset：将所有设置复位。即将手机(模拟器)恢复到启动到appium前的状态
NoReset：不需要重置手机(模拟器)中的app
剩下的几项不重要。可以不需要知道作用。
6.2.2. Launch Device
本模块是模拟器设置，针对的是SDK创建的模拟器，不是genymotion等其他模拟器。
LaunchAVD：要启动的模拟器名称。
DeviceReady
Timeout：等待模拟器启动时间。
Arguments：启动模拟器时需要的参数。
6.2.3.Capabilities
运行测试的相关信息。
PlatformName：测试平台，可以选择Android、FireFox OS、MAC版的还可以选择IOS。
utomationName：测试引擎的名称，我们使用的是appium，所以你第一眼就能看见Appium，但是他还有一个Selendroid。可能看到这里会有一些疑惑，为什么appium要选择两套系统呢？其实这个应该追溯到android的版本问题，android自己的工具在4.2版本以前是一个，但是后面进行了更新，可能也正是因为这个原因appium也才采用了两套，所以当你测试的app安装的机器时在4.2或之前的版本时那么这里的引擎你就必须选择Selendroid，
PlatformVersion：被测试手机(模拟器)版本。
DeviceName：设备名称，手机连接电脑后打开cmd输入adb devices可获取。
Language：被测试手机(模拟器)使用语言。
Locale：被测试手机(模拟器)所属区域。
5.2.2. 　Advanced
此模块不需要关心，这个标签只是在你想同一台电脑同时控制多台手机的时候才能使用，需要更改Bootstrap Port的端口号，记住这一点就好。
5.3.  General Setting
全局设置，分为Server和Logging两个，分别是对appium服务和输出日志的设置
5.3.1. 1、Server
此模块测试appium server信息
ServerAddress：如果测试机与开发机是同一台机器默认即可，否则写appium所在服务器IP
port：默认4723，可修改。
CheckFor Updates：启动appium时是否检测更新
Pre-LaunchApplication：与Android Settings中的Application模块的ApplicationPath配合，启动appium后会直接启动安装的app。
OverridingExisting
Session：覆盖之前的session。
UseRomote Server：使用远程appium Server。
SeleniumGrid
Configuration File：配置Selenium
Grid文件。并发和分布式时用到。
5.3.2. 2、Logging
日志设置
ShowTimestamps：appium界面输出日志时带时间戳
Logto File：默认状态是没有任何数据，但是在做自动化时建议选择，因为选择之后appium在运行时产生的日志都会保留到你设置的问题件，这个对后期的bug定位有相当大的帮助。切记！
5.4.  元素侦测：
这个按钮的功能和firebug的定位工具功能类似，但是他还有一个功能，他会检测你的各个系统配置是否正确，如果前面各项参数不正确时，使用该功能会报错。如果你不正常连接手机也不行。还是建议用sdk工具里面自带的uiautomatorviewer。
5.5.  启动服务
所有参数配置好后你需要做的就是启动appium服务，只有启动之后你才能够做自动化。
5.6.  清除日志(右下角)：
在写脚本、调试过程中会产生很多的日志，但是你可能想看的只是中间某个时间段的，那么你在这个时候可以将页面的日志清除。
6.     Appium查看界面元素的工具
6.1.  通过android sdk的uiautomaterviewer获取元素内容
uiautomaterviewer所在目录：..\sdk\tools\bin
uiautomatorviewer.bat是一个用来来扫描和分析Android应用程序的UI组件的GUI工具。具体使用方法可参考。打开uiautomatorviewer以后，可以看到uiautomatorviewer已经将模拟器的图形展示在上面了。
6.2.  右侧xml节点详解
节点名  解释
index  父目录下的第几个元素，以0开头
text   显示在界面上的内容
resource-id   该元素的id(开发不规范时，此id有可能会不存在或多个相同)
class  元素的类型
package    apk的包名
content-desc  描述信息
checkable  元素特征：是否可选择
checked    元素特征：当前是否已选中
chlickable 元素特征：是否可点击
enabled    元素特征
focusable  元素特征
focused    元素特征
scrollable 元素特征
long-clickable    元素特征
password   元素特征
selected   元素特征
bounds 边界，左上角和右下角的坐标(从屏幕最左侧和最上侧开始)
6.3.  使用过程常见问题
打不开uiautomaterviewer
解决方法：以文本方式打开此文件，更改文件结尾处的Dcom.android.uiautomator.bindir="$progdir"为Dcom.android.uiautomator.bindir="sdk下tools文件夹的路径"
7.     获取appPackage和appActivity
appPackage和appActivity 进行appium自动化测试非常重要的两个参数，我们所测试的APP不同，这两个参数肯定也是不一样的。那如何快速的获取这APP的这两个参数呢
7.1.  方法一:通过cmd指令来获取
1. adb shell
2. dumpsys activity | grep mFocusedActivity
3、adb shell dumpsys activity activities >E:1.txt
7.2.  方法二:使用Appium来获取
进入设置页，选择APK 路径，下面就会显示包名和Activity名称
8.     Appium常用定位方法讲解
对象定位是自动化测试中很关键的一步，也可以说是最关键的一步，毕竟你对象都没定位那么你想操作也不行，下面我们来看我们常用的一些定位方式。
8.1.   ID定位(取resource-id的值)：
无论是在web自动化还是app自动化中id都是唯一的，可能有的小伙伴看到这里会有疑问，因为有的资料说是通过name定位是唯一的，为什么你这里是id呢，其实这个在之前是不冲突的，但是如果你用的是appium较新版本是不行的，在新版本中name定位被去掉了，所以在以后的定位中不会有name定位了，通常情况下我们也更喜欢用id进行定位。这里可能刚学的小伙伴会有疑问，
有的时候你的应用为什么没有id，或者说在这个手机上有但是另外的手机上没有。1、开发没有添加。2、android版本是4.4以下的。
如果我们需要对“7”这个数字进行点击操作，
driver.find_element_by_id("com.android.calculator2:id/digit7").click()
8.2.  通过name定位元素(一般text属性认为是name)
driver.find_element_by_name("5").click()
8.3.     className定位(取class的内容)
在实际工作中className定位用得相对而言会比较少。当你经常去看class时你会发现很多的className是一样的，你没有办法对其进行唯一定位，下面我们看下面两张图片
我们可以仔细看一下这两张图片中手机号、密码两个输入框中的className都是一样的，如果在这种情况下你使用
driver.find_element_by_class_name("android.widget.EditText").send_keys("111111")
这种方式去定位，你会发现你永远定位不了密码栏，这是为什么呢？因为在设计的时候如果你查找的元素在页面有多个，系统会自动给你选择第一个，所以你永远操作不了后面的
8.4.  text定位(需要使用uiautomator的定位方式，使用text的内容)
driver.find_elements_by_android_uiautomator("new UiSelector().text('7')")
使用这里需要注意一下，如果通过text定位的结果是个list，不能直接click。所以如果要点击需要取数组的值，比如下面是点击找到的第一个元素
driver.find_elements_by_android_uiautomator("new UiSelector().text('7')")[0].click()
8.5.     xpath定位
xpath定位在web自动化中是最常见的，而且也是最有效的，使用xpath定位避免了找不到元素导致报错的问题，但是在app中使用xpath定位是一件很low的事情。只要遇见使用xpath定位元素他的反应就会比较慢，自动化的目的是为了提高效率，但是使用xpath后会降低效率，所以这里说很 low
在上面两张图片中我们能够清除的看见他们的id、className都是一样的，这样的情况下不用层级定位方式我们只能够采用xpath来进行定位，首先根据前面web的学习大家可以思考一下该怎么定位。我们直接看代码
driver.find_element_by_xpath("//android.widget.TextView[@text='JavaScript']").click()
在xpath里面我们的语法是这样“//android.widget.TextView[@text='JavaScript']”，这个和我们之前web的xpath一样，意思是查找所有节点中节点为android.widget.TextView (这里使用的是className，也可以使用id，系统会依次去找)并且他的text属性值为JavaScript，这样是否更容易理解呢？下来多练习。这样的定位方式不推荐，效率很慢。
8.6.  css_selector定位(webview)--加载网页--css
只适用于webview的html页面，继承自webdriver，与pc版本的UI测试一致
driver.find_element_by_css_selector()
8.7.  link_text定位(webview)
只适用于webview容器中的html页面，继承自webdriver，与pc版本的UI测试一致
driver.find_element_by_link_text()
8.8.  源代码
#coding:utf-8
from appium import webdriver
#desired_caps是一个字典
desired_caps = {}
#你要测试的手机操作系统
desired_caps['platformName'] = 'Android'
#手机操作系统的版本
desired_caps['platformVersion'] = '7.0'
#使用的手机类型或模拟器类型
desired_caps['deviceName'] = 'XPUDU17113015063'
#deviceName你的模拟器名字，就是在下载AVD的时候，你填写的，忘了的回头去找，或者在模拟器顶部会显示
#所运行的app包名
desired_caps['appPackage'] = 'com.example.login'
#app运行的事件
desired_caps['appActivity'] = '.MainActivity'
#启动打开app
driver = webdriver.Remote('http://127.0.0.1:4723/wd/hub', desired_caps)
#根据元素定位，执行点击操作
# user= driver.find_element_by_name("请输入用户名")
# user = driver.find_element_by_id("com.example.login:id/et_username")
driver.find_element_by_class_name("android.widget.EditText").send_keys("jilidaxue")
# driver.find_element_by_id("com.example.login:id/et_password").send_keys("66889558")
# user.send_keys("liangyibo")
driver.find_element_by_xpath("//android.widget.EditText[@text='请输入密码']").send_keys("233254545")
# pwd = driver.find_element_by_name("请输入密码")
# pwd.send_keys("123456")
# # driver.find_element_by_xpath("//android.widget.FrameLayout[1]//android.widget.LinearLayout[3]").click()
driver.find_element_by_xpath("//android.widget.Button[@text='登录']").click()
driver.quit()
9.     Appium操作界面元素
9.1.  安装上两个apk，供测试使用
9.2.  Click(点击事件操作)
定位元素
点击元素
driver.find_element_by_id("com.wuba.zhuanzhuan:id/ae8").click()
方法二：(了解)
除了定位到元素的点击外，也可以通过tab实现坐标的点击
通过触摸时间控制点击tap()
tap([左上角坐标,右下角坐标],持续时间)
通过定位工具获取坐标值([540,243][1080,363])，
03-查看界面元素的工具
使用tap()方法点击元素
driver.tap([(918,413),(1026,521)], 100) #持续时间100是指100毫秒
9.3.  Clear(清空输入框内容)
定位输入框元素
清空输入框的内容
driver.find_element_by_id("com.wuba.zhuanzhuan:id/ij").clear()
9.4.  send_keys(输入框内输入内容 )
1.定位输入框元素
2.输入(发送)内容
driver.find_element_by_id("com.wuba.zhuanzhuan:id/ij").send_keys("test content")
9.5.  Text(获得元素的text内容 )
1.定位元素
2.获取元素内容
driver.find_elements_by_class_name("android.widget.EditText")[0].text;
9.6.  编写脚本代码
#coding:utf-8
from appium import webdriver
#desired_caps是一个字典
desired_caps = {}
#你要测试的手机操作系统
desired_caps['platformName'] = 'Android'
#手机操作系统的版本
desired_caps['platformVersion'] = '7.0'
#使用的手机类型或模拟器类型
desired_caps['deviceName'] = 'XPUDU17113015063'
#deviceName你的模拟器名字，就是在下载AVD的时候，你填写的，忘了的回头去找，或者在模拟器顶部会显示
#所运行的app包名
desired_caps['appPackage'] = 'com.example.login'
#app运行的事件
desired_caps['appActivity'] = '.MainActivity'
#启动打开app
driver = webdriver.Remote('http://127.0.0.1:4723/wd/hub', desired_caps)
#根据元素定位，执行点击操作
#1、通过name定位元素
# user= driver.find_element_by_name("请输入用户名")
#2、通过id定位元素
user = driver.find_element_by_id("com.example.login:id/et_username")
#3、通过class_name定位元素，对元素进行清空，再发送内容为：jilidaxue
# user = driver.find_element_by_class_name("android.widget.EditText").clear().send_keys("jilidaxue")
#4、通过id定位元素，发送内容为66889558
# driver.find_element_by_id("com.example.login:id/et_password").send_keys("66889558")
user.send_keys("liangyibo")
#5、打印获取的text属性值，文本内容
print(user.text)
#6、通过Xpath定位元素，输入密码
driver.find_element_by_xpath("//android.widget.EditText[@text='请输入密码']").send_keys("233254545")
#7、通过Xpath定位登录元素，进行点击操作
driver.find_element_by_xpath("//android.widget.Button[@text='登录']").click()
#8、退出操作
driver.quit()
10.  Appium操作界面之触摸操作(了解)
10.1.    规范中的可用事件有：
* 短按 (press)
* 释放 (release)
* 移动到 (moveTo)
* 点击 (tap)
* 等待 (wait)
* 长按 (longPress)
* 取消 (cancel)
* 执行 (perform)
10.2.    单点触摸TouchAction(driver)
通过TouchAction对象，添加tap、move_to等操作，然后perform()执行，可以实现解锁屏幕等功能
action=TouchAction(driver)
action.press(x=220,y=700).move_to(x=840,y=700).move_to(x=220,
y=1530).move_to(x=840, y=1530).release().perform()
10.3.    多点触控MultiAction()
通过MultiAction().add()添加多个TouchAction操作，最后调用perform()一起执行这些操作
举例
action0 = TouchAction().tap(el)
action1 = TouchAction().tap(el)
MultiAction().add(action0).add(action1).perform()
10.4.    滑动driver.swipe(x1, y1,x2,y2,duration)
命令解释：从坐标(x1,x2)滑动到坐标(x2,y2)，duration非必填项，滑动时间(滑动时中间要加等待时间，不加等待时间容易出错，而且加等待时间的长短也要掌握好，一般在200-1000毫秒之间应该差不多，自己调试几次感觉一下哪个时间比较稳，每个程序可能会有所差异)
滑动的坐标不能超过屏幕的宽高
可以通过【driver.get_window_size()】命令获得窗口高和宽{'width': 1080, 'height': 1788}
# 获得机器屏幕大小x,y
def
getSize(driver):
x = driver.get_window_size()['width']
y = driver.get_window_size()['height']
return (x, y)
# 屏幕向上滑动
def
swipeUp(driver, t=500):
l = getSize(driver)
x1 = int(l[0] * 0.5)  # x坐标
y1 = int(l[1] * 0.75)  # 起始y坐标
y2 = int(l[1] * 0.25)  # 终点y坐标
driver.swipe(x1, y1, x1, y2, t)
# 屏幕向下滑动
def
swipeDown(driver,t=500):
l = getSize(driver)
x1 = int(l[0] * 0.5)  # x坐标
y1 = int(l[1] * 0.25)  # 起始y坐标
y2 = int(l[1] * 0.75)  # 终点y坐标
driver.swipe(x1, y1, x1, y2, t)
# 屏幕向左滑动
def
swipLeft(driver,t=500):
l = getSize(driver)
x1 = int(l[0] * 0.75)
y1 = int(l[1] * 0.5)
x2 = int(l[0] * 0.05)
driver.swipe(x1, y1, x2, y1, t)
# 屏幕向右滑动
def swipRight(driver,t=500):
l = getSize(driver)
x1 = int(l[0] * 0.05)
y1 = int(l[1] * 0.5)
x2 = int(l[0] * 0.75)
driver.swipe(x1, y1, x2, y1, t)
10.5.    长按示例
# [0,219][1080,363] ----获取某个按钮的位置，执行长按操作touch=TouchAction(driver)
touch.long_press(x=100,y=250).perform();
10.6.    滑屏示例
10.6.1.    安装涂鸦app
10.6.2.    打开界面，使用如下指令，查看activity和package
10.6.3.    编写python脚本代码
#coding:utf-8
from appium import webdriver
#desired_caps是一个字典
from appium.webdriver.common.touch_action import TouchAction
desired_caps = {}
#你要测试的手机操作系统
desired_caps['platformName'] = 'Android'
#手机操作系统的版本
desired_caps['platformVersion'] = '7.0'
#使用的手机类型或模拟器类型
desired_caps['deviceName'] = 'XPUDU17113015063'
#deviceName你的模拟器名字，就是在下载AVD的时候，你填写的，忘了的回头去找，或者在模拟器顶部会显示
#所运行的app包名
desired_caps['appPackage'] = 'com.example.graffiti'
#app运行的事件
desired_caps['appActivity'] = '.MainActivity'
#启动打开app
driver = webdriver.Remote('http://127.0.0.1:4723/wd/hub', desired_caps)
#根据元素定位，执行点击操作
action=TouchAction(driver)
action.press(x=120,y=200).move_to(x=100, y=180).release().perform()
driver.quit()
11.  系统按键事件(了解)
press_keycode(AndroidKeyCode)#发送按键事件
例如：点击home键，home键的KeyCode是3
12.  driver的一些比较重要操作
12.1.    reset()
#重置app#这时候driver会重置，相当于卸载重装应用。所以本地缓存会失效
driver.reset()
12.2.    start_activity(包名,activity名)
例如：
#启动app的某一个activity
driver.start_activity("com.wuba.zhuanzhuan","./presentation.view.activity.LaunchActivity")
启动一个activity，这个activity必须是AndroidManifest.xml中有intent-filter的activity，对于其他的activity需要程序跳转过去
12.3.    scroll(起始元素，结束元素)
driver.scroll(origin_el,destination_el)
12.4.    获得当前页面的所有元素
driver.page_source
这可以用来判断元素是否存在，例如(assert “发布成功” in driver.page_source)
12.5.    补充一些driver启动时可能用到的项(了解)
其实这些在上一篇启动里都有介绍，但是有些可能大家没注意到的点再列一下。这些点也是我在测试中实际遇到的点
autoLaunch ：Appium是否要自动启动或安装app，默认true
desired_caps[‘autoLaunch’] = ‘false’
有的时候我不想让appium每次都启动app，想自己去启动activity，那这个项这时就可以起作用了
noReset：在会话前是否重置app状态。默认是false
desired_caps[‘noReset’] = ‘true’
newCommandTimeout：设置未接收到新命令的超时时间，默认60s
如果60s内没有接收到新命令，appium会自动断开连接，如果我需要很长时间做driver之外的操作，可能延长接收新命令的超时时间
desired_caps[“newCommandTimeout”]=1800
13.  自动化测试简单案例-登录
13.1.    打开UI Automator Viewer
13.2.    代码实现
driver.find_element_by_id("com.example.login:id/et_username").send_keys("hello");
driver.find_element_by_id("com.example.login:id/et_password").send_keys("123");
driver.find_elements_by_class_name("android.widget.Button")[1].click()
14.  自动化测试案例2-转转
14.1.    下载转转，并打开，在初始界面查看包和activity
14.2.    使用UI Automator Viewer查看转转按钮
14.3.    点击跳过
#强制等待3秒钟time.sleep(3)
#跳过按钮
#driver.find_element_by_id("com.wuba.zhuanzhuan:id/arw").click()
14.4.    点击分类
driver.implicitly_wait(10)
#分类按钮driver.find_element_by_id("com.wuba.zhuanzhuan:id/b1v").click()
driver.implicitly_wait(10)
#搜索按钮driver.find_element_by_id("com.wuba.zhuanzhuan:id/b1p").click()
driver.implicitly_wait(10)
#搜索框中输入搜索内容driver.find_element_by_id("com.wuba.zhuanzhuan:id/mg").send_keys(u"电动车")
time.sleep(10)
#点击搜索
driver.find_element_by_id("com.wuba.zhuanzhuan:id/mi").click()
driver.quit()
15.  启信宝案例
#coding:utf-8fromappium importwebdriver
#desired_caps是一个字典desired_caps = {}
#你要测试的手机操作系统desired_caps['platformName'] = 'Android'#手机操作系统的版本desired_caps['platformVersion'] = '7.0'#使用的手机类型或模拟器类型desired_caps['deviceName'] = 'XPUDU17113015063'#deviceName你的模拟器名字，就是在下载AVD的时候，你填写的，忘了的回头去找，或者在模拟器顶部会显示
#所运行的app包名desired_caps['appPackage'] = 'com.bertadata.qxb'#app运行的事件desired_caps['appActivity'] = '.activity.SplashActivity'#启动打开appdriver = webdriver.Remote('http://127.0.0.1:4723/wd/hub', desired_caps)
#根据元素定位，执行点击操作driver.implicitly_wait(10)
serh = driver.find_element_by_id("com.bertadata.qxb:id/tv_home_search_desc")
serh.click()
driver.find_element_by_id("com.bertadata.qxb:id/et_search_content").send_keys("优思安科技")
driver.quit()

用python写自动化测试脚本常用功能：结果记录，运行日志，测试配置，带颜色打印在控制台
利用csv库来记录测试结果
利用logging库来记录脚本运行信息
利用ConfigParser库来读取测试配置信息
利用ctypes库将测试信息带颜色打印在控制台
总结

利用csv库来记录测试结果
在进行自动化测试时，我们需要记录测试运行结果，将结果存入文件进行自动化测试结果报告；
python csv库完全能满足这个功能,下面直接看code:

#生成测试结果
import csv
class Report_test:
	def __init__(self):
		self.setting = Config()
		#生成的csv文件: ..\Report_20181025101010.csv
		self.fname = "..\\Report_"+str(time.strftime('%Y%m%d%H%M%S',time.localtime(time.time())))+".csv"
		
	#将测试结果写入csv文件
	def writer_data(self,data_log):
		with open(self.fname,'ab') as csvfile:
			csvwriter = csv.writer(csvfile,delimiter=',',lineterminator='\r\n')
			csvwriter.writerow(data_log)
	#读取csv文件
	def read(self):  
		with open(self.fname, 'r+') as csv_file:
			reader = csv.reader(csv_file)
			'''
			reader_list=[]
			for i in reader:
				reader_list.append(i)
			return reader_list
			'''
			return [row for row in reader] 
	
	#写入测试结果并将信息打印在控制台
	def now_data(self,data_log):
		Report_test.writer_data(self,data_log)
		print Report_test.read(self)[len(Report_test.read(self))-1]

# =====  test  =====
rep=Report_test()
rep.now_data(["pass"])
rep.writer_data(["333","3333","33333","3333"])
print rep.read()[len(rep.read())-1]

利用logging库来记录脚本运行信息
在自动化脚本运行时，我们需要了解当前脚本运行的状态，
需要了解脚本运行的所有信息来帮助我们进一步的优化和调试脚本；
python logging库完全能满足这个功能,下面直接看code:

#生成测试结果
class AddLog:
	setting = Config()
	logger=logging.getLogger()
	log_path= 'c:\\'#setting.log_path()
	#False log内容不会再控制台显示
	#True  log内容会在控制台显示
	def __init__(self,input=True):
		try:
			date=str(time.strftime('%Y%m%d%H%M%S',time.localtime(time.time())))
			logname=AddLog.log_path+"\\"+date+".log"
			logging.basicConfig(filename=logname,
					level=logging.DEBUG ,
					format='%(asctime)s %(levelname)s :$  %(message)s',
					datefmt='[ %Y-%m-%d %H:%M:%S ]',
					filemode='w',
					encoding='utf-8')
			if input == True:
				console=logging.StreamHandler()
				console.setLevel(logging.DEBUG)
				formatter=logging.Formatter(" %(asctime)s %(levelname)s : %(message)s ","[ %Y-%m-%d %H:%M:%S ]")
				console.setFormatter(formatter)
				AddLog.logger.addHandler(console)
			elif input == False:
				print "Not show logs."	
			else:
				print "The parameter is wrong, only False and True."
		except:
			import os
			os.makedirs(AddLog.log_path)
	def log(self):
		return AddLog.logger
		
# =====  test  =====
logger=AddLog(True).log()
logger.info("aaaaaaaaaa")

利用ConfigParser库来读取测试配置信息
自动化测试脚本常常会用到外部配置参数来健壮脚本的重复利用。
python ConfigParser库完全能满足这个功能,下面直接看code:

#读取配置文件
class Config():
	def __init__(self):
		self.setting_path="C:\\Users\\utility\\settings.ini"

	def get_config(self, sector, item):
		config = ConfigParser.ConfigParser()
		config.read(self.setting_path)
		value = config.get(sector, item)
		return value

	def get_dir_path(self):
		res = self.get_config('Path', 'dir_path')
		return res.replace("\\", "\\\\")

	def agent_path(self):
		res = self.get_config('Path', 'agent_path')
		return res.replace("\\", "\\\\")

	def client_path(self):
		res = self.get_config('Path', 'client_path')
		return res.replace("\\", "\\\\")


	def call_number(self):
		res = self.get_config('Test_cfg', 'call_number')
		return res

	def log_path(self):
		res = self.get_config('Settings', 'log_path')
		return res

	def report_path(self):
		res = self.get_config('Settings','report_path')
		return res

# =====  test  =====
test_init = Config()
log_path = test_init.log_path()

settings.ini
[Path]
dir_path = C:\Users\
agent_path = C:\Users\
client_path = C:\Users\

[Test_cfg]
call_number = 10086

[Settings]
log_path = C:\Users\
report_path = C:\Users\

利用ctypes库将测试信息带颜色打印在控制台
有时候我们需要更直观看到当前测试状态，测试结果Passed 将以绿色显示在控制台，测试结果failed以红色显示在控制台；
python ctypes库完全能满足这个功能,下面直接看code:

#生成测试结果
class Out_color:
    FOREGROUND_WHITE = 0x0007
    FOREGROUND_BLUE = 0x01 | 0x08# text color contains blue.
    FOREGROUND_GREEN= 0x02 | 0x08 # text color contains green.
    FOREGROUND_RED  = 0x04 | 0x08 # text color contains red.
    FOREGROUND_YELLOW = FOREGROUND_RED | FOREGROUND_GREEN
    STD_OUTPUT_HANDLE= -11
    std_out_handle = ctypes.windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
    
    def __init__(self):
        pass

    #@ set color in computer terminal.
    def set_color(self, color, handle=std_out_handle):
        bool = ctypes.windll.kernel32.SetConsoleTextAttribute(handle, color)
        return bool

    # Failed or Error messge is text color contains red.
    def messge_error(self, str):
        self.set_color(Out_color.FOREGROUND_RED)
        print str
        logger.info(str)
        self.set_color(Out_color.FOREGROUND_WHITE)

    # Passed messge is text color contains green.
    def messge_pass(self, str):
        self.set_color(Out_color.FOREGROUND_GREEN)
        print str
        logger.info(str)
        self.set_color(Out_color.FOREGROUND_WHITE)


	# Title messge is text color contains blue. 
    def title(self, str):
        self.set_color(Out_color.FOREGROUND_BLUE)
        print str
        logger.info(str)
        self.set_color(Out_color.FOREGROUND_WHITE)

		
# =====  test  =====
output=Out_color()
output.messge_pass("Passed")
output.messge_fail("Failed")

总结
使用以上功能可以提高测试脚本的健壮性；

版权声明：本文出自Man_ge博客原创文章，转载必须注明出处：https://blog.csdn.net/Man_ge/article/details/83445358
作者：Man_ge https://blog.csdn.net/Man_ge