# Copyright (C) 2010 Google Inc. All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: # # * Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # * Redistributions in binary form must reproduce the above # copyright notice, this list of conditions and the following disclaimer # in the documentation and/or other materials provided with the # distribution. # * Neither the name of Google Inc. nor the names of its # contributors may be used to endorse or promote products derived from # this software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. import optparse import sys import tempfile import unittest from webkitpy.common.system.executive import Executive, ScriptError from webkitpy.common.system import executive_mock from webkitpy.common.system.filesystem_mock import MockFileSystem from webkitpy.common.system import outputcapture from webkitpy.common.system.path import abspath_to_uri from webkitpy.thirdparty.mock import Mock from webkitpy.tool import mocktool import base import config import config_mock class PortTest(unittest.TestCase): def test_format_wdiff_output_as_html(self): output = "OUTPUT %s %s %s" % (base.Port._WDIFF_DEL, base.Port._WDIFF_ADD, base.Port._WDIFF_END) html = base.Port()._format_wdiff_output_as_html(output) expected_html = "
OUTPUT
" self.assertEqual(html, expected_html) def test_wdiff_command(self): port = base.Port() port._path_to_wdiff = lambda: "/path/to/wdiff" command = port._wdiff_command("/actual/path", "/expected/path") expected_command = [ "/path/to/wdiff", "--start-delete=##WDIFF_DEL##", "--end-delete=##WDIFF_END##", "--start-insert=##WDIFF_ADD##", "--end-insert=##WDIFF_END##", "/actual/path", "/expected/path", ] self.assertEqual(command, expected_command) def _file_with_contents(self, contents, encoding="utf-8"): new_file = tempfile.NamedTemporaryFile() new_file.write(contents.encode(encoding)) new_file.flush() return new_file def test_pretty_patch_os_error(self): port = base.Port(executive=executive_mock.MockExecutive2(exception=OSError)) oc = outputcapture.OutputCapture() oc.capture_output() self.assertEqual(port.pretty_patch_text("patch.txt"), port._pretty_patch_error_html) # This tests repeated calls to make sure we cache the result. self.assertEqual(port.pretty_patch_text("patch.txt"), port._pretty_patch_error_html) oc.restore_output() def test_pretty_patch_script_error(self): # FIXME: This is some ugly white-box test hacking ... port = base.Port(executive=executive_mock.MockExecutive2(exception=ScriptError)) port._pretty_patch_available = True self.assertEqual(port.pretty_patch_text("patch.txt"), port._pretty_patch_error_html) # This tests repeated calls to make sure we cache the result. self.assertEqual(port.pretty_patch_text("patch.txt"), port._pretty_patch_error_html) def test_run_wdiff(self): executive = Executive() # This may fail on some systems. We could ask the port # object for the wdiff path, but since we don't know what # port object to use, this is sufficient for now. try: wdiff_path = executive.run_command(["which", "wdiff"]).rstrip() except Exception, e: wdiff_path = None port = base.Port() port._path_to_wdiff = lambda: wdiff_path if wdiff_path: # "with tempfile.NamedTemporaryFile() as actual" does not seem to work in Python 2.5 actual = self._file_with_contents(u"foo") expected = self._file_with_contents(u"bar") wdiff = port._run_wdiff(actual.name, expected.name) expected_wdiff = "
foobar
" self.assertEqual(wdiff, expected_wdiff) # Running the full wdiff_text method should give the same result. port._wdiff_available = True # In case it's somehow already disabled. wdiff = port.wdiff_text(actual.name, expected.name) self.assertEqual(wdiff, expected_wdiff) # wdiff should still be available after running wdiff_text with a valid diff. self.assertTrue(port._wdiff_available) actual.close() expected.close() # Bogus paths should raise a script error. self.assertRaises(ScriptError, port._run_wdiff, "/does/not/exist", "/does/not/exist2") self.assertRaises(ScriptError, port.wdiff_text, "/does/not/exist", "/does/not/exist2") # wdiff will still be available after running wdiff_text with invalid paths. self.assertTrue(port._wdiff_available) base._wdiff_available = True # If wdiff does not exist _run_wdiff should throw an OSError. port._path_to_wdiff = lambda: "/invalid/path/to/wdiff" self.assertRaises(OSError, port._run_wdiff, "foo", "bar") # wdiff_text should not throw an error if wdiff does not exist. self.assertEqual(port.wdiff_text("foo", "bar"), "") # However wdiff should not be available after running wdiff_text if wdiff is missing. self.assertFalse(port._wdiff_available) def test_diff_text(self): port = base.Port() # Make sure that we don't run into decoding exceptions when the # filenames are unicode, with regular or malformed input (expected or # actual input is always raw bytes, not unicode). port.diff_text('exp', 'act', 'exp.txt', 'act.txt') port.diff_text('exp', 'act', u'exp.txt', 'act.txt') port.diff_text('exp', 'act', u'a\xac\u1234\u20ac\U00008000', 'act.txt') port.diff_text('exp' + chr(255), 'act', 'exp.txt', 'act.txt') port.diff_text('exp' + chr(255), 'act', u'exp.txt', 'act.txt') # Though expected and actual files should always be read in with no # encoding (and be stored as str objects), test unicode inputs just to # be safe. port.diff_text(u'exp', 'act', 'exp.txt', 'act.txt') port.diff_text( u'a\xac\u1234\u20ac\U00008000', 'act', 'exp.txt', 'act.txt') # And make sure we actually get diff output. diff = port.diff_text('foo', 'bar', 'exp.txt', 'act.txt') self.assertTrue('foo' in diff) self.assertTrue('bar' in diff) self.assertTrue('exp.txt' in diff) self.assertTrue('act.txt' in diff) self.assertFalse('nosuchthing' in diff) def test_default_configuration_notfound(self): # Test that we delegate to the config object properly. port = base.Port(config=config_mock.MockConfig(default_configuration='default')) self.assertEqual(port.default_configuration(), 'default') def test_layout_tests_skipping(self): port = base.Port() port.skipped_layout_tests = lambda: ['foo/bar.html', 'media'] self.assertTrue(port.skips_layout_test('foo/bar.html')) self.assertTrue(port.skips_layout_test('media/video-zoom.html')) self.assertFalse(port.skips_layout_test('foo/foo.html')) def test_setup_test_run(self): port = base.Port() # This routine is a no-op. We just test it for coverage. port.setup_test_run() def test_test_dirs(self): port = base.Port() dirs = port.test_dirs() self.assertTrue('canvas' in dirs) self.assertTrue('css2.1' in dirs) def test_filename_to_uri(self): port = base.Port() layout_test_dir = port.layout_tests_dir() test_file = port._filesystem.join(layout_test_dir, "foo", "bar.html") # On Windows, absolute paths are of the form "c:\foo.txt". However, # all current browsers (except for Opera) normalize file URLs by # prepending an additional "/" as if the absolute path was # "/c:/foo.txt". This means that all file URLs end up with "file:///" # at the beginning. if sys.platform == 'win32': prefix = "file:///" path = test_file.replace("\\", "/") else: prefix = "file://" path = test_file self.assertEqual(port.filename_to_uri(test_file), abspath_to_uri(test_file)) def test_get_option__set(self): options, args = optparse.OptionParser().parse_args([]) options.foo = 'bar' port = base.Port(options=options) self.assertEqual(port.get_option('foo'), 'bar') def test_get_option__unset(self): port = base.Port() self.assertEqual(port.get_option('foo'), None) def test_get_option__default(self): port = base.Port() self.assertEqual(port.get_option('foo', 'bar'), 'bar') def test_name__unset(self): port = base.Port() self.assertEqual(port.name(), None) def test_name__set(self): port = base.Port(port_name='foo') self.assertEqual(port.name(), 'foo') def test_additional_platform_directory(self): filesystem = MockFileSystem() options, args = optparse.OptionParser().parse_args([]) port = base.Port(port_name='foo', filesystem=filesystem, options=options) port.baseline_search_path = lambda: [] layout_test_dir = port.layout_tests_dir() test_file = filesystem.join(layout_test_dir, 'fast', 'test.html') # No additional platform directory self.assertEqual( port.expected_baselines(test_file, '.txt'), [(None, 'fast/test-expected.txt')]) # Simple additional platform directory options.additional_platform_directory = ['/tmp/local-baselines'] filesystem.files = { '/tmp/local-baselines/fast/test-expected.txt': 'foo', } self.assertEqual( port.expected_baselines(test_file, '.txt'), [('/tmp/local-baselines', 'fast/test-expected.txt')]) # Multiple additional platform directories options.additional_platform_directory = ['/foo', '/tmp/local-baselines'] self.assertEqual( port.expected_baselines(test_file, '.txt'), [('/tmp/local-baselines', 'fast/test-expected.txt')]) class VirtualTest(unittest.TestCase): """Tests that various methods expected to be virtual are.""" def assertVirtual(self, method, *args, **kwargs): self.assertRaises(NotImplementedError, method, *args, **kwargs) def test_virtual_methods(self): port = base.Port() self.assertVirtual(port.baseline_path) self.assertVirtual(port.baseline_search_path) self.assertVirtual(port.check_build, None) self.assertVirtual(port.check_image_diff) self.assertVirtual(port.create_driver, 0) self.assertVirtual(port.diff_image, None, None) self.assertVirtual(port.path_to_test_expectations_file) self.assertVirtual(port.default_results_directory) self.assertVirtual(port.test_expectations) self.assertVirtual(port._path_to_apache) self.assertVirtual(port._path_to_apache_config_file) self.assertVirtual(port._path_to_driver) self.assertVirtual(port._path_to_helper) self.assertVirtual(port._path_to_image_diff) self.assertVirtual(port._path_to_lighttpd) self.assertVirtual(port._path_to_lighttpd_modules) self.assertVirtual(port._path_to_lighttpd_php) self.assertVirtual(port._path_to_wdiff) self.assertVirtual(port._shut_down_http_server, None) def test_virtual_driver_method(self): self.assertRaises(NotImplementedError, base.Driver, base.Port(), 0) def test_virtual_driver_methods(self): class VirtualDriver(base.Driver): def __init__(self): pass driver = VirtualDriver() self.assertVirtual(driver.run_test, None) self.assertVirtual(driver.poll) self.assertVirtual(driver.stop) class DriverTest(unittest.TestCase): def _assert_wrapper(self, wrapper_string, expected_wrapper): wrapper = base.Driver._command_wrapper(wrapper_string) self.assertEqual(wrapper, expected_wrapper) def test_command_wrapper(self): self._assert_wrapper(None, []) self._assert_wrapper("valgrind", ["valgrind"]) # Validate that shlex works as expected. command_with_spaces = "valgrind --smc-check=\"check with spaces!\" --foo" expected_parse = ["valgrind", "--smc-check=check with spaces!", "--foo"] self._assert_wrapper(command_with_spaces, expected_parse) if __name__ == '__main__': unittest.main()