Refactoring: Replace test_prefix_list variables with TestBaselineSet objects.

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.layout_test_results import LayoutTestResults
 from webkitpy.common.system.executive_mock import MockExecutive
 from webkitpy.common.system.output_capture import OutputCapture
 from webkitpy.layout_tests.builder_list import BuilderList
+from webkitpy.layout_tests.port.factory_mock import MockPortFactory
 from webkitpy.tool.commands.rebaseline import (
     AbstractParallelRebaselineCommand, CopyExistingBaselinesInternal,
-    Rebaseline, RebaselineExpectations, RebaselineJson, RebaselineTest
+    Rebaseline, RebaselineExpectations, RebaselineJson, RebaselineTest,
+    TestBaselineSet
 )
 from webkitpy.tool.mock_tool import MockWebKitPatch
 
 
 # pylint: disable=protected-access
 class BaseTestCase(unittest.TestCase):
+
     WEB_PREFIX = 'https://storage.googleapis.com/chromium-layout-test-archives/MOCK_Mac10_11/results/layout-test-results'
 
-    command_constructor = None
+    command_constructor = lambda: None
 
     def setUp(self):
         self.tool = MockWebKitPatch()
-        # Lint warns that command_constructor might not be set, but this is intentional; pylint: disable=not-callable
+        self.command = None
         self.command = self.command_constructor()
         self.command._tool = self.tool
         self.tool.builders = BuilderList({
             'MOCK Mac10.10 (dbg)': {'port_name': 'test-mac-mac10.10', 'specifiers': ['Mac10.10', 'Debug']},
             'MOCK Mac10.10': {'port_name': 'test-mac-mac10.10', 'specifiers': ['Mac10.10', 'Release']},
             'MOCK Mac10.11 (dbg)': {'port_name': 'test-mac-mac10.11', 'specifiers': ['Mac10.11', 'Debug']},
             'MOCK Mac10.11 ASAN': {'port_name': 'test-mac-mac10.11', 'specifiers': ['Mac10.11', 'Release']},
             'MOCK Mac10.11': {'port_name': 'test-mac-mac10.11', 'specifiers': ['Mac10.11', 'Release']},
             'MOCK Precise': {'port_name': 'test-linux-precise', 'specifiers': ['Precise', 'Release']},
             'MOCK Trusty': {'port_name': 'test-linux-trusty', 'specifiers': ['Trusty', 'Release']},
@@ skipping 279 matching lines @@
         self.assertMultiLineEqual(
             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'])
+        self.assertEqual(builders_to_fetch, ['MOCK Win10', 'MOCK Win7'])
 
-    def test_all_baseline_paths(self):
-        test_prefix_list = {
-            'passes/text.html': [
-                Build('MOCK Win7'),
-                Build('MOCK Win10'),
-            ]
-        }
+    def test_possible_baseline_paths(self):
+        test_baseline_set = TestBaselineSet(self.tool)
+        test_baseline_set.add('passes/text.html', Build('MOCK Win7'))
+        test_baseline_set.add('passes/text.html', Build('MOCK Win10'))
+
         # pylint: disable=protected-access
-        baseline_paths = self.command._all_baseline_paths(test_prefix_list)
+        baseline_paths = self.command._possible_baseline_paths(test_baseline_set)
         self.assertEqual(baseline_paths, [
             '/test.checkout/LayoutTests/passes/text-expected.png',
             '/test.checkout/LayoutTests/passes/text-expected.txt',
             '/test.checkout/LayoutTests/passes/text-expected.wav',
             '/test.checkout/LayoutTests/platform/test-win-win10/passes/text-expected.png',
             '/test.checkout/LayoutTests/platform/test-win-win10/passes/text-expected.txt',
             '/test.checkout/LayoutTests/platform/test-win-win10/passes/text-expected.wav',
             '/test.checkout/LayoutTests/platform/test-win-win7/passes/text-expected.png',
             '/test.checkout/LayoutTests/platform/test-win-win7/passes/text-expected.txt',
             '/test.checkout/LayoutTests/platform/test-win-win7/passes/text-expected.wav',
         ])
 
     def test_remove_all_pass_testharness_baselines(self):
         self.tool.filesystem.write_text_file(
             '/test.checkout/LayoutTests/passes/text-expected.txt',
             ('This is a testharness.js-based test.\n'
              'PASS: foo\n'
              'Harness: the test ran to completion.\n'))
-        test_prefix_list = {
-            'passes/text.html': [
-                Build('MOCK Win7'),
-                Build('MOCK Win10'),
-            ]
-        }
-        self.command._remove_all_pass_testharness_baselines(test_prefix_list)
+        test_baseline_set = TestBaselineSet(self.tool)
+        test_baseline_set.add('passes/text.html', Build('MOCK Win7'))
+        test_baseline_set.add('passes/text.html', Build('MOCK Win10'))
+        self.command._remove_all_pass_testharness_baselines(test_baseline_set)
         self.assertFalse(self.tool.filesystem.exists(
             '/test.checkout/LayoutTests/passes/text-expected.txt'))
 
 
 class TestRebaselineJson(BaseTestCase):
     command_constructor = RebaselineJson
 
     def setUp(self):
         super(TestRebaselineJson, self).setUp()
         self.tool.executive = MockExecutive()
@@ skipping 18 matching lines @@
                     'first-test.html': {
                         'expected': 'NEEDSREBASELINE',
                         'actual': 'PASS'
                     }
                 }
             }
         }))
 
         self._write(self.mac_expectations_path, 'Bug(x) userscripts/first-test.html [ Failure ]\n')
         self._write('userscripts/first-test.html', 'Dummy test contents')
-        self.command.rebaseline(self.options(), {'userscripts/first-test.html': {Build('MOCK Win7'): ['txt', 'png']}})
+        test_baseline_set = TestBaselineSet(self.tool)
+        test_baseline_set.add('userscripts/first-test.html', Build('MOCK Win7'))
+        self.command.rebaseline(self.options(), test_baseline_set)
 
         self.assertEqual(self.tool.executive.calls, [])
 
     def test_rebaseline_all(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'): ['txt', 'png']}})
+        test_baseline_set = TestBaselineSet(self.tool)
+        test_baseline_set.add('userscripts/first-test.html', Build('MOCK Win7'))
+        self.command.rebaseline(self.options(), test_baseline_set)
 
-        # 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', '--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')
+        test_baseline_set = TestBaselineSet(self.tool)
+        test_baseline_set.add('userscripts/first-test.html', Build('MOCK Win7 (dbg)'))
 
-        self._write('userscripts/first-test.html', 'Dummy test contents')
-        self.command.rebaseline(self.options(), {'userscripts/first-test.html': {Build('MOCK Win7 (dbg)'): ['txt', 'png']}})
+        self.command.rebaseline(self.options(), test_baseline_set)
 
-        # 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', '--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']}})
+        test_baseline_set = TestBaselineSet(self.tool)
+        test_baseline_set.add('userscripts/first-test.html', Build('MOCK Win7'))
+        self.command.rebaseline(self.options(optimize=False), test_baseline_set)
 
-        # 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 Win7', '--test', 'userscripts/first-test.html', '--verbose']],
                 [['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt,png',
                   '--builder', 'MOCK Win7', '--test', 'userscripts/first-test.html', '--verbose']]
             ])
 
     def test_results_directory(self):
         self._setup_mock_build_data()
         self._write('userscripts/first-test.html', 'Dummy test contents')
-        self.command.rebaseline(
-            self.options(optimize=False, results_directory='/tmp'),
-            {'userscripts/first-test.html': {Build('MOCK Win7'): ['txt', 'png']}})
+        test_baseline_set = TestBaselineSet(self.tool)
+        test_baseline_set.add('userscripts/first-test.html', Build('MOCK Win7'))
+        self.command.rebaseline(self.options(optimize=False, results_directory='/tmp'), test_baseline_set)
 
-        # 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 Win7', '--test', 'userscripts/first-test.html', '--verbose']],
                 [['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt,png',
                   '--builder', 'MOCK Win7', '--test', 'userscripts/first-test.html', '--verbose', '--results-directory', '/tmp']]
             ])
 
     def test_unstaged_baselines(self):
@@ skipping 32 matching lines @@
             'results_directory': None
         })
 
     def test_rebaseline_updates_expectations_file(self):
         self._write(
             self.mac_expectations_path,
             ('Bug(x) [ Mac ] userscripts/first-test.html [ Failure ]\n'
              'bug(z) [ Linux ] userscripts/first-test.html [ Failure ]\n'))
         self._write('userscripts/first-test.html', 'Dummy test contents')
         self._setup_mock_build_data()
+        test_baseline_set = TestBaselineSet(self.tool)
+        test_baseline_set.add('userscripts/first-test.html', Build('MOCK Mac10.11'))
 
-        self.command.rebaseline(
-            self.options(),
-            {'userscripts/first-test.html': {Build('MOCK Mac10.11'): ['txt', 'png']}})
+        self.command.rebaseline(self.options(), test_baseline_set)
 
         new_expectations = self._read(self.mac_expectations_path)
         self.assertMultiLineEqual(
             new_expectations,
             ('Bug(x) [ Mac10.10 ] userscripts/first-test.html [ Failure ]\n'
              'bug(z) [ Linux ] userscripts/first-test.html [ Failure ]\n'))
 
     def test_rebaseline_updates_expectations_file_all_platforms(self):
         self._write(self.mac_expectations_path, 'Bug(x) userscripts/first-test.html [ Failure ]\n')
         self._write('userscripts/first-test.html', 'Dummy test contents')
         self._setup_mock_build_data()
-        self.command.rebaseline(
-            self.options(),
-            {'userscripts/first-test.html': {Build('MOCK Mac10.11'): ['txt', 'png']}})
+        test_baseline_set = TestBaselineSet(self.tool)
+        test_baseline_set.add('userscripts/first-test.html', Build('MOCK Mac10.11'))
+
+        self.command.rebaseline(self.options(), test_baseline_set)
+
         new_expectations = self._read(self.mac_expectations_path)
         self.assertMultiLineEqual(
             new_expectations, 'Bug(x) [ Linux Mac10.10 Win ] userscripts/first-test.html [ Failure ]\n')
 
     def test_rebaseline_handles_platform_skips(self):
         # This test is just like test_rebaseline_updates_expectations_file_all_platforms(),
         # except that if a particular port happens to SKIP a test in an overrides file,
         # we count that as passing, and do not think that we still need to rebaseline it.
         self._write(self.mac_expectations_path, 'Bug(x) userscripts/first-test.html [ Failure ]\n')
         self._write('NeverFixTests', 'Bug(y) [ Android ] userscripts [ WontFix ]\n')
         self._write('userscripts/first-test.html', 'Dummy test contents')
         self._setup_mock_build_data()
+        test_baseline_set = TestBaselineSet(self.tool)
+        test_baseline_set.add('userscripts/first-test.html', Build('MOCK Mac10.11'))
 
-        self.command.rebaseline(
-            self.options(),
-            {'userscripts/first-test.html': {Build('MOCK Mac10.11'): ['txt', 'png']}})
+        self.command.rebaseline(self.options(), test_baseline_set)
 
         new_expectations = self._read(self.mac_expectations_path)
         self.assertMultiLineEqual(
             new_expectations, 'Bug(x) [ Linux Mac10.10 Win ] userscripts/first-test.html [ Failure ]\n')
 
     def test_rebaseline_handles_skips_in_file(self):
         # This test is like test_Rebaseline_handles_platform_skips, except that the
         # Skip is in the same (generic) file rather than a platform file. In this case,
         # the Skip line should be left unmodified. Note that the first line is now
         # qualified as "[Linux Mac Win]"; if it was unqualified, it would conflict with
         # the second line.
         self._write(self.mac_expectations_path,
                     ('Bug(x) [ Linux Mac Win ] userscripts/first-test.html [ Failure ]\n'
                      'Bug(y) [ Android ] userscripts/first-test.html [ Skip ]\n'))
         self._write('userscripts/first-test.html', 'Dummy test contents')
         self._setup_mock_build_data()
+        test_baseline_set = TestBaselineSet(self.tool)
+        test_baseline_set.add('userscripts/first-test.html', Build('MOCK Mac10.11'))
 
-        self.command.rebaseline(
-            self.options(),
-            {'userscripts/first-test.html': {Build('MOCK Mac10.11'): ['txt', 'png']}})
+        self.command.rebaseline(self.options(), test_baseline_set)
 
         new_expectations = self._read(self.mac_expectations_path)
         self.assertMultiLineEqual(
             new_expectations,
             ('Bug(x) [ Linux Mac10.10 Win ] userscripts/first-test.html [ Failure ]\n'
              'Bug(y) [ Android ] userscripts/first-test.html [ Skip ]\n'))
 
     def test_rebaseline_handles_smoke_tests(self):
         # This test is just like test_rebaseline_handles_platform_skips, except that we check for
         # a test not being in the SmokeTests file, instead of using overrides files.
         # If a test is not part of the smoke tests, we count that as passing on ports that only
         # run smoke tests, and do not think that we still need to rebaseline it.
         self._write(self.mac_expectations_path, 'Bug(x) userscripts/first-test.html [ Failure ]\n')
         self._write('SmokeTests', 'fast/html/article-element.html')
         self._write('userscripts/first-test.html', 'Dummy test contents')
         self._setup_mock_build_data()
+        test_baseline_set = TestBaselineSet(self.tool)
+        test_baseline_set.add('userscripts/first-test.html', Build('MOCK Mac10.11'))
 
-        self.command.rebaseline(
-            self.options(),
-            {'userscripts/first-test.html': {Build('MOCK Mac10.11'): ['txt', 'png']}})
+        self.command.rebaseline(self.options(), test_baseline_set)
 
         new_expectations = self._read(self.mac_expectations_path)
         self.assertMultiLineEqual(
             new_expectations, 'Bug(x) [ Linux Mac10.10 Win ] userscripts/first-test.html [ Failure ]\n')
 
 
 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
@@ skipping 178 matching lines @@
             [
                 ['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt',
                  '--builder', 'MOCK Mac10.10', '--test', 'userscripts/reftest-text.html'],
                 ['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt',
                  '--builder', 'MOCK Mac10.11', '--test', 'userscripts/reftest-text.html'],
             ],
         ])
 
     def test_rebaseline_expectations_noop(self):
         self._zero_out_test_expectations()
-
-        oc = OutputCapture()
-        try:
-            oc.capture_output()
-            self.command.execute(self.options(), [], self.tool)
-        finally:
-            _, _, logs = oc.restore_output()
-            self.assertEqual(self.tool.filesystem.written_files, {})
-            self.assertEqual(logs, 'Did not find any tests marked Rebaseline.\n')
+        self.command.execute(self.options(), [], self.tool)
+        self.assertEqual(self.tool.filesystem.written_files, {})
 
     def disabled_test_overrides_are_included_correctly(self):
         # TODO(qyearsley): Fix or remove this test method.
         # This tests that any tests marked as REBASELINE in the overrides are found, but
         # that the overrides do not get written into the main file.
         self._zero_out_test_expectations()
 
         self._write(self.mac_expectations_path, '')
         self.mac_port.expectations_dict = lambda: {
             self.mac_expectations_path: '',
@@ skipping 21 matching lines @@
                             'prototype-taco.html': {
                                 'expected': 'FAIL',
                                 'actual': 'PASS',
                                 'is_unexpected': True
                             }
                         }
                     }
                 }
             }))
 
-        self.tool.filesystem.write_text_file(test_port.path_to_generic_test_expectations_file(), """
-Bug(foo) fast/dom/prototype-taco.html [ Rebaseline ]
-""")
+        self.tool.filesystem.write_text_file(
+            test_port.path_to_generic_test_expectations_file(),
+            'Bug(foo) fast/dom/prototype-taco.html [ Rebaseline ]\n')
 
         self._write_test_file(test_port, 'fast/dom/prototype-taco.html', 'Dummy test contents')
 
         self.tool.executive = MockLineRemovingExecutive()
 
         self.tool.builders = BuilderList({
             'MOCK Mac10.10': {'port_name': 'test-mac-mac10.10', 'specifiers': ['Mac10.10', 'Release']},
             'MOCK Mac10.11': {'port_name': 'test-mac-mac10.11', 'specifiers': ['Mac10.11', 'Release']},
         })
 
         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 the builder list.
-        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 ]
-""")
+        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 ]\n')
 
     def test_rebaseline_missing(self):
         self.tool.buildbot.set_results(Build('MOCK Mac10.10'), LayoutTestResults({
             'tests': {
                 'fast': {
                     'dom': {
                         'missing-text.html': {
                             'expected': 'PASS',
                             'actual': 'MISSING',
                             'is_unexpected': True,
@@ skipping 59 matching lines @@
         for cmd_line, cwd in commands:
             out = self.run_command(cmd_line, cwd=cwd)
             if 'rebaseline-test-internal' in cmd_line:
                 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
+
+
+class TestBaselineSetTest(unittest.TestCase):
+
+    def setUp(self):
+        host = MockWebKitPatch()
+        host.port_factory = MockPortFactory(host)
+        port = host.port_factory.get()
+        base_dir = port.layout_tests_dir()
+        host.filesystem.write_text_file(base_dir + '/a/x.html', '<html>')
+        host.filesystem.write_text_file(base_dir + '/a/y.html', '<html>')
+        host.filesystem.write_text_file(base_dir + '/a/z.html', '<html>')
+        host.builders = BuilderList({
+            'MOCK Mac10.12': {'port_name': 'test-mac-mac10.12', 'specifiers': ['Mac10.12', 'Release']},
+            'MOCK Trusty': {'port_name': 'test-linux-trusty', 'specifiers': ['Trusty', 'Release']},
+            'MOCK Win10': {'port_name': 'test-win-win10', 'specifiers': ['Win10', 'Release']},
+        })
+        self.host = host
+
+    def test_add_and_iter_tests(self):
+        test_baseline_set = TestBaselineSet(host=self.host)
+        test_baseline_set.add('a', Build('MOCK Trusty'))
+        test_baseline_set.add('a/z.html', Build('MOCK Win10'))
+        self.assertEqual(
+            list(test_baseline_set),
+            [
+                ('a/x.html', Build(builder_name='MOCK Trusty')),
+                ('a/y.html', Build(builder_name='MOCK Trusty')),
+                ('a/z.html', Build(builder_name='MOCK Trusty')),
+                ('a/z.html', Build(builder_name='MOCK Win10')),
+            ])
+
+    def test_str_empty(self):
+        test_baseline_set = TestBaselineSet(host=self.host)
+        self.assertEqual(str(test_baseline_set), '<Empty TestBaselineSet>')
+
+    def test_str_basic(self):
+        test_baseline_set = TestBaselineSet(host=self.host)
+        test_baseline_set.add('a/x.html', Build('MOCK Mac10.12'))
+        test_baseline_set.add('a/x.html', Build('MOCK Win10'))
+        self.assertEqual(
+            str(test_baseline_set),
+            ('<TestBaselineSet with:\n'
+             '  a/x.html: Build(builder_name=\'MOCK Mac10.12\', build_number=None)\n'
+             '  a/x.html: Build(builder_name=\'MOCK Win10\', build_number=None)>'))