Extract analyze-baselines command out of rebaseline.py.

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

-# Copyright (C) 2010 Google Inc. All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#    * Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-#    * Redistributions in binary form must reproduce the above
-# copyright notice, this list of conditions and the following disclaimer
-# in the documentation and/or other materials provided with the
-# distribution.
-#    * Neither the name of Google Inc. nor the names of its
-# contributors may be used to endorse or promote products derived from
-# this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+# 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 unittest
-import webkitpy.tool.commands.rebaseline
 
 from webkitpy.common.checkout.baselineoptimizer import BaselineOptimizer
 from webkitpy.common.checkout.scm.scm_mock import MockSCM
 from webkitpy.common.host_mock import MockHost
 from webkitpy.common.net.buildbot_mock import MockBuilder
 from webkitpy.common.net.layouttestresults import LayoutTestResults
 from webkitpy.common.system.executive_mock import MockExecutive
 from webkitpy.common.system.executive_mock import MockExecutive2
 from webkitpy.common.system.outputcapture import OutputCapture
 from webkitpy.layout_tests.builder_list import BuilderList
 from webkitpy.tool.commands.rebaseline import *
 from webkitpy.tool.mocktool import MockTool, MockOptions
 
 
-class _BaseTestCase(unittest.TestCase):
+class BaseTestCase(unittest.TestCase):
     MOCK_WEB_RESULT = 'MOCK Web result, convert 404 to None=True'
     WEB_PREFIX = 'http://example.com/f/builders/WebKit Mac10.11/results/layout-test-results'
 
     command_constructor = None
 
     def setUp(self):
         self.tool = MockTool()
         self.command = self.command_constructor()  # lint warns that command_constructor might not be set, but this is intentional; pylint: disable=E1102
         self.command.bind_to_tool(self.tool)
         self.mac_port = self.tool.port_factory.get_from_builder_name("WebKit Mac10.11")
@@ skipping 37 matching lines @@
                 "actual": "IMAGE+TEXT"
             }
         }
     }
 });""")
         # FIXME: crbug.com/279494 - we shouldn't be mixing mock and real builder names.
         for builder in ['MOCK builder', 'MOCK builder (Debug)', 'WebKit Mac10.11']:
             self.command._builder_data[builder] = data
 
 
-class TestCopyExistingBaselinesInternal(_BaseTestCase):
+class TestCopyExistingBaselinesInternal(BaseTestCase):
     command_constructor = CopyExistingBaselinesInternal
 
     def setUp(self):
         super(TestCopyExistingBaselinesInternal, self).setUp()
 
     def test_copying_overwritten_baseline(self):
         self.tool.executive = MockExecutive2()
 
         # FIXME: crbug.com/279494. it's confusing that this is the test- port, and
         # not the regular mac10.10 port. Really all of the tests should be using
@@ skipping 113 matching lines @@
             out, _, _ = oc.restore_output()
 
         self.assertFalse(fs.exists(fs.join(port.layout_tests_dir(), 'platform/test-mac-mac10.10/failures/expected/image-expected.txt')))
         self.assertFalse(fs.exists(fs.join(port.layout_tests_dir(), 'platform/test-linux-trusty/failures/expected/image-expected.txt')))
         self.assertFalse(fs.exists(fs.join(port.layout_tests_dir(),
                                            'platform/test-linux-precise/failures/expected/image-expected.txt')))
         self.assertEqual(self._read(fs.join(port.layout_tests_dir(), 'platform/test-win-win7/failures/expected/image-expected.txt')),
                          'original win7 result')
 
 
-class TestRebaselineTest(_BaseTestCase):
+class TestRebaselineTest(BaseTestCase):
     command_constructor = RebaselineTest  # AKA webkit-patch rebaseline-test-internal
 
     def setUp(self):
         super(TestRebaselineTest, self).setUp()
         self.options = MockOptions(builder="WebKit Mac10.11", test="userscripts/another-test.html",
                                    suffixes="txt", results_directory=None)
 
     def test_baseline_directory(self):
         command = self.command
         self.assertMultiLineEqual(command._baseline_directory("WebKit Mac10.11"),
@@ skipping 80 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')
 
 
-class TestAbstractParallelRebaselineCommand(_BaseTestCase):
+class TestAbstractParallelRebaselineCommand(BaseTestCase):
     command_constructor = AbstractParallelRebaselineCommand
 
     def test_builders_to_fetch_from(self):
         self.tool.builders = BuilderList({
             "MOCK Win10": {"port_name": "test-win-win10"},
             "MOCK Win7": {"port_name": "test-win-win7"},
             "MOCK Win7 (dbg)(1)": {"port_name": "test-win-win7"},
             "MOCK Win7 (dbg)(2)": {"port_name": "test-win-win7"},
         })
 
         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"])
 
 
-class TestRebaselineJson(_BaseTestCase):
+class TestRebaselineJson(BaseTestCase):
     command_constructor = RebaselineJson
 
     def setUp(self):
         super(TestRebaselineJson, self).setUp()
         self.tool.executive = MockExecutive2()
         self.tool.builders = BuilderList({
             "MOCK builder": {"port_name": "test-mac-mac10.11"},
             "MOCK builder (Debug)": {"port_name": "test-mac-mac10.11"},
         })
 
@@ skipping 73 matching lines @@
         options = MockOptions(optimize=False, verbose=True, results_directory='/tmp')
         self._write("userscripts/first-test.html", "Dummy test contents")
         self.command._rebaseline(options, {"userscripts/first-test.html": {"MOCK builder": ["txt", "png"]}})
 
         # Note that we have only one run_in_parallel() call
         self.assertEqual(self.tool.executive.calls,
                          [[['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt,png', '--builder', 'MOCK builder', '--test', 'userscripts/first-test.html', '--results-directory', '/tmp', '--verbose']],
                           [['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt,png', '--builder', 'MOCK builder', '--test', 'userscripts/first-test.html', '--results-directory', '/tmp', '--verbose']]])
 
 
-class TestRebaselineJsonUpdatesExpectationsFiles(_BaseTestCase):
+class TestRebaselineJsonUpdatesExpectationsFiles(BaseTestCase):
     command_constructor = RebaselineJson
 
     def setUp(self):
         super(TestRebaselineJsonUpdatesExpectationsFiles, self).setUp()
         self.tool.executive = MockExecutive2()
 
         def mock_run_command(args,
                              cwd=None,
                              input=None,
                              error_handler=None,
@@ skipping 82 matching lines @@
         self._write("userscripts/first-test.html", "Dummy test contents")
         self._setup_mock_builder_data()
 
         self.command._rebaseline(options, {"userscripts/first-test.html": {"WebKit Mac10.11": ["txt", "png"]}})
 
         new_expectations = self._read(self.mac_expectations_path)
         self.assertMultiLineEqual(
             new_expectations, "Bug(x) [ Linux Mac10.10 Mac10.9 Retina Win ] userscripts/first-test.html [ Failure ]\n")
 
 
-class TestRebaseline(_BaseTestCase):
+class TestRebaseline(BaseTestCase):
     # This command shares most of its logic with RebaselineJson, so these tests just test what is different.
 
     command_constructor = Rebaseline  # AKA webkit-patch rebaseline
 
     def test_rebaseline(self):
         self.command._builders_to_pull_from = lambda: [MockBuilder('MOCK builder')]
 
         self._write("userscripts/first-test.html", "test data")
 
         self._zero_out_test_expectations()
@@ skipping 44 matching lines @@
             if 'rebaseline-test-internal' in cmd_line:
                 out = '{"add": [], "remove-lines": [{"test": "%s", "builder": "%s"}], "delete": []}\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
 
 
-class TestRebaselineExpectations(_BaseTestCase):
+class TestRebaselineExpectations(BaseTestCase):
     command_constructor = RebaselineExpectations
 
     def setUp(self):
         super(TestRebaselineExpectations, self).setUp()
         self.options = MockOptions(optimize=False, builders=None, suffixes=[
                                    'txt'], verbose=False, platform=None, results_directory=None)
 
     def _write_test_file(self, port, path, contents):
         abs_path = self.tool.filesystem.join(port.layout_tests_dir(), path)
         self.tool.filesystem.write_text_file(abs_path, contents)
@@ skipping 207 matching lines @@
         })
         self.command.execute(self.options, [], self.tool)
         self.assertEqual(self.tool.executive.calls, [])
 
         # The mac ports should both be removed since they're the only ones in builders._exact_matches.
         self.assertEqual(self.tool.filesystem.read_text_file(test_port.path_to_generic_test_expectations_file()), """
 Bug(foo) [ Linux Win ] fast/dom/prototype-taco.html [ Rebaseline ]
 """)
 
 
-class _FakeOptimizer(BaselineOptimizer):
-
-    def read_results_by_directory(self, baseline_name):
-        if baseline_name.endswith('txt'):
-            return {'LayoutTests/passes/text.html': '123456'}
-        return {}
-
-
-class TestOptimizeBaselines(_BaseTestCase):
+class TestOptimizeBaselines(BaseTestCase):
     command_constructor = OptimizeBaselines
 
     def _write_test_file(self, port, path, contents):
         abs_path = self.tool.filesystem.join(port.layout_tests_dir(), path)
         self.tool.filesystem.write_text_file(abs_path, contents)
 
     def setUp(self):
         super(TestOptimizeBaselines, self).setUp()
 
         # FIXME: This is a hack to get the unittest and the BaselineOptimize to both use /mock-checkout
@@ skipping 65 matching lines @@
         self.assertFalse(self.tool.filesystem.exists(self.tool.filesystem.join(
             test_port.layout_tests_dir(), 'platform/mac/another/test-expected.txt')))
         self.assertFalse(self.tool.filesystem.exists(self.tool.filesystem.join(
             test_port.layout_tests_dir(), 'platform/mac/another/test-expected.png')))
         self.assertTrue(self.tool.filesystem.exists(self.tool.filesystem.join(
             test_port.layout_tests_dir(), 'another/test-expected.txt')))
         self.assertTrue(self.tool.filesystem.exists(self.tool.filesystem.join(
             test_port.layout_tests_dir(), 'another/test-expected.png')))
 
 
-class TestAnalyzeBaselines(_BaseTestCase):
-    command_constructor = AnalyzeBaselines
-
-    def setUp(self):
-        super(TestAnalyzeBaselines, self).setUp()
-        self.port = self.tool.port_factory.get('test')
-        self.tool.port_factory.get = (lambda port_name=None, options=None: self.port)
-        self.lines = []
-        self.command._optimizer_class = _FakeOptimizer
-        # pylint bug warning about unnecessary lambda? pylint: disable=W0108
-        self.command._write = (lambda msg: self.lines.append(msg))
-
-    def test_default(self):
-        self.command.execute(MockOptions(suffixes='txt', missing=False, platform=None), ['passes/text.html'], self.tool)
-        self.assertEqual(self.lines,
-                         ['passes/text-expected.txt:',
-                          '  (generic): 123456'])
-
-    def test_missing_baselines(self):
-        self.command.execute(MockOptions(suffixes='png,txt', missing=True, platform=None), ['passes/text.html'], self.tool)
-        self.assertEqual(self.lines,
-                         ['passes/text-expected.png: (no baselines found)',
-                          'passes/text-expected.txt:',
-                          '  (generic): 123456'])
-
-
-class TestAutoRebaseline(_BaseTestCase):
+class TestAutoRebaseline(BaseTestCase):
     command_constructor = AutoRebaseline
 
     def _write_test_file(self, port, path, contents):
         abs_path = self.tool.filesystem.join(port.layout_tests_dir(), path)
         self.tool.filesystem.write_text_file(abs_path, contents)
 
     def _setup_test_port(self):
         test_port = self.tool.port_factory.get('test')
         original_get = self.tool.port_factory.get
 
@@ skipping 513 matching lines @@
                 ['git', 'cl', 'upload', '-f', '--auth-refresh-token-json', RIETVELD_REFRESH_TOKEN],
                 ['git', 'pull'],
                 ['git', 'cl', 'land', '-f', '-v', '--auth-refresh-token-json', RIETVELD_REFRESH_TOKEN],
                 ['git', 'config', 'branch.auto-rebaseline-temporary-branch.rietveldissue'],
             ],
             auth_refresh_token_json=RIETVELD_REFRESH_TOKEN)
 
     def test_execute_with_dry_run(self):
         self._basic_execute_test([], dry_run=True)
         self.assertEqual(self.tool.scm().local_commits(), [])