def __init__(self, addr=DEFAULT_ADDR):
try:
port = int(addr.rsplit(":", 1)[-1])
except ValueError:
raise ValueError(
'Argument `addr` should be a string-like format. e.g. "ws://192.168.1.2:5003". Got {}'
.format(repr(addr)))
if not current_device():
connect_device("Android:///")
if device_platform() == 'Android':
local_port, _ = current_device().adb.setup_forward(
'tcp:{}'.format(port))
ip = 'localhost'
port = local_port
elif device_platform() == 'IOS':
# Note: ios is now support for now.
# ip = device.get_ip_address()
# use iproxy first
ip = 'localhost'
local_port, _ = current_device().instruct_helper.setup_proxy(port)
port = local_port
else:
import socket
ip = socket.gethostbyname(socket.gethostname())
self.conn = WebSocketClient('ws://{}:{}'.format(ip, port))
self.c = RpcClient(self.conn)
self.c.connect()
hierarchy = FrozenUIHierarchy(Dumper(self.c))
screen = AirtestScreen()
inputs = AirtestInput()
super(CocosJsPocoAgent, self).__init__(hierarchy, inputs, screen, None)
def __init__(self, port=DEFAULT_PORT, device=None, **kwargs):
self.device = device or current_device()
if not self.device:
self.device = connect_device("Android:///")
platform_name = device_platform(self.device)
if platform_name == 'Android':
# always forward for android device to avoid network unreachable
local_port, _ = self.device.adb.setup_forward(
'tcp:{}'.format(port))
ip = self.device.adb.host or 'localhost'
port = local_port
elif platform_name == 'IOS':
# ip = device.get_ip_address()
# use iproxy first
ip = 'localhost'
local_port, _ = self.device.instruct_helper.setup_proxy(port)
port = local_port
else:
try:
ip = self.device.get_ip_address()
except AttributeError:
try:
ip = socket.gethostbyname(socket.gethostname())
except socket.gaierror:
# 某些特殊情况下会出现这个error，无法正确获取本机ip地址
ip = 'localhost'
agent = StdPocoAgent((ip, port))
super(StdPoco, self).__init__(agent, **kwargs)
def applyMotionEvents(self, events):
if device_platform() != 'Android':
raise NotImplementedError
# Android minitouch only, currently
from airtest.core.android.minitouch import DownEvent, MoveEvent, UpEvent, SleepEvent
mes = []
for e in events:
t = e[0]
if t == 'd':
contact = e[2]
x, y = e[1]
pos = self.get_target_pos(x, y)
me = DownEvent(pos, contact)
elif t == 'm':
contact = e[2]
x, y = e[1]
pos = self.get_target_pos(x, y)
me = MoveEvent(pos, contact)
elif t == 'u':
contact = e[1]
me = UpEvent(contact)
elif t == 's':
how_long = e[1]
me = SleepEvent(how_long)
else:
raise ValueError('Unknown event type {}'.format(repr(t)))
mes.append(me)
current_device().minitouch.perform(mes, interval=0)
def StartRecording(self):
if device_platform(self.m_oDev) == 'Windows':
output = os.path.join(self.logdir, 'recording_0.mp4')
video.InitVideoRecorder(self.m_oDev)
self.m_oDev.start_recording(output)
else:
self.m_oDev.start_recording()
def __init__(self, port, device=None):
self.device = device or current_device()
if not self.device:
self.device = connect_device("Android:///")
platform_name = device_platform(self.device)
if platform_name == 'Android':
local_port, _ = self.device.adb.setup_forward(
'tcp:{}'.format(port))
ip = self.device.adb.host or 'localhost'
port = local_port
elif platform_name == 'IOS':
# Note: ios is now support for now.
# ip = device.get_ip_address()
# use iproxy first
ip = 'localhost'
local_port, _ = self.device.instruct_helper.setup_proxy(port)
port = local_port
else:
ip = self.device.get_ip_address()
# transport
self.conn = WebSocketClient('ws://{}:{}'.format(ip, port))
self.c = RpcClient(self.conn)
self.c.connect()
hierarchy = FrozenUIHierarchy(Dumper(self.c))
screen = AirtestScreen()
inputs = AirtestInput()
super(CocosJsPocoAgent, self).__init__(hierarchy, inputs, screen, None)
def _get_touch_resolution(self):
"""
get real time resolution on device if full screen
or window size if running in window mode
"""
if device_platform() == 'Android':
if self.use_render_resolution:
return current_device().get_render_resolution()
w, h = current_device().get_current_resolution()
return 0, 0, w, h
def app_fixture(request):
"""
相当于setupclass、teardownclas，提供公共资源，测试完毕释放资源
"""
with allure.step("工程初始化和生成APP对象"):
"""
setup code
"""
logger.info("Session start test.")
ST.THRESHOLD_STRICT = 0.6
client_platform = os.getenv('client_platform')
try:
app = None
if client_platform == ANDROID_PLATFORM:
app = AndroidApp(
Phone(client_platform, phone_ip, phone_port, request.param,
app_name))
elif client_platform == IOS_PLATFORM:
app = IOSApp(
Phone(client_platform, phone_ip, phone_port, request.param,
app_name))
app.base_page.app_name = app.app_name
except Exception as e:
logger.error("create app fail: {}".format(e))
allure.attach(body='',
name="create app fail: {}".format(e),
attachment_type=allure.attachment_type.TEXT)
pytest.exit("create app fail: {}".format(e))
assert (app is not None)
app.ensure_current_device()
logger.info("current test platform: {}".format(device_platform()))
logger.info("start app {0} in {1}:{2}".format(app.app_name,
client_platform,
G.DEVICE.uuid))
wake_device(G.DEVICE)
def teardown_test():
"""
teardown code
"""
with allure.step("teardown session"):
pass
logger.info("Session stop test.")
request.addfinalizer(teardown_test) # 注册teardown, 这样即使setup出现异常，也可以最终调用到
return app
def __init__(self, port=DEFAULT_PORT, device=None, **kwargs):
device = device or current_device()
ip = socket.gethostbyname(socket.gethostname())
if not device:
import warnings
warnings.warn(
"no airtest device connected, please connect_device first")
elif device_platform(device) == 'Android':
# always forward for android device to avoid network unreachable
local_port, _ = device.adb.setup_forward('tcp:{}'.format(port))
ip = device.adb.host or 'localhost'
port = local_port
elif device_platform(device) == 'IOS':
# ip = device.get_ip_address()
# use iproxy first
ip = 'localhost'
local_port, _ = device.instruct_helper.setup_proxy(port)
port = local_port
agent = StdPocoAgent((ip, port))
super(StdPoco, self).__init__(agent, **kwargs)
def __init__(self, port=DEFAULT_PORT, device=None, **kwargs):
device = device or current_device()
if not device:
raise RuntimeError('Please call `connect_device` first. see airtest.core.api.connect_device to get '
'more infomation')
# always forward for android device to avoid network unreachable
if device_platform() == 'Android':
local_port, _ = device.adb.setup_forward('tcp:{}'.format(port))
ip = 'localhost'
port = local_port
elif device_platform() == 'IOS':
# ip = device.get_ip_address()
# use iproxy first
ip = 'localhost'
else:
import socket
ip = socket.gethostbyname(socket.gethostname())
# Note: ios is not support for now.
agent = StdPocoAgent((ip, port))
super(StdPoco, self).__init__(agent, **kwargs)
def setUpClass(cls):
super(AndroidAppCase, cls).setUpClass()
if not current_device():
connect_device('Android:///')
dev = current_device()
meta_info_emitter = cls.get_result_emitter('metaInfo')
if device_platform() == 'Android':
meta_info_emitter.snapshot_device_info(dev.serialno,
dev.adb.get_device_info())
cls.poco = AndroidUiautomationPoco(screenshot_each_action=False)
action_tracker = ActionTracker(cls.poco)
cls.register_addon(action_tracker)
cls.site_capturer = SiteCaptor(cls.poco)
cls.register_addon(cls.site_capturer)
def __init__(self,
addr=DEFAULT_ADDR,
unity_editor=False,
connect_default_device=True):
# init airtest env
try:
# new version
from airtest.core.api import connect_device, device as current_device
from airtest.core.helper import device_platform
if unity_editor and not current_device():
connect_device(
"Windows:///?class_name=UnityWndClass&title_re=Unity.*")
game_window = current_device().app.top_window().child_window(
title="UnityEditor.GameView")
current_device()._top_window = game_window.wrapper_object()
current_device().focus_rect = (0, 40, 0, 0)
if connect_default_device and not current_device():
# currently only connect to Android as default
# can apply auto detection in the future
connect_device("Android:///")
if device_platform() == "Android":
# always forward port for Android
# unity games poco sdk listens on Android localhost:5001
current_device().adb.forward("tcp:%s" % addr[1], "tcp:5001",
False)
except ImportError:
# old version, 逐渐废弃
from airtest.cli.runner import device as current_device
from airtest.core.main import set_serialno
if not current_device():
set_serialno()
# unity games poco sdk listens on Android localhost:5001
current_device().adb.forward("tcp:%s" % addr[1], "tcp:5001", False)
self.conn = TcpClient(addr)
self.c = RpcClient(self.conn)
self.c.DEBUG = False
self.c.wait_connected()
hierarchy = FrozenUIHierarchy(Dumper(self.c), UnityAttributor(self.c))
screen = UnityScreen(self.c)
input = AirtestInput()
super(UnityPocoAgent, self).__init__(hierarchy, input, screen, None)
def _get_touch_resolution(self):
"""
get real time resolution on device if full screen
or window size if running in window mode
"""
if device_platform() == 'Windows':
if self.surface is None:
raise RuntimeError(
'Please initialize AirtestInput with surface object, '
'when running test suites on windows as target device.')
return self.surface.getPortSize()
else:
display_info = current_device().display_info
w, h = display_info["width"], display_info["height"]
if display_info["orientation"] in (1, 3):
return h, w
else:
return w, h
def __init__(self,
game_name,
phone_name="",
on_connect=None,
on_close=None):
"""address is (host, port) tuple"""
self.game_name = game_name
self.info = Information()
self.phone_name = phone_name
self.on_connect = on_connect
self.on_close = on_close
self.sock = None
self.buf = b""
self.prot = SimpleProtocolFilter()
self.device = None or current_device()
if not self.device and self.phone_name != None:
self.device = connect_device("Android:///" + self.phone_name)
self.platform_name = device_platform(self.device)
self.connect_phone()
self.address = (self.ip, self.port)
def app_fixture(request):
"""
相当于setupclass、teardownclas，提供公共资源，测试完毕释放资源
"""
with allure.step("工程初始化和生成APP对象"):
"""
setup code
"""
logger.info("Session start test.")
ST.THRESHOLD_STRICT = 0.6
client_platform = os.getenv('client_platform')
app = TestAPP(
Phone(client_platform, phone_ip, phone_port, request.param,
app_name))
assert (app is not None)
app.ensure_current_device()
logger.info("current test platform: {}".format(device_platform()))
logger.info("start app {0} in {1}:{2}".format(app.app_name,
client_platform,
G.DEVICE.uuid))
def teardown_test():
"""
teardown code
"""
with allure.step("teardown session"):
pass
logger.info("Session stop test.")
request.addfinalizer(teardown_test) # 注册teardown, 这样即使setup出现异常，也可以最终调用到
return app
