Proper mocking.

tests/unit/states/test_augeas.py

@@ -5,10 +5,10 @@
 '''
 # Import Python libs
 from __future__ import absolute_import
-
 import os
 
 # Import Salt Testing Libs
+from tests.support.mixins import LoaderModuleMockMixin
 from tests.support.unit import skipIf, TestCase
 from tests.support.mock import (
     mock_open,
@@ -23,14 +23,15 @@ import salt.states.augeas as augeas
 
 
 @skipIf(NO_MOCK, NO_MOCK_REASON)
-class AugeasTestCase(TestCase):
+class AugeasTestCase(TestCase, LoaderModuleMockMixin):
     '''
     Test cases for salt.states.augeas
     '''
+    def setup_loader_modules(self):
+        return {augeas: {}}
+
     # 'change' function tests: 1
     def setUp(self):
-        augeas.__opts__ = {}
-        augeas.__salt__ = {}
         self.name = 'zabbix'
         self.context = '/files/etc/services'
         self.changes = ['ins service-name after service-name[last()]',
@@ -54,6 +55,12 @@ class AugeasTestCase(TestCase):
         }
         self.mock_method_map = MagicMock(return_value=method_map)
 
+    def tearDown(self):
+        del self.ret
+        del self.changes
+        del self.fp_changes
+        del self.mock_method_map
+
     def test_change_non_list_changes(self):
         '''
         Test if none list changes handled correctly

tests/unit/states/test_elasticsearch.py

@@ -6,6 +6,7 @@
 from __future__ import absolute_import
 
 # Import Salt Testing Libs
+from tests.support.mixins import LoaderModuleMockMixin
 from tests.support.unit import skipIf, TestCase
 from tests.support.mock import (
     NO_MOCK,
@@ -19,16 +20,20 @@ from salt.exceptions import CommandExecutionError
 from salt.states import elasticsearch
 from salt.utils import dictdiffer
 
-elasticsearch.__salt__ = {}
-elasticsearch.__opts__ = {'test': False}
-elasticsearch.__utils__ = {'dictdiffer.deep_diff': dictdiffer.deep_diff}
-
 
 @skipIf(NO_MOCK, NO_MOCK_REASON)
-class ElasticsearchTestCase(TestCase):
+class ElasticsearchTestCase(TestCase, LoaderModuleMockMixin):
     '''
     Test cases for salt.states.elasticsearch
     '''
+    def setup_loader_modules(self):
+        return {
+            elasticsearch: {
+                '__opts__': {'test': False},
+                '__utils__': {'dictdiffer.deep_diff': dictdiffer.deep_diff}
+            }
+        }
+
     # 'index_absent' function tests: 1
 
     def test_index_absent(self):
@@ -166,7 +171,7 @@ class ElasticsearchTestCase(TestCase):
         mock_create = MagicMock(side_effect=[True, True, False, CommandExecutionError])
 
         with patch.dict(elasticsearch.__salt__, {'elasticsearch.alias_get': mock_get,
-                                             'elasticsearch.alias_create': mock_create}):
+                                                 'elasticsearch.alias_create': mock_create}):
             self.assertDictEqual(elasticsearch.alias_present(name, index, {"test": "key"}), ret)
 
             ret.update({'comment': "Successfully replaced alias foo for index bar", 'changes': {'old': {"test": "key"}, 'new': {"test2": "key"}}})

tests/unit/states/test_environ.py

@@ -106,8 +106,8 @@ class TestEnvironState(TestCase, LoaderModuleMockMixin):
 
     def test_setenv_test_mode(self):
         '''test that imitating action returns good values'''
-        envstate.__opts__ = {'test': True}
-        ret = envstate.setenv('test', 'value')
-        self.assertEqual(ret['changes'], {'test': 'value'})
-        ret = envstate.setenv('INITIAL', 'initial')
-        self.assertEqual(ret['changes'], {})
+        with patch.dict(envstate.__opts__, {'test': True}):
+            ret = envstate.setenv('test', 'value')
+            self.assertEqual(ret['changes'], {'test': 'value'})
+            ret = envstate.setenv('INITIAL', 'initial')
+            self.assertEqual(ret['changes'], {})

tests/unit/states/test_file.py

@@ -107,11 +107,6 @@ class TestFileState(TestCase, LoaderModuleMockMixin):
 
     def run_contents_pillar(self, pillar_value, expected):
         returner = MagicMock(return_value=None)
-
-        filestate.__salt__ = {
-            'file.manage_file': returner
-        }
-
         path = '/tmp/foo'
         pillar_path = 'foo:bar'
 

tests/unit/states/test_postgres_initdb.py

@@ -4,6 +4,7 @@
 '''
 from __future__ import absolute_import
 
+from tests.support.mixins import LoaderModuleMockMixin
 from tests.support.unit import skipIf, TestCase
 from tests.support.mock import (
     NO_MOCK,
@@ -16,17 +17,18 @@ import salt.states.postgres_initdb as postgres_initdb
 
 
 @skipIf(NO_MOCK, NO_MOCK_REASON)
-class PostgresInitdbTestCase(TestCase):
+class PostgresInitdbTestCase(TestCase, LoaderModuleMockMixin):
     '''
     Test cases for salt.states.postgres_initdb
     '''
 
+    def setup_loader_modules(self):
+        return {postgres_initdb: {}}
+
     def setUp(self):
         '''
         Setup data for the tests
         '''
-        postgres_initdb.__opts__ = {}
-        postgres_initdb.__salt__ = {}
         self.name = '/var/lib/psql/data'
         self.ret = {
             'name': self.name,
@@ -36,6 +38,11 @@ class PostgresInitdbTestCase(TestCase):
         self.mock_true = MagicMock(return_value=True)
         self.mock_false = MagicMock(return_value=False)
 
+    def tearDown(self):
+        del self.ret
+        del self.mock_true
+        del self.mock_false
+
     def test_present_existing(self):
         '''
         Test existing data directory handled correctly

tests/unit/states/test_postgres_language.py

@@ -4,6 +4,7 @@
 '''
 from __future__ import absolute_import
 
+from tests.support.mixins import LoaderModuleMockMixin
 from tests.support.unit import skipIf, TestCase
 from tests.support.mock import (
     NO_MOCK,
@@ -16,28 +17,36 @@ import salt.states.postgres_language as postgres_language
 
 
 @skipIf(NO_MOCK, NO_MOCK_REASON)
-class PostgresLanguageTestCase(TestCase):
+class PostgresLanguageTestCase(TestCase, LoaderModuleMockMixin):
     '''
     Test cases for salt.states.postgres_language
     '''
 
+    def setup_loader_modules(self):
+        return {postgres_language: {}}
+
     def setUp(self):
         '''
         Setup data for the tests
         '''
-        postgres_language.__opts__ = {}
-        postgres_language.__salt__ = {}
         self.name = 'plpgsql'
         self.ret = {'name': self.name,
-               'changes': {},
-               'result': False,
-               'comment': ''}
+                    'changes': {},
+                    'result': False,
+                    'comment': ''}
         self.mock_true = MagicMock(return_value=True)
         self.mock_false = MagicMock(return_value=False)
         self.mock_empty_language_list = MagicMock(return_value={})
         self.mock_language_list = MagicMock(
             return_value={'plpgsql': self.name})
 
+    def tearDown(self):
+        del self.ret
+        del self.mock_true
+        del self.mock_false
+        del self.mock_language_list
+        del self.mock_empty_language_list
+
     def test_present_existing(self):
         '''
         Test present, language is already present in database

tests/unit/states/test_postgres_privileges.py

@@ -4,6 +4,7 @@
 '''
 from __future__ import absolute_import
 
+from tests.support.mixins import LoaderModuleMockMixin
 from tests.support.unit import skipIf, TestCase
 from tests.support.mock import (
     NO_MOCK,
@@ -16,27 +17,33 @@ import salt.states.postgres_privileges as postgres_privileges
 
 
 @skipIf(NO_MOCK, NO_MOCK_REASON)
-class PostgresPrivilegesTestCase(TestCase):
+class PostgresPrivilegesTestCase(TestCase, LoaderModuleMockMixin):
     '''
     Test cases for salt.states.postgres_privileges
     '''
 
+    def setup_loader_modules(self):
+        return {postgres_privileges: {}}
+
     def setUp(self):
         '''
         Setup data for the tests
         '''
-        postgres_privileges.__opts__ = {}
-        postgres_privileges.__salt__ = {}
         self.table_name = 'awl'
         self.group_name = 'admins'
         self.name = 'baruwa'
         self.ret = {'name': self.name,
-               'changes': {},
-               'result': False,
-               'comment': ''}
+                    'changes': {},
+                    'result': False,
+                    'comment': ''}
         self.mock_true = MagicMock(return_value=True)
         self.mock_false = MagicMock(return_value=False)
 
+    def tearDown(self):
+        del self.ret
+        del self.mock_true
+        del self.mock_false
+
     def test_present_table(self):
         '''
         Test present