def test_coverage_works(self):
# This is awkward; by design, running test-webkitpy -c will
# create a .coverage file in tools, so we need to be
# careful not to clobber an existing one, and to clean up.
# FIXME: This design needs to change since it means we can't actually
# run this method itself under coverage properly.
filesystem = FileSystem()
executive = Executive()
module_path = filesystem.path_to_module(self.__module__)
script_dir = module_path[0:module_path.find('webkitpy') - 1]
coverage_file = filesystem.join(script_dir, '.coverage')
coverage_file_orig = None
if filesystem.exists(coverage_file):
coverage_file_orig = coverage_file + '.orig'
filesystem.move(coverage_file, coverage_file_orig)
try:
proc = executive.popen([
sys.executable,
filesystem.join(script_dir, 'test-webkitpy'), '-c',
STUBS_CLASS + '.test_empty'
],
stdout=executive.PIPE,
stderr=executive.PIPE)
out, _ = proc.communicate()
retcode = proc.returncode
self.assertEqual(retcode, 0)
self.assertIn('Cover', out)
finally:
if coverage_file_orig:
filesystem.move(coverage_file_orig, coverage_file)
elif filesystem.exists(coverage_file):
filesystem.remove(coverage_file)
def test_coverage_works(self):
# This is awkward; by design, running test-webkitpy -c will
# create a .coverage file in tools, so we need to be
# careful not to clobber an existing one, and to clean up.
# FIXME: This design needs to change since it means we can't actually
# run this method itself under coverage properly.
filesystem = FileSystem()
executive = Executive()
module_path = filesystem.path_to_module(self.__module__)
script_dir = module_path[0:module_path.find('webkitpy') - 1]
coverage_file = filesystem.join(script_dir, '.coverage')
coverage_file_orig = None
if filesystem.exists(coverage_file):
coverage_file_orig = coverage_file + '.orig'
filesystem.move(coverage_file, coverage_file_orig)
try:
proc = executive.popen([sys.executable, filesystem.join(script_dir, 'test-webkitpy'), '-c', STUBS_CLASS + '.test_empty'],
stdout=executive.PIPE, stderr=executive.PIPE)
out, _ = proc.communicate()
retcode = proc.returncode
self.assertEqual(retcode, 0)
self.assertIn('Cover', out)
finally:
if coverage_file_orig:
filesystem.move(coverage_file_orig, coverage_file)
elif filesystem.exists(coverage_file):
filesystem.remove(coverage_file)
def test_import_web_platform_test_modules(self):
fs = FileSystem()
current_dir, name = fs.split(fs.realpath(__file__))
doc_root_dir = fs.join(current_dir, "..", "..", "..", "..", "..", "LayoutTests", "imported", "w3c", "web-platform-tests")
tools_dir = fs.join(doc_root_dir, "tools")
sys.path.insert(0, doc_root_dir)
try:
file, pathname, description = imp.find_module("tools")
except ImportError, e:
self.fail(e)
def test_import_web_platform_test_modules(self):
fs = FileSystem()
current_dir, name = fs.split(fs.realpath(__file__))
doc_root_dir = fs.join(current_dir, "..", "..", "..", "..", "..",
"LayoutTests", "imported", "w3c",
"web-platform-tests")
tools_dir = fs.join(doc_root_dir, "tools")
sys.path.insert(0, doc_root_dir)
try:
file, pathname, description = imp.find_module("tools")
except ImportError, e:
self.fail(e)
def parse_args(args):
parser = argparse.ArgumentParser(prog='import-w3c-tests [w3c_test_source_directory]')
parser.add_argument('-n', '--no-overwrite', dest='overwrite', action='store_false', default=True,
help='Flag to prevent duplicate test files from overwriting existing tests. By default, they will be overwritten')
parser.add_argument('-l', '--no-links-conversion', dest='convert_test_harness_links', action='store_false', default=True,
help='Do not change links (testharness js or css e.g.). This option only applies when providing a source directory, in which case by default, links are converted to point to WebKit testharness files. When tests are downloaded from W3C repository, links are converted for CSS tests and remain unchanged for WPT tests')
parser.add_argument('-a', '--all', action='store_true', default=False,
help='Import all tests including reftests, JS tests, and manual/pixel tests. By default, only reftests and JS tests are imported')
fs = FileSystem()
parser.add_argument('-d', '--dest-dir', dest='destination', default=fs.join('imported', 'w3c'),
help='Import into a specified directory relative to the LayoutTests root. By default, imports into imported/w3c')
list_of_repositories = ' or '.join([test_repository['name'] for test_repository in TestDownloader.load_test_repositories()])
parser.add_argument('-t', '--test-path', action='append', dest='test_paths', default=[],
help='Import only tests in the supplied subdirectory of the source directory. Can be supplied multiple times to give multiple paths. For tests directly cloned from W3C repositories, use ' + list_of_repositories + ' prefixes to filter specific tests')
parser.add_argument('-v', '--verbose', action='store_true', default=False,
help='Print maximal log')
parser.add_argument('--no-fetch', action='store_false', dest='fetch', default=True,
help='Do not fetch the repositories. By default, repositories are fetched if a source directory is not provided')
parser.add_argument('--import-all', action='store_true', default=False,
help='Ignore the ImportExpectations file. All tests will be imported. This option only applies when tests are downloaded from W3C repository')
parser.add_argument('--clean-dest-dir', action='store_true', dest='clean_destination_directory', default=False,
help='Clean destination directory. All files in the destination directory will be deleted except for WebKit specific files (test expectations, .gitignore...) before new tests import. Dangling test expectations (expectation file that is no longer related to a test) are removed after tests import.')
options, args = parser.parse_known_args(args)
if len(args) > 1:
parser.error('Incorrect number of arguments')
return options, args
def parse_args(args):
description = """
To import a web-platform-tests test suite named xyz, use: 'import-w3c-tests web-platform-tests/xyz'.
To import a web-platform-tests suite from a specific folder, use 'import-w3c-tests xyz -l -s my-folder-containing-web-platform-tests-folder'"""
parser = argparse.ArgumentParser(prog='import-w3c-tests [web-platform-tests/test-suite-name...]', description=description, formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument('-n', '--no-overwrite', dest='overwrite', action='store_false', default=True,
help='Flag to prevent duplicate test files from overwriting existing tests. By default, they will be overwritten')
parser.add_argument('-l', '--no-links-conversion', dest='convert_test_harness_links', action='store_false', default=True,
help='Do not change links (testharness js or css e.g.). This option only applies when providing a source directory, in which case by default, links are converted to point to WebKit testharness files. When tests are downloaded from W3C repository, links are converted for CSS tests and remain unchanged for WPT tests')
parser.add_argument('-t', '--tip-of-tree', dest='use_tip_of_tree', action='store_true', default=False,
help='Import all tests using the latest repository revision')
parser.add_argument('-a', '--all', action='store_true', default=False,
help='Import all tests including reftests, JS tests, and manual/pixel tests. By default, only reftests and JS tests are imported')
fs = FileSystem()
parser.add_argument('-d', '--dest-dir', dest='destination', default=fs.join('imported', 'w3c'),
help='Import into a specified directory relative to the LayoutTests root. By default, imports into imported/w3c')
parser.add_argument('-s', '--src-dir', dest='source', default=None,
help='Import from a specific folder which contains web-platform-tests folder. If not provided, the script will clone the necessary repositories.')
parser.add_argument('-v', '--verbose', action='store_true', default=False,
help='Print maximal log')
parser.add_argument('--no-fetch', action='store_false', dest='fetch', default=True,
help='Do not fetch the repositories. By default, repositories are fetched if a source directory is not provided')
parser.add_argument('--import-all', action='store_true', default=False,
help='Ignore the import-expectations.json file. All tests will be imported. This option only applies when tests are downloaded from W3C repository')
parser.add_argument('--clean-dest-dir', action='store_true', dest='clean_destination_directory', default=False,
help='Clean destination directory. All files in the destination directory will be deleted except for WebKit specific files (test expectations, .gitignore...) before new tests import. Dangling test expectations (expectation file that is no longer related to a test) are removed after tests import.')
options, args = parser.parse_known_args(args)
return options, args
def load_json(self):
filesystem = FileSystem()
json_path = filesystem.join(filesystem.dirname(filesystem.path_to_module('webkitpy.common.config')), 'contributors.json')
try:
contributors = json.loads(filesystem.read_text_file(json_path))
except ValueError, e:
sys.exit('contributors.json is malformed: ' + str(e))
def load_ews_classes(cls):
filesystem = FileSystem()
json_path = filesystem.join(filesystem.dirname(filesystem.path_to_module('webkitpy.common.config')), 'ews.json')
try:
ewses = json.loads(filesystem.read_text_file(json_path))
except ValueError:
return None
classes = []
for name, config in ewses.items():
if sys.version_info > (3, 0):
translated = string_utils.encode(name, target_type=str).translate(' -')
else:
translated = string_utils.encode(name, target_type=str).translate(None, ' -')
classes.append(type(translated, (cls,), {
'name': config.get('name', config['port'] + '-ews'),
'port_name': config['port'],
'architecture': config.get('architecture', None),
'_build_style': config.get('style', "release"),
'watchers': config.get('watchers', []),
'run_tests': config.get('runTests', cls.run_tests),
'_group': config.get('group', None),
'should_build': config.get('shouldBuild', True),
}))
return classes
def reformat_in_place(self):
filesystem = FileSystem()
json_path = filesystem.join(
filesystem.dirname(
filesystem.path_to_module('webkitpy.common.config')),
'contributors.json')
filesystem.write_text_file(json_path, self.as_json())
def parse_args(args):
parser = argparse.ArgumentParser(prog='import-w3c-tests [w3c_test_source_directory]')
parser.add_argument('-n', '--no-overwrite', dest='overwrite', action='store_false', default=True,
help='Flag to prevent duplicate test files from overwriting existing tests. By default, they will be overwritten')
parser.add_argument('-l', '--no-links-conversion', dest='convert_test_harness_links', action='store_false', default=True,
help='Do not change links (testharness js or css e.g.). This option only applies when providing a source directory, in which case by default, links are converted to point to WebKit testharness files. When tests are downloaded from W3C repository, links are converted for CSS tests and remain unchanged for WPT tests')
parser.add_argument('-a', '--all', action='store_true', default=False,
help='Import all tests including reftests, JS tests, and manual/pixel tests. By default, only reftests and JS tests are imported')
fs = FileSystem()
parser.add_argument('-d', '--dest-dir', dest='destination', default=fs.join('imported', 'w3c'),
help='Import into a specified directory relative to the LayoutTests root. By default, imports into imported/w3c')
list_of_repositories = ' or '.join([test_repository['name'] for test_repository in TestDownloader.load_test_repositories()])
parser.add_argument('-t', '--test-path', action='append', dest='test_paths', default=[],
help='Import only tests in the supplied subdirectory of the source directory. Can be supplied multiple times to give multiple paths. For tests directly cloned from W3C repositories, use ' + list_of_repositories + ' prefixes to filter specific tests')
parser.add_argument('-v', '--verbose', action='store_true', default=False,
help='Print maximal log')
parser.add_argument('--no-fetch', action='store_false', dest='fetch', default=True,
help='Do not fetch the repositories. By default, repositories are fetched if a source directory is not provided')
parser.add_argument('--import-all', action='store_true', default=False,
help='Ignore the ImportExpectations file. All tests will be imported. This option only applies when tests are downloaded from W3C repository')
options, args = parser.parse_known_args(args)
if len(args) > 1:
parser.error('Incorrect number of arguments')
return options, args
def load_ews_classes(cls):
filesystem = FileSystem()
json_path = filesystem.join(
filesystem.dirname(
filesystem.path_to_module('webkitpy.common.config')),
'ews.json')
try:
ewses = json.loads(filesystem.read_text_file(json_path))
except ValueError:
return None
classes = []
for name, config in ewses.iteritems():
classes.append(
type(
name.encode('utf-8').translate(None, ' -'), (cls, ), {
'name': config.get('name', config['port'] + '-ews'),
'port_name': config['port'],
'architecture': config.get('architecture', None),
'_build_style': config.get('style', "release"),
'watchers': config.get('watchers', []),
'run_tests': config.get('runTests', cls.run_tests),
'_group': config.get('group', None),
}))
return classes
def load_json():
filesystem = FileSystem()
json_path = filesystem.join(filesystem.dirname(filesystem.path_to_module('webkitpy.common.config')), 'contributors.json')
contributors = json.loads(filesystem.read_text_file(json_path))
return {
'Contributors': [Contributor(name, data.get('emails'), data.get('nicks')) for name, data in contributors['Contributors'].iteritems()],
'Committers': [Committer(name, data.get('emails'), data.get('nicks')) for name, data in contributors['Committers'].iteritems()],
'Reviewers': [Reviewer(name, data.get('emails'), data.get('nicks')) for name, data in contributors['Reviewers'].iteritems()],
}
def load_json():
filesystem = FileSystem()
json_path = filesystem.join(filesystem.dirname(filesystem.path_to_module('webkitpy.common.config')), 'contributors.json')
contributors = json.loads(filesystem.read_text_file(json_path))
return {
'Contributors': [Contributor(name, data.get('emails'), data.get('nicks')) for name, data in contributors['Contributors'].iteritems()],
'Committers': [Committer(name, data.get('emails'), data.get('nicks')) for name, data in contributors['Committers'].iteritems()],
'Reviewers': [Reviewer(name, data.get('emails'), data.get('nicks')) for name, data in contributors['Reviewers'].iteritems()],
}
def load_json(self):
filesystem = FileSystem()
json_path = filesystem.join(
filesystem.dirname(
filesystem.path_to_module('webkitpy.common.config')),
'contributors.json')
try:
contributors = json.loads(filesystem.read_text_file(json_path))
except ValueError, e:
sys.exit('contributors.json is malformed: ' + str(e))
class TextFileReaderTest(LoggingTestCase):
class MockProcessor(ProcessorBase):
"""A processor for test purposes.
This processor simply records the parameters passed to its process()
method for later checking by the unittest test methods.
"""
def __init__(self):
self.processed = []
"""The parameters passed for all calls to the process() method."""
def should_process(self, file_path):
return not file_path.endswith('should_not_process.txt')
def process(self, lines, file_path, test_kwarg=None):
self.processed.append((lines, file_path, test_kwarg))
def setUp(self):
LoggingTestCase.setUp(self)
# FIXME: This should be a MockFileSystem once TextFileReader is moved entirely on top of FileSystem.
self.filesystem = FileSystem()
self._temp_dir = str(self.filesystem.mkdtemp())
self._processor = TextFileReaderTest.MockProcessor()
self._file_reader = TextFileReader(self.filesystem, self._processor)
def tearDown(self):
LoggingTestCase.tearDown(self)
self.filesystem.rmtree(self._temp_dir)
def _create_file(self, rel_path, text):
"""Create a file with given text and return the path to the file."""
# FIXME: There are better/more secure APIs for creating tmp file paths.
file_path = self.filesystem.join(self._temp_dir, rel_path)
self.filesystem.write_text_file(file_path, text)
return file_path
def _passed_to_processor(self):
"""Return the parameters passed to MockProcessor.process()."""
return self._processor.processed
def _assert_file_reader(self, passed_to_processor, file_count):
"""Assert the state of the file reader."""
self.assertEqual(passed_to_processor, self._passed_to_processor())
self.assertEqual(file_count, self._file_reader.file_count)
def test_process_file__does_not_exist(self):
try:
self._file_reader.process_file('does_not_exist.txt')
except SystemExit, err:
self.assertEqual(str(err), '1')
else:
class TextFileReaderTest(LoggingTestCase):
class MockProcessor(ProcessorBase):
"""A processor for test purposes.
This processor simply records the parameters passed to its process()
method for later checking by the unittest test methods.
"""
def __init__(self):
self.processed = []
"""The parameters passed for all calls to the process() method."""
def should_process(self, file_path):
return not file_path.endswith('should_not_process.txt')
def process(self, lines, file_path, test_kwarg=None):
self.processed.append((lines, file_path, test_kwarg))
def setUp(self):
LoggingTestCase.setUp(self)
# FIXME: This should be a MockFileSystem once TextFileReader is moved entirely on top of FileSystem.
self.filesystem = FileSystem()
self._temp_dir = str(self.filesystem.mkdtemp())
self._processor = TextFileReaderTest.MockProcessor()
self._file_reader = TextFileReader(self.filesystem, self._processor)
def tearDown(self):
LoggingTestCase.tearDown(self)
self.filesystem.rmtree(self._temp_dir)
def _create_file(self, rel_path, text):
"""Create a file with given text and return the path to the file."""
# FIXME: There are better/more secure APIs for creating tmp file paths.
file_path = self.filesystem.join(self._temp_dir, rel_path)
self.filesystem.write_text_file(file_path, text)
return file_path
def _passed_to_processor(self):
"""Return the parameters passed to MockProcessor.process()."""
return self._processor.processed
def _assert_file_reader(self, passed_to_processor, file_count):
"""Assert the state of the file reader."""
self.assertEqual(passed_to_processor, self._passed_to_processor())
self.assertEqual(file_count, self._file_reader.file_count)
def test_process_file__does_not_exist(self):
try:
self._file_reader.process_file('does_not_exist.txt')
except SystemExit, err:
self.assertEqual(str(err), '1')
else:
def _find_parent_path_matching_callback_condition(cls, path, callback, filesystem=None):
if not filesystem:
filesystem = FileSystem()
previous_path = ''
path = filesystem.abspath(path)
while path and path != previous_path:
if filesystem.exists(filesystem.join(path, cls._stub_repository_json)):
return callback(path)
previous_path = path
path = filesystem.dirname(path)
return None
def integration_test_coverage_works(self):
filesystem = FileSystem()
executive = Executive()
module_path = filesystem.path_to_module(self.__module__)
script_dir = module_path[0:module_path.find('webkitpy') - 1]
proc = executive.popen([sys.executable, filesystem.join(script_dir, 'test-webkitpy'), '-c', STUBS_CLASS + '.test_empty'],
stdout=executive.PIPE, stderr=executive.PIPE)
out, _ = proc.communicate()
retcode = proc.returncode
self.assertEqual(retcode, 0)
self.assertIn('Cover', out)
def integration_test_coverage_works(self):
filesystem = FileSystem()
executive = Executive()
module_path = filesystem.path_to_module(self.__module__)
script_dir = module_path[0:module_path.find('webkitpy') - 1]
proc = executive.popen([
sys.executable,
filesystem.join(script_dir, 'test-webkitpy'), '-c',
STUBS_CLASS + '.test_empty'
],
stdout=executive.PIPE,
stderr=executive.PIPE)
out, _ = proc.communicate()
retcode = proc.returncode
self.assertEqual(retcode, 0)
self.assertIn('Cover', out)
def test_dirs_under(self):
fs = FileSystem()
parentDir = fs.normpath(fs.join(self._this_dir, ".."))
self.assertTrue(self._this_dir in fs.dirs_under(parentDir))
def filter_no_dir(fs, dirpath):
return False
self.assertEqual(len(fs.dirs_under(parentDir, filter_no_dir)), 0)
def filter_this_dir(fs, dirpath):
return dirpath != self._this_dir
self.assertFalse(
self._this_dir in fs.dirs_under(parentDir, filter_this_dir))
def load_ews_classes(cls):
filesystem = FileSystem()
json_path = filesystem.join(filesystem.dirname(filesystem.path_to_module('webkitpy.common.config')), 'ews.json')
try:
ewses = json.loads(filesystem.read_text_file(json_path))
except ValueError:
return None
classes = []
for name, config in ewses.iteritems():
classes.append(type(str(name.replace(' ', '')), (AbstractEarlyWarningSystem,), {
'name': config['port'] + '-ews',
'port_name': config['port'],
'watchers': config.get('watchers', []),
'run_tests': config.get('runTests', cls.run_tests),
}))
return classes
def load_ews_classes(cls):
filesystem = FileSystem()
json_path = filesystem.join(filesystem.dirname(filesystem.path_to_module('webkitpy.common.config')), 'ews.json')
try:
ewses = json.loads(filesystem.read_text_file(json_path))
except ValueError:
return None
classes = []
for name, config in ewses.iteritems():
classes.append(type(str(name.replace(' ', '')), (AbstractEarlyWarningSystem,), {
'name': config['port'] + '-ews',
'port_name': config['port'],
'watchers': config.get('watchers', []),
'run_tests': config.get('runTests', cls.run_tests),
}))
return classes
def load_ews_classes(cls):
filesystem = FileSystem()
json_path = filesystem.join(filesystem.dirname(filesystem.path_to_module('webkitpy.common.config')), 'ews.json')
try:
ewses = json.loads(filesystem.read_text_file(json_path))
except ValueError:
return None
classes = []
for name, config in ewses.iteritems():
classes.append(type(name.encode('utf-8').translate(None, ' -'), (AbstractEarlyWarningSystem,), {
'name': config.get('name', config['port'] + '-ews'),
'port_name': config['port'],
'architecture': config.get('architecture', None),
'_build_style': config.get('style', "release"),
'watchers': config.get('watchers', []),
'run_tests': config.get('runTests', cls.run_tests),
}))
return classes
def test_maybe_make_directory__failure(self):
# FIXME: os.chmod() doesn't work on Windows to set directories
# as readonly, so we skip this test for now.
if sys.platform == 'win32':
return
fs = FileSystem()
with fs.mkdtemp(prefix='filesystem_unittest_') as d:
# Remove write permissions on the parent directory.
os.chmod(d, stat.S_IRUSR)
# Now try to create a sub directory - should fail.
sub_dir = fs.join(d, 'subdir')
self.assertRaises(OSError, fs.maybe_make_directory, sub_dir)
# Clean up in case the test failed and we did create the
# directory.
if os.path.exists(sub_dir):
os.rmdir(sub_dir)
def test_maybe_make_directory__failure(self):
# FIXME: os.chmod() doesn't work on Windows to set directories
# as readonly, so we skip this test for now.
if sys.platform in ('win32', 'cygwin'):
return
fs = FileSystem()
with fs.mkdtemp(prefix='filesystem_unittest_') as d:
# Remove write permissions on the parent directory.
os.chmod(d, stat.S_IRUSR)
# Now try to create a sub directory - should fail.
sub_dir = fs.join(d, 'subdir')
self.assertRaises(OSError, fs.maybe_make_directory, sub_dir)
# Clean up in case the test failed and we did create the
# directory.
if os.path.exists(sub_dir):
os.rmdir(sub_dir)
def load_json(self):
filesystem = FileSystem()
json_path = filesystem.join(
filesystem.dirname(
filesystem.path_to_module('webkitpy.common.config')),
'contributors.json')
try:
contributors = json.loads(filesystem.read_text_file(json_path))
except ValueError as e:
sys.exit('contributors.json is malformed: ' + str(e))
self._contributors = []
self._committers = []
self._reviewers = []
for name, data in contributors.items():
contributor = None
status = data.get('status')
if status == "reviewer":
contributor = Reviewer(name, data.get('emails'),
data.get('nicks'), data.get('aliases'),
data.get('expertise'))
self._reviewers.append(contributor)
self._committers.append(contributor)
elif status == "committer":
contributor = Committer(name, data.get('emails'),
data.get('nicks'), data.get('aliases'),
data.get('expertise'))
self._committers.append(contributor)
elif data.get('class') == 'bot':
contributor = Bot(name, data.get('emails'), data.get('nicks'),
data.get('aliases'), data.get('expertise'))
else:
contributor = Contributor(name, data.get('emails'),
data.get('nicks'),
data.get('aliases'),
data.get('expertise'))
self._contributors.append(contributor)
class CommitMessageForThisCommitTest(unittest.TestCase):
def setUp(self):
# FIXME: This should not need to touch the filesystem, however
# ChangeLog is difficult to mock at current.
self.filesystem = FileSystem()
self.temp_dir = str(self.filesystem.mkdtemp(suffix="changelogs"))
self.old_cwd = self.filesystem.getcwd()
self.filesystem.chdir(self.temp_dir)
self.webkit_base = WebKitFinder(self.filesystem).webkit_base()
# Trick commit-log-editor into thinking we're in a Subversion working copy so it won't
# complain about not being able to figure out what SCM is in use.
# FIXME: VCSTools.pm is no longer so easily fooled. It logs because "svn info" doesn't
# treat a bare .svn directory being part of an svn checkout.
self.filesystem.maybe_make_directory(".svn")
def mock_changelog(self, changelogs):
for path, contents in zip(self.changelog_paths, changelogs):
self.filesystem.maybe_make_directory(self.filesystem.dirname(path))
self.filesystem.write_text_file(path, contents)
def tearDown(self):
self.filesystem.rmtree(self.temp_dir)
self.filesystem.chdir(self.old_cwd)
def mock_checkout_for_test(self):
executive = Executive()
def mock_run(*args, **kwargs):
# Note that we use a real Executive here, not a MockExecutive, so we can test that we're
# invoking commit-log-editor correctly.
env = os.environ.copy()
env['CHANGE_LOG_EMAIL_ADDRESS'] = '*****@*****.**'
kwargs['env'] = env
return executive.run_command(*args, **kwargs)
detector = SCMDetector(self.filesystem, executive)
real_scm = detector.detect_scm_system(self.webkit_base)
mock_scm = MockSCM()
mock_scm.run = mock_run
real_checkout = Checkout(real_scm)
checkout = Checkout(mock_scm)
checkout.script_path = real_checkout.script_path
checkout.modified_changelogs = lambda git_commit, changed_files=None: self.changelog_paths
return checkout
def test_commit_message_for_unreviewed_changelogs_with_different_messages(
self):
expected_commit_message = u"""Unreviewed build fix to un-break webkit-patch land.
Tools:
Move commit_message_for_this_commit from scm to checkout
https://bugs.webkit.org/show_bug.cgi?id=36629
* Scripts/webkitpy/common/checkout/api.py: import scm.CommitMessage
LayoutTests:
Second part of this complicated change by me, Tor Arne Vestb\u00f8!
* Path/To/Complicated/File: Added.
"""
self.changelog_paths = map(
self.filesystem.abspath,
(self.filesystem.join("Tools", "ChangeLog"),
self.filesystem.join("LayoutTests", "ChangeLog")))
self.mock_changelog((_changelog1, _changelog2))
checkout = self.mock_checkout_for_test()
commit_message = checkout.commit_message_for_this_commit(
git_commit=None, return_stderr=True)
# Throw away the first line - a warning about unknown VCS root.
commit_message.message_lines = commit_message.message_lines[1:]
self.assertMultiLineEqual(commit_message.message(),
expected_commit_message)
def test_commit_message_for_one_reviewed_changelog(self):
expected_commit_message = u"""SECTORDER_FLAGS should be defined in target's xcconfig file, not Base.xcconfig
<http://webkit.org/b/135006>
Patch by David Kilzer <*****@*****.**> on 2014-07-17
Reviewed by Darin Adler.
* WebKit.xcodeproj/project.pbxproj: Remove references to unused
WebKit.xcconfig file.
"""
self.changelog_paths = map(
self.filesystem.abspath,
[self.filesystem.join("Source/WebKit", "ChangeLog")])
self.mock_changelog([_changelog3])
checkout = self.mock_checkout_for_test()
commit_message = checkout.commit_message_for_this_commit(
git_commit=None, return_stderr=True)
# Throw away the first line - a warning about unknown VCS root.
commit_message.message_lines = commit_message.message_lines[1:]
self.assertMultiLineEqual(commit_message.message(),
expected_commit_message)
def test_commit_message_for_changelogs_with_same_messages(self):
expected_commit_message = u"""SECTORDER_FLAGS should be defined in target's xcconfig file, not Base.xcconfig
<http://webkit.org/b/135006>
Patch by David Kilzer <*****@*****.**> on 2014-07-17
Reviewed by Darin Adler.
Source/WebKit:
* WebKit.xcodeproj/project.pbxproj: Remove references to unused
WebKit.xcconfig file.
LayoutTests:
* Path/To/Complicated/File: Added.
"""
self.changelog_paths = map(
self.filesystem.abspath,
(self.filesystem.join("Source/WebKit", "ChangeLog"),
self.filesystem.join("LayoutTests", "ChangeLog")))
self.mock_changelog((_changelog3, _changelog4))
checkout = self.mock_checkout_for_test()
commit_message = checkout.commit_message_for_this_commit(
git_commit=None, return_stderr=True)
# Throw away the first line - a warning about unknown VCS root.
commit_message.message_lines = commit_message.message_lines[1:]
self.assertMultiLineEqual(commit_message.message(),
expected_commit_message)
def test_commit_message_for_changelogs_with_different_messages(self):
expected_commit_message = u"""SECTORDER_FLAGS should be defined in target's xcconfig file, not Base.xcconfig
<http://webkit.org/b/135006>
Patch by David Kilzer <*****@*****.**> on 2014-07-17
Reviewed by Darin Adler.
Source/WebKit:
* WebKit.xcodeproj/project.pbxproj: Remove references to unused
WebKit.xcconfig file.
LayoutTests:
Filler change.
* Path/To/Complicated/File: Added.
"""
self.changelog_paths = map(
self.filesystem.abspath,
(self.filesystem.join("Source/WebKit", "ChangeLog"),
self.filesystem.join("LayoutTests", "ChangeLog")))
self.mock_changelog((_changelog3, _changelog5))
checkout = self.mock_checkout_for_test()
commit_message = checkout.commit_message_for_this_commit(
git_commit=None, return_stderr=True)
# Throw away the first line - a warning about unknown VCS root.
commit_message.message_lines = commit_message.message_lines[1:]
self.assertMultiLineEqual(commit_message.message(),
expected_commit_message)
def test_commit_message_for_one_rollout_changelog(self):
expected_commit_message = u"""Rolling out r170340 and r170339.
Changeset r170339 broke the Apple Windows Debug and Release builds.
Reverted changesets:
"[Win] Build fix after r134209"
http://trac.webkit.org/changeset/170340
"[Win] Clean up and refactor WinLauncher"
https://bugs.webkit.org/show_bug.cgi?id=134209
http://trac.webkit.org/changeset/170339
Patch by Daniel Bates <*****@*****.**> on 2014-06-23
"""
self.changelog_paths = map(
self.filesystem.abspath,
[self.filesystem.join("Tools", "ChangeLog")])
self.mock_changelog([_changelog6])
checkout = self.mock_checkout_for_test()
commit_message = checkout.commit_message_for_this_commit(
git_commit=None, return_stderr=True)
# Throw away the first line - a warning about unknown VCS root.
commit_message.message_lines = commit_message.message_lines[1:]
self.assertMultiLineEqual(commit_message.message(),
expected_commit_message)
def test_commit_message_for_rollout_changelogs_with_different_directories(
self):
expected_commit_message = u"""Rolling out r170340 and r170339.
Changeset r170339 broke the Apple Windows Debug and Release builds.
Reverted changesets:
"[Win] Build fix after r134209"
http://trac.webkit.org/changeset/170340
"[Win] Clean up and refactor WinLauncher"
https://bugs.webkit.org/show_bug.cgi?id=134209
http://trac.webkit.org/changeset/170339
Patch by Daniel Bates <*****@*****.**> on 2014-06-23
"""
self.changelog_paths = map(
self.filesystem.abspath,
(self.filesystem.join("Tools", "ChangeLog"),
self.filesystem.join("Source/WebCore", "ChangeLog")))
self.mock_changelog((_changelog6, _changelog6))
checkout = self.mock_checkout_for_test()
commit_message = checkout.commit_message_for_this_commit(
git_commit=None, return_stderr=True)
# Throw away the first line - a warning about unknown VCS root.
commit_message.message_lines = commit_message.message_lines[1:]
self.assertMultiLineEqual(commit_message.message(),
expected_commit_message)
class SCMTestBase(unittest.TestCase):
def __init__(self, *args, **kwargs):
super(SCMTestBase, self).__init__(*args, **kwargs)
self.scm = None
self.executive = None
self.fs = None
self.original_cwd = None
def setUp(self):
self.executive = Executive()
self.fs = FileSystem()
self.original_cwd = self.fs.getcwd()
def tearDown(self):
self._chdir(self.original_cwd)
def _join(self, *comps):
return self.fs.join(*comps)
def _chdir(self, path):
self.fs.chdir(path)
def _mkdir(self, path):
assert not self.fs.exists(path)
self.fs.maybe_make_directory(path)
def _mkdtemp(self, **kwargs):
return str(self.fs.mkdtemp(**kwargs))
def _remove(self, path):
self.fs.remove(path)
def _rmtree(self, path):
self.fs.rmtree(path)
def _run(self, *args, **kwargs):
return self.executive.run_command(*args, **kwargs)
def _run_silent(self, args, **kwargs):
self.executive.run_command(args, **kwargs)
def _write_text_file(self, path, contents):
self.fs.write_text_file(path, contents)
def _write_binary_file(self, path, contents):
self.fs.write_binary_file(path, contents)
def _make_diff(self, command, *args):
# We use this wrapper to disable output decoding. diffs should be treated as
# binary files since they may include text files of multiple different encodings.
return self._run([command, "diff"] + list(args), decode_output=False)
def _git_diff(self, *args):
return self._make_diff("git", *args)
def _shared_test_add_recursively(self):
self._mkdir("added_dir")
self._write_text_file("added_dir/added_file", "new stuff")
self.scm.add("added_dir/added_file")
self.assertIn("added_dir/added_file", self.scm._added_files())
def _shared_test_delete_recursively(self):
self._mkdir("added_dir")
self._write_text_file("added_dir/added_file", "new stuff")
self.scm.add("added_dir/added_file")
self.assertIn("added_dir/added_file", self.scm._added_files())
self.scm.delete("added_dir/added_file")
self.assertNotIn("added_dir", self.scm._added_files())
def _shared_test_delete_recursively_or_not(self):
self._mkdir("added_dir")
self._write_text_file("added_dir/added_file", "new stuff")
self._write_text_file("added_dir/another_added_file", "more new stuff")
self.scm.add("added_dir/added_file")
self.scm.add("added_dir/another_added_file")
self.assertIn("added_dir/added_file", self.scm._added_files())
self.assertIn("added_dir/another_added_file", self.scm._added_files())
self.scm.delete("added_dir/added_file")
self.assertIn("added_dir/another_added_file", self.scm._added_files())
def _shared_test_exists(self, scm, commit_function):
self._chdir(scm.checkout_root)
self.assertFalse(scm.exists('foo.txt'))
self._write_text_file('foo.txt', 'some stuff')
self.assertFalse(scm.exists('foo.txt'))
scm.add('foo.txt')
commit_function('adding foo')
self.assertTrue(scm.exists('foo.txt'))
scm.delete('foo.txt')
commit_function('deleting foo')
self.assertFalse(scm.exists('foo.txt'))
def _shared_test_move(self):
self._write_text_file('added_file', 'new stuff')
self.scm.add('added_file')
self.scm.move('added_file', 'moved_file')
self.assertIn('moved_file', self.scm._added_files())
def _shared_test_move_recursive(self):
self._mkdir("added_dir")
self._write_text_file('added_dir/added_file', 'new stuff')
self._write_text_file('added_dir/another_added_file', 'more new stuff')
self.scm.add('added_dir')
self.scm.move('added_dir', 'moved_dir')
self.assertIn('moved_dir/added_file', self.scm._added_files())
self.assertIn('moved_dir/another_added_file', self.scm._added_files())
class SCMTestBase(unittest.TestCase):
def __init__(self, *args, **kwargs):
super(SCMTestBase, self).__init__(*args, **kwargs)
self.scm = None
self.executive = None
self.fs = None
self.original_cwd = None
def setUp(self):
self.executive = Executive()
self.fs = FileSystem()
self.original_cwd = self.fs.getcwd()
def tearDown(self):
self._chdir(self.original_cwd)
def _join(self, *comps):
return self.fs.join(*comps)
def _chdir(self, path):
self.fs.chdir(path)
def _mkdir(self, path):
assert not self.fs.exists(path)
self.fs.maybe_make_directory(path)
def _mkdtemp(self, **kwargs):
return str(self.fs.mkdtemp(**kwargs))
def _remove(self, path):
self.fs.remove(path)
def _rmtree(self, path):
self.fs.rmtree(path)
def _run(self, *args, **kwargs):
return self.executive.run_command(*args, **kwargs)
def _run_silent(self, args, **kwargs):
self.executive.run_and_throw_if_fail(args, quiet=True, **kwargs)
def _write_text_file(self, path, contents):
self.fs.write_text_file(path, contents)
def _write_binary_file(self, path, contents):
self.fs.write_binary_file(path, contents)
def _make_diff(self, command, *args):
# We use this wrapper to disable output decoding. diffs should be treated as
# binary files since they may include text files of multiple differnet encodings.
return self._run([command, "diff"] + list(args), decode_output=False)
def _svn_diff(self, *args):
return self._make_diff("svn", *args)
def _git_diff(self, *args):
return self._make_diff("git", *args)
def _svn_add(self, path):
self._run(["svn", "add", path])
def _svn_commit(self, message):
self._run(["svn", "commit", "--quiet", "--message", message])
# This is a hot function since it's invoked by unittest before calling each test_ method in SVNTest and
# GitTest. We create a mock SVN repo once and then perform an SVN checkout from a filesystem copy of
# it since it's expensive to create the mock repo.
def _set_up_svn_checkout(self):
global cached_svn_repo_path
global original_cwd
if not cached_svn_repo_path:
cached_svn_repo_path = self._set_up_svn_repo()
original_cwd = self.original_cwd
self.temp_directory = self._mkdtemp(suffix="svn_test")
self.svn_repo_path = self._join(self.temp_directory, "repo")
self.svn_repo_url = "file://%s" % self.svn_repo_path
self.svn_checkout_path = self._join(self.temp_directory, "checkout")
shutil.copytree(cached_svn_repo_path, self.svn_repo_path)
self._run(["svn", "checkout", "--quiet", self.svn_repo_url + "/trunk", self.svn_checkout_path])
def _set_up_svn_repo(self):
svn_repo_path = self._mkdtemp(suffix="svn_test_repo")
svn_repo_url = "file://%s" % svn_repo_path # Not sure this will work on windows
# git svn complains if we don't pass --pre-1.5-compatible, not sure why:
# Expected FS format '2'; found format '3' at /usr/local/libexec/git-core//git-svn line 1477
self._run(["svnadmin", "create", "--pre-1.5-compatible", svn_repo_path])
# Create a test svn checkout
svn_checkout_path = self._mkdtemp(suffix="svn_test_checkout")
self._run(["svn", "checkout", "--quiet", svn_repo_url, svn_checkout_path])
# Create and checkout a trunk dir to match the standard svn configuration to match git-svn's expectations
self._chdir(svn_checkout_path)
self._mkdir("trunk")
self._svn_add("trunk")
# We can add tags and branches as well if we ever need to test those.
self._svn_commit("add trunk")
self._rmtree(svn_checkout_path)
self._set_up_svn_test_commits(svn_repo_url + "/trunk")
return svn_repo_path
def _set_up_svn_test_commits(self, svn_repo_url):
svn_checkout_path = self._mkdtemp(suffix="svn_test_checkout")
self._run(["svn", "checkout", "--quiet", svn_repo_url, svn_checkout_path])
# Add some test commits
self._chdir(svn_checkout_path)
self._write_text_file("test_file", "test1")
self._svn_add("test_file")
self._svn_commit("initial commit")
self._write_text_file("test_file", "test1test2")
# This used to be the last commit, but doing so broke
# GitTest.test_apply_git_patch which use the inverse diff of the last commit.
# svn-apply fails to remove directories in Git, see:
# https://bugs.webkit.org/show_bug.cgi?id=34871
self._mkdir("test_dir")
# Slash should always be the right path separator since we use cygwin on Windows.
test_file3_path = "test_dir/test_file3"
self._write_text_file(test_file3_path, "third file")
self._svn_add("test_dir")
self._svn_commit("second commit")
self._write_text_file("test_file", "test1test2test3\n")
self._write_text_file("test_file2", "second file")
self._svn_add("test_file2")
self._svn_commit("third commit")
# This 4th commit is used to make sure that our patch file handling
# code correctly treats patches as binary and does not attempt to
# decode them assuming they're utf-8.
self._write_binary_file("test_file", u"latin1 test: \u00A0\n".encode("latin-1"))
self._write_binary_file("test_file2", u"utf-8 test: \u00A0\n".encode("utf-8"))
self._svn_commit("fourth commit")
# svn does not seem to update after commit as I would expect.
self._run(["svn", "update"])
self._rmtree(svn_checkout_path)
def _tear_down_svn_checkout(self):
self._rmtree(self.temp_directory)
def _shared_test_add_recursively(self):
self._mkdir("added_dir")
self._write_text_file("added_dir/added_file", "new stuff")
self.scm.add("added_dir/added_file")
self.assertIn("added_dir/added_file", self.scm._added_files())
def _shared_test_delete_recursively(self):
self._mkdir("added_dir")
self._write_text_file("added_dir/added_file", "new stuff")
self.scm.add("added_dir/added_file")
self.assertIn("added_dir/added_file", self.scm._added_files())
self.scm.delete("added_dir/added_file")
self.assertNotIn("added_dir", self.scm._added_files())
def _shared_test_delete_recursively_or_not(self):
self._mkdir("added_dir")
self._write_text_file("added_dir/added_file", "new stuff")
self._write_text_file("added_dir/another_added_file", "more new stuff")
self.scm.add("added_dir/added_file")
self.scm.add("added_dir/another_added_file")
self.assertIn("added_dir/added_file", self.scm._added_files())
self.assertIn("added_dir/another_added_file", self.scm._added_files())
self.scm.delete("added_dir/added_file")
self.assertIn("added_dir/another_added_file", self.scm._added_files())
def _shared_test_exists(self, scm, commit_function):
self._chdir(scm.checkout_root)
self.assertFalse(scm.exists("foo.txt"))
self._write_text_file("foo.txt", "some stuff")
self.assertFalse(scm.exists("foo.txt"))
scm.add("foo.txt")
commit_function("adding foo")
self.assertTrue(scm.exists("foo.txt"))
scm.delete("foo.txt")
commit_function("deleting foo")
self.assertFalse(scm.exists("foo.txt"))
def _shared_test_move(self):
self._write_text_file("added_file", "new stuff")
self.scm.add("added_file")
self.scm.move("added_file", "moved_file")
self.assertIn("moved_file", self.scm._added_files())
def _shared_test_move_recursive(self):
self._mkdir("added_dir")
self._write_text_file("added_dir/added_file", "new stuff")
self._write_text_file("added_dir/another_added_file", "more new stuff")
self.scm.add("added_dir")
self.scm.move("added_dir", "moved_dir")
self.assertIn("moved_dir/added_file", self.scm._added_files())
self.assertIn("moved_dir/another_added_file", self.scm._added_files())
class GitTestWithRealFilesystemAndExecutive(unittest.TestCase):
def setUp(self):
self.executive = Executive()
self.filesystem = FileSystem()
self.original_cwd = self.filesystem.getcwd()
# Set up fresh git repository with one commit.
self.untracking_checkout_path = self._mkdtemp(suffix='-git_unittest_untracking')
self._run(['git', 'init', self.untracking_checkout_path])
self._chdir(self.untracking_checkout_path)
self._write_text_file('foo_file', 'foo')
self._run(['git', 'add', 'foo_file'])
self._run(['git', 'commit', '-am', 'dummy commit'])
self.untracking_git = Git(cwd=self.untracking_checkout_path, filesystem=self.filesystem, executive=self.executive)
# Then set up a second git repo that tracks the first one.
self.tracking_git_checkout_path = self._mkdtemp(suffix='-git_unittest_tracking')
self._run(['git', 'clone', '--quiet', self.untracking_checkout_path, self.tracking_git_checkout_path])
self._chdir(self.tracking_git_checkout_path)
self.tracking_git = Git(cwd=self.tracking_git_checkout_path, filesystem=self.filesystem, executive=self.executive)
def tearDown(self):
self._chdir(self.original_cwd)
self._run(['rm', '-rf', self.tracking_git_checkout_path])
self._run(['rm', '-rf', self.untracking_checkout_path])
def _join(self, *comps):
return self.filesystem.join(*comps)
def _chdir(self, path):
self.filesystem.chdir(path)
def _mkdir(self, path):
assert not self.filesystem.exists(path)
self.filesystem.maybe_make_directory(path)
def _mkdtemp(self, **kwargs):
return str(self.filesystem.mkdtemp(**kwargs))
def _remove(self, path):
self.filesystem.remove(path)
def _run(self, *args, **kwargs):
return self.executive.run_command(*args, **kwargs)
def _write_text_file(self, path, contents):
self.filesystem.write_text_file(path, contents)
def test_add_list(self):
self._chdir(self.untracking_checkout_path)
git = self.untracking_git
self._mkdir('added_dir')
self._write_text_file('added_dir/added_file', 'new stuff')
print self._run(['ls', 'added_dir'])
print self._run(['pwd'])
print self._run(['cat', 'added_dir/added_file'])
git.add_list(['added_dir/added_file'])
self.assertIn('added_dir/added_file', git.added_files())
def test_delete_recursively(self):
self._chdir(self.untracking_checkout_path)
git = self.untracking_git
self._mkdir('added_dir')
self._write_text_file('added_dir/added_file', 'new stuff')
git.add_list(['added_dir/added_file'])
self.assertIn('added_dir/added_file', git.added_files())
git.delete_list(['added_dir/added_file'])
self.assertNotIn('added_dir', git.added_files())
def test_delete_recursively_or_not(self):
self._chdir(self.untracking_checkout_path)
git = self.untracking_git
self._mkdir('added_dir')
self._write_text_file('added_dir/added_file', 'new stuff')
self._write_text_file('added_dir/another_added_file', 'more new stuff')
git.add_list(['added_dir/added_file', 'added_dir/another_added_file'])
self.assertIn('added_dir/added_file', git.added_files())
self.assertIn('added_dir/another_added_file', git.added_files())
git.delete_list(['added_dir/added_file'])
self.assertIn('added_dir/another_added_file', git.added_files())
def test_exists(self):
self._chdir(self.untracking_checkout_path)
git = self.untracking_git
self._chdir(git.checkout_root)
self.assertFalse(git.exists('foo.txt'))
self._write_text_file('foo.txt', 'some stuff')
self.assertFalse(git.exists('foo.txt'))
git.add_list(['foo.txt'])
git.commit_locally_with_message('adding foo')
self.assertTrue(git.exists('foo.txt'))
git.delete_list(['foo.txt'])
git.commit_locally_with_message('deleting foo')
self.assertFalse(git.exists('foo.txt'))
def test_move(self):
self._chdir(self.untracking_checkout_path)
git = self.untracking_git
self._write_text_file('added_file', 'new stuff')
git.add_list(['added_file'])
git.move('added_file', 'moved_file')
self.assertIn('moved_file', git.added_files())
def test_move_recursive(self):
self._chdir(self.untracking_checkout_path)
git = self.untracking_git
self._mkdir('added_dir')
self._write_text_file('added_dir/added_file', 'new stuff')
self._write_text_file('added_dir/another_added_file', 'more new stuff')
git.add_list(['added_dir'])
git.move('added_dir', 'moved_dir')
self.assertIn('moved_dir/added_file', git.added_files())
self.assertIn('moved_dir/another_added_file', git.added_files())
def test_remote_branch_ref(self):
# This tests a protected method. pylint: disable=protected-access
self.assertEqual(self.tracking_git._remote_branch_ref(), 'refs/remotes/origin/master')
self._chdir(self.untracking_checkout_path)
self.assertRaises(ScriptError, self.untracking_git._remote_branch_ref)
def test_create_patch(self):
self._chdir(self.tracking_git_checkout_path)
git = self.tracking_git
self._write_text_file('test_file_commit1', 'contents')
self._run(['git', 'add', 'test_file_commit1'])
git.commit_locally_with_message('message')
git._patch_order = lambda: '' # pylint: disable=protected-access
patch = git.create_patch()
self.assertNotRegexpMatches(patch, r'Subversion Revision:')
def test_patches_have_filenames_with_prefixes(self):
self._chdir(self.tracking_git_checkout_path)
git = self.tracking_git
self._write_text_file('test_file_commit1', 'contents')
self._run(['git', 'add', 'test_file_commit1'])
git.commit_locally_with_message('message')
# Even if diff.noprefix is enabled, create_patch() produces diffs with prefixes.
self._run(['git', 'config', 'diff.noprefix', 'true'])
git._patch_order = lambda: '' # pylint: disable=protected-access
patch = git.create_patch()
self.assertRegexpMatches(patch, r'^diff --git a/test_file_commit1 b/test_file_commit1')
def test_rename_files(self):
self._chdir(self.tracking_git_checkout_path)
git = self.tracking_git
git.move('foo_file', 'bar_file')
git.commit_locally_with_message('message')
def test_commit_position_from_git_log(self):
# This tests a protected method. pylint: disable=protected-access
git_log = """
commit 624c3081c0
Author: foobarbaz1 <*****@*****.**>
Date: Mon Sep 28 19:10:30 2015 -0700
Test foo bar baz qux 123.
BUG=000000
Review URL: https://codereview.chromium.org/999999999
Cr-Commit-Position: refs/heads/master@{#1234567}
"""
self._chdir(self.tracking_git_checkout_path)
git = self.tracking_git
self.assertEqual(git._commit_position_from_git_log(git_log), 1234567)
def test_timestamp_of_revision(self):
# This tests a protected method. pylint: disable=protected-access
self._chdir(self.tracking_git_checkout_path)
git = self.tracking_git
position_regex = git._commit_position_regex_for_timestamp()
git.most_recent_log_matching(position_regex, git.checkout_root)
def reformat_in_place(self):
filesystem = FileSystem()
json_path = filesystem.join(filesystem.dirname(filesystem.path_to_module('webkitpy.common.config')), 'contributors.json')
filesystem.write_text_file(json_path, self.as_json())
class CommitMessageForThisCommitTest(unittest.TestCase):
expected_commit_message = u"""Unreviewed build fix to un-break webkit-patch land.
Tools:
Move commit_message_for_this_commit from scm to checkout
https://bugs.webkit.org/show_bug.cgi?id=36629
* Scripts/webkitpy/common/checkout/api.py: import scm.CommitMessage
LayoutTests:
Second part of this complicated change by me, Tor Arne Vestb\u00f8!
* Path/To/Complicated/File: Added.
"""
def setUp(self):
# FIXME: This should not need to touch the filesystem, however
# ChangeLog is difficult to mock at current.
self.filesystem = FileSystem()
self.temp_dir = str(self.filesystem.mkdtemp(suffix="changelogs"))
self.old_cwd = self.filesystem.getcwd()
self.filesystem.chdir(self.temp_dir)
# Trick commit-log-editor into thinking we're in a Subversion working copy so it won't
# complain about not being able to figure out what SCM is in use.
# FIXME: VCSTools.pm is no longer so easily fooled. It logs because "svn info" doesn't
# treat a bare .svn directory being part of an svn checkout.
self.filesystem.maybe_make_directory(".svn")
self.changelogs = map(self.filesystem.abspath, (self.filesystem.join("Tools", "ChangeLog"), self.filesystem.join("LayoutTests", "ChangeLog")))
for path, contents in zip(self.changelogs, (_changelog1, _changelog2)):
self.filesystem.maybe_make_directory(self.filesystem.dirname(path))
self.filesystem.write_text_file(path, contents)
def tearDown(self):
self.filesystem.rmtree(self.temp_dir)
self.filesystem.chdir(self.old_cwd)
def test_commit_message_for_this_commit(self):
executive = Executive()
def mock_run(*args, **kwargs):
# Note that we use a real Executive here, not a MockExecutive, so we can test that we're
# invoking commit-log-editor correctly.
env = os.environ.copy()
env['CHANGE_LOG_EMAIL_ADDRESS'] = '*****@*****.**'
kwargs['env'] = env
return executive.run_command(*args, **kwargs)
detector = SCMDetector(self.filesystem, executive)
real_scm = detector.detect_scm_system(self.old_cwd)
mock_scm = MockSCM()
mock_scm.run = mock_run
mock_scm.script_path = real_scm.script_path
checkout = Checkout(mock_scm)
checkout.modified_changelogs = lambda git_commit, changed_files=None: self.changelogs
commit_message = checkout.commit_message_for_this_commit(git_commit=None, return_stderr=True)
# Throw away the first line - a warning about unknown VCS root.
commit_message.message_lines = commit_message.message_lines[1:]
self.assertMultiLineEqual(commit_message.message(), self.expected_commit_message)
# Putting the autoinstall code into webkitpy/thirdparty/__init__.py
# ensures that no autoinstalling occurs until a caller imports from
# webkitpy.thirdparty. This is useful if the caller wants to configure
# logging prior to executing autoinstall code.
# FIXME: If any of these servers is offline, webkit-patch breaks (and maybe
# other scripts do, too). See <http://webkit.org/b/42080>.
# We put auto-installed third-party modules in this directory--
#
# webkitpy/thirdparty/autoinstalled
fs = FileSystem()
fs.maybe_make_directory(_AUTOINSTALLED_DIR)
init_path = fs.join(_AUTOINSTALLED_DIR, "__init__.py")
if not fs.exists(init_path):
fs.write_text_file(init_path, "")
readme_path = fs.join(_AUTOINSTALLED_DIR, "README")
if not fs.exists(readme_path):
fs.write_text_file(readme_path,
"This directory is auto-generated by WebKit and is "
"safe to delete.\nIt contains needed third-party Python "
"packages automatically downloaded from the web.")
class AutoinstallImportHook(object):
def __init__(self, filesystem=None):
self._fs = filesystem or FileSystem()
def test_join(self):
fs = FileSystem()
self.assertEqual(fs.join('foo', 'bar'),
os.path.join('foo', 'bar'))
class TextFileReaderTest(LoggingTestCase):
class MockProcessor(ProcessorBase):
"""A processor for test purposes.
This processor simply records the parameters passed to its process()
method for later checking by the unittest test methods.
"""
def __init__(self):
self.processed = []
"""The parameters passed for all calls to the process() method."""
def should_process(self, file_path):
return not file_path.endswith('should_not_process.txt')
def process(self, lines, file_path, test_kwarg=None):
self.processed.append((lines, file_path, test_kwarg))
def setUp(self):
LoggingTestCase.setUp(self)
# FIXME: This should be a MockFileSystem once TextFileReader is moved entirely on top of FileSystem.
self.filesystem = FileSystem()
self._temp_dir = str(self.filesystem.mkdtemp())
self._processor = TextFileReaderTest.MockProcessor()
self._file_reader = TextFileReader(self.filesystem, self._processor)
def tearDown(self):
LoggingTestCase.tearDown(self)
self.filesystem.rmtree(self._temp_dir)
def _create_file(self, rel_path, text):
"""Create a file with given text and return the path to the file."""
# FIXME: There are better/more secure APIs for creating tmp file paths.
file_path = self.filesystem.join(self._temp_dir, rel_path)
self.filesystem.write_text_file(file_path, text)
return file_path
def _passed_to_processor(self):
"""Return the parameters passed to MockProcessor.process()."""
return self._processor.processed
def _assert_file_reader(self, passed_to_processor, file_count):
"""Assert the state of the file reader."""
self.assertEqual(passed_to_processor, self._passed_to_processor())
self.assertEqual(file_count, self._file_reader.file_count)
def test_process_file__does_not_exist(self):
try:
self._file_reader.process_file('does_not_exist.txt')
except SystemExit as err:
self.assertEqual(str(err), '1')
else:
self.fail('No Exception raised.')
self._assert_file_reader([], 1)
self.assertLog(["ERROR: File does not exist: 'does_not_exist.txt'\n"])
def test_process_file__is_dir(self):
temp_dir = self.filesystem.join(self._temp_dir, 'test_dir')
self.filesystem.maybe_make_directory(temp_dir)
self._file_reader.process_file(temp_dir)
# Because the log message below contains exception text, it is
# possible that the text varies across platforms. For this reason,
# we check only the portion of the log message that we control,
# namely the text at the beginning.
log_messages = self.logMessages()
# We remove the message we are looking at to prevent the tearDown()
# from raising an exception when it asserts that no log messages
# remain.
message = log_messages.pop()
self.assertTrue(message.startswith("WARNING: Could not read file. Skipping: '%s'\n " % temp_dir))
self._assert_file_reader([], 1)
def test_process_file__should_not_process(self):
file_path = self._create_file('should_not_process.txt', 'contents')
self._file_reader.process_file(file_path)
self._assert_file_reader([], 1)
def test_process_file__multiple_lines(self):
file_path = self._create_file('foo.txt', 'line one\r\nline two\n')
self._file_reader.process_file(file_path)
processed = [(['line one\r', 'line two', ''], file_path, None)]
self._assert_file_reader(processed, 1)
def test_process_file__file_stdin(self):
file_path = self._create_file('-', 'file contents')
self._file_reader.process_file(file_path=file_path, test_kwarg='foo')
processed = [(['file contents'], file_path, 'foo')]
self._assert_file_reader(processed, 1)
def test_process_file__with_kwarg(self):
file_path = self._create_file('foo.txt', 'file contents')
self._file_reader.process_file(file_path=file_path, test_kwarg='foo')
processed = [(['file contents'], file_path, 'foo')]
self._assert_file_reader(processed, 1)
def test_process_paths(self):
# We test a list of paths that contains both a file and a directory.
dir = self.filesystem.join(self._temp_dir, 'foo_dir')
self.filesystem.maybe_make_directory(dir)
file_path1 = self._create_file('file1.txt', 'foo')
rel_path = self.filesystem.join('foo_dir', 'file2.txt')
file_path2 = self._create_file(rel_path, 'bar')
self._file_reader.process_paths([dir, file_path1])
processed = [(['bar'], file_path2, None),
(['foo'], file_path1, None)]
self._assert_file_reader(processed, 2)
def test_count_delete_only_file(self):
self._file_reader.count_delete_only_file()
delete_only_file_count = self._file_reader.delete_only_file_count
self.assertEqual(delete_only_file_count, 1)
def parse_args(args):
parser = argparse.ArgumentParser(prog="import-w3c-tests [w3c_test_source_directory]")
parser.add_argument(
"-n",
"--no-overwrite",
dest="overwrite",
action="store_false",
default=True,
help="Flag to prevent duplicate test files from overwriting existing tests. By default, they will be overwritten",
)
parser.add_argument(
"-l",
"--no-links-conversion",
dest="convert_test_harness_links",
action="store_false",
default=True,
help="Do not change links (testharness js or css e.g.). This option only applies when providing a source directory, in which case by default, links are converted to point to WebKit testharness files. When tests are downloaded from W3C repository, links are converted for CSS tests and remain unchanged for WPT tests",
)
parser.add_argument(
"-a",
"--all",
action="store_true",
default=False,
help="Import all tests including reftests, JS tests, and manual/pixel tests. By default, only reftests and JS tests are imported",
)
fs = FileSystem()
parser.add_argument(
"-d",
"--dest-dir",
dest="destination",
default=fs.join("imported", "w3c"),
help="Import into a specified directory relative to the LayoutTests root. By default, imports into imported/w3c",
)
list_of_repositories = " or ".join(
[test_repository["name"] for test_repository in TestDownloader.load_test_repositories()]
)
parser.add_argument(
"-t",
"--test-path",
action="append",
dest="test_paths",
default=[],
help="Import only tests in the supplied subdirectory of the source directory. Can be supplied multiple times to give multiple paths. For tests directly cloned from W3C repositories, use "
+ list_of_repositories
+ " prefixes to filter specific tests",
)
parser.add_argument("-v", "--verbose", action="store_true", default=False, help="Print maximal log")
parser.add_argument(
"--no-fetch",
action="store_false",
dest="fetch",
default=True,
help="Do not fetch the repositories. By default, repositories are fetched if a source directory is not provided",
)
parser.add_argument(
"--import-all",
action="store_true",
default=False,
help="Ignore the ImportExpectations file. All tests will be imported. This option only applies when tests are downloaded from W3C repository",
)
parser.add_argument(
"--clean-dest-dir",
action="store_true",
dest="clean_destination_directory",
default=False,
help="Clean destination directory. All files in the destination directory will be deleted except for WebKit specific files (test expectations, .gitignore...) before new tests import. Dangling test expectations (expectation file that is no longer related to a test) are removed after tests import.",
)
options, args = parser.parse_known_args(args)
if len(args) > 1:
parser.error("Incorrect number of arguments")
return options, args
def test_sep(self):
fs = FileSystem()
self.assertEqual(fs.sep, os.sep)
self.assertEqual(fs.join("foo", "bar"), os.path.join("foo", "bar"))
class SCMTestBase(unittest.TestCase):
def __init__(self, *args, **kwargs):
super(SCMTestBase, self).__init__(*args, **kwargs)
self.scm = None
self.executive = None
self.fs = None
self.original_cwd = None
def setUp(self):
self.executive = Executive()
self.fs = FileSystem()
self.original_cwd = self.fs.getcwd()
def tearDown(self):
self._chdir(self.original_cwd)
def _join(self, *comps):
return self.fs.join(*comps)
def _chdir(self, path):
self.fs.chdir(path)
def _mkdir(self, path):
assert not self.fs.exists(path)
self.fs.maybe_make_directory(path)
def _mkdtemp(self, **kwargs):
return str(self.fs.mkdtemp(**kwargs))
def _remove(self, path):
self.fs.remove(path)
def _rmtree(self, path):
self.fs.rmtree(path)
def _run(self, *args, **kwargs):
return self.executive.run_command(*args, **kwargs)
def _run_silent(self, args, **kwargs):
self.executive.run_command(args, **kwargs)
def _write_text_file(self, path, contents):
self.fs.write_text_file(path, contents)
def _write_binary_file(self, path, contents):
self.fs.write_binary_file(path, contents)
def _make_diff(self, command, *args):
# We use this wrapper to disable output decoding. diffs should be treated as
# binary files since they may include text files of multiple differnet encodings.
return self._run([command, "diff"] + list(args), decode_output=False)
def _git_diff(self, *args):
return self._make_diff("git", *args)
def _shared_test_add_recursively(self):
self._mkdir("added_dir")
self._write_text_file("added_dir/added_file", "new stuff")
self.scm.add("added_dir/added_file")
self.assertIn("added_dir/added_file", self.scm._added_files())
def _shared_test_delete_recursively(self):
self._mkdir("added_dir")
self._write_text_file("added_dir/added_file", "new stuff")
self.scm.add("added_dir/added_file")
self.assertIn("added_dir/added_file", self.scm._added_files())
self.scm.delete("added_dir/added_file")
self.assertNotIn("added_dir", self.scm._added_files())
def _shared_test_delete_recursively_or_not(self):
self._mkdir("added_dir")
self._write_text_file("added_dir/added_file", "new stuff")
self._write_text_file("added_dir/another_added_file", "more new stuff")
self.scm.add("added_dir/added_file")
self.scm.add("added_dir/another_added_file")
self.assertIn("added_dir/added_file", self.scm._added_files())
self.assertIn("added_dir/another_added_file", self.scm._added_files())
self.scm.delete("added_dir/added_file")
self.assertIn("added_dir/another_added_file", self.scm._added_files())
def _shared_test_exists(self, scm, commit_function):
self._chdir(scm.checkout_root)
self.assertFalse(scm.exists('foo.txt'))
self._write_text_file('foo.txt', 'some stuff')
self.assertFalse(scm.exists('foo.txt'))
scm.add('foo.txt')
commit_function('adding foo')
self.assertTrue(scm.exists('foo.txt'))
scm.delete('foo.txt')
commit_function('deleting foo')
self.assertFalse(scm.exists('foo.txt'))
def _shared_test_move(self):
self._write_text_file('added_file', 'new stuff')
self.scm.add('added_file')
self.scm.move('added_file', 'moved_file')
self.assertIn('moved_file', self.scm._added_files())
def _shared_test_move_recursive(self):
self._mkdir("added_dir")
self._write_text_file('added_dir/added_file', 'new stuff')
self._write_text_file('added_dir/another_added_file', 'more new stuff')
self.scm.add('added_dir')
self.scm.move('added_dir', 'moved_dir')
self.assertIn('moved_dir/added_file', self.scm._added_files())
self.assertIn('moved_dir/another_added_file', self.scm._added_files())
class CommitMessageForThisCommitTest(unittest.TestCase):
def setUp(self):
# FIXME: This should not need to touch the filesystem, however
# ChangeLog is difficult to mock at current.
self.filesystem = FileSystem()
self.temp_dir = str(self.filesystem.mkdtemp(suffix="changelogs"))
self.old_cwd = self.filesystem.getcwd()
self.filesystem.chdir(self.temp_dir)
self.webkit_base = WebKitFinder(self.filesystem).webkit_base()
# Trick commit-log-editor into thinking we're in a Subversion working copy so it won't
# complain about not being able to figure out what SCM is in use.
# FIXME: VCSTools.pm is no longer so easily fooled. It logs because "svn info" doesn't
# treat a bare .svn directory being part of an svn checkout.
self.filesystem.maybe_make_directory(".svn")
def mock_changelog(self, changelogs):
for path, contents in zip(self.changelog_paths, changelogs):
self.filesystem.maybe_make_directory(self.filesystem.dirname(path))
self.filesystem.write_text_file(path, contents)
def tearDown(self):
self.filesystem.rmtree(self.temp_dir)
self.filesystem.chdir(self.old_cwd)
def mock_checkout_for_test(self):
executive = Executive()
def mock_run(*args, **kwargs):
# Note that we use a real Executive here, not a MockExecutive, so we can test that we're
# invoking commit-log-editor correctly.
env = os.environ.copy()
env['CHANGE_LOG_EMAIL_ADDRESS'] = '*****@*****.**'
kwargs['env'] = env
return executive.run_command(*args, **kwargs)
detector = SCMDetector(self.filesystem, executive)
real_scm = detector.detect_scm_system(self.webkit_base)
mock_scm = MockSCM()
mock_scm.run = mock_run
real_checkout = Checkout(real_scm)
checkout = Checkout(mock_scm)
checkout.script_path = real_checkout.script_path
checkout.modified_changelogs = lambda git_commit, changed_files=None: self.changelog_paths
return checkout
def test_commit_message_for_unreviewed_changelogs_with_different_messages(self):
expected_commit_message = u"""Unreviewed build fix to un-break webkit-patch land.
Tools:
Move commit_message_for_this_commit from scm to checkout
https://bugs.webkit.org/show_bug.cgi?id=36629
* Scripts/webkitpy/common/checkout/api.py: import scm.CommitMessage
LayoutTests:
Second part of this complicated change by me, Tor Arne Vestb\u00f8!
* Path/To/Complicated/File: Added.
"""
self.changelog_paths = map(self.filesystem.abspath, (self.filesystem.join("Tools", "ChangeLog"), self.filesystem.join("LayoutTests", "ChangeLog")))
self.mock_changelog((_changelog1, _changelog2))
checkout = self.mock_checkout_for_test()
commit_message = checkout.commit_message_for_this_commit(git_commit=None, return_stderr=True)
# Throw away the first line - a warning about unknown VCS root.
commit_message.message_lines = commit_message.message_lines[1:]
self.assertMultiLineEqual(commit_message.message(), expected_commit_message)
def test_commit_message_for_one_reviewed_changelog(self):
expected_commit_message = u"""SECTORDER_FLAGS should be defined in target's xcconfig file, not Base.xcconfig
<http://webkit.org/b/135006>
Patch by David Kilzer <*****@*****.**> on 2014-07-17
Reviewed by Darin Adler.
* WebKit.xcodeproj/project.pbxproj: Remove references to unused
WebKit.xcconfig file.
"""
self.changelog_paths = map(self.filesystem.abspath, [self.filesystem.join("Source/WebKit", "ChangeLog")])
self.mock_changelog([_changelog3])
checkout = self.mock_checkout_for_test()
commit_message = checkout.commit_message_for_this_commit(git_commit=None, return_stderr=True)
# Throw away the first line - a warning about unknown VCS root.
commit_message.message_lines = commit_message.message_lines[1:]
self.assertMultiLineEqual(commit_message.message(), expected_commit_message)
def test_commit_message_for_changelogs_with_same_messages(self):
expected_commit_message = u"""SECTORDER_FLAGS should be defined in target's xcconfig file, not Base.xcconfig
<http://webkit.org/b/135006>
Patch by David Kilzer <*****@*****.**> on 2014-07-17
Reviewed by Darin Adler.
Source/WebKit:
* WebKit.xcodeproj/project.pbxproj: Remove references to unused
WebKit.xcconfig file.
LayoutTests:
* Path/To/Complicated/File: Added.
"""
self.changelog_paths = map(self.filesystem.abspath, (self.filesystem.join("Source/WebKit", "ChangeLog"), self.filesystem.join("LayoutTests", "ChangeLog")))
self.mock_changelog((_changelog3, _changelog4))
checkout = self.mock_checkout_for_test()
commit_message = checkout.commit_message_for_this_commit(git_commit=None, return_stderr=True)
# Throw away the first line - a warning about unknown VCS root.
commit_message.message_lines = commit_message.message_lines[1:]
self.assertMultiLineEqual(commit_message.message(), expected_commit_message)
def test_commit_message_for_changelogs_with_different_messages(self):
expected_commit_message = u"""SECTORDER_FLAGS should be defined in target's xcconfig file, not Base.xcconfig
<http://webkit.org/b/135006>
Patch by David Kilzer <*****@*****.**> on 2014-07-17
Reviewed by Darin Adler.
Source/WebKit:
* WebKit.xcodeproj/project.pbxproj: Remove references to unused
WebKit.xcconfig file.
LayoutTests:
Filler change.
* Path/To/Complicated/File: Added.
"""
self.changelog_paths = map(self.filesystem.abspath, (self.filesystem.join("Source/WebKit", "ChangeLog"), self.filesystem.join("LayoutTests", "ChangeLog")))
self.mock_changelog((_changelog3, _changelog5))
checkout = self.mock_checkout_for_test()
commit_message = checkout.commit_message_for_this_commit(git_commit=None, return_stderr=True)
# Throw away the first line - a warning about unknown VCS root.
commit_message.message_lines = commit_message.message_lines[1:]
self.assertMultiLineEqual(commit_message.message(), expected_commit_message)
def test_commit_message_for_one_rollout_changelog(self):
expected_commit_message = u"""Rolling out r170340 and r170339.
Changeset r170339 broke the Apple Windows Debug and Release builds.
Reverted changesets:
"[Win] Build fix after r134209"
http://trac.webkit.org/changeset/170340
"[Win] Clean up and refactor WinLauncher"
https://bugs.webkit.org/show_bug.cgi?id=134209
http://trac.webkit.org/changeset/170339
Patch by Daniel Bates <*****@*****.**> on 2014-06-23
"""
self.changelog_paths = map(self.filesystem.abspath, [self.filesystem.join("Tools", "ChangeLog")])
self.mock_changelog([_changelog6])
checkout = self.mock_checkout_for_test()
commit_message = checkout.commit_message_for_this_commit(git_commit=None, return_stderr=True)
# Throw away the first line - a warning about unknown VCS root.
commit_message.message_lines = commit_message.message_lines[1:]
self.assertMultiLineEqual(commit_message.message(), expected_commit_message)
def test_commit_message_for_rollout_changelogs_with_different_directories(self):
expected_commit_message = u"""Rolling out r170340 and r170339.
Changeset r170339 broke the Apple Windows Debug and Release builds.
Reverted changesets:
"[Win] Build fix after r134209"
http://trac.webkit.org/changeset/170340
"[Win] Clean up and refactor WinLauncher"
https://bugs.webkit.org/show_bug.cgi?id=134209
http://trac.webkit.org/changeset/170339
Patch by Daniel Bates <*****@*****.**> on 2014-06-23
"""
self.changelog_paths = map(self.filesystem.abspath, (self.filesystem.join("Tools", "ChangeLog"), self.filesystem.join("Source/WebCore", "ChangeLog")))
self.mock_changelog((_changelog6, _changelog6))
checkout = self.mock_checkout_for_test()
commit_message = checkout.commit_message_for_this_commit(git_commit=None, return_stderr=True)
# Throw away the first line - a warning about unknown VCS root.
commit_message.message_lines = commit_message.message_lines[1:]
self.assertMultiLineEqual(commit_message.message(), expected_commit_message)
def test_sep(self):
fs = FileSystem()
self.assertEqual(fs.sep, os.sep)
self.assertEqual(fs.join('foo', 'bar'), os.path.join('foo', 'bar'))
def test_sep(self):
fs = FileSystem()
self.assertEqual(fs.sep, os.sep)
self.assertEqual(fs.join("foo", "bar"),
os.path.join("foo", "bar"))
class CommitMessageForThisCommitTest(unittest.TestCase):
expected_commit_message = u"""Unreviewed build fix to un-break webkit-patch land.
Tools:
Move commit_message_for_this_commit from scm to checkout
https://bugs.webkit.org/show_bug.cgi?id=36629
* Scripts/webkitpy/common/checkout/api.py: import scm.CommitMessage
LayoutTests:
Second part of this complicated change by me, Tor Arne Vestb\u00f8!
* Path/To/Complicated/File: Added.
"""
def setUp(self):
# FIXME: This should not need to touch the filesystem, however
# ChangeLog is difficult to mock at current.
self.filesystem = FileSystem()
self.temp_dir = str(self.filesystem.mkdtemp(suffix="changelogs"))
self.old_cwd = self.filesystem.getcwd()
self.filesystem.chdir(self.temp_dir)
# Trick commit-log-editor into thinking we're in a Subversion working copy so it won't
# complain about not being able to figure out what SCM is in use.
# FIXME: VCSTools.pm is no longer so easily fooled. It logs because "svn info" doesn't
# treat a bare .svn directory being part of an svn checkout.
self.filesystem.maybe_make_directory(".svn")
self.changelogs = map(self.filesystem.abspath, (self.filesystem.join("Tools", "ChangeLog"), self.filesystem.join("LayoutTests", "ChangeLog")))
for path, contents in zip(self.changelogs, (_changelog1, _changelog2)):
self.filesystem.maybe_make_directory(self.filesystem.dirname(path))
self.filesystem.write_text_file(path, contents)
def tearDown(self):
self.filesystem.rmtree(self.temp_dir)
self.filesystem.chdir(self.old_cwd)
def test_commit_message_for_this_commit(self):
executive = Executive()
def mock_run(*args, **kwargs):
# Note that we use a real Executive here, not a MockExecutive, so we can test that we're
# invoking commit-log-editor correctly.
env = os.environ.copy()
env['CHANGE_LOG_EMAIL_ADDRESS'] = '*****@*****.**'
kwargs['env'] = env
return executive.run_command(*args, **kwargs)
detector = SCMDetector(self.filesystem, executive)
real_scm = detector.detect_scm_system(self.old_cwd)
mock_scm = MockSCM()
mock_scm.run = mock_run
mock_scm.script_path = real_scm.script_path
checkout = Checkout(mock_scm)
checkout.modified_changelogs = lambda git_commit, changed_files=None: self.changelogs
commit_message = checkout.commit_message_for_this_commit(git_commit=None, return_stderr=True)
# Throw away the first line - a warning about unknown VCS root.
commit_message.message_lines = commit_message.message_lines[1:]
self.assertEqual(commit_message.message(), self.expected_commit_message)
class TextFileReaderTest(LoggingTestCase):
class MockProcessor(ProcessorBase):
"""A processor for test purposes.
This processor simply records the parameters passed to its process()
method for later checking by the unittest test methods.
"""
def __init__(self):
self.processed = []
"""The parameters passed for all calls to the process() method."""
def should_process(self, file_path):
return not file_path.endswith('should_not_process.txt')
def process(self, lines, file_path, test_kwarg=None):
self.processed.append((lines, file_path, test_kwarg))
def setUp(self):
LoggingTestCase.setUp(self)
# FIXME: This should be a MockFileSystem once TextFileReader is moved entirely on top of FileSystem.
self.filesystem = FileSystem()
self._temp_dir = str(self.filesystem.mkdtemp())
self._processor = TextFileReaderTest.MockProcessor()
self._file_reader = TextFileReader(self.filesystem, self._processor)
def tearDown(self):
LoggingTestCase.tearDown(self)
self.filesystem.rmtree(self._temp_dir)
def _create_file(self, rel_path, text):
"""Create a file with given text and return the path to the file."""
# FIXME: There are better/more secure APIs for creating tmp file paths.
file_path = self.filesystem.join(self._temp_dir, rel_path)
self.filesystem.write_text_file(file_path, text)
return file_path
def _passed_to_processor(self):
"""Return the parameters passed to MockProcessor.process()."""
return self._processor.processed
def _assert_file_reader(self, passed_to_processor, file_count):
"""Assert the state of the file reader."""
self.assertEqual(passed_to_processor, self._passed_to_processor())
self.assertEqual(file_count, self._file_reader.file_count)
def test_process_file__does_not_exist(self):
try:
self._file_reader.process_file('does_not_exist.txt')
except SystemExit as err:
self.assertEqual(str(err), '1')
else:
self.fail('No Exception raised.')
self._assert_file_reader([], 1)
self.assertLog(["ERROR: File does not exist: 'does_not_exist.txt'\n"])
def test_process_file__is_dir(self):
temp_dir = self.filesystem.join(self._temp_dir, 'test_dir')
self.filesystem.maybe_make_directory(temp_dir)
self._file_reader.process_file(temp_dir)
# Because the log message below contains exception text, it is
# possible that the text varies across platforms. For this reason,
# we check only the portion of the log message that we control,
# namely the text at the beginning.
log_messages = self.logMessages()
# We remove the message we are looking at to prevent the tearDown()
# from raising an exception when it asserts that no log messages
# remain.
message = log_messages.pop()
self.assertTrue(
message.startswith(
"WARNING: Could not read file. Skipping: '%s'\n " % temp_dir))
self._assert_file_reader([], 1)
def test_process_file__should_not_process(self):
file_path = self._create_file('should_not_process.txt', 'contents')
self._file_reader.process_file(file_path)
self._assert_file_reader([], 1)
def test_process_file__multiple_lines(self):
file_path = self._create_file('foo.txt', 'line one\r\nline two\n')
self._file_reader.process_file(file_path)
processed = [(['line one\r', 'line two', ''], file_path, None)]
self._assert_file_reader(processed, 1)
def test_process_file__file_stdin(self):
file_path = self._create_file('-', 'file contents')
self._file_reader.process_file(file_path=file_path, test_kwarg='foo')
processed = [(['file contents'], file_path, 'foo')]
self._assert_file_reader(processed, 1)
def test_process_file__with_kwarg(self):
file_path = self._create_file('foo.txt', 'file contents')
self._file_reader.process_file(file_path=file_path, test_kwarg='foo')
processed = [(['file contents'], file_path, 'foo')]
self._assert_file_reader(processed, 1)
def test_process_paths(self):
# We test a list of paths that contains both a file and a directory.
dir = self.filesystem.join(self._temp_dir, 'foo_dir')
self.filesystem.maybe_make_directory(dir)
file_path1 = self._create_file('file1.txt', 'foo')
rel_path = self.filesystem.join('foo_dir', 'file2.txt')
file_path2 = self._create_file(rel_path, 'bar')
self._file_reader.process_paths([dir, file_path1])
processed = [(['bar'], file_path2, None), (['foo'], file_path1, None)]
self._assert_file_reader(processed, 2)
def test_count_delete_only_file(self):
self._file_reader.count_delete_only_file()
delete_only_file_count = self._file_reader.delete_only_file_count
self.assertEqual(delete_only_file_count, 1)
# Putting the autoinstall code into webkitpy/thirdparty/__init__.py
# ensures that no autoinstalling occurs until a caller imports from
# webkitpy.thirdparty. This is useful if the caller wants to configure
# logging prior to executing autoinstall code.
# FIXME: If any of these servers is offline, webkit-patch breaks (and maybe
# other scripts do, too). See <http://webkit.org/b/42080>.
# We put auto-installed third-party modules in this directory--
#
# webkitpy/thirdparty/autoinstalled
fs = FileSystem()
fs.maybe_make_directory(_AUTOINSTALLED_DIR)
init_path = fs.join(_AUTOINSTALLED_DIR, "__init__.py")
if not fs.exists(init_path):
fs.write_text_file(init_path, "")
readme_path = fs.join(_AUTOINSTALLED_DIR, "README")
if not fs.exists(readme_path):
fs.write_text_file(readme_path,
"This directory is auto-generated by WebKit and is "
"safe to delete.\nIt contains needed third-party Python "
"packages automatically downloaded from the web.")
class AutoinstallImportHook(object):
def __init__(self, filesystem=None):
self._fs = filesystem or FileSystem()
class SCMTestBase(unittest.TestCase):
def __init__(self, *args, **kwargs):
super(SCMTestBase, self).__init__(*args, **kwargs)
self.scm = None
self.executive = None
self.fs = None
self.original_cwd = None
def setUp(self):
self.executive = Executive()
self.fs = FileSystem()
self.original_cwd = self.fs.getcwd()
def tearDown(self):
self._chdir(self.original_cwd)
def _join(self, *comps):
return self.fs.join(*comps)
def _chdir(self, path):
self.fs.chdir(path)
def _mkdir(self, path):
assert not self.fs.exists(path)
self.fs.maybe_make_directory(path)
def _mkdtemp(self, **kwargs):
return str(self.fs.mkdtemp(**kwargs))
def _remove(self, path):
self.fs.remove(path)
def _rmtree(self, path):
self.fs.rmtree(path)
def _run(self, *args, **kwargs):
return self.executive.run_command(*args, **kwargs)
def _run_silent(self, args, **kwargs):
self.executive.run_and_throw_if_fail(args, quiet=True, **kwargs)
def _write_text_file(self, path, contents):
self.fs.write_text_file(path, contents)
def _write_binary_file(self, path, contents):
self.fs.write_binary_file(path, contents)
def _make_diff(self, command, *args):
# We use this wrapper to disable output decoding. diffs should be treated as
# binary files since they may include text files of multiple differnet encodings.
return self._run([command, "diff"] + list(args), decode_output=False)
def _svn_diff(self, *args):
return self._make_diff("svn", *args)
def _git_diff(self, *args):
return self._make_diff("git", *args)
def _svn_add(self, path):
self._run(["svn", "add", path])
def _svn_commit(self, message):
self._run(["svn", "commit", "--quiet", "--message", message])
# This is a hot function since it's invoked by unittest before calling each test_ method in SVNTest and
# GitTest. We create a mock SVN repo once and then perform an SVN checkout from a filesystem copy of
# it since it's expensive to create the mock repo.
def _set_up_svn_checkout(self):
global cached_svn_repo_path
global original_cwd
if not cached_svn_repo_path:
cached_svn_repo_path = self._set_up_svn_repo()
original_cwd = self.original_cwd
self.temp_directory = self._mkdtemp(suffix="svn_test")
self.svn_repo_path = self._join(self.temp_directory, "repo")
self.svn_repo_url = "file://%s" % self.svn_repo_path
self.svn_checkout_path = self._join(self.temp_directory, "checkout")
shutil.copytree(cached_svn_repo_path, self.svn_repo_path)
self._run([
'svn', 'checkout', '--quiet', self.svn_repo_url + "/trunk",
self.svn_checkout_path
])
def _set_up_svn_repo(self):
svn_repo_path = self._mkdtemp(suffix="svn_test_repo")
svn_repo_url = "file://%s" % svn_repo_path # Not sure this will work on windows
# git svn complains if we don't pass --pre-1.5-compatible, not sure why:
# Expected FS format '2'; found format '3' at /usr/local/libexec/git-core//git-svn line 1477
self._run(
['svnadmin', 'create', '--pre-1.5-compatible', svn_repo_path])
# Create a test svn checkout
svn_checkout_path = self._mkdtemp(suffix="svn_test_checkout")
self._run(
['svn', 'checkout', '--quiet', svn_repo_url, svn_checkout_path])
# Create and checkout a trunk dir to match the standard svn configuration to match git-svn's expectations
self._chdir(svn_checkout_path)
self._mkdir('trunk')
self._svn_add('trunk')
# We can add tags and branches as well if we ever need to test those.
self._svn_commit('add trunk')
self._rmtree(svn_checkout_path)
self._set_up_svn_test_commits(svn_repo_url + "/trunk")
return svn_repo_path
def _set_up_svn_test_commits(self, svn_repo_url):
svn_checkout_path = self._mkdtemp(suffix="svn_test_checkout")
self._run(
['svn', 'checkout', '--quiet', svn_repo_url, svn_checkout_path])
# Add some test commits
self._chdir(svn_checkout_path)
self._write_text_file("test_file", "test1")
self._svn_add("test_file")
self._svn_commit("initial commit")
self._write_text_file("test_file", "test1test2")
# This used to be the last commit, but doing so broke
# GitTest.test_apply_git_patch which use the inverse diff of the last commit.
# svn-apply fails to remove directories in Git, see:
# https://bugs.webkit.org/show_bug.cgi?id=34871
self._mkdir("test_dir")
# Slash should always be the right path separator since we use cygwin on Windows.
test_file3_path = "test_dir/test_file3"
self._write_text_file(test_file3_path, "third file")
self._svn_add("test_dir")
self._svn_commit("second commit")
self._write_text_file("test_file", "test1test2test3\n")
self._write_text_file("test_file2", "second file")
self._svn_add("test_file2")
self._svn_commit("third commit")
# This 4th commit is used to make sure that our patch file handling
# code correctly treats patches as binary and does not attempt to
# decode them assuming they're utf-8.
self._write_binary_file("test_file",
u"latin1 test: \u00A0\n".encode("latin-1"))
self._write_binary_file("test_file2",
u"utf-8 test: \u00A0\n".encode("utf-8"))
self._svn_commit("fourth commit")
# svn does not seem to update after commit as I would expect.
self._run(['svn', 'update'])
self._rmtree(svn_checkout_path)
def _tear_down_svn_checkout(self):
self._rmtree(self.temp_directory)
def _shared_test_add_recursively(self):
self._mkdir("added_dir")
self._write_text_file("added_dir/added_file", "new stuff")
self.scm.add("added_dir/added_file")
self.assertIn("added_dir/added_file", self.scm._added_files())
def _shared_test_delete_recursively(self):
self._mkdir("added_dir")
self._write_text_file("added_dir/added_file", "new stuff")
self.scm.add("added_dir/added_file")
self.assertIn("added_dir/added_file", self.scm._added_files())
self.scm.delete("added_dir/added_file")
self.assertNotIn("added_dir", self.scm._added_files())
def _shared_test_delete_recursively_or_not(self):
self._mkdir("added_dir")
self._write_text_file("added_dir/added_file", "new stuff")
self._write_text_file("added_dir/another_added_file", "more new stuff")
self.scm.add("added_dir/added_file")
self.scm.add("added_dir/another_added_file")
self.assertIn("added_dir/added_file", self.scm._added_files())
self.assertIn("added_dir/another_added_file", self.scm._added_files())
self.scm.delete("added_dir/added_file")
self.assertIn("added_dir/another_added_file", self.scm._added_files())
def _shared_test_exists(self, scm, commit_function):
self._chdir(scm.checkout_root)
self.assertFalse(scm.exists('foo.txt'))
self._write_text_file('foo.txt', 'some stuff')
self.assertFalse(scm.exists('foo.txt'))
scm.add('foo.txt')
commit_function('adding foo')
self.assertTrue(scm.exists('foo.txt'))
scm.delete('foo.txt')
commit_function('deleting foo')
self.assertFalse(scm.exists('foo.txt'))
def _shared_test_move(self):
self._write_text_file('added_file', 'new stuff')
self.scm.add('added_file')
self.scm.move('added_file', 'moved_file')
self.assertIn('moved_file', self.scm._added_files())
def _shared_test_move_recursive(self):
self._mkdir("added_dir")
self._write_text_file('added_dir/added_file', 'new stuff')
self._write_text_file('added_dir/another_added_file', 'more new stuff')
self.scm.add('added_dir')
self.scm.move('added_dir', 'moved_dir')
self.assertIn('moved_dir/added_file', self.scm._added_files())
self.assertIn('moved_dir/another_added_file', self.scm._added_files())