Replace webkitpy standalone builders functions with instantiable class.

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
@@ skipping 19 matching lines @@
 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.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.builders import Builders
 from webkitpy.tool.commands.rebaseline import *
 from webkitpy.tool.mocktool import MockTool, MockOptions
 
 
+class FakeBuilders(Builders):
+
+    def __init__(self, builders_dict):
+        super(FakeBuilders, self).__init__()
+        self._exact_matches = builders_dict
+
+
 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)
@@ skipping 54 matching lines @@
     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
         # the test ports.
         port = self.tool.port_factory.get('test-mac-mac10.10')
         self._write(port._filesystem.join(port.layout_tests_dir(),
                                           'platform/test-mac-mac10.10/failures/expected/image-expected.txt'), 'original mac10.11 result')
 
-        old_exact_matches = builders._exact_matches
+        self.tool.builders = FakeBuilders({
+            "MOCK Mac10.10": {"port_name": "test-mac-mac10.10", "specifiers": set(["mock-specifier"])},
+            "MOCK Mac10.11": {"port_name": "test-mac-mac10.11", "specifiers": set(["mock-specifier"])},
+        })
+
         oc = OutputCapture()
         try:
-            builders._exact_matches = {
-                "MOCK Mac10.10": {"port_name": "test-mac-mac10.10", "specifiers": set(["mock-specifier"])},
-                "MOCK Mac10.11": {"port_name": "test-mac-mac10.11", "specifiers": set(["mock-specifier"])},
-            }
-
             options = MockOptions(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()
-            builders._exact_matches = old_exact_matches
 
         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()
 
         # FIXME: crbug.com/279494. it's confusing that this is the test- port, and
         # not the regular win port. Really all of the tests should be using the
         # test ports.
         port = self.tool.port_factory.get('test-win-win7')
         self._write(port._filesystem.join(port.layout_tests_dir(),
                                           'platform/test-win-win7/failures/expected/image-expected.txt'), 'original win7 result')
 
-        old_exact_matches = builders._exact_matches
+        self.tool.builders = FakeBuilders({
+            "MOCK Mac10.10": {"port_name": "test-mac-mac10.10", "specifiers": set(["mock-specifier"])},
+            "MOCK Trusty": {"port_name": "test-linux-trusty", "specifiers": set(["mock-specifier"])},
+            "MOCK Precise": {"port_name": "test-linux-precise", "specifiers": set(["mock-specifier"])},
+            "MOCK Win7": {"port_name": "test-win-win7", "specifiers": set(["mock-specifier"])},
+        })
         oc = OutputCapture()
         try:
-            builders._exact_matches = {
-                "MOCK Mac10.10": {"port_name": "test-mac-mac10.10", "specifiers": set(["mock-specifier"])},
-                "MOCK Trusty": {"port_name": "test-linux-trusty", "specifiers": set(["mock-specifier"])},
-                "MOCK Precise": {"port_name": "test-linux-precise", "specifiers": set(["mock-specifier"])},
-                "MOCK Win7": {"port_name": "test-win-win7", "specifiers": set(["mock-specifier"])},
-            }
-
             options = MockOptions(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()
-            builders._exact_matches = old_exact_matches
 
         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()
 
         # FIXME: it's confusing that this is the test- port, and not the regular
         # win port. Really all of the tests should be using the test ports.
         port = self.tool.port_factory.get('test-win-win7')
         self._write(port._filesystem.join(port.layout_tests_dir(),
                                           'platform/test-win-win7/failures/expected/image-expected.txt'), 'original win7 result')
 
-        old_exact_matches = builders._exact_matches
+        self.tool.builders = FakeBuilders({
+            "MOCK Mac10.10": {"port_name": "test-mac-mac10.10", "specifiers": set(["mock-specifier"])},
+            "MOCK Trusty": {"port_name": "test-linux-trusty", "specifiers": set(["mock-specifier"])},
+            "MOCK Win7": {"port_name": "test-win-win7", "specifiers": set(["mock-specifier"])},
+        })
         oc = OutputCapture()
         try:
-            builders._exact_matches = {
-                "MOCK Mac10.10": {"port_name": "test-mac-mac10.10", "specifiers": set(["mock-specifier"])},
-                "MOCK Trusty": {"port_name": "test-linux-trusty", "specifiers": set(["mock-specifier"])},
-                "MOCK Win7": {"port_name": "test-win-win7", "specifiers": set(["mock-specifier"])},
-            }
-
             options = MockOptions(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()
-            builders._exact_matches = old_exact_matches
 
         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')
         expectations_path = fs.join(port.path_to_generic_test_expectations_file())
         self._write(expectations_path, (
             "[ Win ] failures/expected/image.html [ Failure ]\n"
             "[ Linux ] failures/expected/image.html [ Skip ]\n"))
-        old_exact_matches = builders._exact_matches
+        self.tool.builders = FakeBuilders({
+            "MOCK Mac10.10": {"port_name": "test-mac-mac10.10", "specifiers": set(["mock-specifier"])},
+            "MOCK Trusty": {"port_name": "test-linux-trusty", "specifiers": set(["mock-specifier"])},
+            "MOCK Precise": {"port_name": "test-linux-precise", "specifiers": set(["mock-specifier"])},
+            "MOCK Win7": {"port_name": "test-win-win7", "specifiers": set(["mock-specifier"])},
+        })
         oc = OutputCapture()
         try:
-            builders._exact_matches = {
-                "MOCK Mac10.10": {"port_name": "test-mac-mac10.10", "specifiers": set(["mock-specifier"])},
-                "MOCK Trusty": {"port_name": "test-linux-trusty", "specifiers": set(["mock-specifier"])},
-                "MOCK Precise": {"port_name": "test-linux-precise", "specifiers": set(["mock-specifier"])},
-                "MOCK Win7": {"port_name": "test-win-win7", "specifiers": set(["mock-specifier"])},
-            }
-
             options = MockOptions(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()
-            builders._exact_matches = old_exact_matches
 
         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):
@@ skipping 67 matching lines @@
 
     def test_rebaseline_test_internal_with_port_that_lacks_buildbot(self):
         self.tool.executive = MockExecutive2()
 
         # FIXME: it's confusing that this is the test- port, and not the regular
         # win port. Really all of the tests should be using the test ports.
         port = self.tool.port_factory.get('test-win-win7')
         self._write(port._filesystem.join(port.layout_tests_dir(),
                                           'platform/test-win-win10/failures/expected/image-expected.txt'), 'original win10 result')
 
-        old_exact_matches = builders._exact_matches
+        self.tool.builders = FakeBuilders({
+            "MOCK Win7": {"port_name": "test-win-win7"},
+            "MOCK Win10": {"port_name": "test-win-win10"},
+        })
         oc = OutputCapture()
         try:
-            builders._exact_matches = {
-                "MOCK Win7": {"port_name": "test-win-win7"},
-                "MOCK Win10": {"port_name": "test-win-win10"},
-            }
-
             options = MockOptions(optimize=True, builder="MOCK Win10", 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()
-            builders._exact_matches = old_exact_matches
 
         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):
     command_constructor = AbstractParallelRebaselineCommand
 
     def test_builders_to_fetch_from(self):
-        old_exact_matches = builders._exact_matches
-        try:
-            builders._exact_matches = {
-                "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"},
-            }
+        self.tool.builders = FakeBuilders({
+            "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"])
-        finally:
-            builders._exact_matches = old_exact_matches
+        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):
     command_constructor = RebaselineJson
 
     def setUp(self):
         super(TestRebaselineJson, self).setUp()
         self.tool.executive = MockExecutive2()
-        self.old_exact_matches = builders._exact_matches
-        builders._exact_matches = {
+        self.tool.builders = FakeBuilders({
             "MOCK builder": {"port_name": "test-mac-mac10.11"},
             "MOCK builder (Debug)": {"port_name": "test-mac-mac10.11"},
-        }
+        })
 
     def tearDown(self):
-        builders._exact_matches = self.old_exact_matches
         super(TestRebaselineJson, self).tearDown()
 
     def test_rebaseline_test_passes_on_all_builders(self):
         self._setup_mock_builder_data()
 
         def builder_data():
             self.command._builder_data['MOCK builder'] = LayoutTestResults.results_from_string("""ADD_RESULTS({
     "tests": {
         "userscripts": {
             "first-test.html": {
@@ skipping 178 matching lines @@
     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()
         self._setup_mock_builder_data()
 
-        old_exact_matches = builders._exact_matches
-        try:
-            builders._exact_matches = {
-                "MOCK builder": {"port_name": "test-mac-mac10.10", "specifiers": set(["mock-specifier"])},
-            }
-            self.command.execute(MockOptions(results_directory=False, optimize=False, builders=None,
-                                             suffixes="txt,png", verbose=True), ['userscripts/first-test.html'], self.tool)
-        finally:
-            builders._exact_matches = old_exact_matches
+        self.tool.builders = FakeBuilders({
+            "MOCK builder": {"port_name": "test-mac-mac10.10", "specifiers": set(["mock-specifier"])},
+        })
+        self.command.execute(MockOptions(results_directory=False, optimize=False, builders=None,
+                                         suffixes="txt,png", verbose=True), ['userscripts/first-test.html'], self.tool)
 
         calls = filter(lambda x: x != ['qmake', '-v'] and x[0] != 'perl', self.tool.executive.calls)
         self.assertEqual(calls,
                          [[['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt,png', '--builder', 'MOCK builder', '--test', 'userscripts/first-test.html', '--verbose']],
                           [['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt,png', '--builder', 'MOCK builder', '--test', 'userscripts/first-test.html', '--verbose']]])
 
     def test_rebaseline_directory(self):
         self.command._builders_to_pull_from = lambda: [MockBuilder('MOCK builder')]
 
         self._write("userscripts/first-test.html", "test data")
         self._write("userscripts/second-test.html", "test data")
 
         self._setup_mock_builder_data()
 
-        old_exact_matches = builders._exact_matches
-        try:
-            builders._exact_matches = {
-                "MOCK builder": {"port_name": "test-mac-mac10.10", "specifiers": set(["mock-specifier"])},
-            }
-            self.command.execute(MockOptions(results_directory=False, optimize=False, builders=None,
-                                             suffixes="txt,png", verbose=True), ['userscripts'], self.tool)
-        finally:
-            builders._exact_matches = old_exact_matches
+        self.tool.builders = FakeBuilders({
+            "MOCK builder": {"port_name": "test-mac-mac10.10", "specifiers": set(["mock-specifier"])},
+        })
+        self.command.execute(MockOptions(results_directory=False, optimize=False, builders=None,
+                                         suffixes="txt,png", verbose=True), ['userscripts'], self.tool)
 
         calls = filter(lambda x: x != ['qmake', '-v'] and x[0] != 'perl', self.tool.executive.calls)
         self.assertEqual(calls,
                          [[['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt,png', '--builder', 'MOCK builder', '--test', 'userscripts/first-test.html', '--verbose'],
                            ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt,png', '--builder', 'MOCK builder', '--test', 'userscripts/second-test.html', '--verbose']],
                              [['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt,png', '--builder', 'MOCK builder', '--test', 'userscripts/first-test.html', '--verbose'],
                               ['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt,png', '--builder', 'MOCK builder', '--test', 'userscripts/second-test.html', '--verbose']]])
 
 
 class MockLineRemovingExecutive(MockExecutive):
@@ skipping 66 matching lines @@
         self.command.builder_data = builder_data
 
         self._write("userscripts/another-test.html", "Dummy test contents")
         self._write("userscripts/images.svg", "Dummy test contents")
         self.command._tests_to_rebaseline = lambda port: {
             'userscripts/another-test.html': set(['txt']),
             'userscripts/images.svg': set(['png']),
             'userscripts/not-actually-failing.html': set(['txt', 'png', 'wav']),
         }
 
-        old_exact_matches = builders._exact_matches
-        try:
-            builders._exact_matches = {
-                "MOCK Mac10.10": {"port_name": "test-mac-mac10.10", "specifiers": set(["mock-specifier"])},
-                "MOCK Mac10.11": {"port_name": "test-mac-mac10.11", "specifiers": set(["mock-specifier"])},
-            }
-            self.command.execute(self.options, [], self.tool)
-        finally:
-            builders._exact_matches = old_exact_matches
+        self.tool.builders = FakeBuilders({
+            "MOCK Mac10.10": {"port_name": "test-mac-mac10.10", "specifiers": set(["mock-specifier"])},
+            "MOCK Mac10.11": {"port_name": "test-mac-mac10.11", "specifiers": set(["mock-specifier"])},
+        })
+        self.command.execute(self.options, [], self.tool)
 
         # FIXME: change this to use the test- ports.
         calls = filter(lambda x: x != ['qmake', '-v'], self.tool.executive.calls)
         self.assertEqual(self.tool.executive.calls, [
             [
                 ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt',
                     '--builder', 'MOCK Mac10.10', '--test', 'userscripts/another-test.html'],
                 ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt',
                     '--builder', 'MOCK Mac10.11', '--test', 'userscripts/another-test.html'],
                 ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'png',
@@ skipping 71 matching lines @@
         self.command.builder_data = builder_data
 
         self.tool.filesystem.write_text_file(test_port.path_to_generic_test_expectations_file(), """
 Bug(foo) fast/dom/prototype-taco.html [ Rebaseline ]
 """)
 
         self._write_test_file(test_port, 'fast/dom/prototype-taco.html', "Dummy test contents")
 
         self.tool.executive = MockLineRemovingExecutive()
 
-        old_exact_matches = builders._exact_matches
-        try:
-            builders._exact_matches = {
-                "MOCK Mac10.10": {"port_name": "test-mac-mac10.10", "specifiers": set(["mock-specifier"])},
-                "MOCK Mac10.11": {"port_name": "test-mac-mac10.11", "specifiers": set(["mock-specifier"])},
-            }
+        self.tool.builders = FakeBuilders({
+            "MOCK Mac10.10": {"port_name": "test-mac-mac10.10", "specifiers": set(["mock-specifier"])},
+            "MOCK Mac10.11": {"port_name": "test-mac-mac10.11", "specifiers": set(["mock-specifier"])},
+        })
+        self.command.execute(self.options, [], self.tool)
+        self.assertEqual(self.tool.executive.calls, [])
 
-            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()), """
+        # 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 ]
 """)
-        finally:
-            builders._exact_matches = old_exact_matches
 
 
 class _FakeOptimizer(BaselineOptimizer):
 
     def read_results_by_directory(self, baseline_name):
         if baseline_name.endswith('txt'):
             return {'LayoutTests/passes/text.html': '123456'}
         return {}
 
 
@@ skipping 11 matching lines @@
         # instead of one using /mock-checkout and one using /test-checkout.
         default_port = self.tool.port_factory.get()
         self.tool.port_factory.get = lambda port_name=None: default_port
 
     def test_modify_scm(self):
         test_port = self.tool.port_factory.get('test')
         self._write_test_file(test_port, 'another/test.html', "Dummy test contents")
         self._write_test_file(test_port, 'platform/mac/another/test-expected.txt', "result A")
         self._write_test_file(test_port, 'another/test-expected.txt', "result A")
 
-        old_exact_matches = builders._exact_matches
-        try:
-            builders._exact_matches = {
-                "MOCK Mac10.10 Debug": {"port_name": "test-mac-mac10.10", "specifiers": set(["mock-specifier"])},
-            }
-            OutputCapture().assert_outputs(self, self.command.execute, args=[
-                MockOptions(suffixes='txt', no_modify_scm=False, platform='test-mac-mac10.10'),
-                ['another/test.html'],
-                self.tool,
-            ], expected_stdout='{"add": [], "remove-lines": [], "delete": []}\n')
-        finally:
-            builders._exact_matches = old_exact_matches
+        self.tool.builders = FakeBuilders({
+            "MOCK Mac10.10 Debug": {"port_name": "test-mac-mac10.10", "specifiers": set(["mock-specifier"])},
+        })
+        OutputCapture().assert_outputs(self, self.command.execute, args=[
+            MockOptions(suffixes='txt', no_modify_scm=False, platform='test-mac-mac10.10'),
+            ['another/test.html'],
+            self.tool,
+        ], expected_stdout='{"add": [], "remove-lines": [], "delete": []}\n')
 
         self.assertFalse(self.tool.filesystem.exists(self.tool.filesystem.join(
             test_port.layout_tests_dir(), 'platform/mac/another/test-expected.txt')))
         self.assertTrue(self.tool.filesystem.exists(self.tool.filesystem.join(
             test_port.layout_tests_dir(), 'another/test-expected.txt')))
 
     def test_no_modify_scm(self):
         test_port = self.tool.port_factory.get('test')
         self._write_test_file(test_port, 'another/test.html', "Dummy test contents")
         self._write_test_file(test_port, 'platform/mac-mac10.10/another/test-expected.txt', "result A")
         self._write_test_file(test_port, 'another/test-expected.txt', "result A")
 
-        old_exact_matches = builders._exact_matches
-        try:
-            builders._exact_matches = {
-                "MOCK Mac10.10 Debug": {"port_name": "test-mac-mac10.10", "specifiers": set(["mock-specifier"])},
-            }
-            OutputCapture().assert_outputs(self, self.command.execute, args=[
-                MockOptions(suffixes='txt', no_modify_scm=True, platform='test-mac-mac10.10'),
-                ['another/test.html'],
-                self.tool,
-            ], expected_stdout='{"add": [], "remove-lines": [], "delete": ["/mock-checkout/third_party/WebKit/LayoutTests/platform/mac-mac10.10/another/test-expected.txt"]}\n')
-        finally:
-            builders._exact_matches = old_exact_matches
+        self.tool.builders = FakeBuilders({
+            "MOCK Mac10.10 Debug": {"port_name": "test-mac-mac10.10", "specifiers": set(["mock-specifier"])},
+        })
+        OutputCapture().assert_outputs(self, self.command.execute, args=[
+            MockOptions(suffixes='txt', no_modify_scm=True, platform='test-mac-mac10.10'),
+            ['another/test.html'],
+            self.tool,
+        ], expected_stdout='{"add": [], "remove-lines": [], "delete": ["/mock-checkout/third_party/WebKit/LayoutTests/platform/mac-mac10.10/another/test-expected.txt"]}\n')
 
         self.assertFalse(self.tool.filesystem.exists(self.tool.filesystem.join(
             test_port.layout_tests_dir(), 'platform/mac/another/test-expected.txt')))
         self.assertTrue(self.tool.filesystem.exists(self.tool.filesystem.join(
             test_port.layout_tests_dir(), 'another/test-expected.txt')))
 
     def test_optimize_all_suffixes_by_default(self):
         test_port = self.tool.port_factory.get('test')
         self._write_test_file(test_port, 'another/test.html', "Dummy test contents")
         self._write_test_file(test_port, 'platform/mac-mac10.10/another/test-expected.txt', "result A")
         self._write_test_file(test_port, 'platform/mac-mac10.10/another/test-expected.png', "result A png")
         self._write_test_file(test_port, 'another/test-expected.txt', "result A")
         self._write_test_file(test_port, 'another/test-expected.png', "result A png")
 
-        old_exact_matches = builders._exact_matches
+        self.tool.builders = FakeBuilders({
+            "MOCK Mac10.10 Debug": {"port_name": "test-mac-mac10.10", "specifiers": set(["mock-specifier"])},
+        })
         try:
-            builders._exact_matches = {
-                "MOCK Mac10.10 Debug": {"port_name": "test-mac-mac10.10", "specifiers": set(["mock-specifier"])},
-            }
             oc = OutputCapture()
             oc.capture_output()
             self.command.execute(MockOptions(suffixes='txt,wav,png', no_modify_scm=True, platform='test-mac-mac10.10'),
                                  ['another/test.html'],
                                  self.tool)
         finally:
             out, err, logs = oc.restore_output()
-            builders._exact_matches = old_exact_matches
 
         self.assertEquals(out, '{"add": [], "remove-lines": [], "delete": ["/mock-checkout/third_party/WebKit/LayoutTests/platform/mac-mac10.10/another/test-expected.txt", "/mock-checkout/third_party/WebKit/LayoutTests/platform/mac-mac10.10/another/test-expected.png"]}\n')
         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')))
@@ skipping 51 matching lines @@
             optimize=True, verbose=False, results_directory=False, auth_refresh_token_json=auth_refresh_token_json,
             commit_author=commit_author, dry_run=dry_run),
             [], self.tool)
 
     def setUp(self):
         super(TestAutoRebaseline, self).setUp()
         self.command.latest_revision_processed_on_all_bots = lambda: 9000
         self.command.bot_revision_data = lambda: [{"builder": "Mock builder", "revision": "9000"}]
 
     def test_release_builders(self):
-        old_exact_matches = builders._exact_matches
-        try:
-            builders._exact_matches = {
-                "MOCK Mac10.10": {"port_name": "test-mac-mac10.10", "specifiers": set(["mock-specifier"])},
-                "MOCK Mac10.11 Debug": {"port_name": "test-mac-mac10.11", "specifiers": set(["mock-specifier"])},
-                "MOCK Mac10.11 ASAN": {"port_name": "test-mac-mac10.11", "specifiers": set(["mock-specifier"])},
-            }
-            self.assertEqual(self.command._release_builders(), ['MOCK Mac10.10'])
-        finally:
-            builders._exact_matches = old_exact_matches
+        self.tool.builders = FakeBuilders({
+            "MOCK Mac10.10": {"port_name": "test-mac-mac10.10", "specifiers": set(["mock-specifier"])},
+            "MOCK Mac10.11 Debug": {"port_name": "test-mac-mac10.11", "specifiers": set(["mock-specifier"])},
+            "MOCK Mac10.11 ASAN": {"port_name": "test-mac-mac10.11", "specifiers": set(["mock-specifier"])},
+        })
+        self.assertEqual(self.command._release_builders(), ['MOCK Mac10.10'])
 
     def test_tests_to_rebaseline(self):
         def blame(path):
             return """
 624c3081c0 path/to/TestExpectations                   (<foobarbaz1@chromium.org> 2013-06-14 20:18:46 +0000   11) crbug.com/24182 [ Debug ] path/to/norebaseline.html [ Failure ]
 624c3081c0 path/to/TestExpectations                   (<foobarbaz1@chromium.org@bbb929c8-8fbe-4397-9dbb-9b2b20218538> 2013-06-14 20:18:46 +0000   11) crbug.com/24182 [ Debug ] path/to/norebaseline-email-with-hash.html [ Failure ]
 624c3081c0 path/to/TestExpectations                   (<foobarbaz1@chromium.org> 2013-04-28 04:52:41 +0000   13) Bug(foo) path/to/rebaseline-without-bug-number.html [ NeedsRebaseline ]
 624c3081c0 path/to/TestExpectations                   (<foobarbaz1@chromium.org> 2013-06-14 20:18:46 +0000   11) crbug.com/24182 [ Debug ] path/to/rebaseline-with-modifiers.html [ NeedsRebaseline ]
 624c3081c0 path/to/TestExpectations                   (<foobarbaz1@chromium.org> 2013-04-28 04:52:41 +0000   12) crbug.com/24182 crbug.com/234 path/to/rebaseline-without-modifiers.html [ NeedsRebaseline ]
 6469e754a1 path/to/TestExpectations                   (<foobarbaz1@chromium.org@bbb929c8-8fbe-4397-9dbb-9b2b20218538> 2013-04-28 04:52:41 +0000   12) crbug.com/24182 path/to/rebaseline-new-revision.html [ NeedsRebaseline ]
@@ skipping 120 matching lines @@
 crbug.com/24182 path/to/not-cycled-through-bots.html [ NeedsRebaseline ]
 crbug.com/24182 path/to/locally-changed-lined.html [ NeedsRebaseline ]
 """)
 
         self._write_test_file(test_port, 'fast/dom/prototype-taco.html', "Dummy test contents")
         self._write_test_file(test_port, 'fast/dom/prototype-strawberry.html', "Dummy test contents")
         self._write_test_file(test_port, 'fast/dom/prototype-chocolate.html', "Dummy test contents")
 
         self.tool.executive = MockLineRemovingExecutive()
 
-        old_exact_matches = builders._exact_matches
-        try:
-            builders._exact_matches = {
-                "MOCK Mac10.10": {"port_name": "test-mac-mac10.10", "specifiers": set(["mock-specifier"])},
-                "MOCK Mac10.11": {"port_name": "test-mac-mac10.11", "specifiers": set(["mock-specifier"])},
-            }
+        self.tool.builders = FakeBuilders({
+            "MOCK Mac10.10": {"port_name": "test-mac-mac10.10", "specifiers": set(["mock-specifier"])},
+            "MOCK Mac10.11": {"port_name": "test-mac-mac10.11", "specifiers": set(["mock-specifier"])},
+        })
 
-            self.command.tree_status = lambda: 'closed'
-            self._execute_command_with_mock_options()
-            self.assertEqual(self.tool.executive.calls, [])
+        self.command.tree_status = lambda: 'closed'
+        self._execute_command_with_mock_options()
+        self.assertEqual(self.tool.executive.calls, [])
 
-            self.command.tree_status = lambda: 'open'
-            self.tool.executive.calls = []
-            self._execute_command_with_mock_options()
+        self.command.tree_status = lambda: 'open'
+        self.tool.executive.calls = []
+        self._execute_command_with_mock_options()
 
-            self.assertEqual(self.tool.executive.calls, [
-                [
-                    ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt,png',
-                        '--builder', 'MOCK Mac10.10', '--test', 'fast/dom/prototype-chocolate.html'],
-                    ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'png',
-                        '--builder', 'MOCK Mac10.11', '--test', 'fast/dom/prototype-strawberry.html'],
-                    ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt',
-                        '--builder', 'MOCK Mac10.10', '--test', 'fast/dom/prototype-taco.html'],
-                    ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt',
-                        '--builder', 'MOCK Mac10.11', '--test', 'fast/dom/prototype-taco.html'],
-                ],
-                [
-                    ['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt,png',
-                        '--builder', 'MOCK Mac10.10', '--test', 'fast/dom/prototype-chocolate.html'],
-                    ['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'png', '--builder',
-                        'MOCK Mac10.11', '--test', 'fast/dom/prototype-strawberry.html'],
-                    ['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt',
-                        '--builder', 'MOCK Mac10.10', '--test', 'fast/dom/prototype-taco.html'],
-                    ['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt',
-                        '--builder', 'MOCK Mac10.11', '--test', 'fast/dom/prototype-taco.html'],
-                ],
-                [
-                    ['python', 'echo', 'optimize-baselines', '--no-modify-scm',
-                        '--suffixes', 'txt,png', 'fast/dom/prototype-chocolate.html'],
-                    ['python', 'echo', 'optimize-baselines', '--no-modify-scm',
-                        '--suffixes', 'png', 'fast/dom/prototype-strawberry.html'],
-                    ['python', 'echo', 'optimize-baselines', '--no-modify-scm', '--suffixes', 'txt', 'fast/dom/prototype-taco.html'],
-                ],
-                ['git', 'cl', 'upload', '-f'],
-                ['git', 'pull'],
-                ['git', 'cl', 'land', '-f', '-v'],
-                ['git', 'config', 'branch.auto-rebaseline-temporary-branch.rietveldissue'],
-            ])
+        self.assertEqual(self.tool.executive.calls, [
+            [
+                ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt,png',
+                    '--builder', 'MOCK Mac10.10', '--test', 'fast/dom/prototype-chocolate.html'],
+                ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'png',
+                    '--builder', 'MOCK Mac10.11', '--test', 'fast/dom/prototype-strawberry.html'],
+                ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt',
+                    '--builder', 'MOCK Mac10.10', '--test', 'fast/dom/prototype-taco.html'],
+                ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt',
+                    '--builder', 'MOCK Mac10.11', '--test', 'fast/dom/prototype-taco.html'],
+            ],
+            [
+                ['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt,png',
+                    '--builder', 'MOCK Mac10.10', '--test', 'fast/dom/prototype-chocolate.html'],
+                ['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'png', '--builder',
+                    'MOCK Mac10.11', '--test', 'fast/dom/prototype-strawberry.html'],
+                ['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt',
+                    '--builder', 'MOCK Mac10.10', '--test', 'fast/dom/prototype-taco.html'],
+                ['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt',
+                    '--builder', 'MOCK Mac10.11', '--test', 'fast/dom/prototype-taco.html'],
+            ],
+            [
+                ['python', 'echo', 'optimize-baselines', '--no-modify-scm',
+                    '--suffixes', 'txt,png', 'fast/dom/prototype-chocolate.html'],
+                ['python', 'echo', 'optimize-baselines', '--no-modify-scm',
+                    '--suffixes', 'png', 'fast/dom/prototype-strawberry.html'],
+                ['python', 'echo', 'optimize-baselines', '--no-modify-scm', '--suffixes', 'txt', 'fast/dom/prototype-taco.html'],
+            ],
+            ['git', 'cl', 'upload', '-f'],
+            ['git', 'pull'],
+            ['git', 'cl', 'land', '-f', '-v'],
+            ['git', 'config', 'branch.auto-rebaseline-temporary-branch.rietveldissue'],
+        ])
 
-            # 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()), """
+        # 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()), """
 crbug.com/24182 [ Debug ] path/to/norebaseline.html [ Rebaseline ]
 Bug(foo) [ Linux Win ] fast/dom/prototype-taco.html [ NeedsRebaseline ]
 crbug.com/24182 [ Linux Win ] fast/dom/prototype-chocolate.html [ NeedsRebaseline ]
 crbug.com/24182 path/to/not-cycled-through-bots.html [ NeedsRebaseline ]
 crbug.com/24182 path/to/locally-changed-lined.html [ NeedsRebaseline ]
 """)
-        finally:
-            builders._exact_matches = old_exact_matches
 
     def test_execute_git_cl_hangs(self):
         def blame(path):
             return """
 6469e754a1 path/to/TestExpectations                   (<foobarbaz1@chromium.org> 2013-04-28 04:52:41 +0000   13) Bug(foo) fast/dom/prototype-taco.html [ NeedsRebaseline ]
 """
         self.tool.scm().blame = blame
 
         test_port = self._setup_test_port()
 
@@ skipping 18 matching lines @@
             return self.command._builder_data
 
         self.command.builder_data = builder_data
 
         self.tool.filesystem.write_text_file(test_port.path_to_generic_test_expectations_file(), """
 Bug(foo) fast/dom/prototype-taco.html [ NeedsRebaseline ]
 """)
 
         self._write_test_file(test_port, 'fast/dom/prototype-taco.html', "Dummy test contents")
 
-        old_exact_matches = builders._exact_matches
-        try:
-            builders._exact_matches = {
-                "MOCK Mac10.11": {"port_name": "test-mac-mac10.11", "specifiers": set(["mock-specifier"])},
-            }
+        self.tool.builders = FakeBuilders({
+            "MOCK Mac10.11": {"port_name": "test-mac-mac10.11", "specifiers": set(["mock-specifier"])},
+        })
 
-            self.command.SECONDS_BEFORE_GIVING_UP = 0
-            self.command.tree_status = lambda: 'open'
-            self.tool.executive = MockExecutive()
-            self.tool.executive.calls = []
-            self._execute_command_with_mock_options()
+        self.command.SECONDS_BEFORE_GIVING_UP = 0
+        self.command.tree_status = lambda: 'open'
+        self.tool.executive = MockExecutive()
+        self.tool.executive.calls = []
+        self._execute_command_with_mock_options()
 
-            self.assertEqual(self.tool.executive.calls, [
-                [
-                    ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt',
-                        '--builder', 'MOCK Mac10.11', '--test', 'fast/dom/prototype-taco.html'],
-                ],
-                [
-                    ['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt',
-                        '--builder', 'MOCK Mac10.11', '--test', 'fast/dom/prototype-taco.html'],
-                ],
-                [['python', 'echo', 'optimize-baselines', '--no-modify-scm', '--suffixes', 'txt', 'fast/dom/prototype-taco.html']],
-                ['git', 'cl', 'upload', '-f'],
-            ])
-        finally:
-            builders._exact_matches = old_exact_matches
+        self.assertEqual(self.tool.executive.calls, [
+            [
+                ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt',
+                    '--builder', 'MOCK Mac10.11', '--test', 'fast/dom/prototype-taco.html'],
+            ],
+            [
+                ['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt',
+                    '--builder', 'MOCK Mac10.11', '--test', 'fast/dom/prototype-taco.html'],
+            ],
+            [['python', 'echo', 'optimize-baselines', '--no-modify-scm', '--suffixes', 'txt', 'fast/dom/prototype-taco.html']],
+            ['git', 'cl', 'upload', '-f'],
+        ])
 
     def test_execute_test_passes_everywhere(self):
         def blame(path):
             return """
 6469e754a1 path/to/TestExpectations                   (<foobarbaz1@chromium.org> 2013-04-28 04:52:41 +0000   13) Bug(foo) fast/dom/prototype-taco.html [ NeedsRebaseline ]
 """
         self.tool.scm().blame = blame
 
         test_port = self._setup_test_port()
 
@@ skipping 18 matching lines @@
         self.command.builder_data = builder_data
 
         self.tool.filesystem.write_text_file(test_port.path_to_generic_test_expectations_file(), """
 Bug(foo) fast/dom/prototype-taco.html [ NeedsRebaseline ]
 """)
 
         self._write_test_file(test_port, 'fast/dom/prototype-taco.html', "Dummy test contents")
 
         self.tool.executive = MockLineRemovingExecutive()
 
-        old_exact_matches = builders._exact_matches
-        try:
-            builders._exact_matches = {
-                "MOCK Mac10.10": {"port_name": "test-mac-mac10.10", "specifiers": set(["mock-specifier"])},
-                "MOCK Mac10.11": {"port_name": "test-mac-mac10.11", "specifiers": set(["mock-specifier"])},
-            }
+        self.tool.builders = FakeBuilders({
+            "MOCK Mac10.10": {"port_name": "test-mac-mac10.10", "specifiers": set(["mock-specifier"])},
+            "MOCK Mac10.11": {"port_name": "test-mac-mac10.11", "specifiers": set(["mock-specifier"])},
+        })
 
-            self.command.tree_status = lambda: 'open'
-            self._execute_command_with_mock_options()
-            self.assertEqual(self.tool.executive.calls, [
-                ['git', 'cl', 'upload', '-f'],
-                ['git', 'pull'],
-                ['git', 'cl', 'land', '-f', '-v'],
-                ['git', 'config', 'branch.auto-rebaseline-temporary-branch.rietveldissue'],
-            ])
+        self.command.tree_status = lambda: 'open'
+        self._execute_command_with_mock_options()
+        self.assertEqual(self.tool.executive.calls, [
+            ['git', 'cl', 'upload', '-f'],
+            ['git', 'pull'],
+            ['git', 'cl', 'land', '-f', '-v'],
+            ['git', 'config', 'branch.auto-rebaseline-temporary-branch.rietveldissue'],
+        ])
 
-            # 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()), """
+        # 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 [ NeedsRebaseline ]
 """)
-        finally:
-            builders._exact_matches = old_exact_matches
 
     def test_execute_use_alternate_rebaseline_branch(self):
         def blame(path):
             return """
 6469e754a1 path/to/TestExpectations                   (<foobarbaz1@chromium.org> 2013-04-28 04:52:41 +0000   13) Bug(foo) fast/dom/prototype-taco.html [ NeedsRebaseline ]
 """
         self.tool.scm().blame = blame
 
         test_port = self._setup_test_port()
 
@@ skipping 18 matching lines @@
         self.command.builder_data = builder_data
 
         self.tool.filesystem.write_text_file(test_port.path_to_generic_test_expectations_file(), """
 Bug(foo) fast/dom/prototype-taco.html [ NeedsRebaseline ]
 """)
 
         self._write_test_file(test_port, 'fast/dom/prototype-taco.html', "Dummy test contents")
 
         self.tool.executive = MockLineRemovingExecutive()
 
-        old_exact_matches = builders._exact_matches
+        self.tool.builders = FakeBuilders({
+            "MOCK Win": {"port_name": "test-win-win7", "specifiers": set(["mock-specifier"])},
+        })
         old_branch_name = webkitpy.tool.commands.rebaseline._get_branch_name_or_ref
         try:
-            builders._exact_matches = {
-                "MOCK Win": {"port_name": "test-win-win7", "specifiers": set(["mock-specifier"])},
-            }
-
             self.command.tree_status = lambda: 'open'
             webkitpy.tool.commands.rebaseline._get_branch_name_or_ref = lambda x: 'auto-rebaseline-temporary-branch'
             self._execute_command_with_mock_options()
             self.assertEqual(self.tool.executive.calls, [
                 ['git', 'cl', 'upload', '-f'],
                 ['git', 'pull'],
                 ['git', 'cl', 'land', '-f', '-v'],
                 ['git', 'config', 'branch.auto-rebaseline-alt-temporary-branch.rietveldissue'],
             ])
 
             self.assertEqual(self.tool.filesystem.read_text_file(test_port.path_to_generic_test_expectations_file()), """
 Bug(foo) [ Linux Mac Win10 ] fast/dom/prototype-taco.html [ NeedsRebaseline ]
 """)
         finally:
-            builders._exact_matches = old_exact_matches
             webkitpy.tool.commands.rebaseline._get_branch_name_or_ref = old_branch_name
 
     def test_execute_stuck_on_alternate_rebaseline_branch(self):
         def blame(path):
             return """
 6469e754a1 path/to/TestExpectations                   (<foobarbaz1@chromium.org> 2013-04-28 04:52:41 +0000   13) Bug(foo) fast/dom/prototype-taco.html [ NeedsRebaseline ]
 """
         self.tool.scm().blame = blame
 
         test_port = self._setup_test_port()
@@ skipping 19 matching lines @@
         self.command.builder_data = builder_data
 
         self.tool.filesystem.write_text_file(test_port.path_to_generic_test_expectations_file(), """
 Bug(foo) fast/dom/prototype-taco.html [ NeedsRebaseline ]
 """)
 
         self._write_test_file(test_port, 'fast/dom/prototype-taco.html', "Dummy test contents")
 
         self.tool.executive = MockLineRemovingExecutive()
 
-        old_exact_matches = builders._exact_matches
+        self.tool.builders = FakeBuilders({
+            "MOCK Win": {"port_name": "test-win-win7", "specifiers": set(["mock-specifier"])},
+        })
+
         old_branch_name = webkitpy.tool.commands.rebaseline._get_branch_name_or_ref
         try:
-            builders._exact_matches = {
-                "MOCK Win": {"port_name": "test-win-win7", "specifiers": set(["mock-specifier"])},
-            }
-
             self.command.tree_status = lambda: 'open'
             webkitpy.tool.commands.rebaseline._get_branch_name_or_ref = lambda x: 'auto-rebaseline-alt-temporary-branch'
             self._execute_command_with_mock_options()
             self.assertEqual(self.tool.executive.calls, [
                 ['git', 'cl', 'upload', '-f'],
                 ['git', 'pull'],
                 ['git', 'cl', 'land', '-f', '-v'],
                 ['git', 'config', 'branch.auto-rebaseline-temporary-branch.rietveldissue'],
             ])
 
             self.assertEqual(self.tool.filesystem.read_text_file(test_port.path_to_generic_test_expectations_file()), """
 Bug(foo) [ Linux Mac Win10 ] fast/dom/prototype-taco.html [ NeedsRebaseline ]
 """)
         finally:
-            builders._exact_matches = old_exact_matches
             webkitpy.tool.commands.rebaseline._get_branch_name_or_ref = old_branch_name
 
     def _basic_execute_test(self, expected_executive_calls, auth_refresh_token_json=None, commit_author=None, dry_run=False):
         def blame(path):
             return """
 6469e754a1 path/to/TestExpectations                   (<foobarbaz1@chromium.org> 2013-04-28 04:52:41 +0000   13) Bug(foo) fast/dom/prototype-taco.html [ NeedsRebaseline ]
 """
         self.tool.scm().blame = blame
 
         test_port = self._setup_test_port()
@@ skipping 19 matching lines @@
         self.command.builder_data = builder_data
 
         self.tool.filesystem.write_text_file(test_port.path_to_generic_test_expectations_file(), """
 Bug(foo) fast/dom/prototype-taco.html [ NeedsRebaseline ]
 """)
 
         self._write_test_file(test_port, 'fast/dom/prototype-taco.html', "Dummy test contents")
 
         self.tool.executive = MockLineRemovingExecutive()
 
-        old_exact_matches = builders._exact_matches
-        try:
-            builders._exact_matches = {
-                "MOCK Mac10.10": {"port_name": "test-mac-mac10.10", "specifiers": set(["mock-specifier"])},
-                "MOCK Mac10.11": {"port_name": "test-mac-mac10.11", "specifiers": set(["mock-specifier"])},
-            }
+        self.tool.builders = FakeBuilders({
+            "MOCK Mac10.10": {"port_name": "test-mac-mac10.10", "specifiers": set(["mock-specifier"])},
+            "MOCK Mac10.11": {"port_name": "test-mac-mac10.11", "specifiers": set(["mock-specifier"])},
+        })
 
-            self.command.tree_status = lambda: 'open'
-            self._execute_command_with_mock_options(auth_refresh_token_json=auth_refresh_token_json,
-                                                    commit_author=commit_author, dry_run=dry_run)
-            self.assertEqual(self.tool.executive.calls, expected_executive_calls)
+        self.command.tree_status = lambda: 'open'
+        self._execute_command_with_mock_options(auth_refresh_token_json=auth_refresh_token_json,
+                                                commit_author=commit_author, dry_run=dry_run)
+        self.assertEqual(self.tool.executive.calls, expected_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()), """
+        # 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 [ NeedsRebaseline ]
 """)
-        finally:
-            builders._exact_matches = old_exact_matches
 
     def test_execute_with_rietveld_auth_refresh_token(self):
         RIETVELD_REFRESH_TOKEN = '/creds/refresh_tokens/test_rietveld_token'
         self._basic_execute_test(
             [
                 ['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'],
             ],
@@ skipping 45 matching lines @@
         oc.capture_output()
         self.command._do_one_rebaseline()
         out, _, _ = oc.restore_output()
 
         self.assertEqual(out, 'MOCK STDOUT\n')
         self.assertEqual(self.tool.executive.calls, [
             ['git', 'pull'],
             ['/mock-checkout/third_party/WebKit/Tools/Scripts/webkit-patch', 'auto-rebaseline', '--verbose'],
         ])
         self.assertEqual(self._logs, ['MOCK STDOUT'])