Don't track SCM changes in rebaseline commands.

third_party/WebKit/Tools/Scripts/webkitpy/tool/commands/rebaseline_unittest.py

 # 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 optparse
 import unittest
 
 from webkitpy.common.net.buildbot import Build
 from webkitpy.common.net.layouttestresults import LayoutTestResults
 from webkitpy.common.system.executive_mock import MockExecutive, MockExecutive2
 from webkitpy.common.system.outputcapture import OutputCapture
 from webkitpy.layout_tests.builder_list import BuilderList
 from webkitpy.tool.commands.rebaseline import (
     AbstractParallelRebaselineCommand, CopyExistingBaselinesInternal,
-    Rebaseline, RebaselineExpectations, RebaselineJson, RebaselineTest, ChangeSet
+    Rebaseline, RebaselineExpectations, RebaselineJson, RebaselineTest
 )
 from webkitpy.tool.mock_tool import MockWebKitPatch
 
 
 # pylint: disable=protected-access
 class BaseTestCase(unittest.TestCase):
     MOCK_WEB_RESULT = 'MOCK Web result, convert 404 to None=True'
     WEB_PREFIX = 'https://storage.googleapis.com/chromium-layout-test-archives/MOCK_Mac10_11/results/layout-test-results'
 
     command_constructor = None
@@ skipping 98 matching lines @@
             options = optparse.Values({
                 'builder': "MOCK Mac10.11",
                 'suffixes': 'txt',
                 'verbose': True,
                 'test': "failures/expected/image.html",
                 'results_directory': None
             })
             oc.capture_output()
             self.command.execute(options, [], self.tool)
         finally:
-            out, _, _ = oc.restore_output()
+            oc.restore_output()
 
         self.assertMultiLineEqual(
             self._read(self.tool.filesystem.join(
                 port.layout_tests_dir(),
                 'platform/test-mac-mac10.10/failures/expected/image-expected.txt')),
             'original mac10.11 result')
-        self.assertMultiLineEqual(out, '{"add": [], "remove-lines": [], "delete": []}\n')
 
     def test_copying_overwritten_baseline_to_multiple_locations(self):
         self.tool.executive = MockExecutive2()
 
         port = self.tool.port_factory.get('test-win-win7')
         self._write(
             port.host.filesystem.join(port.layout_tests_dir(), 'platform/test-win-win7/failures/expected/image-expected.txt'),
             'original win7 result')
 
         oc = OutputCapture()
         try:
             options = optparse.Values({
                 'builder': "MOCK Win7",
                 'suffixes': "txt",
                 'verbose': True,
                 'test': "failures/expected/image.html",
                 'results_directory': None
             })
             oc.capture_output()
             self.command.execute(options, [], self.tool)
         finally:
-            out, _, _ = oc.restore_output()
+            oc.restore_output()
 
         self.assertMultiLineEqual(
             self._read(self.tool.filesystem.join(
                 port.layout_tests_dir(),
                 'platform/test-linux-trusty/failures/expected/image-expected.txt')),
             'original win7 result')
         self.assertFalse(self.tool.filesystem.exists(self.tool.filesystem.join(
             port.layout_tests_dir(), 'platform/test-linux-precise/userscripts/another-test-expected.txt')))
         self.assertFalse(self.tool.filesystem.exists(self.tool.filesystem.join(
             port.layout_tests_dir(), 'platform/test-mac-mac10.10/userscripts/another-test-expected.txt')))
-        self.assertMultiLineEqual(out, '{"add": [], "remove-lines": [], "delete": []}\n')
 
     def test_no_copy_existing_baseline(self):
         self.tool.executive = MockExecutive2()
 
         port = self.tool.port_factory.get('test-win-win7')
         self._write(
             port.host.filesystem.join(
                 port.layout_tests_dir(),
                 'platform/test-win-win7/failures/expected/image-expected.txt'),
             'original win7 result')
 
         oc = OutputCapture()
         try:
             options = optparse.Values({
                 'builder': "MOCK Win7",
                 'suffixes': "txt",
                 'verbose': True,
                 'test': "failures/expected/image.html",
                 'results_directory': None
             })
             oc.capture_output()
             self.command.execute(options, [], self.tool)
         finally:
-            out, _, _ = oc.restore_output()
+            oc.restore_output()
 
         self.assertMultiLineEqual(
             self._read(self.tool.filesystem.join(
                 port.layout_tests_dir(),
                 'platform/test-linux-trusty/failures/expected/image-expected.txt')),
             'original win7 result')
         self.assertMultiLineEqual(
             self._read(self.tool.filesystem.join(
                 port.layout_tests_dir(),
                 'platform/test-win-win7/failures/expected/image-expected.txt')),
             'original win7 result')
         self.assertFalse(self.tool.filesystem.exists(self.tool.filesystem.join(
             port.layout_tests_dir(), 'platform/test-mac-mac10.10/userscripts/another-test-expected.txt')))
-        self.assertMultiLineEqual(out, '{"add": [], "remove-lines": [], "delete": []}\n')
 
     def test_no_copy_skipped_test(self):
         self.tool.executive = MockExecutive2()
         port = self.tool.port_factory.get('test-win-win7')
         fs = self.tool.filesystem
         self._write(
             fs.join(
                 port.layout_tests_dir(),
                 'platform/test-win-win7/failures/expected/image-expected.txt'),
             'original win7 result')
@@ skipping 93 matching lines @@
              "bug(z) [ Linux ] userscripts/another-test.html [ Failure ]\n"))
         self.command._rebaseline_test_and_update_expectations(self.options(results_directory='/tmp'))
         self.assertItemsEqual(self.tool.web.urls_fetched, ['file:///tmp/userscripts/another-test-actual.txt'])
 
     def test_rebaseline_reftest(self):
         self._write("userscripts/another-test.html", "test data")
         self._write("userscripts/another-test-expected.html", "generic result")
         OutputCapture().assert_outputs(
             self, self.command._rebaseline_test_and_update_expectations, args=[self.options(suffixes='png')],
             expected_logs="Cannot rebaseline image result for reftest: userscripts/another-test.html\n")
-        self.assertDictEqual(self.command._scm_changes.to_dict(), {'add': [], 'remove-lines': [], "delete": []})
-
-    def test_rebaseline_test_and_print_scm_changes(self):
-        self.command._print_scm_changes = True
-        self.command._scm_changes = ChangeSet()
-        self.tool._scm.exists = lambda x: False
-
-        self.command._rebaseline_test("MOCK Trusty", "userscripts/another-test.html", "txt", None)
-
-        self.assertDictEqual(
-            self.command._scm_changes.to_dict(),
-            {
-                'add': ['/test.checkout/LayoutTests/platform/test-linux-trusty/userscripts/another-test-expected.txt'],
-                'delete': [],
-                'remove-lines': []
-            })
+        self.assertDictEqual(self.command.expectation_line_changes.to_dict(), {'remove-lines': []})
 
     def test_rebaseline_test_internal_with_port_that_lacks_buildbot(self):
         self.tool.executive = MockExecutive2()
 
         port = self.tool.port_factory.get('test-win-win7')
         self._write(
             port.host.filesystem.join(
                 port.layout_tests_dir(),
                 'platform/test-win-win10/failures/expected/image-expected.txt'),
             'original win10 result')
@@ skipping 15 matching lines @@
             out, _, _ = oc.restore_output()
 
         self.assertMultiLineEqual(
             self._read(self.tool.filesystem.join(
                 port.layout_tests_dir(),
                 'platform/test-win-win10/failures/expected/image-expected.txt')),
             'MOCK Web result, convert 404 to None=True')
         self.assertFalse(self.tool.filesystem.exists(self.tool.filesystem.join(
             port.layout_tests_dir(), 'platform/test-win-win7/failures/expected/image-expected.txt')))
         self.assertMultiLineEqual(
-            out, '{"add": [], "remove-lines": [{"test": "failures/expected/image.html", "builder": "MOCK Win10"}], "delete": []}\n')
+            out, '{"remove-lines": [{"test": "failures/expected/image.html", "builder": "MOCK Win10"}]}\n')
 
 
 class TestAbstractParallelRebaselineCommand(BaseTestCase):
     command_constructor = AbstractParallelRebaselineCommand
 
     def test_builders_to_fetch_from(self):
         builders_to_fetch = self.command._builders_to_fetch_from(
             ["MOCK Win10", "MOCK Win7 (dbg)(1)", "MOCK Win7 (dbg)(2)", "MOCK Win7"])
         self.assertEqual(builders_to_fetch, ["MOCK Win7", "MOCK Win10"])
 
@@ skipping 43 matching lines @@
         self.command.rebaseline(self.options(), {"userscripts/first-test.html": {Build("MOCK Win7"): ["txt", "png"]}})
 
         # Note that we have one run_in_parallel() call followed by a run_command()
         self.assertEqual(
             self.tool.executive.calls,
             [
                 [['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt,png',
                   '--builder', 'MOCK Win7', '--test', 'userscripts/first-test.html', '--verbose']],
                 [['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt,png',
                   '--builder', 'MOCK Win7', '--test', 'userscripts/first-test.html', '--verbose']],
-                [['python', 'echo', 'optimize-baselines', '--no-modify-scm', '--suffixes', 'txt,png',
+                [['python', 'echo', 'optimize-baselines', '--suffixes', 'txt,png',
                   'userscripts/first-test.html', '--verbose']]
             ])
 
     def test_rebaseline_debug(self):
         self._setup_mock_build_data()
 
         self._write("userscripts/first-test.html", "Dummy test contents")
         self.command.rebaseline(self.options(), {"userscripts/first-test.html": {Build("MOCK Win7 (dbg)"): ["txt", "png"]}})
 
         # Note that we have one run_in_parallel() call followed by a run_command()
         self.assertEqual(
             self.tool.executive.calls,
             [
                 [['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt,png',
                   '--builder', 'MOCK Win7 (dbg)', '--test', 'userscripts/first-test.html', '--verbose']],
                 [['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt,png', '--builder',
                   'MOCK Win7 (dbg)', '--test', 'userscripts/first-test.html', '--verbose']],
-                [['python', 'echo', 'optimize-baselines', '--no-modify-scm', '--suffixes', 'txt,png',
+                [['python', 'echo', 'optimize-baselines', '--suffixes', 'txt,png',
                   'userscripts/first-test.html', '--verbose']]
             ])
 
     def test_no_optimize(self):
         self._setup_mock_build_data()
         self._write("userscripts/first-test.html", "Dummy test contents")
         self.command.rebaseline(
             self.options(optimize=False),
             {"userscripts/first-test.html": {Build("MOCK Win7"): ["txt", "png"]}})
 
@@ skipping 459 matching lines @@
 class MockLineRemovingExecutive(MockExecutive):
 
     def run_in_parallel(self, commands):
         assert len(commands)
 
         num_previous_calls = len(self.calls)
         command_outputs = []
         for cmd_line, cwd in commands:
             out = self.run_command(cmd_line, cwd=cwd)
             if 'rebaseline-test-internal' in cmd_line:
-                out = '{"add": [], "remove-lines": [{"test": "%s", "builder": "%s"}], "delete": []}\n' % (cmd_line[8], cmd_line[6])
+                out = '{"remove-lines": [{"test": "%s", "builder": "%s"}]}\n' % (cmd_line[8], cmd_line[6])
             command_outputs.append([0, out, ''])
 
         new_calls = self.calls[num_previous_calls:]
         self.calls = self.calls[:num_previous_calls]
         self.calls.append(new_calls)
         return command_outputs