Remove MockOptions, and replace all usages of it with optparse.Values.

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

 # Copyright 2016 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
+import optparse
 import unittest
 
 from webkitpy.common.net.buildbot import Build
 from webkitpy.common.net.layouttestresults import LayoutTestResults
 from webkitpy.common.net.rietveld import Build
 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 AbstractParallelRebaselineCommand
 from webkitpy.tool.commands.rebaseline import CopyExistingBaselinesInternal
+from webkitpy.tool.commands.rebaseline import Rebaseline
 from webkitpy.tool.commands.rebaseline import RebaselineExpectations
-from webkitpy.tool.commands.rebaseline import Rebaseline
 from webkitpy.tool.commands.rebaseline import RebaselineJson
 from webkitpy.tool.commands.rebaseline import RebaselineTest
-from webkitpy.tool.commands.rebaseline import AbstractParallelRebaselineCommand
-from webkitpy.tool.mock_tool import MockOptions
 from webkitpy.tool.mock_tool import MockWebKitPatch
 
 
 # pylint: disable=protected-access
 class BaseTestCase(unittest.TestCase):
     MOCK_WEB_RESULT = 'MOCK Web result, convert 404 to None=True'
     WEB_PREFIX = 'https://storage.googleapis.com/chromium-layout-test-archives/MOCK_Mac10_11/results/layout-test-results'
 
     command_constructor = None
 
@@ skipping 86 matching lines @@
 
         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')
 
         oc = OutputCapture()
         try:
-            options = MockOptions(builder="MOCK Mac10.11", suffixes="txt", verbose=True,
-                                  test="failures/expected/image.html", results_directory=None)
-
+            options = optparse.Values({
+                'builder': "MOCK Mac10.11",
+                'suffixes': 'txt',
+                'verbose': True,
+                'test': "failures/expected/image.html",
+                'results_directory': None
+            })
             oc.capture_output()
             self.command.execute(options, [], self.tool)
         finally:
             out, _, _ = oc.restore_output()
 
         self.assertMultiLineEqual(
             self._read(self.tool.filesystem.join(
                 port.layout_tests_dir(),
                 'platform/test-mac-mac10.10/failures/expected/image-expected.txt')),
             'original mac10.11 result')
         self.assertMultiLineEqual(out, '{"add": [], "remove-lines": [], "delete": []}\n')
 
     def test_copying_overwritten_baseline_to_multiple_locations(self):
         self.tool.executive = MockExecutive2()
 
         port = self.tool.port_factory.get('test-win-win7')
         self._write(
             port._filesystem.join(port.layout_tests_dir(), 'platform/test-win-win7/failures/expected/image-expected.txt'),
             'original win7 result')
 
         oc = OutputCapture()
         try:
-            options = MockOptions(builder="MOCK Win7", suffixes="txt", verbose=True,
-                                  test="failures/expected/image.html", results_directory=None)
-
+            options = optparse.Values({
+                'builder': "MOCK Win7",
+                'suffixes': "txt",
+                'verbose': True,
+                'test': "failures/expected/image.html",
+                'results_directory': None
+            })
             oc.capture_output()
             self.command.execute(options, [], self.tool)
         finally:
             out, _, _ = oc.restore_output()
 
         self.assertMultiLineEqual(
             self._read(self.tool.filesystem.join(
                 port.layout_tests_dir(),
                 'platform/test-linux-trusty/failures/expected/image-expected.txt')),
             'original win7 result')
         self.assertFalse(self.tool.filesystem.exists(self.tool.filesystem.join(
             port.layout_tests_dir(), 'platform/test-linux-precise/userscripts/another-test-expected.txt')))
         self.assertFalse(self.tool.filesystem.exists(self.tool.filesystem.join(
             port.layout_tests_dir(), 'platform/test-mac-mac10.10/userscripts/another-test-expected.txt')))
         self.assertMultiLineEqual(out, '{"add": [], "remove-lines": [], "delete": []}\n')
 
     def test_no_copy_existing_baseline(self):
         self.tool.executive = MockExecutive2()
 
         port = self.tool.port_factory.get('test-win-win7')
         self._write(port._filesystem.join(port.layout_tests_dir(),
                                           'platform/test-win-win7/failures/expected/image-expected.txt'), 'original win7 result')
 
         oc = OutputCapture()
         try:
-            options = MockOptions(builder="MOCK Win7", suffixes="txt", verbose=True,
-                                  test="failures/expected/image.html", results_directory=None)
-
+            options = optparse.Values({
+                'builder': "MOCK Win7",
+                'suffixes': "txt",
+                'verbose': True,
+                'test': "failures/expected/image.html",
+                'results_directory': None
+            })
             oc.capture_output()
             self.command.execute(options, [], self.tool)
         finally:
             out, _, _ = oc.restore_output()
 
         self.assertMultiLineEqual(
             self._read(self.tool.filesystem.join(
                 port.layout_tests_dir(),
                 'platform/test-linux-trusty/failures/expected/image-expected.txt')),
             'original win7 result')
@@ skipping 15 matching lines @@
                 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"))
         oc = OutputCapture()
         try:
-            options = MockOptions(builder="MOCK Win7", suffixes="txt", verbose=True,
-                                  test="failures/expected/image.html", results_directory=None)
-
+            options = optparse.Values({
+                'builder': "MOCK Win7",
+                'suffixes': "txt", 'verbose': True,
+                'test': "failures/expected/image.html",
+                'results_directory': None
+            })
             oc.capture_output()
             self.command.execute(options, [], self.tool)
         finally:
             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):
     command_constructor = RebaselineTest  # AKA webkit-patch rebaseline-test-internal
 
     def setUp(self):
         super(TestRebaselineTest, self).setUp()
-        self.options = MockOptions(
-            builder="MOCK Mac10.11", test="userscripts/another-test.html", suffixes="txt", results_directory=None,
-            build_number=None)
+
+    @staticmethod
+    def options(**kwargs):
+        return optparse.Values(dict({
+            'builder': "MOCK Mac10.11",
+            'test': "userscripts/another-test.html",
+            'suffixes': "txt",
+            'results_directory': None,
+            'build_number': None
+        }, **kwargs))
 
     def test_baseline_directory(self):
         command = self.command
         self.assertMultiLineEqual(command._baseline_directory("MOCK Mac10.11"),
                                   "/test.checkout/LayoutTests/platform/test-mac-mac10.11")
         self.assertMultiLineEqual(command._baseline_directory("MOCK Mac10.10"),
                                   "/test.checkout/LayoutTests/platform/test-mac-mac10.10")
         self.assertMultiLineEqual(command._baseline_directory("MOCK Trusty"),
                                   "/test.checkout/LayoutTests/platform/test-linux-trusty")
         self.assertMultiLineEqual(command._baseline_directory("MOCK Precise"),
                                   "/test.checkout/LayoutTests/platform/test-linux-precise")
 
     def test_rebaseline_updates_expectations_file_noop(self):
         self._zero_out_test_expectations()
         self._write(
             self.mac_expectations_path,
             ("Bug(B) [ Mac Linux Win7 Debug ] fast/dom/Window/window-postmessage-clone-really-deep-array.html [ Pass ]\n"
              "Bug(A) [ Debug ] : fast/css/large-list-of-rules-crash.html [ Failure ]\n"))
         self._write("fast/dom/Window/window-postmessage-clone-really-deep-array.html", "Dummy test contents")
         self._write("fast/css/large-list-of-rules-crash.html", "Dummy test contents")
         self._write("userscripts/another-test.html", "Dummy test contents")
 
-        self.options.suffixes = "png,wav,txt"
-        self.command._rebaseline_test_and_update_expectations(self.options)
+        self.command._rebaseline_test_and_update_expectations(self.options(suffixes="png,wav,txt"))
 
         self.assertItemsEqual(self.tool.web.urls_fetched,
                               [self.WEB_PREFIX + '/userscripts/another-test-actual.png',
                                self.WEB_PREFIX + '/userscripts/another-test-actual.wav',
                                self.WEB_PREFIX + '/userscripts/another-test-actual.txt'])
         new_expectations = self._read(self.mac_expectations_path)
         self.assertMultiLineEqual(
             new_expectations,
             ("Bug(B) [ Mac Linux Win7 Debug ] fast/dom/Window/window-postmessage-clone-really-deep-array.html [ Pass ]\n"
              "Bug(A) [ Debug ] : fast/css/large-list-of-rules-crash.html [ Failure ]\n"))
 
     def test_rebaseline_test(self):
         self.command._rebaseline_test("MOCK Trusty", "userscripts/another-test.html", "txt", self.WEB_PREFIX)
         self.assertItemsEqual(self.tool.web.urls_fetched, [self.WEB_PREFIX + '/userscripts/another-test-actual.txt'])
 
     def test_rebaseline_test_with_results_directory(self):
         self._write("userscripts/another-test.html", "test data")
         self._write(
             self.mac_expectations_path,
             ("Bug(x) [ Mac ] userscripts/another-test.html [ Failure ]\n"
              "bug(z) [ Linux ] userscripts/another-test.html [ Failure ]\n"))
-        self.options.results_directory = '/tmp'
-        self.command._rebaseline_test_and_update_expectations(self.options)
+        self.command._rebaseline_test_and_update_expectations(self.options(results_directory='/tmp'))
         self.assertItemsEqual(self.tool.web.urls_fetched, ['file:///tmp/userscripts/another-test-actual.txt'])
 
     def test_rebaseline_reftest(self):
         self._write("userscripts/another-test.html", "test data")
         self._write("userscripts/another-test-expected.html", "generic result")
-        self.options.suffixes = 'png'
-        OutputCapture().assert_outputs(self, self.command._rebaseline_test_and_update_expectations, args=[self.options],
+        OutputCapture().assert_outputs(self, self.command._rebaseline_test_and_update_expectations, args=[self.options(suffixes='png')],
                                        expected_logs="Cannot rebaseline image result for reftest: userscripts/another-test.html\n")
         self.assertDictEqual(self.command._scm_changes, {'add': [], 'remove-lines': [], "delete": []})
 
     def test_rebaseline_test_and_print_scm_changes(self):
         self.command._print_scm_changes = True
         self.command._scm_changes = {'add': [], 'delete': []}
         self.tool._scm.exists = lambda x: False
 
         self.command._rebaseline_test("MOCK Trusty", "userscripts/another-test.html", "txt", None)
 
         self.assertDictEqual(self.command._scm_changes, {
             'add': ['/test.checkout/LayoutTests/platform/test-linux-trusty/userscripts/another-test-expected.txt'],
             'delete': []
         })
 
     def test_rebaseline_test_internal_with_port_that_lacks_buildbot(self):
         self.tool.executive = MockExecutive2()
 
         port = self.tool.port_factory.get('test-win-win7')
         self._write(port._filesystem.join(port.layout_tests_dir(),
                                           'platform/test-win-win10/failures/expected/image-expected.txt'), 'original win10 result')
 
         oc = OutputCapture()
         try:
-            options = MockOptions(
-                optimize=True, builder="MOCK Win10", suffixes="txt", verbose=True, test="failures/expected/image.html",
-                results_directory=None, build_number=None)
-
+            options = optparse.Values({
+                'optimize': True,
+                'builder': "MOCK Win10",
+                'suffixes': "txt",
+                'verbose': True,
+                'test': "failures/expected/image.html",
+                'results_directory': None,
+                'build_number': None
+            })
             oc.capture_output()
             self.command.execute(options, [], self.tool)
         finally:
             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(
@@ skipping 12 matching lines @@
 class TestRebaselineJson(BaseTestCase):
     command_constructor = RebaselineJson
 
     def setUp(self):
         super(TestRebaselineJson, self).setUp()
         self.tool.executive = MockExecutive2()
 
     def tearDown(self):
         super(TestRebaselineJson, self).tearDown()
 
+    @staticmethod
+    def options(**kwargs):
+        return optparse.Values(dict({
+            'optimize': True,
+            'verbose': True,
+            'results_directory': None
+        }, **kwargs))
+
     def test_rebaseline_test_passes_on_all_builders(self):
         self._setup_mock_build_data()
 
         self.tool.buildbot.set_results(Build('MOCK Win7'), LayoutTestResults({
             "tests": {
                 "userscripts": {
                     "first-test.html": {
                         "expected": "NEEDSREBASELINE",
                         "actual": "PASS"
                     }
                 }
             }
         }))
 
-        options = MockOptions(optimize=True, verbose=True, results_directory=None)
-
         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(options, {"userscripts/first-test.html": {Build("MOCK Win7"): ["txt", "png"]}})
+        self.command._rebaseline(self.options(), {"userscripts/first-test.html": {Build("MOCK Win7"): ["txt", "png"]}})
 
         self.assertEqual(self.tool.executive.calls, [])
 
     def test_rebaseline_all(self):
         self._setup_mock_build_data()
 
-        options = MockOptions(optimize=True, verbose=True, results_directory=None)
         self._write("userscripts/first-test.html", "Dummy test contents")
-        self.command._rebaseline(options, {"userscripts/first-test.html": {Build("MOCK Win7"): ["txt", "png"]}})
+        self.command._rebaseline(self.options(), {"userscripts/first-test.html": {Build("MOCK Win7"): ["txt", "png"]}})
 
         # Note that we have one run_in_parallel() call followed by a run_command()
         self.assertEqual(
             self.tool.executive.calls,
             [
                 [['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt,png',
                   '--builder', 'MOCK Win7', '--test', 'userscripts/first-test.html', '--verbose']],
                 [['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt,png',
                   '--builder', 'MOCK Win7', '--test', 'userscripts/first-test.html', '--verbose']],
                 [['python', 'echo', 'optimize-baselines', '--no-modify-scm', '--suffixes', 'txt,png',
                   'userscripts/first-test.html', '--verbose']]
             ])
 
     def test_rebaseline_debug(self):
         self._setup_mock_build_data()
 
-        options = MockOptions(optimize=True, verbose=True, results_directory=None)
         self._write("userscripts/first-test.html", "Dummy test contents")
-        self.command._rebaseline(options, {"userscripts/first-test.html": {Build("MOCK Win7 (dbg)"): ["txt", "png"]}})
+        self.command._rebaseline(self.options(), {"userscripts/first-test.html": {Build("MOCK Win7 (dbg)"): ["txt", "png"]}})
 
         # Note that we have one run_in_parallel() call followed by a run_command()
         self.assertEqual(
             self.tool.executive.calls,
             [
                 [['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt,png',
                   '--builder', 'MOCK Win7 (dbg)', '--test', 'userscripts/first-test.html', '--verbose']],
                 [['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt,png', '--builder',
                   'MOCK Win7 (dbg)', '--test', 'userscripts/first-test.html', '--verbose']],
                 [['python', 'echo', 'optimize-baselines', '--no-modify-scm', '--suffixes', 'txt,png',
                   'userscripts/first-test.html', '--verbose']]
             ])
 
     def test_no_optimize(self):
         self._setup_mock_build_data()
         print self.tool.buildbot._canned_results
 
-        options = MockOptions(optimize=False, verbose=True, results_directory=None)
         self._write("userscripts/first-test.html", "Dummy test contents")
-        self.command._rebaseline(options, {"userscripts/first-test.html": {Build("MOCK Win7"): ["txt", "png"]}})
+        self.command._rebaseline(
+            self.options(optimize=False),
+            {"userscripts/first-test.html": {Build("MOCK Win7"): ["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 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()
 
-        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": {Build("MOCK Win7"): ["txt", "png"]}})
+        self.command._rebaseline(
+            self.options(optimize=False, results_directory='/tmp'),
+            {"userscripts/first-test.html": {Build("MOCK Win7"): ["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 Win7', '--test', 'userscripts/first-test.html', '--results-directory', '/tmp', '--verbose']],
                 [['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt,png',
                   '--builder', 'MOCK Win7', '--test', 'userscripts/first-test.html', '--results-directory', '/tmp', '--verbose']]
             ])
 
 
 class TestRebaselineJsonUpdatesExpectationsFiles(BaseTestCase):
     command_constructor = RebaselineJson
 
     def setUp(self):
         super(TestRebaselineJsonUpdatesExpectationsFiles, self).setUp()
         self.tool.executive = MockExecutive2()
 
         def mock_run_command(*args, **kwargs):  # pylint: disable=unused-argument
             return '{"add": [], "remove-lines": [{"test": "userscripts/first-test.html", "builder": "MOCK Mac10.11"}]}\n'
         self.tool.executive.run_command = mock_run_command
 
+    @staticmethod
+    def options():
+        return optparse.Values({
+            'optimize': False,
+            'verbose': True,
+            'results_directory': None
+        })
+
     def test_rebaseline_updates_expectations_file(self):
-        options = MockOptions(optimize=False, verbose=True, results_directory=None)
-
         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()
 
-        self.command._rebaseline(options, {"userscripts/first-test.html": {Build("MOCK Mac10.11"): ["txt", "png"]}})
+        self.command._rebaseline(
+            self.options(),
+            {"userscripts/first-test.html": {Build("MOCK Mac10.11"): ["txt", "png"]}})
 
         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):
-        options = MockOptions(optimize=False, verbose=True, results_directory=None)
-
         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(options, {"userscripts/first-test.html": {Build("MOCK Mac10.11"): ["txt", "png"]}})
+        self.command._rebaseline(
+            self.options(),
+            {"userscripts/first-test.html": {Build("MOCK Mac10.11"): ["txt", "png"]}})
 
         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.
-        options = MockOptions(optimize=False, verbose=True, results_directory=None)
-
         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()
 
-        self.command._rebaseline(options, {"userscripts/first-test.html": {Build("MOCK Mac10.11"): ["txt", "png"]}})
+        self.command._rebaseline(
+            self.options(),
+            {"userscripts/first-test.html": {Build("MOCK Mac10.11"): ["txt", "png"]}})
 
         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.
-        options = MockOptions(optimize=False, verbose=True, results_directory=None)
-
         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()
 
-        self.command._rebaseline(options, {"userscripts/first-test.html": {Build("MOCK Mac10.11"): ["txt", "png"]}})
+        self.command._rebaseline(
+            self.options(),
+            {"userscripts/first-test.html": {Build("MOCK Mac10.11"): ["txt", "png"]}})
 
         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.
-        options = MockOptions(optimize=False, verbose=True, results_directory=None)
-
         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()
 
-        self.command._rebaseline(options, {"userscripts/first-test.html": {Build("MOCK Mac10.11"): ["txt", "png"]}})
+        self.command._rebaseline(
+            self.options(),
+            {"userscripts/first-test.html": {Build("MOCK Mac10.11"): ["txt", "png"]}})
 
         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
 
     def test_rebaseline(self):
         self.command._builders_to_pull_from = lambda: ['MOCK Win7']
 
         self._write("userscripts/first-test.html", "test data")
 
         self._zero_out_test_expectations()
         self._setup_mock_build_data()
-
-        self.command.execute(MockOptions(results_directory=False, optimize=False, builders=None,
-                                         suffixes="txt,png", verbose=True), ['userscripts/first-test.html'], self.tool)
+        options = optparse.Values({
+            'results_directory': False,
+            'optimize': False,
+            'builders': None,
+            'suffixes': "txt,png",
+            'verbose': True
+        })
+        self.command.execute(options, ['userscripts/first-test.html'], self.tool)
 
         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_rebaseline_directory(self):
         self.command._builders_to_pull_from = lambda: ['MOCK Win7']
 
         self._write("userscripts/first-test.html", "test data")
         self._write("userscripts/second-test.html", "test data")
 
         self._setup_mock_build_data()
-
-        self.command.execute(MockOptions(results_directory=False, optimize=False, builders=None,
-                                         suffixes="txt,png", verbose=True), ['userscripts'], self.tool)
+        options = optparse.Values({
+            'results_directory': False,
+            'optimize': False,
+            'builders': None,
+            'suffixes': "txt,png",
+            'verbose': True
+        })
+        self.command.execute(options, ['userscripts'], self.tool)
 
         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', 'copy-existing-baselines-internal', '--suffixes', 'txt,png',
                      '--builder', 'MOCK Win7', '--test', 'userscripts/second-test.html', '--verbose']
                 ],
                 [
                     ['python', 'echo', 'rebaseline-test-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/second-test.html', '--verbose']
                 ]
             ])
 
 
 
 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)
+
+    @staticmethod
+    def options():
+        return optparse.Values({
+            '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)
 
     def test_rebaseline_expectations(self):
         self._zero_out_test_expectations()
 
         self.tool.executive = MockExecutive2()
 
@@ skipping 14 matching lines @@
             }))
 
         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']),
         }
 
-        self.command.execute(self.options, [], self.tool)
+        self.command.execute(self.options(), [], self.tool)
 
         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',
                  '--builder', 'MOCK Mac10.10', '--test', 'userscripts/images.svg'],
                 ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'png',
@@ skipping 38 matching lines @@
 
         self._write("userscripts/reftest-text.html", "Dummy test contents")
         self._write("userscripts/reftest-text-expected.html", "Dummy test contents")
         self._write("userscripts/reftest-text-expected.html", "Dummy test contents")
         self.command._tests_to_rebaseline = lambda port: {
             'userscripts/reftest-text.html': set(['txt']),
             'userscripts/reftest-image.html': set(['png']),
             'userscripts/reftest-image-text.html': set(['png', 'txt']),
         }
 
-        self.command.execute(self.options, [], self.tool)
+        self.command.execute(self.options(), [], self.tool)
 
         self.assertEqual(self.tool.executive.calls, [
             [
                 ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt',
                  '--builder', 'MOCK Mac10.10', '--test', 'userscripts/reftest-text.html'],
                 ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt',
                  '--builder', 'MOCK Mac10.11', '--test', 'userscripts/reftest-text.html'],
             ],
             [
                 ['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)
+            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')
 
     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()
@@ skipping 39 matching lines @@
 
         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.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 ]
 """)
 
     def test_rebaseline_missing(self):
         self.tool.buildbot.set_results(Build('MOCK Mac10.10'), LayoutTestResults({
             "tests": {
@@ skipping 26 matching lines @@
         self._write('fast/dom/missing-text.html', "Dummy test contents")
         self._write('fast/dom/missing-text-and-image.html', "Dummy test contents")
         self._write('fast/dom/missing-image.html', "Dummy test contents")
 
         self.command._tests_to_rebaseline = lambda port: {
             'fast/dom/missing-text.html': set(['txt', 'png']),
             'fast/dom/missing-text-and-image.html': set(['txt', 'png']),
             'fast/dom/missing-image.html': set(['txt', 'png']),
         }
 
-        self.command.execute(self.options, [], self.tool)
+        self.command.execute(self.options(), [], self.tool)
 
         self.assertEqual(self.tool.executive.calls, [
             [
                 ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt',
                  '--builder', 'MOCK Mac10.10', '--test', 'fast/dom/missing-text.html'],
                 ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt,png',
                  '--builder', 'MOCK Mac10.10', '--test', 'fast/dom/missing-text-and-image.html'],
                 ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'png',
                  '--builder', 'MOCK Mac10.10', '--test', 'fast/dom/missing-image.html'],
             ],
@@ skipping 18 matching lines @@
         for cmd_line, cwd in commands:
             out = self.run_command(cmd_line, cwd=cwd)
             if 'rebaseline-test-internal' in cmd_line:
                 out = '{"add": [], "remove-lines": [{"test": "%s", "builder": "%s"}], "delete": []}\n' % (cmd_line[8], cmd_line[6])
             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