More test ports from mocker to mock.

3 files changed, 112 insertions, 77 deletions

diff --git a/tests/unittests/test_datasource/test_configdrive.py b/tests/unittests/test_datasource/test_configdrive.py
index d88066e5..800c5fd8 100644
--- a/tests/unittests/test_datasource/test_configdrive.py
+++ b/tests/unittests/test_datasource/test_configdrive.py
@@ -1,10 +1,18 @@
 from copy import copy
 import json
 import os
-import os.path
-
-import mocker
-from mocker import MockerTestCase
+import shutil
+import tempfile
+import unittest
+
+try:
+    from unittest import mock
+except ImportError:
+    import mock
+try:
+    from contextlib import ExitStack
+except ImportError:
+    from contextlib2 import ExitStack
 
 from cloudinit import helpers
 from cloudinit import settings
@@ -12,8 +20,6 @@ from cloudinit.sources import DataSourceConfigDrive as ds
 from cloudinit.sources.helpers import openstack
 from cloudinit import util
 
-from .. import helpers as unit_helpers
-
 PUBKEY = u'ssh-rsa AAAAB3NzaC1....sIkJhq8wdX+4I3A4cYbYP ubuntu@server-460\n'
 EC2_META = {
     'ami-id': 'ami-00000001',
@@ -64,11 +70,12 @@ CFG_DRIVE_FILES_V2 = {
   'openstack/latest/user_data': USER_DATA}
 
 
-class TestConfigDriveDataSource(MockerTestCase):
+class TestConfigDriveDataSource(unittest.TestCase):
 
     def setUp(self):
         super(TestConfigDriveDataSource, self).setUp()
-        self.tmp = self.makeDir()
+        self.tmp = tempfile.mkdtemp()
+        self.addCleanup(shutil.rmtree, self.tmp)
 
     def test_ec2_metadata(self):
         populate_dir(self.tmp, CFG_DRIVE_FILES_V2)
@@ -91,23 +98,28 @@ class TestConfigDriveDataSource(MockerTestCase):
             'swap': '/dev/vda3',
         }
         for name, dev_name in name_tests.items():
-            with unit_helpers.mocker() as my_mock:
-                find_mock = my_mock.replace(util.find_devs_with,
-                                            spec=False, passthrough=False)
+            with ExitStack() as mocks:
                 provided_name = dev_name[len('/dev/'):]
                 provided_name = "s" + provided_name[1:]
-                find_mock(mocker.ARGS)
-                my_mock.result([provided_name])
-                exists_mock = my_mock.replace(os.path.exists,
-                                              spec=False, passthrough=False)
-                exists_mock(mocker.ARGS)
-                my_mock.result(False)
-                exists_mock(mocker.ARGS)
-                my_mock.result(True)
-                my_mock.replay()
+                find_mock = mocks.enter_context(
+                    mock.patch.object(util, 'find_devs_with',
+                                      return_value=[provided_name]))
+                # We want os.path.exists() to return False on its first call,
+                # and True on its second call.  We use a handy generator as
+                # the mock side effect for this.  The mocked function returns
+                # what the side effect returns.
+                def exists_side_effect():
+                    yield False
+                    yield True
+                exists_mock = mocks.enter_context(
+                    mock.patch.object(os.path, 'exists',
+                                      side_effect=exists_side_effect()))
                 device = cfg_ds.device_name_to_device(name)
                 self.assertEquals(dev_name, device)
 
+                find_mock.assert_called_once_with(mock.ANY)
+                self.assertEqual(exists_mock.call_count, 2)
+
     def test_dev_os_map(self):
         populate_dir(self.tmp, CFG_DRIVE_FILES_V2)
         cfg_ds = ds.DataSourceConfigDrive(settings.CFG_BUILTIN,
@@ -123,19 +135,19 @@ class TestConfigDriveDataSource(MockerTestCase):
             'swap': '/dev/vda3',
         }
         for name, dev_name in name_tests.items():
-            with unit_helpers.mocker() as my_mock:
-                find_mock = my_mock.replace(util.find_devs_with,
-                                            spec=False, passthrough=False)
-                find_mock(mocker.ARGS)
-                my_mock.result([dev_name])
-                exists_mock = my_mock.replace(os.path.exists,
-                                              spec=False, passthrough=False)
-                exists_mock(mocker.ARGS)
-                my_mock.result(True)
-                my_mock.replay()
+            with ExitStack() as mocks:
+                find_mock = mocks.enter_context(
+                    mock.patch.object(util, 'find_devs_with',
+                                      return_value=[dev_name]))
+                exists_mock = mocks.enter_context(
+                    mock.patch.object(os.path, 'exists',
+                                      return_value=True))
                 device = cfg_ds.device_name_to_device(name)
                 self.assertEquals(dev_name, device)
 
+                find_mock.assert_called_once_with(mock.ANY)
+                exists_mock.assert_called_once_with(mock.ANY)
+
     def test_dev_ec2_remap(self):
         populate_dir(self.tmp, CFG_DRIVE_FILES_V2)
         cfg_ds = ds.DataSourceConfigDrive(settings.CFG_BUILTIN,
@@ -156,16 +168,21 @@ class TestConfigDriveDataSource(MockerTestCase):
             'root2k': None,
         }
         for name, dev_name in name_tests.items():
-            with unit_helpers.mocker(verify_calls=False) as my_mock:
-                exists_mock = my_mock.replace(os.path.exists,
-                                              spec=False, passthrough=False)
-                exists_mock(mocker.ARGS)
-                my_mock.result(False)
-                exists_mock(mocker.ARGS)
-                my_mock.result(True)
-                my_mock.replay()
+            # We want os.path.exists() to return False on its first call,
+            # and True on its second call.  We use a handy generator as
+            # the mock side effect for this.  The mocked function returns
+            # what the side effect returns.
+            def exists_side_effect():
+                yield False
+                yield True
+            with mock.patch.object(os.path, 'exists',
+                                   side_effect=exists_side_effect()):
                 device = cfg_ds.device_name_to_device(name)
                 self.assertEquals(dev_name, device)
+                # We don't assert the call count for os.path.exists() because
+                # not all of the entries in name_tests results in two calls to
+                # that function.  Specifically, 'root2k' doesn't seem to call
+                # it at all.
 
     def test_dev_ec2_map(self):
         populate_dir(self.tmp, CFG_DRIVE_FILES_V2)
@@ -173,12 +190,6 @@ class TestConfigDriveDataSource(MockerTestCase):
                                           None,
                                           helpers.Paths({}))
         found = ds.read_config_drive(self.tmp)
-        exists_mock = self.mocker.replace(os.path.exists,
-                                          spec=False, passthrough=False)
-        exists_mock(mocker.ARGS)
-        self.mocker.count(0, None)
-        self.mocker.result(True)
-        self.mocker.replay()
         ec2_md = found['ec2-metadata']
         os_md = found['metadata']
         cfg_ds.ec2_metadata = ec2_md
@@ -193,8 +204,9 @@ class TestConfigDriveDataSource(MockerTestCase):
             'root2k': None,
         }
         for name, dev_name in name_tests.items():
-            device = cfg_ds.device_name_to_device(name)
-            self.assertEquals(dev_name, device)
+            with mock.patch.object(os.path, 'exists', return_value=True):
+                device = cfg_ds.device_name_to_device(name)
+                self.assertEquals(dev_name, device)
 
     def test_dir_valid(self):
         """Verify a dir is read as such."""
diff --git a/tests/unittests/test_datasource/test_maas.py b/tests/unittests/test_datasource/test_maas.py
index c157beb8..6af0cd82 100644
--- a/tests/unittests/test_datasource/test_maas.py
+++ b/tests/unittests/test_datasource/test_maas.py
@@ -1,19 +1,26 @@
 from copy import copy
 import os
+import shutil
+import tempfile
+import unittest
 
 from cloudinit.sources import DataSourceMAAS
 from cloudinit import url_helper
 from ..helpers import populate_dir
 
-import mocker
+try:
+    from unittest import mock
+except ImportError:
+    import mock
 
 
-class TestMAASDataSource(mocker.MockerTestCase):
+class TestMAASDataSource(unittest.TestCase):
 
     def setUp(self):
         super(TestMAASDataSource, self).setUp()
         # Make a temp directoy for tests to use.
-        self.tmp = self.makeDir()
+        self.tmp = tempfile.mkdtemp()
+        self.addCleanup(shutil.rmtree, self.tmp)
 
     def test_seed_dir_valid(self):
         """Verify a valid seeddir is read as such."""
@@ -93,16 +100,18 @@ class TestMAASDataSource(mocker.MockerTestCase):
 
     def test_seed_url_valid(self):
         """Verify that valid seed_url is read as such."""
-        valid = {'meta-data/instance-id': 'i-instanceid',
+        valid = {
+            'meta-data/instance-id': 'i-instanceid',
             'meta-data/local-hostname': 'test-hostname',
             'meta-data/public-keys': 'test-hostname',
-            'user-data': 'foodata'}
+            'user-data': 'foodata',
+            }
         valid_order = [
             'meta-data/local-hostname',
             'meta-data/instance-id',
             'meta-data/public-keys',
             'user-data',
-        ]
+            ]
         my_seed = "http://example.com/xmeta"
         my_ver = "1999-99-99"
         my_headers = {'header1': 'value1', 'header2': 'value2'}
@@ -110,28 +119,38 @@ class TestMAASDataSource(mocker.MockerTestCase):
         def my_headers_cb(url):
             return my_headers
 
-        mock_request = self.mocker.replace(url_helper.readurl,
-            passthrough=False)
-
-        for key in valid_order:
-            url = "%s/%s/%s" % (my_seed, my_ver, key)
-            mock_request(url, headers=None, timeout=mocker.ANY,
-                         data=mocker.ANY, sec_between=mocker.ANY,
-                         ssl_details=mocker.ANY, retries=mocker.ANY,
-                         headers_cb=my_headers_cb,
-                         exception_cb=mocker.ANY)
-            resp = valid.get(key)
-            self.mocker.result(url_helper.StringResponse(resp))
-        self.mocker.replay()
-
-        (userdata, metadata) = DataSourceMAAS.read_maas_seed_url(my_seed,
-            header_cb=my_headers_cb, version=my_ver)
-
-        self.assertEqual("foodata", userdata)
-        self.assertEqual(metadata['instance-id'],
-            valid['meta-data/instance-id'])
-        self.assertEqual(metadata['local-hostname'],
-            valid['meta-data/local-hostname'])
+        # Each time url_helper.readurl() is called, something different is
+        # returned based on the canned data above.  We need to build up a list
+        # of side effect return values, which the mock will return.  At the
+        # same time, we'll build up a list of expected call arguments for
+        # asserting after the code under test is run.
+        calls = []
+
+        def side_effect():
+            for key in valid_order:
+                resp = valid.get(key)
+                url = "%s/%s/%s" % (my_seed, my_ver, key)
+                calls.append(
+                    mock.call(url, headers=None, timeout=mock.ANY,
+                              data=mock.ANY, sec_between=mock.ANY,
+                              ssl_details=mock.ANY, retries=mock.ANY,
+                              headers_cb=my_headers_cb,
+                              exception_cb=mock.ANY))
+                yield url_helper.StringResponse(resp)
+
+        # Now do the actual call of the code under test.
+        with mock.patch.object(url_helper, 'readurl',
+                               side_effect=side_effect()) as mockobj:
+            userdata, metadata = DataSourceMAAS.read_maas_seed_url(
+                my_seed, header_cb=my_headers_cb, version=my_ver)
+
+            self.assertEqual("foodata", userdata)
+            self.assertEqual(metadata['instance-id'],
+                             valid['meta-data/instance-id'])
+            self.assertEqual(metadata['local-hostname'],
+                             valid['meta-data/local-hostname'])
+
+            mockobj.has_calls(calls)
 
     def test_seed_url_invalid(self):
         """Verify that invalid seed_url raises MAASSeedDirMalformed."""
diff --git a/tests/unittests/test_datasource/test_smartos.py b/tests/unittests/test_datasource/test_smartos.py
index 65675106..35d7ef5e 100644
--- a/tests/unittests/test_datasource/test_smartos.py
+++ b/tests/unittests/test_datasource/test_smartos.py
@@ -29,9 +29,12 @@ from .. import helpers
 import os
 import os.path
 import re
+import shutil
+import tempfile
 import stat
 import uuid
 
+
 MOCK_RETURNS = {
     'hostname': 'test-host',
     'root_authorized_keys': 'ssh-rsa AAAAB3Nz...aC1yc2E= keyname',
@@ -109,9 +112,10 @@ class TestSmartOSDataSource(helpers.FilesystemMockingTestCase):
     def setUp(self):
         helpers.FilesystemMockingTestCase.setUp(self)
 
-        # makeDir comes from MockerTestCase
-        self.tmp = self.makeDir()
-        self.legacy_user_d = self.makeDir()
+        self.tmp = tempfile.mkdtemp()
+        self.addCleanup(shutil.rmtree, self.tmp)
+        self.legacy_user_d = tempfile.mkdtemp()
+        self.addCleanup(shutil.rmtree, self.legacy_user_d)
 
         # If you should want to watch the logs...
         self._log = None