Merge lp:~adam-collard/landscape-client/mocker-replace-configuration-part-deux into lp:~landscape/landscape-client/trunk

[Adam Collard]

Convert ConfigurationFunctionsTest to replace use of mocker with mock

Follow on branches will cover the remaining use of mocker in the tests.

Convert ConfigurationFunctionsTest to replace use of mocker with mock

Follow on branches will cover the remaining use of mocker in the tests.

[🤖 Landscape Builder (landscape-builder)]

review: Abstain (executing tests)

[🤖 Landscape Builder (landscape-builder)]

Command: TRIAL_ARGS=-j4 make check
Result: Success
Revno: 850
Branch: lp:~adam-collard/landscape-client/mocker-replace-configuration-part-deux
Jenkins: https://ci.lscape.net/job/latch-test/5087/

review: Approve (test results)

[Данило Шеган (danilo)]

For the lint I mentioned, I am still seeing the following:

=== pyflakes ===

landscape/tests/test_configuration.py:14: 'stop_client_and_disable_init_script' imported but unused
landscape/tests/test_configuration.py:24: 'SysVConfig' imported but unused
landscape/tests/test_configuration.py:27: 'CONTAINS' imported but unused
landscape/tests/test_configuration.py:27: 'ANY' imported but unused

(on xenial)

[Chris Glass (tribaal)]

+1

review: Approve

[🤖 Landscape Builder (landscape-builder)]

review: Abstain (executing tests)

[🤖 Landscape Builder (landscape-builder)]

Command: TRIAL_ARGS=-j4 make check
Result: Success
Revno: 851
Branch: lp:~adam-collard/landscape-client/mocker-replace-configuration-part-deux
Jenkins: https://ci.lscape.net/job/latch-test/5090/

review: Approve (test results)

[lp:~adam-collard/landscape-client/mocker-replace-configuration-part-deux]

852. By Adam Collard on 2016-06-16

Fix typo (thanks danilo!)

[🤖 Landscape Builder (landscape-builder)]

review: Abstain (executing tests)

[🤖 Landscape Builder (landscape-builder)]

Command: TRIAL_ARGS=-j4 make check
Result: Success
Revno: 852
Branch: lp:~adam-collard/landscape-client/mocker-replace-configuration-part-deux
Jenkins: https://ci.lscape.net/job/latch-test/5094/

review: Approve (test results)

[Данило Шеган (danilo)]

Here's a reluctant +1 for you, Adam.

review: Approve

=== modified file 'landscape/tests/test_configuration.py'
--- landscape/tests/test_configuration.py	2016-06-15 22:56:46 +0000
+++ landscape/tests/test_configuration.py	2016-06-16 16:07:42 +0000
@@ -14,17 +14,16 @@
 from landscape.configuration import (
     print_text, LandscapeSetupScript, LandscapeSetupConfiguration,
     register, setup, main, setup_init_script_and_start_client,
-    stop_client_and_disable_init_script, ConfigurationError,
+    ConfigurationError,
     ImportOptionError, store_public_key_data,
     bootstrap_tree, got_connection, success, failure, exchange_failure,
     handle_registration_errors, done, got_error, report_registration_outcome,
     determine_exit_code)
 from landscape.lib.amp import MethodCallError
 from landscape.lib.fetch import HTTPCodeError, PyCurlError
-from landscape.sysvconfig import SysVConfig, ProcessError
+from landscape.sysvconfig import ProcessError
 from landscape.tests.helpers import FakeBrokerServiceHelper
 from landscape.tests.helpers import LandscapeTest, EnvironSaverHelper
-from landscape.tests.mocker import ANY, CONTAINS, expect
 
 
 class LandscapeConfigurationTest(LandscapeTest):
@@ -730,7 +729,8 @@
 
 class BootstrapTreeTest(LandscapeConfigurationTest):
 
-    def test_bootstrap_tree(self):
+    @mock.patch("os.chmod")
+    def test_bootstrap_tree(self, mock_chmod):
         """
         The L{bootstrap_tree} function creates the client dir and
         /annotations.d under it with the correct permissions.
@@ -738,13 +738,10 @@
         client_path = self.makeDir()
         annotations_path = os.path.join(client_path, "annotations.d")
 
-        mock_chmod = self.mocker.replace("os.chmod")
-        mock_chmod(client_path, 0755)
-        mock_chmod(annotations_path, 0755)
-        self.mocker.replay()
-
         config = self.get_config([], data_path=client_path)
         bootstrap_tree(config)
+        mock_chmod.assert_any_call(client_path, 0755)
+        mock_chmod.assert_called_with(annotations_path, 0755)
         self.assertTrue(os.path.isdir(client_path))
         self.assertTrue(os.path.isdir(annotations_path))
 
@@ -754,21 +751,12 @@
     pass
 
 
[e-mail]("landscape.configuration.bootstrap_tree")
[e-mail]("os.getuid", return_value=0)
 class ConfigurationFunctionsTest(LandscapeConfigurationTest):
 
     helpers = [EnvironSaverHelper]
 
-    def setUp(self):
-        super(ConfigurationFunctionsTest, self).setUp()
-        self.mocker.replace("os.getuid")()
-        self.mocker.count(0, None)
-        self.mocker.result(0)
-
-        # Make bootstrap_tree a no-op as a a non-root user can't change
-        # ownership.
-        self.mocker.replace("landscape.configuration.bootstrap_tree")(ANY)
-        self.mocker.count(0, None)
-
     def get_content(self, config):
         """Write C{config} to a file and return it's contents as a string."""
         config_file = self.makeFile("")
@@ -780,7 +768,11 @@
         finally:
             config.config = original_config
 
-    def test_setup(self):
+    @mock.patch("landscape.configuration.print_text")
+    @mock.patch("landscape.configuration.getpass.getpass")
+    @mock.patch("__builtin__.raw_input")
+    def test_setup(self, mock_raw_input, mock_getpass, mock_print_text,
+                   mock_getuid, mock_bootstrap_tree):
         filename = self.makeFile("[client]\n"
                                  "computer_title = Old Title\n"
                                  "account_name = Old Name\n"
@@ -792,32 +784,32 @@
                                  "access_group = webservers\n"
                                  "tags = london, server")
 
-        raw_input = self.mocker.replace("__builtin__.raw_input",
-                                        name="raw_input")
-        getpass = self.mocker.replace("getpass.getpass")
-
-        C = CONTAINS
-
-        expect(raw_input(C("[Old Title]"))).result("New Title")
-        expect(raw_input(C("[Old Name]"))).result("New Name")
-        expect(getpass(C("Account registration key:"))).result("New Password")
-        expect(getpass(C("Please confirm:"))).result("New Password")
-        expect(raw_input(C("[http://old.proxy]"))).result("http://new.proxy")
-        expect(raw_input(C("[https://old.proxy]"))).result("https://new.proxy")
-        expect(raw_input(C("Enable script execution? [Y/n]"))).result("n")
-        expect(raw_input(C("Access group [webservers]: "))).result(
-            u"databases")
-        expect(raw_input(C("Tags [london, server]: "))).result(
-            u"glasgow, laptop")
-
-        # Negative assertion.  We don't want it called in any other way.
-        expect(raw_input(ANY)).count(0)
-
-        # We don't care about these here, but don't show any output please.
-        print_text_mock = self.mocker.replace(print_text)
-        expect(print_text_mock(ANY)).count(0, None)
-
-        self.mocker.replay()
+        def side_effect_raw_input(prompt):
+            fixtures = {
+                "[Old Title]": "New Title",
+                "[Old Name]": "New Name",
+                "[http://old.proxy]": "http://new.proxy",
+                "[https://old.proxy]": "https://new.proxy",
+                "Enable script execution? [Y/n]": "n",
+                "Access group [webservers]: ": u"databases",
+                "Tags [london, server]: ": u"glasgow, laptop",
+            }
+            for key, value in fixtures.iteritems():
+                if key in prompt:
+                    return value
+            raise KeyError("Couldn't find answer for {}".format(prompt))
+
+        def side_effect_getpass(prompt):
+            fixtures = {"Account registration key:": "New Password",
+                        "Please confirm:": "New Password"}
+            for key, value in fixtures.iteritems():
+                if key in prompt:
+                    return value
+            raise KeyError("Couldn't find answer for {}".format(prompt))
+
+        mock_raw_input.side_effect = side_effect_raw_input
+        mock_getpass.side_effect = side_effect_getpass
+
         config = self.get_config(["--no-start", "--config", filename])
         setup(config)
         self.assertEqual(type(config), LandscapeSetupConfiguration)
@@ -834,18 +826,17 @@
         self.assertEqual(config.access_group, u"databases")
         self.assertEqual(config.tags, u"glasgow, laptop")
 
-    def test_silent_setup(self):
+    @mock.patch("landscape.configuration.SysVConfig")
+    def test_silent_setup(
+            self, mock_sysvconfig, mock_getuid, mock_bootstrap_tree):
         """
         Only command-line options are used in silent mode and registration is
         attempted.
         """
-        sysvconfig_mock = self.mocker.patch(SysVConfig)
-        sysvconfig_mock.set_start_on_boot(True)
-        sysvconfig_mock.restart_landscape()
-        self.mocker.replay()
-
         config = self.get_config(["--silent", "-a", "account", "-t", "rex"])
         setup(config)
+        mock_sysvconfig().set_start_on_boot.assert_called_once_with(True)
+        mock_sysvconfig().restart_landscape.assert_called_once_with()
         self.assertConfigEqual(self.get_content(config), """\
 [client]
 computer_title = rex
@@ -854,15 +845,13 @@
 url = https://landscape.canonical.com/message-system
 """ % config.data_path)
 
-    def test_silent_setup_no_register(self):
+    @mock.patch("landscape.configuration.SysVConfig")
+    def test_silent_setup_no_register(
+            self, mock_sysvconfig, mock_getuid, mock_bootstrap_tree):
         """
         Called with command line options to write a config file but no
         registration or validation of parameters is attempted.
         """
-        # Make sure no sysvconfig modifications are attempted
-        self.mocker.patch(SysVConfig)
-        self.mocker.replay()
-
         config = self.get_config(["--silent", "--no-start"])
         setup(config)
         self.assertConfigEqual(self.get_content(config), """\
@@ -871,15 +860,13 @@
 url = https://landscape.canonical.com/message-system
 """ % config.data_path)
 
-    def test_silent_setup_no_register_with_default_preseed_params(self):
+    @mock.patch("landscape.configuration.SysVConfig")
+    def test_silent_setup_no_register_with_default_preseed_params(
+            self, mock_sysvconfig, mock_getuid, mock_bootstrap_tree):
         """
         Make sure that the configuration can be used to write the
         configuration file after a fresh install.
         """
-        # Make sure no sysvconfig modifications are attempted
-        self.mocker.patch(SysVConfig)
-        self.mocker.replay()
-
         args = ["--silent", "--no-start",
                 "--computer-title", "",
                 "--account-name", "",
@@ -910,38 +897,31 @@
             "ping_url = http://landscape.canonical.com/ping\n"
             "urgent_exchange_interval = 60\n" % config.data_path)
 
-    def test_silent_setup_without_computer_title(self):
+    @mock.patch("landscape.configuration.SysVConfig")
+    def test_silent_setup_without_computer_title(
+            self, mock_sysvconfig, mock_getuid, mock_bootstrap_tree):
         """A computer title is required."""
-        sysvconfig_mock = self.mocker.patch(SysVConfig)
-        sysvconfig_mock.set_start_on_boot(True)
-        self.mocker.replay()
-
         config = self.get_config(["--silent", "-a", "account"])
         self.assertRaises(ConfigurationError, setup, config)
 
-    def test_silent_setup_without_account_name(self):
+    @mock.patch("landscape.configuration.SysVConfig")
+    def test_silent_setup_without_account_name(
+            self, mock_sysvconfig, mock_getuid, mock_bootstrap_tree):
         """An account name is required."""
-        sysvconfig_mock = self.mocker.patch(SysVConfig)
-        sysvconfig_mock.set_start_on_boot(True)
-        self.mocker.replay()
-
         config = self.get_config(["--silent", "-t", "rex"])
         self.assertRaises(ConfigurationError, setup, config)
+        mock_sysvconfig().set_start_on_boot.assert_called_once_with(
+            True)
 
-    def test_silent_script_users_imply_script_execution_plugin(self):
+    @mock.patch("__builtin__.raw_input")
+    @mock.patch("landscape.configuration.SysVConfig")
+    def test_silent_script_users_imply_script_execution_plugin(
+            self, mock_sysvconfig, mock_raw_input,
+            mock_getuid, mock_bootstrap_tree):
         """
         If C{--script-users} is specified, without C{ScriptExecution} in the
         list of manager plugins, it will be automatically added.
         """
-        sysvconfig_mock = self.mocker.patch(SysVConfig)
-        sysvconfig_mock.set_start_on_boot(True)
-        sysvconfig_mock.restart_landscape()
-        self.mocker.result(True)
-
-        raw_input_mock = self.mocker.replace(raw_input, passthrough=False)
-        self.expect(raw_input_mock(ANY)).count(0)
-        self.mocker.replay()
-
         filename = self.makeFile("""
 [client]
 url = https://localhost:8080/message-system
@@ -951,7 +931,12 @@
         config = self.get_config(["--config", filename, "--silent",
                                   "-a", "account", "-t", "rex",
                                   "--script-users", "root, nobody"])
+        mock_sysvconfig().restart_landscape.return_value = True
         setup(config)
+        mock_sysvconfig().set_start_on_boot.assert_called_once_with(
+            True)
+        mock_sysvconfig().restart_landscape.assert_called_once_with()
+        mock_raw_input.assert_not_called()
         parser = ConfigParser()
         parser.read(filename)
         self.assertEqual(
@@ -963,15 +948,13 @@
              "account_name": "account"},
             dict(parser.items("client")))
 
-    def test_silent_script_users_with_all_user(self):
+    @mock.patch("landscape.configuration.SysVConfig")
+    def test_silent_script_users_with_all_user(
+            self, mock_sysvconfig, mock_getuid, mock_bootstrap_tree):
         """
         In silent mode, we shouldn't accept invalid users, it should raise a
         configuration error.
         """
-        sysvconfig_mock = self.mocker.patch(SysVConfig)
-        sysvconfig_mock.set_start_on_boot(True)
-        self.mocker.replay()
-
         config = self.get_config(
             ["--script-users", "all",
              "--include-manager-plugins", "ScriptPlugin",
@@ -979,14 +962,13 @@
              "-t", "rex",
              "--silent"])
         self.assertRaises(ConfigurationError, setup, config)
-
-    def test_silent_setup_with_ping_url(self):
-        sysvconfig_mock = self.mocker.patch(SysVConfig)
-        sysvconfig_mock.set_start_on_boot(True)
-        sysvconfig_mock.restart_landscape()
-        self.mocker.result(True)
-        self.mocker.replay()
-
+        mock_sysvconfig().set_start_on_boot.assert_called_once_with(
+            True)
+
+    @mock.patch("landscape.configuration.SysVConfig")
+    def test_silent_setup_with_ping_url(
+            self, mock_sysvconfig, mock_getuid, mock_bootstrap_tree):
+        mock_sysvconfig().restart_landscape.return_value = True
         filename = self.makeFile("""
 [client]
 ping_url = http://landscape.canonical.com/ping
@@ -994,10 +976,15 @@
 log_level = debug
 random_key = random_value
 """)
+
         config = self.get_config(["--config", filename, "--silent",
                                   "-a", "account", "-t", "rex",
                                   "--ping-url", "http://localhost/ping"])
         setup(config)
+        mock_sysvconfig().set_start_on_boot.assert_called_once_with(
+            True)
+        mock_sysvconfig().restart_landscape.assert_called_once_with()
+
         parser = ConfigParser()
         parser.read(filename)
         self.assertEqual(
@@ -1009,38 +996,35 @@
              "account_name": "account"},
             dict(parser.items("client")))
 
-    def test_setup_with_proxies_from_environment(self):
+    @mock.patch("landscape.configuration.LandscapeSetupScript")
+    def test_setup_with_proxies_from_environment(
+            self, mock_setup_script, mock_getuid, mock_bootstrap_tree):
         os.environ["http_proxy"] = "http://environ"
         os.environ["https_proxy"] = "https://environ"
 
-        script_mock = self.mocker.patch(LandscapeSetupScript)
-        script_mock.run()
-
         filename = self.makeFile("[client]\n"
                                  "url = http://url\n")
 
-        self.mocker.replay()
-
         config = self.get_config(["--no-start", "--config", filename])
         setup(config)
 
         # Reload it to ensure it was written down.
         config.reload()
 
+        mock_setup_script().run.assert_called_once_with()
+
         self.assertEqual(config.http_proxy, "http://environ")
         self.assertEqual(config.https_proxy, "https://environ")
 
-    def test_silent_setup_with_proxies_from_environment(self):
+    @mock.patch("landscape.configuration.SysVConfig")
+    def test_silent_setup_with_proxies_from_environment(
+            self, mock_sysvconfig, mock_getuid, mock_bootstrap_tree):
         """
         Only command-line options are used in silent mode and registration is
         attempted.
         """
         os.environ["http_proxy"] = "http://environ"
         os.environ["https_proxy"] = "https://environ"
-        sysvconfig_mock = self.mocker.patch(SysVConfig)
-        sysvconfig_mock.set_start_on_boot(True)
-        sysvconfig_mock.restart_landscape()
-        self.mocker.replay()
 
         filename = self.makeFile("""
 [client]
@@ -1049,6 +1033,8 @@
         config = self.get_config(["--config", filename, "--silent",
                                   "-a", "account", "-t", "rex"])
         setup(config)
+        mock_sysvconfig().set_start_on_boot.assert_called_once_with(True)
+        mock_sysvconfig().restart_landscape.assert_called_once_with()
         parser = ConfigParser()
         parser.read(filename)
         self.assertEqual(
@@ -1059,22 +1045,20 @@
              "account_name": "account"},
             dict(parser.items("client")))
 
-    def test_setup_prefers_proxies_from_config_over_environment(self):
+    @mock.patch("landscape.configuration.LandscapeSetupScript")
+    def test_setup_prefers_proxies_from_config_over_environment(
+            self, mock_setup_script, mock_getuid, mock_bootstrap_tree):
         os.environ["http_proxy"] = "http://environ"
         os.environ["https_proxy"] = "https://environ"
 
-        script_mock = self.mocker.patch(LandscapeSetupScript)
-        script_mock.run()
-
         filename = self.makeFile("[client]\n"
                                  "http_proxy = http://config\n"
                                  "https_proxy = https://config\n"
                                  "url = http://url\n")
 
-        self.mocker.replay()
-
         config = self.get_config(["--no-start", "--config", filename])
         setup(config)
+        mock_setup_script().run.assert_called_once_with()
 
         # Reload it to enusre it was written down.
         config.reload()
@@ -1082,39 +1066,25 @@
         self.assertEqual(config.http_proxy, "http://config")
         self.assertEqual(config.https_proxy, "https://config")
 
-    def test_main_no_registration(self):
-        setup_mock = self.mocker.replace(setup)
-        setup_mock(ANY)
-
-        raw_input_mock = self.mocker.replace(raw_input)
-        raw_input_mock("\nRequest a new registration for "
-                       "this computer now? (Y/n): ")
-        self.mocker.result("n")
-
-        # This must not be called.
-        register_mock = self.mocker.replace(register, passthrough=False)
-        register_mock(ANY, ANY)
-        self.mocker.count(0)
-
-        self.mocker.replay()
-
+    @mock.patch("__builtin__.raw_input", return_value="n")
+    @mock.patch("landscape.configuration.register")
+    @mock.patch("landscape.configuration.setup")
+    def test_main_no_registration(
+            self, mock_setup, mock_register, mock_raw_input, mock_getuid,
+            mock_bootstrap_tree):
         main(["-c", self.make_working_config()], print=noop_print)
+        mock_register.assert_not_called()
+        mock_raw_input.assert_called_once_with(
+            "\nRequest a new registration for this computer now? (Y/n): ")
 
-    def test_main_silent(self):
+    @mock.patch("landscape.configuration.register", return_value="success")
+    @mock.patch("landscape.configuration.setup")
+    def test_main_silent(
+            self, mock_setup, mock_register, mock_getuid, mock_bootstrap_tree):
         """
         In silent mode, the client should register when the registration
         details are changed/set.
         """
-        setup_mock = self.mocker.replace(setup)
-        setup_mock(ANY)
-
-        register_mock = self.mocker.replace(register, passthrough=False)
-        register_mock(ANY, ANY)
-        self.mocker.result("success")
-        self.mocker.count(1)
-
-        self.mocker.replay()
-
         config_filename = self.makeFile(
             "[client]\n"
             "computer_title = Old Title\n"
@@ -1126,24 +1096,16 @@
             SystemExit, main, ["-c", config_filename, "--silent"],
             print=noop_print)
         self.assertEqual(0, exception.code)
+        mock_setup.assert_called_once_with(mock.ANY)
+        mock_register.assert_called_once_with(mock.ANY, mock.ANY)
 
-    def test_main_user_interaction_success(self):
+    @mock.patch("__builtin__.raw_input", return_value="y")
+    @mock.patch("landscape.configuration.register", return_value="success")
+    @mock.patch("landscape.configuration.setup")
+    def test_main_user_interaction_success(
+            self, mock_setup, mock_register, mock_raw_input,
+            mock_getuid, mock_bootstrap_tree):
         """The successful result of register() is communicated to the user."""
-        setup_mock = self.mocker.replace(setup)
-        setup_mock(ANY)
-
-        raw_input_mock = self.mocker.replace(raw_input)
-        raw_input_mock("\nRequest a new registration for "
-                       "this computer now? (Y/n): ")
-        self.mocker.result("y")
-
-        # The register() function will be called.
-        register_mock = self.mocker.replace(register, passthrough=False)
-        register_mock(ANY, ANY)
-        self.mocker.result("success")
-
-        self.mocker.replay()
-
         printed = []
 
         def faux_print(string, file=sys.stdout):
@@ -1153,28 +1115,22 @@
             SystemExit, main, ["-c", self.make_working_config()],
             print=faux_print)
         self.assertEqual(0, exception.code)
+        mock_setup.assert_called_once_with(mock.ANY)
+        mock_register.assert_called_once_with(mock.ANY, mock.ANY)
+        mock_raw_input.assert_called_once_with(
+            "\nRequest a new registration for this computer now? (Y/n): ")
         self.assertEqual(
             [("Please wait...", sys.stdout),
              ("System successfully registered.", sys.stdout)],
             printed)
 
-    def test_main_user_interaction_failure(self):
+    @mock.patch("__builtin__.raw_input", return_value="y")
+    @mock.patch("landscape.configuration.register", return_value="failure")
+    @mock.patch("landscape.configuration.setup")
+    def test_main_user_interaction_failure(
+            self, mock_setup, mock_register, mock_raw_input,
+            mock_getuid, mock_bootstrap_tree):
         """The failed result of register() is communicated to the user."""
-        setup_mock = self.mocker.replace(setup)
-        setup_mock(ANY)
-
-        raw_input_mock = self.mocker.replace(raw_input)
-        raw_input_mock("\nRequest a new registration for "
-                       "this computer now? (Y/n): ")
-        self.mocker.result("y")
-
-        # The register() function will be called.
-        register_mock = self.mocker.replace(register, passthrough=False)
-        register_mock(ANY, ANY)
-        self.mocker.result("failure")
-
-        self.mocker.replay()
-
         printed = []
 
         def faux_print(string, file=sys.stdout):
@@ -1184,6 +1140,10 @@
             SystemExit, main, ["-c", self.make_working_config()],
             print=faux_print)
         self.assertEqual(2, exception.code)
+        mock_setup.assert_called_once_with(mock.ANY)
+        mock_register.assert_called_once_with(mock.ANY, mock.ANY)
+        mock_raw_input.assert_called_once_with(
+            "\nRequest a new registration for this computer now? (Y/n): ")
 
         # Note that the error is output via sys.stderr.
         self.assertEqual(
@@ -1191,23 +1151,14 @@
              ("Invalid account name or registration key.", sys.stderr)],
             printed)
 
-    def test_main_user_interaction_success_silent(self):
+    @mock.patch("__builtin__.raw_input")
+    @mock.patch("landscape.configuration.register", return_value="success")
+    @mock.patch("landscape.configuration.setup")
+    def test_main_user_interaction_success_silent(
+            self, mock_setup, mock_register, mock_raw_input, mock_getuid,
+            mock_bootstrap_tree):
         """A successful result is communicated to the user even with --silent.
         """
-        setup_mock = self.mocker.replace(setup)
-        setup_mock(ANY)
-
-        raw_input_mock = self.mocker.replace(raw_input)
-        raw_input_mock(ANY)
-        self.mocker.count(0)
-
-        # The register() function will be called.
-        register_mock = self.mocker.replace(register, passthrough=False)
-        register_mock(ANY, ANY)
-        self.mocker.result("success")
-
-        self.mocker.replay()
-
         printed = []
 
         def faux_print(string, file=sys.stdout):
@@ -1217,29 +1168,23 @@
             SystemExit, main, ["--silent", "-c", self.make_working_config()],
             print=faux_print)
         self.assertEqual(0, exception.code)
+        mock_setup.assert_called_once_with(mock.ANY)
+        mock_register.assert_called_once_with(mock.ANY, mock.ANY)
+        mock_raw_input.assert_not_called()
 
         self.assertEqual(
             [("Please wait...", sys.stdout),
              ("System successfully registered.", sys.stdout)],
             printed)
 
-    def test_main_user_interaction_failure_silent(self):
+    @mock.patch("__builtin__.raw_input")
+    @mock.patch("landscape.configuration.register", return_value="failure")
+    @mock.patch("landscape.configuration.setup")
+    def test_main_user_interaction_failure_silent(
+            self, mock_setup, mock_register, mock_raw_input,
+            mock_getuid, mock_bootstrap_tree):
         """A failure result is communicated to the user even with --silent.
         """
-        setup_mock = self.mocker.replace(setup)
-        setup_mock(ANY)
-
-        raw_input_mock = self.mocker.replace(raw_input)
-        raw_input_mock(ANY)
-        self.mocker.count(0)
-
-        # The register() function will be called.
-        register_mock = self.mocker.replace(register, passthrough=False)
-        register_mock(ANY, ANY)
-        self.mocker.result("failure")
-
-        self.mocker.replay()
-
         printed = []
 
         def faux_print(string, file=sys.stdout):
@@ -1249,6 +1194,9 @@
             SystemExit, main, ["--silent", "-c", self.make_working_config()],
             print=faux_print)
         self.assertEqual(2, exception.code)
+        mock_setup.assert_called_once_with(mock.ANY)
+        mock_register.assert_called_once_with(mock.ANY, mock.ANY)
+        mock_raw_input.assert_not_called()
         # Note that the error is output via sys.stderr.
         self.assertEqual(
             [("Please wait...", sys.stdout),
@@ -1264,198 +1212,166 @@
                              "https_proxy = https://old.proxy\n"
                              "url = http://url\n")
 
-    def test_register(self):
-        sysvconfig_mock = self.mocker.patch(SysVConfig)
-        sysvconfig_mock.is_configured_to_run()
-        self.mocker.result(False)
-        sysvconfig_mock.set_start_on_boot(True)
-        sysvconfig_mock.restart_landscape()
-
-        script_mock = self.mocker.patch(LandscapeSetupScript)
-        script_mock.run()
-
-        raw_input_mock = self.mocker.replace(raw_input)
-        raw_input_mock("\nRequest a new registration for "
-                       "this computer now? (Y/n): ")
-        self.mocker.result("")
-
-        raw_input_mock("\nThe Landscape client must be started "
-                       "on boot to operate correctly.\n\n"
-                       "Start Landscape client on boot? (Y/n): ")
-        self.mocker.result("")
-
-        register_mock = self.mocker.replace(register, passthrough=False)
-        register_mock(ANY, ANY)
-
-        self.mocker.replay()
+    @mock.patch("__builtin__.raw_input", return_value="")
+    @mock.patch("landscape.configuration.register")
+    @mock.patch("landscape.configuration.LandscapeSetupScript")
+    @mock.patch("landscape.configuration.SysVConfig")
+    def test_register(
+            self, mock_sysvconfig, mock_setup_script, mock_register,
+            mock_raw_input, mock_getuid, mock_bootstrap_tree):
+        mock_sysvconfig().is_configured_to_run.return_value = False
         self.assertRaises(
             SystemExit, main, ["--config", self.make_working_config()],
             print=noop_print)
+        mock_sysvconfig().is_configured_to_run.assert_called_once_with()
+        mock_sysvconfig().set_start_on_boot.assert_called_once_with(True)
+        mock_sysvconfig().restart_landscape.assert_called_once_with()
+        mock_setup_script().run.assert_called_once_with()
+        mock_register.assert_called_once_with(mock.ANY, mock.ANY)
+        mock_raw_input.assert_any_call(
+            "\nThe Landscape client must be started "
+            "on boot to operate correctly.\n\n"
+            "Start Landscape client on boot? (Y/n): ")
+        mock_raw_input.assert_called_with(
+            "\nRequest a new registration for this computer now? (Y/n): ")
 
-    def test_errors_from_restart_landscape(self):
+    @mock.patch("landscape.configuration.print_text")
+    @mock.patch("landscape.configuration.SysVConfig")
+    def test_errors_from_restart_landscape(
+            self, mock_sysvconfig, mock_print_text,
+            mock_getuid, mock_bootstrap_tree):
         """
         If a ProcessError exception is raised from restart_landscape (because
         the client failed to be restarted), an informative message is printed
         and the script exits.
         """
-        sysvconfig_mock = self.mocker.patch(SysVConfig)
-        print_text_mock = self.mocker.replace(print_text)
-
-        sysvconfig_mock.set_start_on_boot(True)
-        sysvconfig_mock.restart_landscape()
-        self.mocker.throw(ProcessError)
-
-        print_text_mock("Couldn't restart the Landscape client.", error=True)
-        print_text_mock(CONTAINS("This machine will be registered"),
-                        error=True)
-
-        self.mocker.replay()
+        mock_sysvconfig().restart_landscape.side_effect = ProcessError()
 
         config = self.get_config(["--silent", "-a", "account", "-t", "rex"])
         system_exit = self.assertRaises(SystemExit, setup, config)
         self.assertEqual(system_exit.code, 2)
+        mock_sysvconfig().set_start_on_boot.assert_called_once_with(True)
+        mock_sysvconfig().restart_landscape.assert_called_once_with()
+        mock_print_text.assert_any_call(
+            "Couldn't restart the Landscape client.", error=True)
+        mock_print_text.assert_called_with(
+            "This machine will be registered with the provided details when "
+            "the client runs.", error=True)
 
-    def test_errors_from_restart_landscape_ok_no_register(self):
+    @mock.patch("landscape.configuration.print_text")
+    @mock.patch("landscape.configuration.SysVConfig")
+    def test_errors_from_restart_landscape_ok_no_register(
+            self, mock_sysvconfig, mock_print_text,
+            mock_getuid, mock_bootstrap_tree):
         """
         Exit code 0 will be returned if the client fails to be restarted and
         --ok-no-register was passed.
         """
-        sysvconfig_mock = self.mocker.patch(SysVConfig)
-        print_text_mock = self.mocker.replace(print_text)
-
-        sysvconfig_mock.set_start_on_boot(True)
-        sysvconfig_mock.restart_landscape()
-        self.mocker.throw(ProcessError)
-
-        print_text_mock("Couldn't restart the Landscape client.", error=True)
-        print_text_mock(CONTAINS("This machine will be registered"),
-                        error=True)
-
-        self.mocker.replay()
+        mock_sysvconfig().restart_landscape.side_effect = ProcessError()
 
         config = self.get_config(["--silent", "-a", "account", "-t", "rex",
                                   "--ok-no-register"])
         system_exit = self.assertRaises(SystemExit, setup, config)
         self.assertEqual(system_exit.code, 0)
-
-    def test_main_with_register(self):
-        setup_mock = self.mocker.replace(setup)
-        setup_mock(ANY)
-        raw_input_mock = self.mocker.replace(raw_input)
-        raw_input_mock("\nRequest a new registration for "
-                       "this computer now? (Y/n): ")
-        self.mocker.result("")
-
-        register_mock = self.mocker.replace(register, passthrough=False)
-        register_mock(ANY, ANY)
-
-        self.mocker.replay()
+        mock_sysvconfig().set_start_on_boot.assert_called_once_with(True)
+        mock_sysvconfig().restart_landscape.assert_called_once_with()
+        mock_print_text.assert_any_call(
+            "Couldn't restart the Landscape client.", error=True)
+        mock_print_text.assert_called_with(
+            "This machine will be registered with the provided details when "
+            "the client runs.", error=True)
+
+    @mock.patch("__builtin__.raw_input", return_value="")
+    @mock.patch("landscape.configuration.register")
+    @mock.patch("landscape.configuration.setup")
+    def test_main_with_register(
+            self, mock_setup, mock_register, mock_raw_input,
+            mock_getuid, mock_bootstrap_tree):
         self.assertRaises(SystemExit, main, ["-c", self.make_working_config()],
-            print=noop_print)
-
-    def test_setup_init_script_and_start_client(self):
-        sysvconfig_mock = self.mocker.patch(SysVConfig)
-        sysvconfig_mock.set_start_on_boot(True)
-        self.mocker.replay()
-
-        setup_init_script_and_start_client()
-
-    def test_setup_init_script_and_start_client_silent(self):
-        sysvconfig_mock = self.mocker.patch(SysVConfig)
-        sysvconfig_mock.set_start_on_boot(True)
-
-        raw_input_mock = self.mocker.replace(raw_input, passthrough=False)
-        raw_input_mock(ANY)
-        self.mocker.count(0)
-        self.mocker.replay()
-        setup_init_script_and_start_client()
-
-    def test_register_silent(self):
+                          print=noop_print)
+        mock_setup.assert_called_once_with(mock.ANY)
+        mock_register.assert_called_once_with(mock.ANY, mock.ANY)
+        mock_raw_input.assert_called_once_with(
+            "\nRequest a new registration for this computer now? (Y/n): ")
+
+    @mock.patch("landscape.configuration.SysVConfig")
+    def test_setup_init_script_and_start_client(
+            self, mock_sysvconfig, mock_getuid, mock_bootstrap_tree):
+        setup_init_script_and_start_client()
+        mock_sysvconfig().set_start_on_boot.assert_called_once_with(True)
+
+    @mock.patch("__builtin__.raw_input")
+    @mock.patch("landscape.configuration.SysVConfig")
+    def test_setup_init_script_and_start_client_silent(
+            self, mock_sysvconfig, mock_raw_input,
+            mock_getuid, mock_bootstrap_tree):
+        setup_init_script_and_start_client()
+        mock_raw_input.assert_not_called()
+        mock_sysvconfig().set_start_on_boot.assert_called_once_with(True)
+
+    @mock.patch("__builtin__.raw_input")
+    @mock.patch("landscape.configuration.register")
+    @mock.patch("landscape.configuration.setup")
+    def test_register_silent(
+            self, mock_setup, mock_register, mock_raw_input,
+            mock_getuid, mock_bootstrap_tree):
         """
         Silent registration uses specified configuration to attempt a
         registration with the server.
         """
-        setup_mock = self.mocker.replace(setup)
-        setup_mock(ANY)
-        # No interaction should be requested.
-        raw_input_mock = self.mocker.replace(raw_input)
-        raw_input_mock(ANY)
-        self.mocker.count(0)
-
-        # The registration logic should be called and passed the configuration
-        # file.
-        register_mock = self.mocker.replace(register, passthrough=False)
-        register_mock(ANY, ANY)
-
-        self.mocker.replay()
-
         self.assertRaises(
             SystemExit, main, ["--silent", "-c", self.make_working_config()],
             print=noop_print)
-
-    def test_disable(self):
-        stop_client_and_disable_init_script_mock = self.mocker.replace(
-            stop_client_and_disable_init_script)
-        stop_client_and_disable_init_script_mock()
-
-        # No interaction should be requested.
-        raw_input_mock = self.mocker.replace(raw_input)
-        raw_input_mock(ANY)
-        self.mocker.count(0)
-
-        # Registration logic should not be invoked.
-        register_mock = self.mocker.replace(register, passthrough=False)
-        register_mock(ANY, ANY, ANY)
-        self.mocker.count(0)
-
-        self.mocker.replay()
-
-        main(["--disable", "-c", self.make_working_config()])
-
-    def test_stop_client_and_disable_init_scripts(self):
-        sysvconfig_mock = self.mocker.patch(SysVConfig)
-        sysvconfig_mock.set_start_on_boot(False)
-        sysvconfig_mock.stop_landscape()
-        self.mocker.replay()
-
-        main(["--disable", "-c", self.make_working_config()])
-
-    def test_non_root(self):
-        self.mocker.reset()  # Forget the thing done in setUp
-        self.mocker.replace("os.getuid")()
-        self.mocker.result(1000)
-        self.mocker.replay()
+        mock_setup.assert_called_once_with(mock.ANY)
+        mock_register.assert_called_once_with(mock.ANY, mock.ANY)
+        mock_raw_input.assert_not_called()
+
+    @mock.patch("__builtin__.raw_input")
+    @mock.patch("landscape.configuration.register")
+    @mock.patch("landscape.configuration.stop_client_and_disable_init_script")
+    def test_disable(
+            self, mock_stop_client, mock_register, mock_raw_input,
+            mock_getuid, mock_bootstrap_tree):
+        main(["--disable", "-c", self.make_working_config()])
+        mock_stop_client.assert_called_once_with()
+        mock_register.assert_not_called()
+        mock_raw_input.assert_not_called()
+
+    @mock.patch("landscape.configuration.SysVConfig")
+    def test_stop_client_and_disable_init_scripts(
+            self, mock_sysvconfig, mock_getuid, mock_bootstrap_tree):
+        main(["--disable", "-c", self.make_working_config()])
+        mock_sysvconfig().set_start_on_boot.assert_called_once_with(True)
+        mock_sysvconfig().stop_landscape.assert_called_once_with()
+
+    def test_non_root(self, mock_getuid, mock_bootstrap_tree):
+        mock_getuid.return_value = 1000
         sys_exit = self.assertRaises(SystemExit,
                                      main, ["-c", self.make_working_config()])
+        mock_getuid.assert_called_once_with()
         self.assertIn("landscape-config must be run as root", str(sys_exit))
 
-    def test_main_with_help_and_non_root(self):
+    @mock.patch("sys.stdout", new_callable=StringIO)
+    def test_main_with_help_and_non_root(
+            self, mock_stdout, mock_getuid, mock_bootstrap_tree):
         """It's possible to call 'landscape-config --help' as normal user."""
-        self.mocker.reset()  # Forget the thing done in setUp
-        output = StringIO()
-        self.mocker.replace("sys.stdout").write(ANY)
-        self.mocker.call(output.write)
-        self.mocker.replay()
+        mock_getuid.return_value = 1000
         self.assertRaises(SystemExit, main, ["--help"])
-        self.assertIn("show this help message and exit", output.getvalue())
+        self.assertIn(
+            "show this help message and exit", mock_stdout.getvalue())
 
-    def test_main_with_help_and_non_root_short(self):
+    @mock.patch("sys.stdout", new_callable=StringIO)
+    def test_main_with_help_and_non_root_short(
+            self, mock_stdout, mock_getuid, mock_bootstrap_tree):
         """It's possible to call 'landscape-config -h' as normal user."""
-        self.mocker.reset()  # Forget the thing done in setUp
-        output = StringIO()
-        self.mocker.replace("sys.stdout").write(ANY)
-        self.mocker.call(output.write)
-        self.mocker.replay()
+        mock_getuid.return_value = 1000
         self.assertRaises(SystemExit, main, ["-h"])
-        self.assertIn("show this help message and exit", output.getvalue())
-
-    def test_import_from_file(self):
-        sysvconfig_mock = self.mocker.patch(SysVConfig)
-        sysvconfig_mock.set_start_on_boot(True)
-        sysvconfig_mock.restart_landscape()
-        self.mocker.result(True)
-        self.mocker.replay()
-
+        self.assertIn(
+            "show this help message and exit", mock_stdout.getvalue())
+
+    @mock.patch("landscape.configuration.SysVConfig")
+    def test_import_from_file(
+            self, mock_sysvconfig, mock_getuid, mock_bootstrap_tree):
         configuration = (
             "[client]\n"
             "computer_title = New Title\n"
@@ -1473,6 +1389,9 @@
                                   "--import", import_filename])
         setup(config)
 
+        mock_sysvconfig().set_start_on_boot.assert_called_once_with(True)
+        mock_sysvconfig().restart_landscape.assert_called_once_with()
+
         options = ConfigParser()
         options.read(config_filename)
 
@@ -1484,9 +1403,7 @@
                           "https_proxy": "https://new.proxy",
                           "url": "http://new.url"})
 
-    def test_import_from_empty_file(self):
-        self.mocker.replay()
-
+    def test_import_from_empty_file(self, mock_getuid, mock_bootstrap_tree):
         config_filename = self.makeFile("", basename="final_config")
         import_filename = self.makeFile("", basename="import_config")
 
@@ -1500,9 +1417,8 @@
         else:
             self.fail("ImportOptionError not raised")
 
-    def test_import_from_non_existent_file(self):
-        self.mocker.replay()
-
+    def test_import_from_non_existent_file(
+            self, mock_getuid, mock_bootstrap_tree):
         config_filename = self.makeFile("", basename="final_config")
         import_filename = self.makeFile(basename="import_config")
 
@@ -1516,9 +1432,8 @@
         else:
             self.fail("ImportOptionError not raised")
 
-    def test_import_from_file_with_empty_client_section(self):
-        self.mocker.replay()
-
+    def test_import_from_file_with_empty_client_section(
+            self, mock_getuid, mock_bootstrap_tree):
         old_configuration = "[client]\n"
 
         config_filename = self.makeFile("", old_configuration,
@@ -1535,9 +1450,7 @@
         else:
             self.fail("ImportOptionError not raised")
 
-    def test_import_from_bogus_file(self):
-        self.mocker.replay()
-
+    def test_import_from_bogus_file(self, mock_getuid, mock_bootstrap_tree):
         config_filename = self.makeFile("", basename="final_config")
         import_filename = self.makeFile("<strong>BOGUS!</strong>",
                                         basename="import_config")
@@ -1552,12 +1465,12 @@
         else:
             self.fail("ImportOptionError not raised")
 
-    def test_import_from_unreadable_file(self):
+    def test_import_from_unreadable_file(
+            self, mock_getuid, mock_bootstrap_tree):
         """
         An error is raised when unable to read configuration from the
         specified file.
         """
-        self.mocker.replay()
         import_filename = self.makeFile(
             "[client]\nfoo=bar", basename="import_config")
         # Remove read permissions
@@ -1568,13 +1481,9 @@
                             import_filename)
         self.assertEqual(str(error), expected_message)
 
-    def test_import_from_file_preserves_old_options(self):
-        sysvconfig_mock = self.mocker.patch(SysVConfig)
-        sysvconfig_mock.set_start_on_boot(True)
-        sysvconfig_mock.restart_landscape()
-        self.mocker.result(True)
-        self.mocker.replay()
-
+    @mock.patch("landscape.configuration.SysVConfig")
+    def test_import_from_file_preserves_old_options(
+            self, mock_sysvconfig, mock_getuid, mock_bootstrap_tree):
         old_configuration = (
             "[client]\n"
             "computer_title = Old Title\n"
@@ -1601,6 +1510,8 @@
                                   "-p", "Command Line Password"])
         setup(config)
 
+        mock_sysvconfig().set_start_on_boot.assert_called_once_with(True)
+        mock_sysvconfig().restart_landscape.assert_called_once_with()
         options = ConfigParser()
         options.read(config_filename)
 
@@ -1612,18 +1523,14 @@
                           "https_proxy": "https://old.proxy",
                           "url": "http://new.url"})
 
-    def test_import_from_file_may_reset_old_options(self):
+    @mock.patch("landscape.configuration.SysVConfig")
+    def test_import_from_file_may_reset_old_options(
+            self, mock_sysvconfig, mock_getuid, mock_bootstrap_tree):
         """
         This test ensures that setting an empty option in an imported
         configuration file will actually set the local value to empty
         too, rather than being ignored.
         """
-        sysvconfig_mock = self.mocker.patch(SysVConfig)
-        sysvconfig_mock.set_start_on_boot(True)
-        sysvconfig_mock.restart_landscape()
-        self.mocker.result(True)
-        self.mocker.replay()
-
         old_configuration = (
             "[client]\n"
             "computer_title = Old Title\n"
@@ -1643,6 +1550,8 @@
         config = self.get_config(["--config", config_filename, "--silent",
                                   "--import", import_filename])
         setup(config)
+        mock_sysvconfig().set_start_on_boot.assert_called_once_with(True)
+        mock_sysvconfig().restart_landscape.assert_called_once_with()
 
         options = ConfigParser()
         options.read(config_filename)
@@ -1653,12 +1562,13 @@
                           "registration_key": "",  # <==
                           "url": "http://old.url"})
 
-    def test_import_from_url(self):
-        sysvconfig_mock = self.mocker.patch(SysVConfig)
-        sysvconfig_mock.set_start_on_boot(True)
-        sysvconfig_mock.restart_landscape()
-        self.mocker.result(True)
-
+    @mock.patch("landscape.configuration.print_text")
+    @mock.patch("landscape.configuration.fetch")
+    @mock.patch("landscape.configuration.SysVConfig")
+    def test_import_from_url(
+            self, mock_sysvconfig, mock_fetch, mock_print_text,
+            mock_getuid, mock_bootstrap_tree):
+        mock_sysvconfig().restart_landscape.return_value = True
         configuration = (
             "[client]\n"
             "computer_title = New Title\n"
@@ -1668,20 +1578,18 @@
             "https_proxy = https://new.proxy\n"
             "url = http://new.url\n")
 
-        fetch_mock = self.mocker.replace("landscape.lib.fetch.fetch")
-        fetch_mock("https://config.url")
-        self.mocker.result(configuration)
-
-        print_text_mock = self.mocker.replace(print_text)
-        print_text_mock("Fetching configuration from https://config.url...")
-
-        self.mocker.replay()
+        mock_fetch.return_value = configuration
 
         config_filename = self.makeFile("", basename="final_config")
 
         config = self.get_config(["--config", config_filename, "--silent",
                                   "--import", "https://config.url"])
         setup(config)
+        mock_fetch.assert_called_once_with("https://config.url")
+        mock_print_text.assert_called_once_with(
+            "Fetching configuration from https://config.url...")
+        mock_sysvconfig().set_start_on_boot.assert_called_once_with(True)
+        mock_sysvconfig().restart_landscape.assert_called_once_with()
 
         options = ConfigParser()
         options.read(config_filename)
@@ -1694,16 +1602,12 @@
                           "https_proxy": "https://new.proxy",
                           "url": "http://new.url"})
 
-    def test_import_from_url_with_http_code_fetch_error(self):
-        fetch_mock = self.mocker.replace("landscape.lib.fetch.fetch")
-        fetch_mock("https://config.url")
-        self.mocker.throw(HTTPCodeError(501, ""))
-
-        print_text_mock = self.mocker.replace(print_text)
-        print_text_mock("Fetching configuration from https://config.url...")
-
-        self.mocker.replay()
-
+    @mock.patch("landscape.configuration.print_text")
+    @mock.patch("landscape.configuration.fetch")
+    def test_import_from_url_with_http_code_fetch_error(
+            self, mock_fetch, mock_print_text,
+            mock_getuid, mock_bootstrap_tree):
+        mock_fetch.side_effect = HTTPCodeError(501, "")
         config_filename = self.makeFile("", basename="final_config")
 
         try:
@@ -1716,16 +1620,16 @@
                              "returned HTTP code 501")
         else:
             self.fail("ImportOptionError not raised")
-
-    def test_import_from_url_with_pycurl_error(self):
-        fetch_mock = self.mocker.replace("landscape.lib.fetch.fetch")
-        fetch_mock("https://config.url")
-        self.mocker.throw(PyCurlError(60, "pycurl message"))
-
-        print_text_mock = self.mocker.replace(print_text)
-        print_text_mock("Fetching configuration from https://config.url...")
-
-        self.mocker.replay()
+        mock_fetch.assert_called_once_with("https://config.url")
+        mock_print_text.assert_called_once_with(
+            "Fetching configuration from https://config.url...")
+
+    @mock.patch("landscape.configuration.print_text")
+    @mock.patch("landscape.configuration.fetch")
+    def test_import_from_url_with_pycurl_error(
+            self, mock_fetch, mock_print_text,
+            mock_getuid, mock_bootstrap_tree):
+        mock_fetch.side_effect = PyCurlError(60, "pycurl message")
 
         config_filename = self.makeFile("", basename="final_config")
 
@@ -1738,17 +1642,15 @@
                              "https://config.url: Error 60: pycurl message")
         else:
             self.fail("ImportOptionError not raised")
-
-    def test_import_from_url_with_empty_content(self):
-        fetch_mock = self.mocker.replace("landscape.lib.fetch.fetch")
-        fetch_mock("https://config.url")
-        self.mocker.result("")
-
-        print_text_mock = self.mocker.replace(print_text)
-        print_text_mock("Fetching configuration from https://config.url...")
-
-        self.mocker.replay()
-
+        mock_fetch.assert_called_once_with("https://config.url")
+        mock_print_text.assert_called_once_with(
+            "Fetching configuration from https://config.url...")
+
+    @mock.patch("landscape.configuration.print_text")
+    @mock.patch("landscape.configuration.fetch", return_value="")
+    def test_import_from_url_with_empty_content(
+            self, mock_fetch, mock_print_text,
+            mock_getuid, mock_bootstrap_tree):
         # Use a command line option as well to test the precedence.
         try:
             self.get_config(["--silent", "--import", "https://config.url"])
@@ -1757,17 +1659,16 @@
                              "Nothing to import at https://config.url.")
         else:
             self.fail("ImportOptionError not raised")
-
-    def test_import_from_url_with_bogus_content(self):
-        fetch_mock = self.mocker.replace("landscape.lib.fetch.fetch")
-        fetch_mock("https://config.url")
-        self.mocker.result("<strong>BOGUS!</strong>")
-
-        print_text_mock = self.mocker.replace(print_text)
-        print_text_mock("Fetching configuration from https://config.url...")
-
-        self.mocker.replay()
-
+        mock_fetch.assert_called_once_with("https://config.url")
+        mock_print_text.assert_called_once_with(
+            "Fetching configuration from https://config.url...")
+
+    @mock.patch("landscape.configuration.print_text")
+    @mock.patch("landscape.configuration.fetch",
+                return_value="<strong>BOGUS!</strong>")
+    def test_import_from_url_with_bogus_content(
+            self, mock_fetch, mock_print_text,
+            mock_getuid, mock_bootstrap_tree):
         # Use a command line option as well to test the precedence.
         try:
             self.get_config(["--silent", "--import", "https://config.url"])
@@ -1776,45 +1677,47 @@
                              str(error))
         else:
             self.fail("ImportOptionError not raised")
-
-    def test_import_error_is_handled_nicely_by_main(self):
-        fetch_mock = self.mocker.replace("landscape.lib.fetch.fetch")
-        fetch_mock("https://config.url")
-        self.mocker.throw(HTTPCodeError(404, ""))
-
-        print_text_mock = self.mocker.replace(print_text)
-        print_text_mock("Fetching configuration from https://config.url...")
-        print_text_mock(CONTAINS("Server returned HTTP code 404"), error=True)
-
-        self.mocker.replay()
-
+        mock_fetch.assert_called_once_with("https://config.url")
+        mock_print_text.assert_called_once_with(
+            "Fetching configuration from https://config.url...")
+
+    @mock.patch("landscape.configuration.print_text")
+    @mock.patch("landscape.configuration.fetch",
+                side_effect=HTTPCodeError(404, ""))
+    def test_import_error_is_handled_nicely_by_main(
+            self, mock_fetch, mock_print_text,
+            mock_getuid, mock_bootstrap_tree):
         system_exit = self.assertRaises(
             SystemExit, main, ["--import", "https://config.url"])
         self.assertEqual(system_exit.code, 1)
-
-    def test_base64_ssl_public_key_is_exported_to_file(self):
-
-        sysvconfig_mock = self.mocker.patch(SysVConfig)
-        sysvconfig_mock.set_start_on_boot(True)
-        sysvconfig_mock.restart_landscape()
-        self.mocker.result(True)
-
+        mock_fetch.assert_called_once_with("https://config.url")
+        mock_print_text.assert_any_call(
+            "Fetching configuration from https://config.url...")
+        mock_print_text.assert_called_with(
+            "Couldn't download configuration from https://config.url: "
+            "Server returned HTTP code 404", error=True)
+
+    @mock.patch("landscape.configuration.print_text")
+    @mock.patch("landscape.configuration.SysVConfig")
+    def test_base64_ssl_public_key_is_exported_to_file(
+            self, mock_sysvconfig, mock_print_text,
+            mock_getuid, mock_bootstrap_tree):
+        mock_sysvconfig().restart_landscape.return_value = True
         data_path = self.makeDir()
         config_filename = self.makeFile("[client]\ndata_path=%s" % data_path)
         key_filename = os.path.join(data_path,
             os.path.basename(config_filename) + ".ssl_public_key")
 
-        print_text_mock = self.mocker.replace(print_text)
-        print_text_mock("Writing SSL CA certificate to %s..." % key_filename)
-
-        self.mocker.replay()
-
         config = self.get_config(["--silent", "-c", config_filename,
                                   "-u", "url", "-a", "account", "-t", "title",
                                   "--ssl-public-key", "base64:SGkgdGhlcmUh"])
         config.data_path = data_path
         setup(config)
 
+        mock_sysvconfig().set_start_on_boot.assert_called_once_with(True)
+        mock_sysvconfig().restart_landscape.assert_called_once_with()
+        mock_print_text.assert_called_once_with(
+            "Writing SSL CA certificate to %s..." % key_filename)
         self.assertEqual("Hi there!", open(key_filename, "r").read())
 
         options = ConfigParser()
@@ -1822,13 +1725,10 @@
         self.assertEqual(options.get("client", "ssl_public_key"),
                          key_filename)
 
-    def test_normal_ssl_public_key_is_not_exported_to_file(self):
-        sysvconfig_mock = self.mocker.patch(SysVConfig)
-        sysvconfig_mock.set_start_on_boot(True)
-        sysvconfig_mock.restart_landscape()
-        self.mocker.result(True)
-        self.mocker.replay()
-
+    @mock.patch("landscape.configuration.SysVConfig")
+    def test_normal_ssl_public_key_is_not_exported_to_file(
+            self, mock_sysvconfig, mock_getuid, mock_bootstrap_tree):
+        mock_sysvconfig().restart_landscape.return_value = True
         config_filename = self.makeFile("")
 
         config = self.get_config(["--silent", "-c", config_filename,
@@ -1836,6 +1736,8 @@
                                   "--ssl-public-key", "/some/filename"])
         setup(config)
 
+        mock_sysvconfig().set_start_on_boot.assert_called_once_with(True)
+        mock_sysvconfig().restart_landscape.assert_called_once_with()
         key_filename = config_filename + ".ssl_public_key"
         self.assertFalse(os.path.isfile(key_filename))
 
@@ -1845,28 +1747,32 @@
                          "/some/filename")
 
     # We test them individually since they must work individually.
-    def test_import_from_url_honors_http_proxy(self):
-        self.ensure_import_from_url_honors_proxy_options("http_proxy")
-
-    def test_import_from_url_honors_https_proxy(self):
-        self.ensure_import_from_url_honors_proxy_options("https_proxy")
-
-    def ensure_import_from_url_honors_proxy_options(self, proxy_option):
+    @mock.patch("landscape.configuration.print_text")
+    @mock.patch("landscape.configuration.fetch")
+    def test_import_from_url_honors_http_proxy(
+            self, mock_fetch, mock_print_text,
+            mock_getuid, mock_bootstrap_tree):
+        self.ensure_import_from_url_honors_proxy_options(
+            "http_proxy", mock_fetch, mock_print_text)
+
+    @mock.patch("landscape.configuration.print_text")
+    @mock.patch("landscape.configuration.fetch")
+    def test_import_from_url_honors_https_proxy(
+            self, mock_fetch, mock_print_text,
+            mock_getuid, mock_bootstrap_tree):
+        self.ensure_import_from_url_honors_proxy_options(
+            "https_proxy", mock_fetch, mock_print_text)
+
+    def ensure_import_from_url_honors_proxy_options(
+            self, proxy_option, mock_fetch, mock_print_text):
 
         def check_proxy(url):
+            self.assertEqual("https://config.url", url)
             self.assertEqual(os.environ.get(proxy_option), "http://proxy")
-
-        fetch_mock = self.mocker.replace("landscape.lib.fetch.fetch")
-        fetch_mock("https://config.url")
-        self.mocker.call(check_proxy)
-
-        # Doesn't matter.  We just want to check the context around it.
-        self.mocker.result("")
-
-        print_text_mock = self.mocker.replace(print_text)
-        print_text_mock("Fetching configuration from https://config.url...")
-
-        self.mocker.replay()
+            # Doesn't matter.  We just want to check the context around it.
+            return ""
+
+        mock_fetch.side_effect = check_proxy
 
         config_filename = self.makeFile("", basename="final_config")
 
@@ -1879,6 +1785,8 @@
             pass  # The returned content is empty.  We don't really
                   # care for this test.  Mocker will ensure the tests
                   # we care about are done.
+        mock_print_text.assert_called_once_with(
+            "Fetching configuration from https://config.url...")
 
 
 class FakeConnectorFactory(object):