class MockDRTPort(object):
"""MockPort implementation of the Port interface."""
def __init__(self, host, **kwargs):
prefix = 'mock-'
if 'port_name' in kwargs:
kwargs['port_name'] = kwargs['port_name'][len(prefix):]
self._host = host
self.__delegate = PortFactory(host).get(**kwargs)
self.__real_name = prefix + self.__delegate.name()
def real_name(self):
return self.__real_name
def __getattr__(self, name):
return getattr(self.__delegate, name)
def check_build(self, needs_http):
return True
def check_sys_deps(self, needs_http):
return True
def driver_cmd_line(self):
driver = self.create_driver(0)
return driver.cmd_line()
def _path_to_driver(self):
return self._host.filesystem.abspath(__file__)
def create_driver(self, worker_number):
# We need to create a driver object as the delegate would, but
# overwrite the path to the driver binary in its command line. We do
# this by actually overwriting its cmd_line() method with a proxy
# method that splices in the mock_drt path and command line arguments
# in place of the actual path to the driver binary.
def overriding_cmd_line():
cmd = self.__original_driver_cmd_line()
index = cmd.index(self.__delegate._path_to_driver())
# FIXME: Why does this need to use sys.executable (instead of something mockable)?
cmd[index:index + 1] = [
sys.executable,
self._path_to_driver(), '--platform',
self.name()
]
return cmd
delegated_driver = self.__delegate.create_driver(worker_number)
self.__original_driver_cmd_line = delegated_driver.cmd_line
delegated_driver.cmd_line = overriding_cmd_line
return delegated_driver
def start_helper(self):
pass
def start_http_server(self):
pass
def start_websocket_server(self):
pass
def acquire_http_lock(self):
pass
def stop_helper(self):
pass
def stop_http_server(self):
pass
def stop_websocket_server(self):
pass
def release_http_lock(self):
pass
class MockDRTPort(object):
port_name = 'mock'
@classmethod
def determine_full_port_name(cls, host, options, port_name):
return port_name
def __init__(self, host, port_name, **kwargs):
self.__delegate = PortFactory(host).get(port_name.replace('mock-', ''), **kwargs)
self.__delegate_driver_class = self.__delegate._driver_class
self.__delegate._driver_class = types.MethodType(self._driver_class, self.__delegate)
def __getattr__(self, name):
return getattr(self.__delegate, name)
def check_build(self, needs_http, printer):
return True
def check_sys_deps(self, needs_http):
return True
def _driver_class(self, delegate):
return self._mocked_driver_maker
def _mocked_driver_maker(self, port, worker_number, pixel_tests, no_timeout=False):
path_to_this_file = self.host.filesystem.abspath(__file__.replace('.pyc', '.py'))
driver = self.__delegate_driver_class()(self, worker_number, pixel_tests, no_timeout)
driver.cmd_line = self._overriding_cmd_line(driver.cmd_line,
self.__delegate._path_to_driver(),
sys.executable,
path_to_this_file,
self.__delegate.name())
return driver
@staticmethod
def _overriding_cmd_line(original_cmd_line, driver_path, python_exe, this_file, port_name):
def new_cmd_line(pixel_tests, per_test_args):
cmd_line = original_cmd_line(pixel_tests, per_test_args)
index = cmd_line.index(driver_path)
cmd_line[index:index + 1] = [python_exe, this_file, '--platform', port_name]
return cmd_line
return new_cmd_line
def start_helper(self):
pass
def start_http_server(self, number_of_servers):
pass
def start_websocket_server(self):
pass
def acquire_http_lock(self):
pass
def stop_helper(self):
pass
def stop_http_server(self):
pass
def stop_websocket_server(self):
pass
def release_http_lock(self):
pass
def _make_wdiff_available(self):
self.__delegate._wdiff_available = True
def setup_environ_for_server(self, server_name):
env = self.__delegate.setup_environ_for_server()
# We need to propagate PATH down so the python code can find the checkout.
env['PATH'] = os.environ['PATH']
return env
def lookup_virtual_test_args(self, test_name):
suite = self.__delegate.lookup_virtual_suite(test_name)
return suite.args + ['--virtual-test-suite-name', suite.name, '--virtual-test-suite-base', suite.base]
class MockDRTPort(object):
port_name = 'mock'
@classmethod
def determine_full_port_name(cls, host, options, port_name):
return port_name
def __init__(self, host, port_name, **kwargs):
self.__delegate = PortFactory(host).get(port_name.replace('mock-', ''),
**kwargs)
self.__delegate_driver_class = self.__delegate._driver_class
self.__delegate._driver_class = types.MethodType(
self._driver_class, self.__delegate)
def __getattr__(self, name):
return getattr(self.__delegate, name)
def check_build(self, needs_http, printer):
return test_run_results.OK_EXIT_STATUS
def check_sys_deps(self, needs_http):
return test_run_results.OK_EXIT_STATUS
def _driver_class(self, delegate):
return self._mocked_driver_maker
def _mocked_driver_maker(self,
port,
worker_number,
pixel_tests,
no_timeout=False):
path_to_this_file = self.host.filesystem.abspath(
__file__.replace('.pyc', '.py'))
driver = self.__delegate_driver_class()(self, worker_number,
pixel_tests, no_timeout)
driver.cmd_line = self._overriding_cmd_line(
driver.cmd_line, self.__delegate._path_to_driver(), sys.executable,
path_to_this_file, self.__delegate.name())
return driver
@staticmethod
def _overriding_cmd_line(original_cmd_line, driver_path, python_exe,
this_file, port_name):
def new_cmd_line(pixel_tests, per_test_args):
cmd_line = original_cmd_line(pixel_tests, per_test_args)
index = cmd_line.index(driver_path)
cmd_line[index:index +
1] = [python_exe, this_file, '--platform', port_name]
return cmd_line
return new_cmd_line
def start_helper(self):
pass
def start_http_server(self, additional_dirs, number_of_servers):
pass
def start_websocket_server(self):
pass
def acquire_http_lock(self):
pass
def stop_helper(self):
pass
def stop_http_server(self):
pass
def stop_websocket_server(self):
pass
def release_http_lock(self):
pass
def _make_wdiff_available(self):
self.__delegate._wdiff_available = True
def setup_environ_for_server(self):
env = self.__delegate.setup_environ_for_server()
# We need to propagate PATH down so the python code can find the checkout.
env['PATH'] = os.environ['PATH']
return env
def lookup_virtual_test_args(self, test_name):
suite = self.__delegate.lookup_virtual_suite(test_name)
return suite.args + [
'--virtual-test-suite-name', suite.name,
'--virtual-test-suite-base', suite.base
]
def lookup_virtual_reference_args(self, test_name):
suite = self.__delegate.lookup_virtual_suite(test_name)
return suite.reference_args + [
'--virtual-test-suite-name', suite.name,
'--virtual-test-suite-base', suite.base
]
class MockDRTPort(object):
"""MockPort implementation of the Port interface."""
def __init__(self, host, **kwargs):
prefix = "mock-"
if "port_name" in kwargs:
kwargs["port_name"] = kwargs["port_name"][len(prefix) :]
self._host = host
self.__delegate = PortFactory(host).get(**kwargs)
self.__real_name = prefix + self.__delegate.name()
def real_name(self):
return self.__real_name
def __getattr__(self, name):
return getattr(self.__delegate, name)
def check_build(self, needs_http):
return True
def check_sys_deps(self, needs_http):
return True
def driver_cmd_line(self):
driver = self.create_driver(0)
return driver.cmd_line()
def _path_to_driver(self):
return self._host.filesystem.abspath(__file__)
def create_driver(self, worker_number):
# We need to create a driver object as the delegate would, but
# overwrite the path to the driver binary in its command line. We do
# this by actually overwriting its cmd_line() method with a proxy
# method that splices in the mock_drt path and command line arguments
# in place of the actual path to the driver binary.
def overriding_cmd_line():
cmd = self.__original_driver_cmd_line()
index = cmd.index(self.__delegate._path_to_driver())
# FIXME: Why does this need to use sys.executable (instead of something mockable)?
cmd[index : index + 1] = [sys.executable, self._path_to_driver(), "--platform", self.name()]
return cmd
delegated_driver = self.__delegate.create_driver(worker_number)
self.__original_driver_cmd_line = delegated_driver.cmd_line
delegated_driver.cmd_line = overriding_cmd_line
return delegated_driver
def start_helper(self):
pass
def start_http_server(self):
pass
def start_websocket_server(self):
pass
def acquire_http_lock(self):
pass
def stop_helper(self):
pass
def stop_http_server(self):
pass
def stop_websocket_server(self):
pass
def release_http_lock(self):
pass
class MockDRTPort(object):
"""MockPort implementation of the Port interface."""
port_name = 'mock'
@classmethod
def determine_full_port_name(cls, host, options, port_name):
"""Return a fully-specified port name that can be used to construct objects."""
# Subclasses will usually override this.
return port_name
def __init__(self, host, port_name, **kwargs):
self.__delegate = PortFactory(host).get(port_name.replace('mock-', ''), **kwargs)
self.__real_name = port_name
self._host = host
def real_name(self):
return self.__real_name
def __getattr__(self, name):
return getattr(self.__delegate, name)
def check_build(self, needs_http):
return True
def check_sys_deps(self, needs_http):
return True
def driver_cmd_line(self):
driver = self.create_driver(0)
return driver.cmd_line()
def _path_to_driver(self):
return self._host.filesystem.abspath(__file__)
def create_driver(self, worker_number):
# We need to create a driver object as the delegate would, but
# overwrite the path to the driver binary in its command line. We do
# this by actually overwriting its cmd_line() method with a proxy
# method that splices in the mock_drt path and command line arguments
# in place of the actual path to the driver binary.
def overriding_cmd_line():
cmd = self.__original_driver_cmd_line()
index = cmd.index(self.__delegate._path_to_driver())
# FIXME: Why does this need to use sys.executable (instead of something mockable)?
cmd[index:index + 1] = [sys.executable, self._path_to_driver(), '--platform', self.name()]
return cmd
delegated_driver = self.__delegate.create_driver(worker_number)
self.__original_driver_cmd_line = delegated_driver.cmd_line
delegated_driver.cmd_line = overriding_cmd_line
return delegated_driver
def start_helper(self):
pass
def start_http_server(self):
pass
def start_websocket_server(self):
pass
def acquire_http_lock(self):
pass
def stop_helper(self):
pass
def stop_http_server(self):
pass
def stop_websocket_server(self):
pass
def release_http_lock(self):
pass
class MockDRTPort(object):
"""MockPort implementation of the Port interface."""
port_name = 'mock'
@classmethod
def determine_full_port_name(cls, host, options, port_name):
"""Return a fully-specified port name that can be used to construct objects."""
# Subclasses will usually override this.
return port_name
def __init__(self, host, port_name, **kwargs):
self.__delegate = PortFactory(host).get(port_name.replace('mock-', ''),
**kwargs)
self.__real_name = port_name
self._host = host
def real_name(self):
return self.__real_name
def __getattr__(self, name):
return getattr(self.__delegate, name)
def check_build(self, needs_http):
return True
def check_sys_deps(self, needs_http):
return True
def driver_cmd_line(self):
driver = self.create_driver(0)
return driver.cmd_line()
def _path_to_driver(self):
return self._host.filesystem.abspath(__file__)
def create_driver(self, worker_number):
# We need to create a driver object as the delegate would, but
# overwrite the path to the driver binary in its command line. We do
# this by actually overwriting its cmd_line() method with a proxy
# method that splices in the mock_drt path and command line arguments
# in place of the actual path to the driver binary.
def overriding_cmd_line():
cmd = self.__original_driver_cmd_line()
index = cmd.index(self.__delegate._path_to_driver())
# FIXME: Why does this need to use sys.executable (instead of something mockable)?
cmd[index:index + 1] = [
sys.executable,
self._path_to_driver(), '--platform',
self.name()
]
return cmd
delegated_driver = self.__delegate.create_driver(worker_number)
self.__original_driver_cmd_line = delegated_driver.cmd_line
delegated_driver.cmd_line = overriding_cmd_line
return delegated_driver
def start_helper(self):
pass
def start_http_server(self):
pass
def start_websocket_server(self):
pass
def acquire_http_lock(self):
pass
def stop_helper(self):
pass
def stop_http_server(self):
pass
def stop_websocket_server(self):
pass
def release_http_lock(self):
pass
