def __init__(self):
self.log4py = LoggingController()
self.clear = shutil
self.report_path = FilePathUtil().get_report_path()
self.script_log = FilePathUtil().get_scripts_log_path()
self.logcat_path = FilePathUtil().get_logcat_path()
self.crash_log_path = FilePathUtil().get_crash_log_path()
self.screeshot_path = FilePathUtil().get_screenshot_path()
self.anr_path = FilePathUtil().get_anr_path()
def __init__(self):
self.system = platform.system()
self.find_type = None
if self.system is "Windows":
self.find_type = "findstr"
else:
self.find_type = "grep"
self.command = "adb"
self.__serialno = ""
self.crash_log_path = FilePathUtil().get_crash_log_path()
self.screenshot_path = FilePathUtil().get_screenshot_path()
self.dt = DateTimeManager().getCurrentDateTime()
self.log4py = LoggingController()
self.xml_path = FilePathUtil().get_xml_path()
self.parm = ParamCheckUtil()
self.yml_path = FilePathUtil().get_yml_path()
self.anr_path = FilePathUtil().get_anr_path()
class InitDriver(object):
def __init__(self):
self.log4py = LoggingController()
self.run_config = InitConfiger()
self.cmd = Cmd()
self.service_path = FilePathUtil().get_service_path()
self.config = ConfigController(self.service_path)
def init_driver(self):
desired_caps_dict = self.run_config.get_desired_caps_dict()
sno_list = self.cmd.get_device_list()
port = 4723
print(sno_list)
if not len(sno_list):
return None
for sno in sno_list:
# self.cmd.set_serialno(sno)
os.system('appium -p %d' % port)
self.cmd.serialno = sno
desired_caps = desired_caps_dict[sno]
url = 'http://127.0.0.1:%d/wd/hub' % port
num = 0
while num <= 5:
try:
driver = webdriver.Remote(url, desired_caps)
except Exception as e:
self.log4py.error(
"连接appium服务，实例化driver时出错，尝试重连...({})".format(num))
num = num + 1
continue
self.log4py.info("webdriver连接信息：{}：{}".format(
url, str(desired_caps)))
while True:
if self.cmd.port_is_used(port):
port = port + 1
else:
break
print(port)
return driver
def __init__(self, env):
self.log4py = LoggingController()
self.poi_type = {
'交通检查': '10002',
'封路': '10003',
'施工': '10006',
'拥堵': '10007',
'积水': '10008',
'浓雾': '10010',
'结冰': '10011',
'交通事故': '10013',
'实时路况': '10015'
}
self.__env = env
self.path = None
if self.__env == 'online':
self.path = r'https://dzt.xxxxxxxxxx.com/deva/pc/pathAndPoi/no/addInfo'
else:
self.path = r'https://dzt-test.xxxxxxxxx.com/deva/pc/pathAndPoi/no/addInfo'
class Cmd(object):
def __init__(self):
self.system = platform.system()
self.find_type = None
if self.system is "Windows":
self.find_type = "findstr"
else:
self.find_type = "grep"
self.command = "adb"
self.__serialno = ""
self.crash_log_path = FilePathUtil().get_crash_log_path()
self.screenshot_path = FilePathUtil().get_screenshot_path()
self.dt = DateTimeManager().getCurrentDateTime()
self.log4py = LoggingController()
self.xml_path = FilePathUtil().get_xml_path()
self.parm = ParamCheckUtil()
self.yml_path = FilePathUtil().get_yml_path()
self.anr_path = FilePathUtil().get_anr_path()
@property
def serialno(self):
return self.__serialno
@serialno.setter
def serialno(self, sno):
self.__serialno = sno
def adb(self, args):
if self.__serialno == "" or self.__serialno is None:
cmd = "%s %s" % (self.command, str(args))
else:
cmd = "%s -s %s %s" % (self.command, self.__serialno, str(args))
return subprocess.Popen(cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
def shell(self, args):
if self.__serialno == "" or self.__serialno is None:
cmd = "%s shell %s" % (self.command, str(args))
else:
cmd = "%s -s %s shell %s" % (self.command, self.__serialno,
str(args))
return subprocess.Popen(cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
def get_device_state(self):
"""
获取设备状态
"""
return self.adb("get-state").stdout.read().decode('utf-8').strip()
def get_device_sno(self):
"""
获取设备id
"""
return self.adb("get-serialno").stdout.read().decode('utf-8').strip()
def get_device_list(self):
"""
获取设备列表
"""
devices = []
result = subprocess.Popen("adb devices",
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE).stdout.readlines()
result.reverse()
for line in result[1:]:
if "attached" not in line.decode('utf-8').strip(
) and "daemon" not in line.decode('utf-8').strip():
devices.append(line.decode('utf-8').split()[0])
else:
break
# print(devices)
return devices
def get_device_num(self):
return len(self.get_device_list())
def get_android_os_version(self):
"""
获取设备中的Android版本号
"""
return self.shell("getprop ro.build.version.release").stdout.read(
).decode('utf-8').strip()
def get_sdk_version(self):
"""
获取设备SDK版本号
"""
return self.shell("getprop ro.build.version.sdk").stdout.read().decode(
'utf-8').strip()
def get_device_model(self):
"""
获取设备型号
"""
return self.shell("getprop ro.product.model").stdout.read().decode(
'utf-8').strip()
def get_device_brand(self):
"""
获取设备品牌
"""
return self.shell("getprop ro.product.brand").stdout.read().decode(
'utf-8').strip()
def get_device_name(self):
"""
获取设备名称
"""
return self.shell("getprop ro.product.name").stdout.read().decode(
'utf-8').strip()
def get_device_board(self):
"""
获取设备处理器型号
"""
return self.shell("getprop ro.product.board").stdout.read().decode(
'utf-8').strip()
def get_screen_size(self):
"""
获取屏幕分辨率
"""
return self.shell("wm size").stdout.read().decode('utf-8').split(
": ")[1].strip()
def get_device_dpi(self):
"""
获取屏幕dpi
"""
return self.shell("wm density").stdout.read().decode('utf-8').split(
": ")[1].strip()
def get_device_ip(self):
"""
获取ip
"""
ip = self.shell("ifconfig wlan0").stdout.readlines()[1].decode(
'utf-8').split()[1].split(":")[1]
return ip
def get_device_mac(self):
"""
获取MAC地址
"""
return self.shell("cat /sys/class/net/wlan0/address").stdout.read(
).decode('utf-8').strip()
def get_device_cpu(self):
"""
获取CPU信息
"""
return self.shell("cat /proc/cpuinfo").stdout.read().decode(
'utf-8').strip()
def get_device_memory(self):
"""
获取系统内存信息
"""
return self.shell("cat /proc/meminfo").stdout.read().decode(
'utf-8').strip()
def get_device_ram(self):
"""
获取ram信息
"""
ram_k = int(self.shell("cat /proc/meminfo").stdout.readlines()[0].decode('utf-8').\
split()[1])
ram_g = ram_k // 1000000
if ram_k % 10000000 >= 500000:
ram_g += 1
return ram_g
def get_app_memory(self, packageName):
"""
获取应用内存信息
"""
return self.shell("cat dumpsys meminfo %s | %s TOTAL" % (packageName, self.find_type))\
.stdout.read().decode('utf-8').strip()
def get_cpu_time(self):
"""
获取总的cpu使用时间
"""
return self.shell("cat /proc/stat").stdout.read().decode(
'utf-8').strip()
def get_pid_cpu_jiff(self, pid):
"""
获取进程cpu时间片
"""
return self.shell("cat /proc/%s/stat" %
pid).stdout.read().decode('utf-8').strip()
def get_pid_fps(self, packageName):
"""
获取进程fps
"""
return self.shell("dumpsys gfxinfo %s" %
packageName).stdout.read().decode('utf-8').strip()
def get_pid_flow(self):
pass
def get_uid(self):
pass
def get_app_version(self, packageName):
return self.shell(
"dumpsys package %s | %s versionName" %
(packageName,
self.find_type)).stdout.read().decode('utf-8').split('=')[1]
def get_app_pid(self, packageName):
"""
获取进程pid
"""
if self.system is "Windows":
pidinfo = self.shell("ps | findstr %s$" %
packageName).stdout.read()
else:
pidinfo = self.shell("ps | grep -w %s" % packageName).stdout.read()
if pidinfo == '':
return "the process doesn't exist."
pattern = re.compile(r"\d+")
result = pidinfo.decode('utf-8').split(" ")
result.remove(result[0])
return pattern.findall(" ".join(result))[0]
# def is_app_running(self, packageName):
# if self
def get_focused_package_and_activity(self):
"""
获取当前应用包名和Activity
:return:
"""
return self.shell("dumpsys window | %s mCurrentFocus" % self.find_type).stdout.\
read().decode('utf-8').split()[-1][:-1]
def get_current_package_name(self):
"""
获取当前应用包名
"""
return self.get_focused_package_and_activity().split('/')[0]
def get_current_activity(self):
"""
获取当前应用Activity
"""
return self.get_focused_package_and_activity().split('/')[1]
def get_system_app_list(self):
"""
获取设备中安装的系统应用包名列表
"""
sysApp = []
for packages in self.shell("pm list packages -s").stdout.readlines():
sysApp.append(
packages.split(
str.encode(":"))[-1].decode('utf-8').splitlines()[0])
return sysApp
def get_all_app_list(self):
"""
获取设备中安装的所有应用列表
"""
allApp = []
for packages in self.shell("pm list packages").stdout.readlines():
allApp.append(
packages.split(
str.encode(":"))[-1].decode('utf-8').splitlines()[0])
return allApp
def get_third_app_list(self):
"""
获取设备中安装的第三方应用包名列表
"""
thirdApp = []
for packages in self.shell("pm list packages -3").stdout.readlines():
thirdApp.append(
packages.split(
str.encode(":"))[-1].decode('utf-8').splitlines()[0])
return thirdApp
def get_matching_app_list(self, keyword):
"""
模糊查询与keyword匹配的应用包名列表
"""
matApp = []
for packages in self.shell("pm list packages %s" %
keyword).stdout.readlines():
matApp.append(
packages.split(
str.encode(":"))[-1].decode('utf-8').splitlines()[0])
return matApp
def get_app_start_total_time(self, component):
"""
获取启动应用所花时间
"""
time = self.shell("am start -W %s | %s TotalTime" % (component, self.find_type)) \
.stdout.read().split(str.encode(": "))[-1]
return int(time)
def do_install_app(self, appFile, packageName):
"""
安装app，app名字不能含中文字符
args:- appFile -: app路径
usage: install("d:\\apps\\Weico.apk")
"""
self.adb("install %s" % appFile)
if not self.is_install_app(packageName):
return True
else:
return False
def do_uninstall_app(self, packageName):
"""
卸载应用
"""
self.adb(" uninstall %s" % packageName)
if not self.is_install_app(packageName):
return True
else:
return False
def is_install_app(self, packageName):
"""
判断应用是否安装，已安装返回True，否则返回False
"""
flag = False
result = self.get_third_app_list()
if result is None or len(result) < 0:
return None
for i in result:
if re.search(packageName, i.strip()):
flag = True
return flag
def do_pull_file(self, remote, local):
"""
pull文件
"""
self.adb(" pull %s %s" % (remote, local))
def do_push_file(self, local, remote):
"""
push文件
"""
self.adb(" push %s %s" % (local, remote))
def do_clear_app_data(self, packageName):
"""
清除应用用户数据
"""
if "Success" in self.shell(
"pm clear %s" %
packageName).stdout.read().decode('utf-8').splitlines():
return "clear user data success "
else:
return "make sure package exist"
def do_start_activity(self, component):
"""
启动一个Activity
"""
self.shell("am start -n %s" % component)
def do_reset_current_app(self):
"""
重置当前应用
"""
packageName = self.get_current_package_name()
component = self.get_focused_package_and_activity()
self.do_clear_app_data(packageName)
self.do_start_activity(component)
def do_reboot(self):
"""
重启设备
"""
self.adb("reboot")
def do_kill_process(self, pid):
"""
杀死应用进程
"""
if self.shell("kill %s" %
str(pid)).stdout.read().decode().split(": ")[-1] == "":
return "kill success"
else:
return self.shell("kill %s" %
str(pid)).stdout.read().decode().split(": ")[-1]
def do_quit_app(self, packageName):
"""
退出app，类似于kill掉进程
"""
self.shell("am force-stop %s" % packageName)
def get_adb_process_pid(self):
"""
获取adb进程pid
"""
pid = os.popen("lsof -i tcp:5037").readlines()[1].split()[1]
return pid
def port_is_used(self, port):
flag = False
port_res = subprocess.Popen('lsof -i tcp:%s' % port,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE).stdout.readlines()
print(port_res)
if len(port_res):
return True
return flag
def do_stop_and_restart_5037(self):
"""
杀掉并重启adb进程，目前只适配了mac
"""
pid = os.popen("lsof -i tcp:5037").readlines()[1].split()[1]
os.system("kill 9 %s" % pid)
os.system("adb start-server")
def get_crash_log(self):
self.adb(r" pull /sdcard/crash/ %s" % self.crash_log_path)
self.log4py.debug("pull crash to result/logs/crash")
def clear_crash_log(self):
self.shell(r" rm -rf sdcard/crash/")
self.log4py.debug("clear device crash")
def get_anr(self):
self.adb(r" pull /data/anr/ %s" % self.anr_path)
self.log4py.debug("pull anr to result/logs/anr")
def clear_anr(self):
self.shell(r" rm -rf /data/anr/")
self.log4py.debug("clear device anr")
def close_logcat(self):
self.shell("killall -2 logcat")
# os.system("adb shell killall -2 logcat")
def clear_logcat(self):
os.popen('adb logcat -b all -c')
# 封装截图方法
def get_screenshot(self):
path = self.screenshot_path + self.dt + r".png"
self.adb("exec-out screencap -p > %s" % path)
return path
def get_uidump_xml(self, yml_name):
if float(self.get_sdk_version()) >= 19:
self.shell(
"uiautomator dump --compressed /data/local/tmp/uidump.xml"
).wait()
else:
self.shell("uiautomator dump /data/local/tmp/uidump.xml").wait()
self.adb("pull /data/local/tmp/uidump.xml %s" %
(self.xml_path + str(self.get_current_package_name()) +
".xml")).wait()
self.shell("rm /data/local/tmp/uidump.xml").wait()
xml_file_name = str(self.get_current_package_name()) + ".xml"
print(xml_file_name)
dict = {}
dict1 = self.parm.load_xml_data(xml_file_name)
dict[self.get_current_package_name()] = dict1
self.parm.write_yaml_data(yml_name, dict)
def __init__(self):
self.log4py = LoggingController()
self.run_config = InitConfiger()
self.cmd = Cmd()
self.service_path = FilePathUtil().get_service_path()
self.config = ConfigController(self.service_path)
def __init__(self):
self.cmd = Cmd()
self.path = FilePathUtil().get_config_run_path()
self.config = ConfigController(self.path)
self.log4py = LoggingController()
self.dev_info = DeviceInfo().get_infos_as_dict()
from page_ddox.set_ll_obj import set_ll_page_obj
from common.utils.LoggingUtil import LoggingController
from poco.drivers.android.uiautomation import AndroidUiautomationPoco
from common.utils.DateTimeUtil import DateTimeManager
from common.baseapi.BaseAppiumApi import BaseAppiumApi
from common.base.BroadcastCommand import BroadcastCommand
DATE_FORMAT = '%Y-%m-%d %H:%M:%S'
driver = None
cmd = Cmd()
bccmd = BroadcastCommand()
fc = FileClearUtil()
fp = FilePathUtil()
dt = DateTimeManager()
log = LoggingController()
def pytest_addoption(parser):
parser.addoption("--cmdopt",
action="store",
default="device_info",
help=None)
@pytest.fixture
def cmdopt(pytestconfig):
#两种写法
return pytestconfig.getoption("--cmdopt")
#return pytestconfig.option.cmdopt
class BaseAppiumApi():
def __init__(self, driver):
self.adb = Cmd()
self.driver = driver
self.log4py = LoggingController()
self.ta = TouchAction()
self.pauseTime = 5
# find_element_by_name 1.5以上的版本已弃用
# 替代方法 BY.XPATH "//*[contains(@text, '开启')]"
def find_element_I(self,loc,timeout=10,poll=0.5):
try:
self.log4py.debug("【定位元素】元素:%s" % str(loc))
return WebDriverWait(self.driver,timeout,poll).until(lambda x:x.find_element(*loc))
except Exception as e:
print(e)
self.log4py.error("【定位元素失败】元素:%s 超时时间:%ds" % (str(loc), timeout))
return None
def find_elements_I(self,loc,timeout=10,poll=0.5):
try:
self.log4py.debug("【定位元素】元素:%s" % str(loc))
return WebDriverWait(self.driver,timeout,poll).until(lambda x:x.find_elements(*loc))
except Exception as e:
print(e)
self.log4py.error("【定位元素失败】元素:%s 超时时间:%ds" % (str(loc), timeout))
return None
def click_element(self,loc):
self.find_element_I(loc).click()
self.log4py.info("【点击】元素:%s" % str(loc))
def click_elements(self,loc,num):
self.find_elements_I(loc)[num].click()
self.log4py.info("【点击】元素:%s 索引:%d" % (str(loc), num))
def input_text(self,loc,text):
"""
在元素中模拟输入（开启appium自带的输入法并配置了appium输入法后，可以输入中英文）
"""
input = self.find_element_I(loc)
# self.do_clear(input)
input.send_keys(text)
self.log4py.info("【输入】元素:%s 文本:%s" % (str(loc), str(text)))
def get_toast(self, loc, timeout=30, poll=0.5):
"""
获取toast
"""
if self.find_element_I(loc, timeout, poll) is None:
self.log4py.error("Toast get fail")
return False
else:
self.log4py.info("Toast get success")
return True
def swipe(self,start_x, start_y, end_x, end_y, duration):
"""
滑动屏幕
"""
self.log4py.info("【滑动】起:x-%s y-%s 止:x-%s y-%s" % (start_x, start_y, end_x, end_y))
self.driver.swipe(start_x, start_y, end_x, end_y, duration)
def is_enabled(self, loc):
"""
返回元素是否可用
"""
element = self.find_element_I(loc)
isEnabled = element.is_enabled()
self.log4py.info("%s 是否可用： %s" % (loc, isEnabled))
return isEnabled
def is_selected(self, loc):
"""
返回元素是否选择。
可以用来检查一个复选框或单选按钮被选中。
"""
is_selected = self.find_element_I(loc).is_selected()
self.log4py.debug("%s 是否被选中： %s" % (loc, is_selected))
return is_selected
def is_element_exist(self, el):
"""
判断元素是否存在
"""
# element = self.find_element_I(loc)
source = self.get_page_source()
if el in source:
self.log4py.debug("元素%s 存在" % el)
return True
else:
self.log4py.error("元素%s 不存在" % el)
return False
def do_sleep(self, millisecond=3):
"""
time.sleep
"""
try:
self.log4py.info("【sleep】%ss" % millisecond)
time.sleep(millisecond)
except Exception as e:
self.log4py.error("sleep error:" + str(e))
def do_navigate_back(self):
"""
返回
"""
self.driver.back()
self.log4py.info("【返回】")
def get_current_activity(self):
"""
获取Activity，调用时不需要括号
"""
activity = self.driver.current_activity
self.log4py.debug("【当前Activity】%s" % activity)
return activity
def get_current_url(self):
"""
获取当前页面的网址
"""
url = self.driver.current_url()
self.log4py.debug("【当前页面网址】%s" % url)
return url
def get_page_source(self):
"""
获取当前页面的源
"""
# source = self.driver.page_source()
source = self.driver.page_source
self.log4py.debug("【当前页面的源】%s" % source)
return source
def get_tag_name(self, loc):
"""
经实践返回的是class name
"""
tag_name = self.driver.find_element_I(loc).tag_name
self.log4py.debug("%s TagName: %s" % (loc, tag_name))
return tag_name
def get_text(self, loc):
"""
返回元素的文本值
"""
text = self.driver.find_element_I(loc).text
self.log4py.debug("%s text: %s" % (loc, str(text)))
return text
def get_screen_size(self):
"""
返回屏幕分辨率（长和宽）
"""
x = self.driver.get_window_size()['width']
y = self.driver.get_window_size()['height']
self.log4py.debug("屏幕分辨率：x-%s y-%s" % (x, y))
return (x, y)
def do_clear(self, loc):
"""
清除输入的内容
"""
element = self.find_element_I(loc)
element.clear()
self.log4py.info("【清空输入】%s" % str(loc))
def do_swipe_up(self, duration_time):
"""
向上滑动
"""
size_screen = self.driver.get_screen_size()
x_start = int(size_screen[0] * 0.5)
x_end = x_start
y_start = int(size_screen[1] * 0.75)
y_end = int(size_screen[1] * 0.25)
self.driver.swipe(x_start, y_start, x_end, y_end, duration_time)
self.log4py.debug("【向上滑动屏幕】")
def do_swipe_down(self, duration_time):
"""
向下滑动
"""
size_screen = self.driver.get_screen_size()
x_start = int(size_screen[0] * 0.5)
x_end = x_start
y_start = int(size_screen[1] * 0.25)
y_end = int(size_screen[1] * 0.75)
self.driver.swipe(x_start, y_start, x_end, y_end, duration_time)
self.log4py.debug("【向下滑动屏幕】")
def do_swipe_left(self, duration_time):
"""
向左滑动
"""
size_screen = self.driver.get_screen_size()
y_start = int(size_screen[1] * 0.5)
y_end = y_start
x_start = int(size_screen[0] * 0.75)
x_end = int(size_screen[0] * 0.25)
self.driver.swipe(x_start, y_start, x_end, y_end, duration_time)
self.log4py.debug("【向左滑动屏幕】")
def do_swipe_right(self, driver, duration_time):
"""
向右滑动屏幕
"""
size_screen = self.driver.get_screen_size()
y_start = int(size_screen[0] * 0.5)
y_end = y_start
x_start = int(size_screen[0] * 0.25)
x_end = int(size_screen[0] * 0.75)
self.driver.swipe(x_start, y_start, x_end, y_end, duration_time)
self.log4py.debug("【向右滑动屏幕】")
def do_tap(self, x, y, count = 500) :
"""
点击坐标位置
"""
self.ta.tap(x, y, count)
self.log4py.info("【点击】坐标:x-%s y-%s" % (x, y))
def do_pinch(self,element):
'''
双指缩放屏幕
'''
self.driver.pinch(element=element)
self.log4py.debug("【双指缩放屏幕】")
def do_zoom(self, element):
'''
放大操作
'''
self.driver.zoom(element=element)
self.log4py.debug("【放大操作】")
def do_shake(self):
"""
摇一摇设备
"""
self.log4py.debug("【摇一摇设备】")
self.driver.shake()
def do_flick(self, start_x, start_y, end_x, end_y):
"""
快速滑动
"""
self.log4py.debug("x:%s y:%s 快速滑动至 x：%s y：%s" % (start_x, start_y, end_x, end_y))
return self.driver.flick(start_x, start_y, end_x, end_y)
def get_screenshot(self, filepath):
"""
截取当前窗口的截图，如果有写入错误会返回False，其它返回True
"""
try:
self.driver.get_screenshot_as_file(filepath)
self.log4py.debug("保存屏幕截图成功，地址：%s" % filepath)
except Exception as e:
self.log4py.error("保存屏幕截图失败，失败信息：%s " % str(e))
def get_contexts(self):
"""
返回当前会话的当前上下文
"""
return self.driver.contexts
def get_current_context(self):
"""
返回当前会话的当前上下文
"""
return self.driver.current_context
def get_context(self):
"""
返回当前会话中的上下文，使用后可以识别H5页面的控件
"""
return self.driver.contexts
def do_reset(self):
"""
删除应用数据
"""
self.driver.reset()
def do_hide_keyboard(self, key_name=None, key=None, strategy=None):
"""
隐藏键盘，安卓不需要参数。ios使用key_name隐藏
"""
self.driver.hide_keyboard()
def do_keyevent(self, keycode, metastate=None):
"""
发送按键码,Android特有
按键码可参考：http://developer.android.com/reference/android/view/KeyEvent.html
"""
self.driver.keyevent(keycode)
# self.log4py.info("【发送按键码】keycode:%s" % keycode)
def do_press_keycode(self, keycode, metastate=None):
"""
发送按钮码，Android独有
参考：http://developer.android.com/reference/android/view/KeyEvent.html
"""
self.driver.press_keycode(keycode)
def do_long_press_keycode(self, keycode, metastate=None):
"""
发送一个长按的按键码
"""
self.driver.long_press_keycode(keycode)
def do_background_app(self, seconds):
"""
后台运行app多少秒
"""
self.log4py.info("将app放置后台%s秒" % str(seconds))
self.driver.background_app(seconds)
def is_app_installed(self, bundle_id):
"""
检查app是否安装
"""
is_installed = self.driver.is_app_installed(bundle_id)
self.log4py.debug("%s 是否安装: %s" % (bundle_id, is_installed))
return is_installed
def do_install_app(self, app_path):
"""
安装app
"""
self.driver.install_app(app_path)
self.log4py.debug("已安装应用: %s" % app_path)
def do_remove_app(self, app_id):
"""
删除app
"""
self.log4py.debug("删除app：%s" % app_id)
self.driver.remove_app(app_id)
def do_launch_app(self):
"""
启动app
"""
self.log4py.debug("启动app")
self.driver.launch_app()
def do_close_app(self):
"""
关闭app
"""
self.log4py.debug("关闭app")
self.driver.close_app()
def do_start_activity(self, app_package, app_activity, **opts):
"""
在测试过程中打开任意活动。如果活动属于另一个应用程序，该应用程序的启动和活动被打开。安卓独有
"""
# self.log4py.info("【启动应用】package：%s activity：%s" % (app_package, app_activity))
self.driver.start_activity(app_package, app_activity)
def do_lock(self, seconds):
"""
锁屏一段时间，ios独有
"""
self.log4py.debug("锁屏%s秒" % seconds)
self.driver.lock(seconds)
def do_open_notifications(self):
"""
打系统通知栏（仅支持API 18 以上的安卓系统）
"""
self.log4py.debug("打开系统通知栏")
self.driver.open_notifications()
def get_network_connection(self):
"""
返回网络类型 数值
"""
network_connection = self.driver.network_connection
self.log4py.debug("网络类型： %s" % network_connection)
return network_connection
def set_network_connection(self, connectionType):
"""
设置网络类型，安卓独有
Possible values:
Value (Alias) | Data | Wifi | Airplane Mode
-------------------------------------------------
0 (None) | 0 | 0 | 0
1 (Airplane Mode) | 0 | 0 | 1
2 (Wifi only) | 0 | 1 | 0
4 (Data only) | 1 | 0 | 0
6 (All network on) | 1 | 1 | 0
用法：
先加载from appium.webdriver.connectiontype import ConnectionType
dr.set_network_connection(ConnectionType.WIFI_ONLY)
"""
self.log4py.debug("网络切换为： %s" % connectionType)
self.driver.set_network_connection(connectionType)
def get_available_ime_engines(self):
"""
返回安卓设备可用的输入法，安卓独有
"""
available_ime = self.driver.available_ime_engines
self.log4py.info("可见的输入法：%s" % available_ime)
return available_ime
def is_ime_active(self):
"""
检查设备是否有输入法服务活动，安卓独有
"""
is_active = self.driver.is_ime_active()
self.log4py.debug("是否有输入法服务: %s" % is_active)
return is_active
def do_activate_ime_engine(self, engine):
"""
激活安卓设备中的指定输入法，设备可用输入法可以从“available_ime_engines”获取
"""
self.log4py.info("激活输入法： %s" % engine)
self.driver.activate_ime_engine(engine)
def deactivate_ime_engine(self):
"""
关闭安卓设备当前的输入法,安卓独有
"""
self.log4py.info("关闭当前输入法")
self.driver.deactivate_ime_engine()
def get_active_ime_engine(self):
"""
返回当前输入法的包名
"""
current_ime = self.driver.active_ime_engine
self.log4py.info("获取到当前的输入法： %s" % current_ime)
return current_ime
def device_time(self):
return self.driver.device_time()
def toggle_location_services(self):
"""
打开安卓设备上的位置定位设置,安卓独有
"""
self.log4py.debug("打开位置定位设置")
self.driver.toggle_location_services()
def set_location(self, latitude, longitude, altitude):
"""
设置经纬度
"""
self.log4py.debug("设置纬度：%s 经度：%s 高度：%s" % (latitude, longitude, altitude))
self.driver.set_location(latitude, longitude, altitude)
def __init__(self, driver):
self.adb = Cmd()
self.driver = driver
self.log4py = LoggingController()
self.ta = TouchAction()
self.pauseTime = 5
def __init__(self, path):
self.path = path
self.config = configparser.ConfigParser()
self.config.read(self.path, encoding="utf-8")
self.log4py = LoggingController()
def __init__(self):
self.cmd = Cmd()
self.log4py = LoggingController()
class DeviceInfo(object):
def __init__(self):
self.cmd = Cmd()
self.log4py = LoggingController()
def get_infos_as_dict(self):
try:
info = {}
lists = self.cmd.get_device_list()
if not len(lists):
self.log4py.info("无任何设备处于连接状态")
return None
self.log4py.info("开始获取设备信息.....")
i = 1
for sno in lists:
# self.cmd.set_serialno(sno)
self.cmd.serialno = sno
brand, model, os_version, dpi, screen_size, name = \
self.get_device_info()
info[sno] = {
"brand": brand,
"model": model,
"os_version": os_version,
"dpi": dpi,
"screen_size": screen_size,
"name": name
}
self.log4py.info("%d.设备连接信息：%s-%s" % (i, sno, info[sno]))
# print(info[sno])
i += 1
self.log4py.info("设备信息获取完毕，设备总数量：%s" % len(lists))
# print(info)
# print(len(lists))
return info
except Exception as e:
print(e)
self.log4py.error("获取设备信息时发生错误")
return None
def get_device_info(self):
"""
获取设备信息
"""
try:
name = self.cmd.get_device_sno()
brand = self.cmd.get_device_brand()
model = self.cmd.get_device_model()
os_version = self.cmd.get_android_os_version()
ram = self.cmd.get_device_ram()
dpi = self.cmd.get_device_dpi()
# ip = self.cmd.get_device_ip()
screen_size = self.cmd.get_screen_size()
return brand, model, os_version, dpi, screen_size, name
except Exception as e:
self.log4py.error("Get device info happen ERROR :" + str(e))
return None
class FileClearUtil():
def __init__(self):
self.log4py = LoggingController()
self.clear = shutil
self.report_path = FilePathUtil().get_report_path()
self.script_log = FilePathUtil().get_scripts_log_path()
self.logcat_path = FilePathUtil().get_logcat_path()
self.crash_log_path = FilePathUtil().get_crash_log_path()
self.screeshot_path = FilePathUtil().get_screenshot_path()
self.anr_path = FilePathUtil().get_anr_path()
def do_clear_screenshot(self):
shutil.rmtree(self.screeshot_path)
self.log4py.debug("clear history screenshot")
os.mkdir(self.screeshot_path)
def do_clear_logcat(self):
shutil.rmtree(self.logcat_path)
self.log4py.debug("clear history logcat")
os.mkdir(self.logcat_path)
def do_clear_crash_log(self):
shutil.rmtree(self.crash_log_path)
self.log4py.debug("clear history crash")
os.mkdir(self.crash_log_path)
def do_clear_report(self):
if self.is_file_by_suffix_json(self.report_path):
shutil.rmtree(self.report_path)
self.log4py.debug("clear history report")
os.mkdir(self.report_path)
else:
self.log4py.debug("history report not exist")
def do_clear_script_log(self):
self.clear_file_input(self.script_log)
self.log4py.debug("clear script.log")
def is_file_by_suffix_json(self, path):
Files = os.listdir(path)
if Files != []:
for k in range(len(Files)):
# 提取文件夹内所有文件的后缀
Files[k] = os.path.splitext(Files[k])[1]
Str = '.json'
if Str in Files:
return True
else:
return False
def is_file_by_suffix_log(cls, path):
Files = os.listdir(path)
if Files != []:
for k in range(len(Files)):
# 提取文件夹内所有文件的后缀
Files[k] = os.path.splitext(Files[k])[1]
Str = '.log'
if Str in Files:
return True
else:
return False
def clear_file_input(self, path):
with open(path, "r+") as f:
f.seek(0)
f.truncate()
def do_clear_anr(self):
shutil.rmtree(self.anr_path)
self.log4py.debug("clear history anr")
os.mkdir(self.anr_path)
class FilePathUtil():
def __init__(self):
self.log4py = LoggingController()
def get_project_path(self):
abspath = os.getcwd()
project_path = abspath.split("common")[0]
return project_path
def get_broadcast_path(self):
# broadcast_path = self.get_project_path() + os.sep + "testdata" + os.sep + "yaml" + os.sep + "broadcast.yml"
broadcast_path = self.get_project_path(
) + "testdata" + os.sep + "yaml" + os.sep + "broadcast.yml"
return broadcast_path
def get_config_run_path(self):
config_run_path = self.get_project_path(
) + os.sep + "config" + os.sep + "run.ini"
return config_run_path
def get_scripts_log_path(self):
scripts_log_path = self.get_project_path(
) + os.sep + "result" + os.sep + "logs" + os.sep + "logs4script" + os.sep + "script.log"
self.log4py.info(scripts_log_path)
return scripts_log_path
def get_report_path(self):
report_path = self.get_project_path(
) + os.sep + "result" + os.sep + "reports"
return report_path
def get_yaml_path(self):
yaml_path = self.get_project_path(
) + os.sep + "testdata" + os.sep + "yaml" + os.sep
return yaml_path
def get_service_path(self):
service_path = self.get_project_path(
) + os.sep + "config" + os.sep + "Service.ini"
return service_path
def get_logcat_path(self):
logcat_path = self.get_project_path(
) + os.sep + "result" + os.sep + "logs" + os.sep + "logcat" + os.sep
return logcat_path
def get_crash_log_path(self):
crash_log_path = self.get_project_path(
) + os.sep + "result" + os.sep + "logs" + os.sep + "crashlog"
return crash_log_path
def get_screenshot_path(self):
screenshot_path = self.get_project_path(
) + os.sep + "result" + os.sep + "screenshot" + os.sep
return screenshot_path
def get_xml_path(self):
xml_path = self.get_project_path(
) + "analysis_UIdump" + os.sep + "xml_file" + os.sep
return xml_path
def get_yml_path(self):
yaml_path = self.get_project_path(
) + "analysis_UIdump" + os.sep + "yml_file" + os.sep
return yaml_path
def get_anr_path(self):
anr_path = self.get_project_path(
) + os.sep + "result" + os.sep + "logs" + os.sep + "anr" + os.sep
return anr_path