| # Copyright 2016 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| import datetime |
| import json |
| |
| from blinkpy.common.checkout.git_mock import MockGit |
| from blinkpy.common.host_mock import MockHost |
| from blinkpy.common.net.buildbot import Build |
| from blinkpy.common.net.git_cl import CLStatus |
| from blinkpy.common.net.git_cl import TryJobStatus |
| from blinkpy.common.net.git_cl_mock import MockGitCL |
| from blinkpy.common.net.network_transaction import NetworkTimeout |
| from blinkpy.common.path_finder import RELATIVE_WEB_TESTS |
| from blinkpy.common.system.executive_mock import MockCall |
| from blinkpy.common.system.executive_mock import MockExecutive |
| from blinkpy.common.system.log_testing import LoggingTestCase |
| from blinkpy.w3c.chromium_commit_mock import MockChromiumCommit |
| from blinkpy.w3c.local_wpt import LocalWPT |
| from blinkpy.w3c.local_wpt_mock import MockLocalWPT |
| from blinkpy.w3c.test_importer import TestImporter, ROTATIONS_URL, TBR_FALLBACK |
| from blinkpy.w3c.wpt_github_mock import MockWPTGitHub |
| from blinkpy.w3c.wpt_manifest import BASE_MANIFEST_NAME |
| from blinkpy.web_tests.builder_list import BuilderList |
| |
| |
| MOCK_WEB_TESTS = '/mock-checkout/' + RELATIVE_WEB_TESTS |
| |
| class TestImporterTest(LoggingTestCase): |
| |
| def test_update_expectations_for_cl_no_results(self): |
| host = MockHost() |
| host.filesystem.write_text_file(MOCK_WEB_TESTS + 'W3CImportExpectations', '') |
| importer = TestImporter(host) |
| importer.git_cl = MockGitCL(host, time_out=True) |
| success = importer.update_expectations_for_cl() |
| self.assertFalse(success) |
| self.assertLog([ |
| 'INFO: Triggering try jobs for updating expectations.\n', |
| 'ERROR: No initial try job results, aborting.\n', |
| ]) |
| self.assertEqual(importer.git_cl.calls[-1], ['git', 'cl', 'set-close']) |
| |
| def test_update_expectations_for_cl_closed_cl(self): |
| host = MockHost() |
| host.filesystem.write_text_file(MOCK_WEB_TESTS + 'W3CImportExpectations', '') |
| importer = TestImporter(host) |
| importer.git_cl = MockGitCL(host, status='closed', try_job_results={ |
| Build('builder-a', 123): TryJobStatus('COMPLETED', 'SUCCESS'), |
| }) |
| success = importer.update_expectations_for_cl() |
| self.assertFalse(success) |
| self.assertLog([ |
| 'INFO: Triggering try jobs for updating expectations.\n', |
| 'ERROR: The CL was closed, aborting.\n', |
| ]) |
| |
| def test_update_expectations_for_cl_all_jobs_pass(self): |
| host = MockHost() |
| host.filesystem.write_text_file(MOCK_WEB_TESTS + 'W3CImportExpectations', '') |
| importer = TestImporter(host) |
| importer.git_cl = MockGitCL(host, status='lgtm', try_job_results={ |
| Build('builder-a', 123): TryJobStatus('COMPLETED', 'SUCCESS'), |
| }) |
| success = importer.update_expectations_for_cl() |
| self.assertLog([ |
| 'INFO: Triggering try jobs for updating expectations.\n', |
| 'INFO: All jobs finished.\n', |
| ]) |
| self.assertTrue(success) |
| |
| def test_update_expectations_for_cl_fail_but_no_changes(self): |
| host = MockHost() |
| host.filesystem.write_text_file(MOCK_WEB_TESTS + 'W3CImportExpectations', '') |
| importer = TestImporter(host) |
| importer.git_cl = MockGitCL(host, status='lgtm', try_job_results={ |
| Build('builder-a', 123): TryJobStatus('COMPLETED', 'FAILURE'), |
| }) |
| importer.fetch_new_expectations_and_baselines = lambda: None |
| success = importer.update_expectations_for_cl() |
| self.assertTrue(success) |
| self.assertLog([ |
| 'INFO: Triggering try jobs for updating expectations.\n', |
| 'INFO: All jobs finished.\n', |
| ]) |
| |
| def test_run_commit_queue_for_cl_pass(self): |
| host = MockHost() |
| host.filesystem.write_text_file(MOCK_WEB_TESTS + 'W3CImportExpectations', '') |
| importer = TestImporter(host) |
| # Only the latest job for each builder is counted. |
| importer.git_cl = MockGitCL(host, status='lgtm', try_job_results={ |
| Build('cq-builder-a', 120): TryJobStatus('COMPLETED', 'FAILURE'), |
| Build('cq-builder-a', 123): TryJobStatus('COMPLETED', 'SUCCESS'), |
| }) |
| success = importer.run_commit_queue_for_cl() |
| self.assertTrue(success) |
| self.assertLog([ |
| 'INFO: Triggering CQ try jobs.\n', |
| 'INFO: All jobs finished.\n', |
| 'INFO: CQ appears to have passed; trying to commit.\n', |
| 'INFO: Update completed.\n', |
| ]) |
| self.assertEqual(importer.git_cl.calls, [ |
| ['git', 'cl', 'try'], |
| ['git', 'cl', 'upload', '-f', '--send-mail'], |
| ['git', 'cl', 'set-commit'], |
| ]) |
| |
| def test_run_commit_queue_for_cl_fail_cq(self): |
| host = MockHost() |
| host.filesystem.write_text_file(MOCK_WEB_TESTS + 'W3CImportExpectations', '') |
| importer = TestImporter(host) |
| importer.git_cl = MockGitCL(host, status='lgtm', try_job_results={ |
| Build('cq-builder-a', 120): TryJobStatus('COMPLETED', 'SUCCESS'), |
| Build('cq-builder-a', 123): TryJobStatus('COMPLETED', 'FAILURE'), |
| Build('cq-builder-b', 200): TryJobStatus('COMPLETED', 'SUCCESS'), |
| }) |
| importer.fetch_new_expectations_and_baselines = lambda: None |
| success = importer.run_commit_queue_for_cl() |
| self.assertFalse(success) |
| self.assertLog([ |
| 'INFO: Triggering CQ try jobs.\n', |
| 'INFO: All jobs finished.\n', |
| 'ERROR: CQ appears to have failed; aborting.\n', |
| ]) |
| self.assertEqual(importer.git_cl.calls, [ |
| ['git', 'cl', 'try'], |
| ['git', 'cl', 'set-close'], |
| ]) |
| |
| def test_run_commit_queue_for_cl_fail_to_land(self): |
| host = MockHost() |
| host.filesystem.write_text_file(MOCK_WEB_TESTS + 'W3CImportExpectations', '') |
| importer = TestImporter(host) |
| # Only the latest job for each builder is counted. |
| importer.git_cl = MockGitCL(host, status='lgtm', try_job_results={ |
| Build('cq-builder-a', 120): TryJobStatus('COMPLETED', 'FAILURE'), |
| Build('cq-builder-a', 123): TryJobStatus('COMPLETED', 'SUCCESS'), |
| }) |
| importer.git_cl.wait_for_closed_status = lambda: False |
| success = importer.run_commit_queue_for_cl() |
| self.assertFalse(success) |
| self.assertLog([ |
| 'INFO: Triggering CQ try jobs.\n', |
| 'INFO: All jobs finished.\n', |
| 'INFO: CQ appears to have passed; trying to commit.\n', |
| 'ERROR: Cannot submit CL; aborting.\n', |
| ]) |
| self.assertEqual(importer.git_cl.calls, [ |
| ['git', 'cl', 'try'], |
| ['git', 'cl', 'upload', '-f', '--send-mail'], |
| ['git', 'cl', 'set-commit'], |
| ['git', 'cl', 'set-close'], |
| ]) |
| |
| def test_run_commit_queue_for_cl_closed_cl(self): |
| host = MockHost() |
| host.filesystem.write_text_file(MOCK_WEB_TESTS + 'W3CImportExpectations', '') |
| importer = TestImporter(host) |
| importer.git_cl = MockGitCL(host, status='closed', try_job_results={ |
| Build('cq-builder-a', 120): TryJobStatus('COMPLETED', 'SUCCESS'), |
| Build('cq-builder-b', 200): TryJobStatus('COMPLETED', 'SUCCESS'), |
| }) |
| success = importer.run_commit_queue_for_cl() |
| self.assertFalse(success) |
| self.assertLog([ |
| 'INFO: Triggering CQ try jobs.\n', |
| 'ERROR: The CL was closed; aborting.\n', |
| ]) |
| self.assertEqual(importer.git_cl.calls, [ |
| ['git', 'cl', 'try'], |
| ]) |
| |
| def test_run_commit_queue_for_cl_timeout(self): |
| # This simulates the case where we time out while waiting for try jobs. |
| host = MockHost() |
| importer = TestImporter(host) |
| importer.git_cl = MockGitCL(host, time_out=True) |
| success = importer.run_commit_queue_for_cl() |
| self.assertFalse(success) |
| self.assertLog([ |
| 'INFO: Triggering CQ try jobs.\n', |
| 'ERROR: Timed out waiting for CQ; aborting.\n' |
| ]) |
| self.assertEqual( |
| importer.git_cl.calls, |
| [['git', 'cl', 'try'], ['git', 'cl', 'set-close']]) |
| |
| def test_submit_cl_timeout_and_already_merged(self): |
| # Here we simulate a case where we timeout waiting for the CQ to submit a |
| # CL because we miss the notification that it was merged. We then get an |
| # error when trying to close the CL because it's already been merged. |
| host = MockHost() |
| host.filesystem.write_text_file(MOCK_WEB_TESTS + 'W3CImportExpectations', '') |
| importer = TestImporter(host) |
| # Define some error text that looks like a typical ScriptError. |
| git_error_text = ( |
| 'This is a git Script Error\n' |
| '...there is usually a stack trace here with some calls\n' |
| '...and maybe other calls\n' |
| 'And finally, there is the exception:\n' |
| 'GerritError: Conflict: change is merged\n' |
| ) |
| importer.git_cl = MockGitCL( |
| host, status='lgtm', git_error_output={'set-close': git_error_text}, |
| # Only the latest job for each builder is counted. |
| try_job_results={ |
| Build('cq-builder-a', 120): TryJobStatus('COMPLETED', 'FAILURE'), |
| Build('cq-builder-a', 123): TryJobStatus('COMPLETED', 'SUCCESS')}) |
| importer.git_cl.wait_for_closed_status = lambda: False |
| success = importer.run_commit_queue_for_cl() |
| # Since the CL is already merged, we absorb the error and treat it as success. |
| self.assertTrue(success) |
| self.assertLog([ |
| 'INFO: Triggering CQ try jobs.\n', |
| 'INFO: All jobs finished.\n', |
| 'INFO: CQ appears to have passed; trying to commit.\n', |
| 'ERROR: Cannot submit CL; aborting.\n', |
| 'ERROR: CL is already merged; treating as success.\n', |
| ]) |
| self.assertEqual(importer.git_cl.calls, [ |
| ['git', 'cl', 'try'], |
| ['git', 'cl', 'upload', '-f', '--send-mail'], |
| ['git', 'cl', 'set-commit'], |
| ['git', 'cl', 'set-close'], |
| ]) |
| |
| def test_apply_exportable_commits_locally(self): |
| # TODO(robertma): Consider using MockLocalWPT. |
| host = MockHost() |
| importer = TestImporter(host, wpt_github=MockWPTGitHub(pull_requests=[])) |
| importer.wpt_git = MockGit(cwd='/tmp/wpt', executive=host.executive) |
| fake_commit = MockChromiumCommit( |
| host, subject='My fake commit', |
| patch=( |
| 'Fake patch contents...\n' |
| '--- a/' + RELATIVE_WEB_TESTS + 'external/wpt/css/css-ui-3/outline-004.html\n' |
| '+++ b/' + RELATIVE_WEB_TESTS + 'external/wpt/css/css-ui-3/outline-004.html\n' |
| '@@ -20,7 +20,7 @@\n' |
| '...')) |
| importer.exportable_but_not_exported_commits = lambda _: [fake_commit] |
| applied = importer.apply_exportable_commits_locally(LocalWPT(host)) |
| self.assertEqual(applied, [fake_commit]) |
| # This assertion is implementation details of LocalWPT.apply_patch. |
| # TODO(robertma): Move this to local_wpt_unittest.py. |
| self.assertEqual(host.executive.full_calls, [ |
| MockCall( |
| ['git', 'apply', '-'], |
| { |
| 'input': ( |
| 'Fake patch contents...\n' |
| '--- a/css/css-ui-3/outline-004.html\n' |
| '+++ b/css/css-ui-3/outline-004.html\n' |
| '@@ -20,7 +20,7 @@\n' |
| '...'), |
| 'cwd': '/tmp/wpt', |
| 'env': None |
| }), |
| MockCall( |
| ['git', 'add', '.'], |
| kwargs={'input': None, 'cwd': '/tmp/wpt', 'env': None}) |
| ]) |
| self.assertEqual(importer.wpt_git.local_commits(), |
| [['Applying patch 14fd77e88e42147c57935c49d9e3b2412b8491b7']]) |
| |
| def test_apply_exportable_commits_locally_returns_none_on_failure(self): |
| host = MockHost() |
| wpt_github = MockWPTGitHub(pull_requests=[]) |
| importer = TestImporter(host, wpt_github=wpt_github) |
| commit = MockChromiumCommit(host, subject='My fake commit') |
| importer.exportable_but_not_exported_commits = lambda _: [commit] |
| local_wpt = MockLocalWPT(apply_patch=['Failed']) # Failure to apply patch. |
| applied = importer.apply_exportable_commits_locally(local_wpt) |
| self.assertIsNone(applied) |
| |
| def test_update_all_test_expectations_files(self): |
| host = MockHost() |
| host.filesystem.files[MOCK_WEB_TESTS + 'TestExpectations'] = ( |
| 'Bug(test) some/test/a.html [ Failure ]\n' |
| 'Bug(test) some/test/b.html [ Failure ]\n' |
| 'Bug(test) some/test/c.html [ Failure ]\n') |
| host.filesystem.files[MOCK_WEB_TESTS + 'WebDriverExpectations'] = ( |
| 'Bug(test) external/wpt/webdriver/some/test/a.html>>foo [ Failure ]\n' |
| 'Bug(test) external/wpt/webdriver/some/test/a.html>>bar [ Failure ]\n' |
| 'Bug(test) external/wpt/webdriver/some/test/b.html>>foo [ Failure ]\n' |
| 'Bug(test) external/wpt/webdriver/some/test/c.html>>a [ Failure ]\n') |
| host.filesystem.files[MOCK_WEB_TESTS + 'VirtualTestSuites'] = '[]' |
| host.filesystem.files[MOCK_WEB_TESTS + 'new/a.html'] = '' |
| host.filesystem.files[MOCK_WEB_TESTS + 'new/b.html'] = '' |
| importer = TestImporter(host) |
| deleted_tests = ['some/test/b.html', 'external/wpt/webdriver/some/test/b.html'] |
| renamed_test_pairs = { |
| 'some/test/a.html': 'new/a.html', |
| 'some/test/c.html': 'new/c.html', |
| 'external/wpt/webdriver/some/test/a.html': 'old/a.html', |
| 'external/wpt/webdriver/some/test/c.html': 'old/c.html', |
| } |
| importer.update_all_test_expectations_files(deleted_tests, renamed_test_pairs) |
| self.assertMultiLineEqual( |
| host.filesystem.read_text_file(MOCK_WEB_TESTS + 'TestExpectations'), |
| ('Bug(test) new/a.html [ Failure ]\n' |
| 'Bug(test) new/c.html [ Failure ]\n')) |
| self.assertMultiLineEqual( |
| host.filesystem.read_text_file(MOCK_WEB_TESTS + 'WebDriverExpectations'), |
| ('Bug(test) old/a.html>>foo [ Failure ]\n' |
| 'Bug(test) old/a.html>>bar [ Failure ]\n' |
| 'Bug(test) old/c.html>>a [ Failure ]\n')) |
| |
| def test_get_directory_owners(self): |
| host = MockHost() |
| host.filesystem.write_text_file(MOCK_WEB_TESTS + 'W3CImportExpectations', '') |
| host.filesystem.write_text_file(MOCK_WEB_TESTS + 'external/wpt/foo/OWNERS', |
| 'someone@chromium.org\n') |
| importer = TestImporter(host) |
| importer.chromium_git.changed_files = lambda: [RELATIVE_WEB_TESTS + 'external/wpt/foo/x.html'] |
| self.assertEqual(importer.get_directory_owners(), {('someone@chromium.org',): ['external/wpt/foo']}) |
| |
| def test_get_directory_owners_no_changed_files(self): |
| host = MockHost() |
| host.filesystem.write_text_file(MOCK_WEB_TESTS + 'W3CImportExpectations', '') |
| host.filesystem.write_text_file(MOCK_WEB_TESTS + 'external/wpt/foo/OWNERS', |
| 'someone@chromium.org\n') |
| importer = TestImporter(host) |
| self.assertEqual(importer.get_directory_owners(), {}) |
| |
| # Tests for protected methods - pylint: disable=protected-access |
| |
| def test_commit_changes(self): |
| host = MockHost() |
| importer = TestImporter(host) |
| importer._commit_changes('dummy message') |
| self.assertEqual(importer.chromium_git.local_commits(), [['dummy message']]) |
| |
| def test_commit_message(self): |
| importer = TestImporter(MockHost()) |
| self.assertEqual( |
| importer._commit_message('aaaa', '1111'), |
| 'Import 1111\n\n' |
| 'Using wpt-import in Chromium aaaa.\n\n' |
| 'No-Export: true') |
| |
| def test_cl_description_with_empty_environ(self): |
| host = MockHost() |
| host.executive = MockExecutive(output='Last commit message\n\n') |
| importer = TestImporter(host) |
| description = importer._cl_description(directory_owners={}) |
| self.assertEqual( |
| description, |
| 'Last commit message\n\n' |
| 'Note to sheriffs: This CL imports external tests and adds\n' |
| 'expectations for those tests; if this CL is large and causes\n' |
| 'a few new failures, please fix the failures by adding new\n' |
| 'lines to TestExpectations rather than reverting. See:\n' |
| 'https://chromium.googlesource.com' |
| '/chromium/src/+/master/docs/testing/web_platform_tests.md\n\n' |
| 'NOAUTOREVERT=true\n' |
| 'No-Export: true') |
| self.assertEqual(host.executive.calls, [['git', 'log', '-1', '--format=%B']]) |
| |
| def test_cl_description_with_environ_variables(self): |
| host = MockHost() |
| host.executive = MockExecutive(output='Last commit message\n') |
| importer = TestImporter(host) |
| importer.host.environ['BUILDBOT_MASTERNAME'] = 'my.master' |
| importer.host.environ['BUILDBOT_BUILDERNAME'] = 'b' |
| importer.host.environ['BUILDBOT_BUILDNUMBER'] = '123' |
| description = importer._cl_description(directory_owners={}) |
| self.assertIn( |
| 'Build: https://ci.chromium.org/buildbot/my.master/b/123\n\n', |
| description) |
| self.assertEqual(host.executive.calls, [['git', 'log', '-1', '--format=%B']]) |
| |
| def test_cl_description_moves_noexport_tag(self): |
| host = MockHost() |
| host.executive = MockExecutive(output='Summary\n\nNo-Export: true\n\n') |
| importer = TestImporter(host) |
| description = importer._cl_description(directory_owners={}) |
| self.assertIn( |
| 'No-Export: true', |
| description) |
| |
| def test_cl_description_with_directory_owners(self): |
| host = MockHost() |
| host.executive = MockExecutive(output='Last commit message\n\n') |
| importer = TestImporter(host) |
| description = importer._cl_description(directory_owners={ |
| ('someone@chromium.org',): ['external/wpt/foo', 'external/wpt/bar'], |
| ('x@chromium.org', 'y@chromium.org'): ['external/wpt/baz'], |
| }) |
| self.assertIn( |
| 'Directory owners for changes in this CL:\n' |
| 'someone@chromium.org:\n' |
| ' external/wpt/foo\n' |
| ' external/wpt/bar\n' |
| 'x@chromium.org, y@chromium.org:\n' |
| ' external/wpt/baz\n\n', |
| description) |
| |
| def test_tbr_reviewer_no_response_uses_backup(self): |
| host = MockHost() |
| importer = TestImporter(host) |
| self.assertEqual(TBR_FALLBACK, importer.tbr_reviewer()) |
| self.assertLog([ |
| 'ERROR: Exception while fetching current sheriff: ' |
| 'No JSON object could be decoded\n' |
| ]) |
| |
| def test_tbr_reviewer_date_not_found(self): |
| host = MockHost() |
| yesterday = (datetime.date.fromtimestamp(host.time()) - |
| datetime.timedelta(days=1)).isoformat() |
| host.web.urls[ROTATIONS_URL] = json.dumps({ |
| 'calendar': [ |
| { |
| 'date': yesterday, |
| 'participants': [['some-sheriff'], ['other-sheriff']], |
| }, |
| ], |
| 'rotations': ['ecosystem_infra', 'other_rotation'] |
| }) |
| importer = TestImporter(host) |
| self.assertEqual(TBR_FALLBACK, importer.tbr_reviewer()) |
| # Use a variable here, otherwise we get different values depending on |
| # the machine's time zone settings (e.g. "1969-12-31" vs "1970-01-01"). |
| today = datetime.date.fromtimestamp(host.time()).isoformat() |
| self.assertLog([ |
| 'ERROR: No entry found for date %s in rotations table.\n' % today |
| ]) |
| |
| def test_tbr_reviewer_nobody_on_rotation(self): |
| host = MockHost() |
| today = datetime.date.fromtimestamp(host.time()).isoformat() |
| host.web.urls[ROTATIONS_URL] = json.dumps({ |
| 'calendar': [ |
| { |
| 'date': today, |
| 'participants': [[], ['some-sheriff']], |
| }, |
| ], |
| 'rotations': ['ecosystem_infra', 'other-rotation'] |
| }) |
| importer = TestImporter(host) |
| self.assertEqual(TBR_FALLBACK, importer.tbr_reviewer()) |
| self.assertLog([ |
| 'INFO: No sheriff today.\n' |
| ]) |
| |
| def test_tbr_reviewer_rotations_url_unavailable(self): |
| def raise_exception(*_): |
| raise NetworkTimeout |
| |
| host = MockHost() |
| host.web.get_binary = raise_exception |
| importer = TestImporter(host) |
| self.assertEqual(TBR_FALLBACK, importer.tbr_reviewer()) |
| self.assertLog([ |
| 'ERROR: Cannot fetch %s\n' % ROTATIONS_URL |
| ]) |
| |
| def test_tbr_reviewer(self): |
| host = MockHost() |
| today = datetime.date.fromtimestamp(host.time()) |
| yesterday = today - datetime.timedelta(days=1) |
| host.web.urls[ROTATIONS_URL] = json.dumps({ |
| 'calendar': [ |
| { |
| 'date': yesterday.isoformat(), |
| 'participants': [['other-sheriff'], ['last-sheriff']], |
| }, |
| { |
| 'date': today.isoformat(), |
| 'participants': [['other-sheriff'], ['current-sheriff']], |
| }, |
| ], |
| 'rotations': ['other-rotation', 'ecosystem_infra'] |
| }) |
| importer = TestImporter(host) |
| self.assertEqual('current-sheriff', importer.tbr_reviewer()) |
| self.assertLog([]) |
| |
| def test_tbr_reviewer_with_full_email_address(self): |
| host = MockHost() |
| today = datetime.date.fromtimestamp(host.time()).isoformat() |
| host.web.urls[ROTATIONS_URL] = json.dumps({ |
| 'calendar': [ |
| { |
| 'date': today, |
| 'participants': [['external@example.com']], |
| }, |
| ], |
| 'rotations': ['ecosystem_infra'] |
| }) |
| importer = TestImporter(host) |
| self.assertEqual('external@example.com', importer.tbr_reviewer()) |
| self.assertLog([]) |
| |
| def test_generate_manifest_successful_run(self): |
| # This test doesn't test any aspect of the real manifest script, it just |
| # asserts that TestImporter._generate_manifest would invoke the script. |
| host = MockHost() |
| importer = TestImporter(host) |
| host.filesystem.write_text_file(MOCK_WEB_TESTS + 'external/wpt/MANIFEST.json', '{}') |
| importer._generate_manifest() |
| self.assertEqual( |
| host.executive.calls, |
| [ |
| [ |
| 'python', |
| '/mock-checkout/third_party/blink/tools/blinkpy/third_party/wpt/wpt/wpt', |
| 'manifest', |
| '--no-download', |
| '--tests-root', |
| MOCK_WEB_TESTS + 'external/wpt', |
| ] |
| ]) |
| self.assertEqual(importer.chromium_git.added_paths, |
| {MOCK_WEB_TESTS + 'external/' + BASE_MANIFEST_NAME}) |
| |
| def test_only_wpt_manifest_changed(self): |
| host = MockHost() |
| importer = TestImporter(host) |
| importer.chromium_git.changed_files = lambda: [ |
| RELATIVE_WEB_TESTS + 'external/' + BASE_MANIFEST_NAME, |
| RELATIVE_WEB_TESTS + 'external/wpt/foo/x.html'] |
| self.assertFalse(importer._only_wpt_manifest_changed()) |
| |
| importer.chromium_git.changed_files = lambda: [ |
| RELATIVE_WEB_TESTS + 'external/' + BASE_MANIFEST_NAME] |
| self.assertTrue(importer._only_wpt_manifest_changed()) |
| |
| def test_delete_orphaned_baselines_basic(self): |
| host = MockHost() |
| importer = TestImporter(host) |
| dest_path = importer.dest_path |
| host.filesystem.write_text_file( |
| dest_path + '/MANIFEST.json', |
| json.dumps({ |
| 'items': { |
| 'testharness': { |
| 'a.html': [['/a.html', {}]], |
| }, |
| 'manual': {}, |
| 'reftest': {}, |
| }, |
| })) |
| host.filesystem.write_text_file(dest_path + '/a.html', '') |
| host.filesystem.write_text_file(dest_path + '/a-expected.txt', '') |
| host.filesystem.write_text_file(dest_path + '/orphaned-expected.txt', '') |
| importer._delete_orphaned_baselines() |
| self.assertFalse(host.filesystem.exists(dest_path + '/orphaned-expected.txt')) |
| self.assertTrue(host.filesystem.exists(dest_path + '/a-expected.txt')) |
| |
| def test_delete_orphaned_baselines_worker_js_tests(self): |
| # This test checks that baselines for existing tests shouldn't be |
| # deleted, even if the test name isn't the same as the file name. |
| host = MockHost() |
| importer = TestImporter(host) |
| dest_path = importer.dest_path |
| host.filesystem.write_text_file( |
| dest_path + '/MANIFEST.json', |
| json.dumps({ |
| 'items': { |
| 'testharness': { |
| 'a.any.js': [ |
| ['/a.any.html', {}], |
| ['/a.any.worker.html', {}], |
| ], |
| 'b.worker.js': [['/b.worker.html', {}]], |
| 'c.html': [ |
| ['/c.html?q=1', {}], |
| ['/c.html?q=2', {}], |
| ], |
| }, |
| 'manual': {}, |
| 'reftest': {}, |
| }, |
| })) |
| host.filesystem.write_text_file(dest_path + '/a.any.js', '') |
| host.filesystem.write_text_file(dest_path + '/a.any-expected.txt', '') |
| host.filesystem.write_text_file(dest_path + '/a.any.worker-expected.txt', '') |
| host.filesystem.write_text_file(dest_path + '/b.worker.js', '') |
| host.filesystem.write_text_file(dest_path + '/b.worker-expected.txt', '') |
| host.filesystem.write_text_file(dest_path + '/c.html', '') |
| host.filesystem.write_text_file(dest_path + '/c-expected.txt', '') |
| importer._delete_orphaned_baselines() |
| self.assertTrue(host.filesystem.exists(dest_path + '/a.any-expected.txt')) |
| self.assertTrue(host.filesystem.exists(dest_path + '/a.any.worker-expected.txt')) |
| self.assertTrue(host.filesystem.exists(dest_path + '/b.worker-expected.txt')) |
| self.assertTrue(host.filesystem.exists(dest_path + '/c-expected.txt')) |
| |
| def test_clear_out_dest_path(self): |
| host = MockHost() |
| importer = TestImporter(host) |
| dest_path = importer.dest_path |
| host.filesystem.write_text_file(dest_path + '/foo-test.html', '') |
| host.filesystem.write_text_file(dest_path + '/foo-test-expected.txt', '') |
| host.filesystem.write_text_file(dest_path + '/OWNERS', '') |
| host.filesystem.write_text_file(dest_path + '/bar/baz/OWNERS', '') |
| # TODO(crbug.com/927187): Delete it once webdrive/tests manual import is done. |
| host.filesystem.write_text_file(dest_path + '/webdriver/tests/A.txt', '') |
| host.filesystem.write_text_file(dest_path + '/webdriver/tests/test/assert.py', '') |
| host.filesystem.write_text_file(dest_path + '/webdriver/META.yml', '') |
| # When the destination path is cleared, OWNERS files and baselines |
| # are kept. |
| importer._clear_out_dest_path() |
| self.assertFalse(host.filesystem.exists(dest_path + '/foo-test.html')) |
| self.assertTrue(host.filesystem.exists(dest_path + '/foo-test-expected.txt')) |
| self.assertTrue(host.filesystem.exists(dest_path + '/OWNERS')) |
| self.assertTrue(host.filesystem.exists(dest_path + '/bar/baz/OWNERS')) |
| |
| self.assertTrue(host.filesystem.exists(dest_path + '/webdriver/tests/A.txt')) |
| self.assertTrue(host.filesystem.exists(dest_path + '/webdriver/tests/test/assert.py')) |
| self.assertTrue(host.filesystem.exists(dest_path + '/webdriver/META.yml')) |
