def _assert_skipped_path(self, search_paths, os_name, use_webkit2=False, qt_version='4.8'): host = MockSystemHost(os_name=os_name) host.executive = MockExecutive2(self._qt_version(qt_version)) port_name = 'qt-' + os_name port = self.make_port(host=host, qt_version=qt_version, port_name=port_name, options=MockOptions(webkit_test_runner=use_webkit2, platform='qt')) self.assertEquals(port._skipped_file_search_paths(), search_paths)
def test_format_docstrings(self): host = MockSystemHost() host.stdin = StringIO.StringIO( ''' def f(): """ triple-quoted docstring with multiple lines """ x = """ this is a regular multi-line string, not a docstring """ return x ''' ) main(host, ["-"]) self.assertMultiLineEqual( host.stdout.getvalue(), ''' def f(): """triple-quoted docstring with multiple lines """ x = """ this is a regular multi-line string, not a docstring """ return x ''', )
def make_port(self, executive=None, with_tests=False, **kwargs): host = MockSystemHost() if executive: host.executive = executive if with_tests: add_unit_tests_to_mock_filesystem(host.filesystem) return TestPort(host, **kwargs) return Port(host, **kwargs)
def _assert_search_path(self, search_paths, sys_platform, use_webkit2=False, qt_version='4.8'): # FIXME: Port constructors should not "parse" the port name, but # rather be passed components (directly or via setters). Once # we fix that, this method will need a re-write. host = MockSystemHost() host.executive = MockExecutive2(self._qt_version(qt_version)) port = QtPort(host, sys_platform=sys_platform, options=MockOptions(webkit_test_runner=use_webkit2, platform='qt')) absolute_search_paths = map(port._webkit_baseline_path, search_paths) self.assertEquals(port.baseline_search_path(), absolute_search_paths)
def assert_version_properties(self, port_name, os_version, expected_name, expected_version, driver_file_output=None): host = MockSystemHost(os_name=self.os_name, os_version=(os_version or self.os_version)) host.filesystem.isfile = lambda x: 'content_shell' in x if driver_file_output: host.executive = executive_mock.MockExecutive2(driver_file_output) port = self.make_port(host=host, port_name=port_name, os_version=os_version) self.assertEqual(port.name(), expected_name) self.assertEqual(port.version(), expected_version)
def _assert_expectations_files(self, search_paths, os_name, use_webkit2=False, qt_version='4.8'): # FIXME: Port constructors should not "parse" the port name, but # rather be passed components (directly or via setters). Once # we fix that, this method will need a re-write. host = MockSystemHost(os_name=os_name) host.executive = MockExecutive2(self._qt_version(qt_version)) port_name = 'qt-' + os_name port = self.make_port(host=host, qt_version=qt_version, port_name=port_name, options=MockOptions(webkit_test_runner=use_webkit2, platform='qt')) self.assertEquals(port.expectations_files(), search_paths)
def test_wdiff_text_fails(self): host = MockSystemHost(os_name=self.os_name, os_version=self.os_version) host.executive = MockExecutive(should_throw=True) port = self.make_port(host=host) port._executive = host.executive # AndroidPortTest.make_port sets its own executive, so reset that as well. # This should raise a ScriptError that gets caught and turned into the # error text, and also mark wdiff as not available. self.make_wdiff_available(port) self.assertTrue(port.wdiff_available()) diff_txt = port.wdiff_text("/tmp/foo.html", "/tmp/bar.html") self.assertEqual(diff_txt, port._wdiff_error_html) self.assertFalse(port.wdiff_available())
def test_test_files(self): host = MockSystemHost() files = { "/mock-checkout/LayoutTests/canvas/philip/test.html": "", "/mock-checkout/LayoutTests/fast/canvas/test.html": "", "/mock-checkout/LayoutTests/fast/html/test.html": "", "/mock-checkout/LayoutTests/foo/bar.html": "", } host.filesystem = MockFileSystem(files) def test_paths(port_name): return PortFactory(host).get(port_name).tests([]) self.assertEqual(test_paths("chromium-gpu-linux"), set(["canvas/philip/test.html", "fast/canvas/test.html"]))
def _assert_search_path(self, search_paths, os_name, use_webkit2=False, qt_version="4.8"): # FIXME: Port constructors should not "parse" the port name, but # rather be passed components (directly or via setters). Once # we fix that, this method will need a re-write. host = MockSystemHost(os_name=os_name) host.executive = MockExecutive2(self._qt_version(qt_version)) port_name = "qt-" + os_name port = self.make_port( host=host, qt_version=qt_version, port_name=port_name, options=MockOptions(webkit_test_runner=use_webkit2, platform="qt"), ) absolute_search_paths = map(port._webkit_baseline_path, search_paths) self.assertEqual(port.baseline_search_path(), absolute_search_paths)
def __init__(self, log_executive=False, executive_throws_when_run=None, initialize_scm_by_default=True, web=None, scm=None): MockSystemHost.__init__(self, log_executive, executive_throws_when_run) add_unit_tests_to_mock_filesystem(self.filesystem) self.web = web or MockWeb() self._scm = scm # FIXME: we should never initialize the SCM by default, since the real # object doesn't either. This has caused at least one bug (see bug 89498). if initialize_scm_by_default: self.initialize_scm() self.buildbot = MockBuildBot() # Note: We're using a real PortFactory here. Tests which don't wish to depend # on the list of known ports should override this with a MockPortFactory. self.port_factory = PortFactory(self)
def assert_architecture(self, port_name=None, file_output=None, expected_architecture=None): host = MockSystemHost() host.filesystem.exists = lambda x: 'content_shell' in x if file_output: host.executive = executive_mock.MockExecutive2(file_output) port = self.make_port(host, port_name=port_name) self.assertEqual(port.architecture(), expected_architecture) if expected_architecture == 'x86': self.assertTrue(port.baseline_path().endswith('chromium-linux-x86')) self.assertTrue(port.baseline_search_path()[0].endswith('chromium-linux-x86')) self.assertTrue(port.baseline_search_path()[1].endswith('chromium-linux')) else: self.assertTrue(port.baseline_path().endswith('chromium-linux')) self.assertTrue(port.baseline_search_path()[0].endswith('chromium-linux'))
def test_determine_architecture_fails(self): # Test that we default to 'x86' if the driver doesn't exist. port = self.make_port() self.assertEqual(port.architecture(), 'x86_64') # Test that we default to 'x86' on an unknown architecture. host = MockSystemHost() host.filesystem.exists = lambda x: True host.executive = executive_mock.MockExecutive2('win32') port = self.make_port(host=host) self.assertEqual(port.architecture(), 'x86_64') # Test that we raise errors if something weird happens. host.executive = executive_mock.MockExecutive2(exception=AssertionError) self.assertRaises(AssertionError, chromium_linux.ChromiumLinuxPort, host, self.port_name)
def test_test_files(self): host = MockSystemHost() files = { '/mock-checkout/LayoutTests/canvas/philip/test.html': '', '/mock-checkout/LayoutTests/fast/canvas/test.html': '', '/mock-checkout/LayoutTests/fast/html/test.html': '', '/mock-checkout/LayoutTests/media/test.html': '', '/mock-checkout/LayoutTests/foo/bar.html': '', } host.filesystem = MockFileSystem(files) def test_paths(port_name): return PortFactory(host).get(port_name).tests([]) self.assertEqual(test_paths('chromium-gpu-linux'), set(['canvas/philip/test.html', 'fast/canvas/test.html', 'media/test.html'])) self.assertEqual(test_paths('chromium-gpu-mac-leopard'), set(['canvas/philip/test.html', 'fast/canvas/test.html']))
def __init__(self, log_executive=False, executive_throws_when_run=None): MockSystemHost.__init__(self, log_executive, executive_throws_when_run) add_unit_tests_to_mock_filesystem(self.filesystem) self.web = MockWeb() self._checkout = MockCheckout() self._scm = MockSCM(filesystem=self.filesystem, executive=self.executive) # Various pieces of code (wrongly) call filesystem.chdir(checkout_root). # Making the checkout_root exist in the mock filesystem makes that chdir not raise. self.filesystem.maybe_make_directory(self._scm.checkout_root) self.bugs = MockBugzilla() self.buildbot = MockBuildBot() self._chromium_buildbot = MockBuildBot() # Note: We're using a real PortFactory here. Tests which don't wish to depend # on the list of known ports should override this with a MockPortFactory. self.port_factory = PortFactory(self) self._watch_list = MockWatchList()
def test_helper_fails_to_stop(self): host = MockSystemHost(MockExecutive()) host.executive._proc = MockProcess() def bad_waiter(): raise IOError('failed to wait') host.executive._proc.wait = bad_waiter port = self.make_port(host) with OutputCapture(): port.start_helper() port.stop_helper()
def test_format_docstrings_indentation(self): host = MockSystemHost() host.stdin = StringIO.StringIO( ''' def f(): """This is a docstring With extra indentation on this line. """ ''' ) main(host, ["-"]) self.assertMultiLineEqual( host.stdout.getvalue(), ''' def f(): """This is a docstring With extra indentation on this line. """ ''', )
def test_test_expectations(self): # Check that we read the expectations file host = MockSystemHost() host.filesystem.write_text_file( '/mock-checkout/LayoutTests/platform/testwebkitport/TestExpectations', 'BUG_TESTEXPECTATIONS SKIP : fast/html/article-element.html = FAIL\n' ) port = TestWebKitPort(host=host) self.assertEqual( ''.join(port.expectations_dict().values()), 'BUG_TESTEXPECTATIONS SKIP : fast/html/article-element.html = FAIL\n' )
def test_main(self): host = MockSystemHost() test.add_unit_tests_to_mock_filesystem(host.filesystem) stdin = newstringio.StringIO() stdout = newstringio.StringIO() stderr = newstringio.StringIO() res = mock_drt.main(['--platform', 'test'] + self.extra_args(False), host, stdin, stdout, stderr) self.assertEqual(res, 0) self.assertEqual(stdout.getvalue(), '') self.assertEqual(stderr.getvalue(), '') self.assertEqual(host.filesystem.written_files, {})
def test_get_timestamp_from_logs_darwin(self): if not SystemHost().platform.is_mac(): return crash_report = make_mock_crash_report_darwin('DumpRenderTree', 28528) crash_logs = CrashLogs(MockSystemHost(), CrashLogsTest.DARWIN_MOCK_CRASH_DIRECTORY) crash_timestamp = crash_logs.get_timestamp_from_log(crash_report) self.assertIn('2011-12-07 13:27:34.816', str(crash_timestamp)) crash_report = crash_report.replace("Date/Time", "") crash_timestamp = crash_logs.get_timestamp_from_log(crash_report) self.assertIsNone(crash_timestamp)
def test_main(self): host = MockSystemHost() test.add_unit_tests_to_mock_filesystem(host.filesystem) stdin = io.BytesIO() stdout = io.BytesIO() stderr = io.BytesIO() res = mock_drt.main(['--run-layout-test', '--platform', 'test', '-'], host, stdin, stdout, stderr) self.assertEqual(res, 0) self.assertEqual(stdout.getvalue(), '#READY\n') self.assertEqual(stderr.getvalue(), '') self.assertEqual(host.filesystem.written_files, {})
def test_helper_starts(self): host = MockSystemHost(MockExecutive()) port = self.make_port(host) oc = OutputCapture() oc.capture_output() host.executive._proc = MockProcess('ready\n') port.start_helper() port.stop_helper() oc.restore_output() # make sure trying to stop the helper twice is safe. port.stop_helper()
def get_shards(self, num_workers, fully_parallel, run_singly, test_list=None, max_locked_shards=1): port = TestPort(MockSystemHost()) self.sharder = Sharder(port.split_test, max_locked_shards) test_list = test_list or self.test_list return self.sharder.shard_tests( [self.get_test_input(test) for test in test_list], num_workers, fully_parallel, run_singly)
def test_two_drivers(self): mock_adb = MockAndroidDebugBridge(2) mock_executive = MockExecutive2(run_command_fn=mock_adb.run_command) port = android.AndroidPort(MockSystemHost(executive=mock_executive), 'android') driver0 = android.ChromiumAndroidDriver(port, worker_number=0, pixel_tests=True, driver_details=android.ContentShellDriverDetails(), android_devices=port._devices) driver1 = android.ChromiumAndroidDriver(port, worker_number=1, pixel_tests=True, driver_details=android.ContentShellDriverDetails(), android_devices=port._devices) self.assertEqual(['adb', '-s', '123456789ABCDEF0', 'shell'], driver0.cmd_line(True, [])) self.assertEqual(['adb', '-s', '123456789ABCDEF1', 'shell'], driver1.cmd_line(True, ['anything']))
def __init__(self, port_name=None, expectations_file=None, skips_file=None, host=None, config=None, **kwargs): port_name = port_name or TestWebKitPort.port_name host = host or MockSystemHost() super(TestWebKitPort, self).__init__(host, port_name=port_name, **kwargs)
def mock_host_for_simctl(): simctl_json = json.loads( simctl_json_output ) # Construct enough of a filesystem for all our simctl code to work. filesystem_map = {} runtime_name_to_id = {} # Runtime mapping for runtime_group in simctl_json['runtimes']: runtime_name_to_id[ runtime_group['name']] = runtime_group['identifier'] # Device type mapping device_type_name_to_id = {} for device_type in simctl_json['devicetypes']: device_type_name_to_id[ device_type['name']] = device_type['identifier'] for runtime, device_groups in simctl_json['devices'].iteritems(): for device in device_groups: file_path = '/Users/mock' + SimulatedDeviceManager.simulator_device_path[ 1:] + '/' + device['udid'] + '/device.plist' # We're taking advantage the fact that the names of the devices match the names of their runtimes in the # provided JSON ouput. This is not generally true, which is why we're only using this fact to build up # a mock filesystem that is used by the actual simctl parsing code. filesystem_map[ file_path] = """<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE plist SYSTEM "{}"> <plist version="1.0"> <dict> <key>UDID</key> <string>{}</string> <key>deviceType</key> <string>{}</string> <key>name</key> <string>{}</string> <key>runtime</key> <string>{}</string> <key>state</key> <integer>{}</integer> </dict> </plist>""".format( file_path, device['udid'], device_type_name_to_id[device['name']], device['name'], runtime_name_to_id[runtime], SimulatedDevice.NAME_FOR_STATE.index( device['state'].upper())) return MockSystemHost( executive=MockExecutive2(output=simctl_json_output), filesystem=MockFileSystem(files=filesystem_map), )
def setUp(self): host = MockSystemHost() options = MockOptions(configuration='Release', additional_drt_flag=['--test-shell']) config = MockConfig(filesystem=host.filesystem, default_configuration='Release') self.port = chromium_mac.ChromiumMacPort(host, 'chromium-mac-snowleopard', options=options, config=config) self.driver = chromium.ChromiumDriver(self.port, worker_number=0, pixel_tests=True)
def assert_port_works(self, port_name, input_name=None, platform=None): host = MockSystemHost() host.filesystem = FileSystem() # FIXME: This test should not use a real filesystem! # test that we got the right port mock_options = MockOptions(accelerated_2d_canvas=None, accelerated_video=None, builder_name='foo', child_processes=None) if input_name and platform: port = PortFactory(host).get(host, platform=platform, port_name=input_name, options=mock_options) else: port = PortFactory(host).get(host, port_name=port_name, options=mock_options) self.assertTrue(port._options.accelerated_2d_canvas) self.assertTrue(port._options.accelerated_video) self.assertTrue(port._options.experimental_fully_parallel) self.assertEqual(port._options.builder_name, 'foo - GPU') self.assertTrue(port.name().startswith(port_name)) # test that it has the right directories in front of the search path. paths = port.baseline_search_path() self.assertEqual(port._webkit_baseline_path(port_name), paths[0]) if port_name == 'chromium-gpu-linux': self.assertEqual(port._webkit_baseline_path('chromium-gpu-win'), paths[1]) self.assertEqual(port._webkit_baseline_path('chromium-gpu'), paths[2]) else: self.assertEqual(port._webkit_baseline_path('chromium-gpu'), paths[1]) # Test that we're limiting to the correct directories. # These two tests are picked mostly at random, but we make sure they # exist separately from being filtered out by the port. # Note that this is using a real filesystem. files = port.tests(None) path = 'fast/html/keygen.html' self.assertTrue(port._filesystem.exists(port.abspath_for_test(path))) self.assertFalse(path in files)
def make_port(self, options=mock_options): host = MockSystemHost() test.add_unit_tests_to_mock_filesystem(host.filesystem) if sys.platform == 'win32': # We use this because the 'win' port doesn't work yet. host.platform.os_name = 'win' host.platform.os_version = 'xp' return mock_drt.MockDRTPort(host, port_name='mock-chromium-win', options=options) return mock_drt.MockDRTPort(host, port_name='mock-mac', options=options)
def setUp(self): self._mock_adb = MockAndroidDebugBridge(1) self._mock_executive = MockExecutive2(run_command_fn=self._mock_adb.run_command) self._port = android.AndroidPort(MockSystemHost(executive=self._mock_executive), 'android') self._driver = android.ChromiumAndroidDriver(self._port, worker_number=0, pixel_tests=True, driver_details=android.ContentShellDriverDetails(), android_devices=self._port._devices) self._errors = [] self._driver._log_error = lambda msg: self._errors.append(msg) self._warnings = [] self._driver._log_warning = lambda msg: self._warnings.append(msg)
def make_driver(self, worker_number=0, xorg_running=False, executive=None): port = Port(host=MockSystemHost(log_executive=True, executive=executive), config=MockConfig()) port._server_process_constructor = MockServerProcess if xorg_running: port._executive._running_pids['Xorg'] = 108 driver = XvfbDriver(port, worker_number=worker_number, pixel_tests=True) driver._startup_delay_secs = 0 return driver
def assert_architecture(self, port_name=None, file_output=None, expected_architecture=None): host = MockSystemHost() host.filesystem.exists = lambda x: 'DumpRenderTree' in x if file_output: host.executive = executive_mock.MockExecutive2(file_output) port = self.make_port(host, port_name=port_name) self.assertEqual(port.architecture(), expected_architecture) if expected_architecture == 'x86': self.assertTrue( port.baseline_path().endswith('chromium-linux-x86')) self.assertTrue( port.baseline_search_path()[0].endswith('chromium-linux-x86')) self.assertTrue( port.baseline_search_path()[1].endswith('chromium-linux')) else: self.assertTrue(port.baseline_path().endswith('chromium-linux')) self.assertTrue( port.baseline_search_path()[0].endswith('chromium-linux'))
def test_default_profiler_output(self): host = MockSystemHost() self.assertFalse(host.filesystem.exists("/tmp/output")) # Default mocks are Mac, so iprofile should be default. profiler = ProfilerFactory.create_profiler(host, '/bin/executable', '/tmp/output') self.assertTrue(host.filesystem.exists("/tmp/output")) self.assertEqual(profiler._output_path, "/tmp/output/test.dtps") # Linux defaults to perf. host.platform.os_name = 'linux' profiler = ProfilerFactory.create_profiler(host, '/bin/executable', '/tmp/output') self.assertEqual(profiler._output_path, "/tmp/output/test.data")
def __init__(self, port_name=None, symbols_string=None, expectations_file=None, skips_file=None, host=None, config=None, **kwargs): port_name = port_name or TestWebKitPort.port_name self.symbols_string = symbols_string # Passing "" disables all staticly-detectable features. host = host or MockSystemHost() super(TestWebKitPort, self).__init__(host, port_name=port_name, **kwargs)
def test_stop(self): port = Port(MockSystemHost(log_executive=True), 'xvfbdrivertestport', options=MockOptions(configuration='Release')) port._executive.kill_process = lambda x: _log.info("MOCK kill_process pid: " + str(x)) driver = XvfbDriver(port, worker_number=0, pixel_tests=True) class FakeXvfbProcess(object): pid = 1234 driver._xvfb_process = FakeXvfbProcess() expected_logs = "MOCK kill_process pid: 1234\n" OutputCapture().assert_outputs(self, driver.stop, [], expected_logs=expected_logs) self.assertIsNone(driver._xvfb_process)
def make_driver(self, worker_number=0, xorg_running=False, executive=None): port = Port(MockSystemHost(log_executive=True, executive=executive), 'xvfbdrivertestport', options=MockOptions(configuration='Release')) port._config.build_directory = lambda configuration: "/mock-build" port._server_process_constructor = MockServerProcess if xorg_running: port._executive._running_pids['Xorg'] = 108 driver = XvfbDriver(port, worker_number=worker_number, pixel_tests=True) driver._startup_delay_secs = 0 return driver
def test_pixeltest__fails(self): host = MockSystemHost() url = '#URL:file://' url = url + '%s/failures/expected/image_checksum.html' % PortFactory(host).get('test').layout_tests_dir() self.assertTest('failures/expected/image_checksum.html', pixel_tests=True, expected_checksum='image_checksum', drt_output=[url + '\n', '#MD5:image_checksum-checksum\n', 'image_checksum-txt', '\n', '#EOF\n'], host=host) self.assertEqual(host.filesystem.written_files, {'/tmp/png_result0.png': 'image_checksum\x8a-pngtEXtchecksum\x00image_checksum-checksum'})
def test_two_drivers(self): mock_run_command = MockRunCommand() mock_run_command.mock_two_devices() port = chromium_android.ChromiumAndroidPort( MockSystemHost(executive=MockExecutive2(run_command_fn=mock_run_command.mock_run_command_fn)), 'chromium-android') driver0 = chromium_android.ChromiumAndroidDriver(port, worker_number=0, pixel_tests=True) driver1 = chromium_android.ChromiumAndroidDriver(port, worker_number=1, pixel_tests=True) cmd_line0 = driver0.cmd_line(True, ['anything']) self.assertEquals(['adb', '-s', mock_run_command._mock_devices[0], 'shell'], cmd_line0) cmd_line1 = driver1.cmd_line(True, ['anything']) self.assertEquals(['adb', '-s', mock_run_command._mock_devices[1], 'shell'], cmd_line1)
def make_driver(self): port = Port(MockSystemHost(log_executive=True), 'westondrivertestport', options=MockOptions(configuration='Release')) port._config.build_directory = lambda configuration: "/mock_build" port._test_runner_process_constructor = MockServerProcess driver = WestonDriver(port, worker_number=0, pixel_tests=True) driver._startup_delay_secs = 0 driver._expected_xvfbdisplay = 23 driver._xvfbdriver = WestonXvfbDriverDisplayTest( driver._expected_xvfbdisplay) driver._environment = port.setup_environ_for_server(port.driver_name()) return driver
def test_test_files(self): host = MockSystemHost() files = { '/mock-checkout/LayoutTests/canvas/philip/test.html': '', '/mock-checkout/LayoutTests/fast/canvas/test.html': '', '/mock-checkout/LayoutTests/fast/html/test.html': '', '/mock-checkout/LayoutTests/media/test.html': '', '/mock-checkout/LayoutTests/foo/bar.html': '', } host.filesystem = MockFileSystem(files) def test_paths(port_name): return PortFactory(host).get(port_name).tests([]) self.assertEqual( test_paths('chromium-gpu-linux'), set([ 'canvas/philip/test.html', 'fast/canvas/test.html', 'media/test.html' ])) self.assertEqual( test_paths('chromium-gpu-mac-leopard'), set(['canvas/philip/test.html', 'fast/canvas/test.html']))
def __init__(self, log_executive=False, executive_throws_when_run=None, initialize_scm_by_default=True): MockSystemHost.__init__(self, log_executive, executive_throws_when_run) add_unit_tests_to_mock_filesystem(self.filesystem) self.web = MockWeb() self._checkout = MockCheckout() self._scm = None # FIXME: we should never initialize the SCM by default, since the real # object doesn't either. This has caused at least one bug (see bug 89498). if initialize_scm_by_default: self._initialize_scm() self.bugs = MockBugzilla() self.buildbot = MockBuildBot() self._chromium_buildbot = MockBuildBot() # Note: We're using a real PortFactory here. Tests which don't wish to depend # on the list of known ports should override this with a MockPortFactory. self.port_factory = PortFactory(self) self._watch_list = MockWatchList()
def test_check(self): errors = [] def mock_handle_style_error(line_number, category, confidence, message): error = (line_number, category, confidence, message) errors.append(error) file_path = '' fs = MockFileSystem() scm = MockSCMDetector('svn') checker = PNGChecker(file_path, mock_handle_style_error, scm, MockSystemHost(filesystem=fs)) checker.check() self.assertEquals(len(errors), 1) self.assertEquals(errors[0], (0, 'image/png', 5, 'Set the svn:mime-type property (svn propset svn:mime-type image/png ).')) files = {'/Users/mock/.subversion/config': 'enable-auto-props = yes\n*.png = svn:mime-type=image/png'} fs = MockFileSystem(files) scm = MockSCMDetector('git') errors = [] checker = PNGChecker("config", mock_handle_style_error, scm, MockSystemHost(os_name='linux', filesystem=fs)) checker.check() self.assertEquals(len(errors), 0) files = {'/Users/mock/.subversion/config': '#enable-auto-props = yes'} fs = MockFileSystem(files) scm = MockSCMDetector('git') errors = [] checker = PNGChecker("config", mock_handle_style_error, scm, MockSystemHost(os_name='linux', filesystem=fs)) checker.check() self.assertEquals(len(errors), 1) files = {'/Users/mock/.subversion/config': 'enable-auto-props = yes\n#enable-auto-props = yes\n*.png = svn:mime-type=image/png'} fs = MockFileSystem(files) scm = MockSCMDetector('git') errors = [] checker = PNGChecker("config", mock_handle_style_error, scm, MockSystemHost(os_name='linux', filesystem=fs)) checker.check() self.assertEquals(len(errors), 0) files = {'/Users/mock/.subversion/config': '#enable-auto-props = yes\nenable-auto-props = yes\n*.png = svn:mime-type=image/png'} fs = MockFileSystem(files) scm = MockSCMDetector('git') errors = [] checker = PNGChecker("config", mock_handle_style_error, scm, MockSystemHost(os_name='linux', filesystem=fs)) checker.check() self.assertEquals(len(errors), 0) files = {'/Users/mock/.subversion/config': 'enable-auto-props = no'} fs = MockFileSystem(files) scm = MockSCMDetector('git') errors = [] checker = PNGChecker("config", mock_handle_style_error, scm, MockSystemHost(os_name='linux', filesystem=fs)) checker.check() self.assertEquals(len(errors), 1)
def create_crash_logs_darwin(self): if not SystemHost().platform.is_mac(): return self.older_mock_crash_report = make_mock_crash_report_darwin( 'DumpRenderTree', 28528) self.sandbox_crash_report = make_mock_sandbox_report_darwin( 'DumpRenderTree', 28530) self.mock_crash_report = make_mock_crash_report_darwin( 'DumpRenderTree', 28530) self.newer_mock_crash_report = make_mock_crash_report_darwin( 'DumpRenderTree', 28529) self.other_process_mock_crash_report = make_mock_crash_report_darwin( 'FooProcess', 28527) self.misformatted_mock_crash_report = 'Junk that should not appear in a crash report' + make_mock_crash_report_darwin( 'DumpRenderTree', 28526)[200:] self.files = {} self.files[ '/Users/mock/Library/Logs/DiagnosticReports/DumpRenderTree_2011-06-13-150715_quadzen.crash'] = self.older_mock_crash_report self.files[ '/Users/mock/Library/Logs/DiagnosticReports/DumpRenderTree_2011-06-13-150716_quadzen_1.crash'] = self.older_mock_crash_report self.files[ '/Users/mock/Library/Logs/DiagnosticReports/DumpRenderTree_2011-06-13-150717_quadzen_2.crash'] = self.older_mock_crash_report self.files[ '/Users/mock/Library/Logs/DiagnosticReports/DumpRenderTree_2011-06-13-150718_quadzen.crash'] = self.sandbox_crash_report self.files[ '/Users/mock/Library/Logs/DiagnosticReports/DumpRenderTree_2011-06-13-150719_quadzen.crash'] = self.mock_crash_report self.files[ '/Users/mock/Library/Logs/DiagnosticReports/DumpRenderTree_2011-06-13-150720_quadzen.crash'] = self.newer_mock_crash_report self.files[ '/Users/mock/Library/Logs/DiagnosticReports/DumpRenderTree_2011-06-13-150721_quadzen.crash'] = None self.files[ '/Users/mock/Library/Logs/DiagnosticReports/DumpRenderTree_2011-06-13-150722_quadzen.crash'] = self.other_process_mock_crash_report self.files[ '/Users/mock/Library/Logs/DiagnosticReports/DumpRenderTree_2011-06-13-150723_quadzen.crash'] = self.misformatted_mock_crash_report self.files = { key: string_utils.encode(value) for key, value in self.files.items() } self.filesystem = MockFileSystem(self.files) crash_logs = CrashLogs(MockSystemHost(filesystem=self.filesystem), CrashLogsTest.DARWIN_MOCK_CRASH_DIRECTORY) logs = self.filesystem.files_under( '/Users/mock/Library/Logs/DiagnosticReports/') for path in reversed(sorted(logs)): self.assertTrue(path in self.files.keys()) return crash_logs
def make_driver(self, worker_number=0, xorg_running=False, executive=None): port = Port(MockSystemHost(log_executive=True, executive=executive), 'xvfbdrivertestport', options=MockOptions(configuration='Release')) port._config.build_directory = lambda configuration: "/mock-build" port._test_runner_process_constructor = MockServerProcess if xorg_running: port._executive._running_pids['Xorg'] = 108 driver = XvfbDriver(port, worker_number=worker_number, pixel_tests=True) driver._startup_delay_secs = 0 driver._xvfb_screen_depth = lambda: '24' driver._xvfb_pipe = lambda: (3, 4) driver._xvfb_read_display_id = lambda x: 1 driver._xvfb_close_pipe = lambda p: None driver._port_server_environment = port.setup_environ_for_server(port.driver_name()) return driver
def make_port(self, host=None, port_name=None, options=None, os_name=None, os_version=None, **kwargs): host = host or MockSystemHost(os_name=(os_name or self.os_name), os_version=(os_version or self.os_version)) options = options or optparse.Values({'configuration': 'Release'}) port_name = port_name or self.port_name port_name = self.port_maker.determine_full_port_name( host, options, port_name) return self.port_maker(host, port_name, options=options, **kwargs)
def test_stop(self): port = Port(MockSystemHost(log_executive=True), 'xvfbdrivertestport', options=MockOptions(configuration='Release')) port._executive.kill_process = lambda x: _log.info("MOCK kill_process pid: " + str(x)) driver = XvfbDriver(port, worker_number=0, pixel_tests=True) class FakeXvfbProcess(object): pid = 1234 driver._xvfb_process = FakeXvfbProcess() with OutputCapture(level=logging.INFO) as captured: driver.stop() self.assertEqual(captured.root.log.getvalue(), "MOCK kill_process pid: 1234\n") self.assertIsNone(driver._xvfb_process)
def test_find_log_darwin(self): if not SystemHost().platform.is_mac(): return older_mock_crash_report = make_mock_crash_report_darwin( 'DumpRenderTree', 28528) mock_crash_report = make_mock_crash_report_darwin( 'DumpRenderTree', 28530) newer_mock_crash_report = make_mock_crash_report_darwin( 'DumpRenderTree', 28529) other_process_mock_crash_report = make_mock_crash_report_darwin( 'FooProcess', 28527) misformatted_mock_crash_report = 'Junk that should not appear in a crash report' + make_mock_crash_report_darwin( 'DumpRenderTree', 28526)[200:] files = {} files[ '/Users/mock/Library/Logs/DiagnosticReports/DumpRenderTree_2011-06-13-150718_quadzen.crash'] = older_mock_crash_report files[ '/Users/mock/Library/Logs/DiagnosticReports/DumpRenderTree_2011-06-13-150719_quadzen.crash'] = mock_crash_report files[ '/Users/mock/Library/Logs/DiagnosticReports/DumpRenderTree_2011-06-13-150720_quadzen.crash'] = newer_mock_crash_report files[ '/Users/mock/Library/Logs/DiagnosticReports/DumpRenderTree_2011-06-13-150721_quadzen.crash'] = None files[ '/Users/mock/Library/Logs/DiagnosticReports/DumpRenderTree_2011-06-13-150722_quadzen.crash'] = other_process_mock_crash_report files[ '/Users/mock/Library/Logs/DiagnosticReports/DumpRenderTree_2011-06-13-150723_quadzen.crash'] = misformatted_mock_crash_report filesystem = MockFileSystem(files) crash_logs = CrashLogs(MockSystemHost(filesystem=filesystem)) log = crash_logs.find_newest_log("DumpRenderTree") self.assertLinesEqual(log, newer_mock_crash_report) log = crash_logs.find_newest_log("DumpRenderTree", 28529) self.assertLinesEqual(log, newer_mock_crash_report) log = crash_logs.find_newest_log("DumpRenderTree", 28530) self.assertLinesEqual(log, mock_crash_report) log = crash_logs.find_newest_log("DumpRenderTree", 28531) self.assertEqual(log, None) log = crash_logs.find_newest_log("DumpRenderTree", newer_than=1.0) self.assertEqual(log, None) def bad_read(path): raise IOError('No such file or directory') filesystem.read_text_file = bad_read log = crash_logs.find_newest_log("DumpRenderTree", 28531, include_errors=True) self.assertTrue('No such file or directory' in log)
def test_stdin_chromium(self): host = MockSystemHost() host.stdin = StringIO.StringIO(ACTUAL_INPUT) main(host, ["--chromium", "-"]) self.assertMultiLineEqual(host.stdout.getvalue(), EXPECTED_CHROMIUM_OUTPUT)
def test_stdin_blink(self): host = MockSystemHost() host.stdin = StringIO.StringIO(ACTUAL_INPUT) main(host, ["-"]) self.assertMultiLineEqual(host.stdout.getvalue(), EXPECTED_BLINK_OUTPUT)
def test_stdin_no_changes(self): host = MockSystemHost() host.stdin = StringIO.StringIO(ACTUAL_INPUT) main(host, ["--no-autopep8", "--leave-strings-alone", "-"]) self.assertMultiLineEqual(host.stdout.getvalue(), ACTUAL_INPUT)
def test_stdin_only_double_quoting(self): host = MockSystemHost() host.stdin = StringIO.StringIO(ACTUAL_INPUT) main(host, ["--no-autopep8", "--double-quote-strings", "-"]) self.assertMultiLineEqual(host.stdout.getvalue(), EXPECTED_ONLY_DOUBLE_QUOTED_OUTPUT)