removed context managers from unit tests

1 files changed, 73 insertions, 67 deletions

diff --git a/testsuite/Testlib/TestClient/TestTools/TestPOSIX/Test__init.py b/testsuite/Testlib/TestClient/TestTools/TestPOSIX/Test__init.py
index e55ab4410..20577a6da 100644
--- a/testsuite/Testlib/TestClient/TestTools/TestPOSIX/Test__init.py
+++ b/testsuite/Testlib/TestClient/TestTools/TestPOSIX/Test__init.py
@@ -1,5 +1,4 @@
 import os
-import unittest
 import lxml.etree
 from mock import Mock, MagicMock, patch
 import Bcfg2.Client.Tools
@@ -29,105 +28,110 @@ def get_posix_object(logger=None, setup=None, config=None):
     
 
 class TestPOSIX(Bcfg2TestCase):
+    def setUp(self):
+        self.posix = get_posix_object()
+
+    def tearDown(self):
+        # just to guarantee that we start fresh each time
+        self.posix = None
+
     def test__init(self):
         entries = [lxml.etree.Element("Path", name="test", type="file")]
-        p = get_posix_object(config=get_config(entries))
-        self.assertIsInstance(p, Bcfg2.Client.Tools.Tool)
-        self.assertIsInstance(p, Bcfg2.Client.Tools.POSIX.POSIX)
-        self.assertIn('Path', p.__req__)
-        self.assertGreater(len(p.__req__['Path']), 0)
-        self.assertGreater(len(p.__handles__), 0)
-        self.assertItemsEqual(p.handled, entries)
+        posix = get_posix_object(config=get_config(entries))
+        self.assertIsInstance(posix, Bcfg2.Client.Tools.Tool)
+        self.assertIsInstance(posix, Bcfg2.Client.Tools.POSIX.POSIX)
+        self.assertIn('Path', posix.__req__)
+        self.assertGreater(len(posix.__req__['Path']), 0)
+        self.assertGreater(len(posix.__handles__), 0)
+        self.assertItemsEqual(posix.handled, entries)
     
     @patch("Bcfg2.Client.Tools.Tool.canVerify")
     def test_canVerify(self, mock_canVerify):
         entry = lxml.etree.Element("Path", name="test", type="file")
-        p = get_posix_object()
 
         # first, test superclass canVerify failure
         mock_canVerify.return_value = False
-        self.assertFalse(p.canVerify(entry))
-        mock_canVerify.assert_called_with(p, entry)
+        self.assertFalse(self.posix.canVerify(entry))
+        mock_canVerify.assert_called_with(self.posix, entry)
         
         # next, test fully_specified failure
-        p.logger.error.reset_mock()
+        self.posix.logger.error.reset_mock()
         mock_canVerify.reset_mock()
         mock_canVerify.return_value = True
         mock_fully_spec = Mock()
         mock_fully_spec.return_value = False
-        p._handlers[entry.get("type")].fully_specified = mock_fully_spec
-        self.assertFalse(p.canVerify(entry))
-        mock_canVerify.assert_called_with(p, entry)
+        self.posix._handlers[entry.get("type")].fully_specified = \
+            mock_fully_spec
+        self.assertFalse(self.posix.canVerify(entry))
+        mock_canVerify.assert_called_with(self.posix, entry)
         mock_fully_spec.assert_called_with(entry)
-        self.assertTrue(p.logger.error.called)
+        self.assertTrue(self.posix.logger.error.called)
         
         # finally, test success
-        p.logger.error.reset_mock()
+        self.posix.logger.error.reset_mock()
         mock_canVerify.reset_mock()
         mock_fully_spec.reset_mock()
         mock_fully_spec.return_value = True
-        self.assertTrue(p.canVerify(entry))
-        mock_canVerify.assert_called_with(p, entry)
+        self.assertTrue(self.posix.canVerify(entry))
+        mock_canVerify.assert_called_with(self.posix, entry)
         mock_fully_spec.assert_called_with(entry)
-        self.assertFalse(p.logger.error.called)
+        self.assertFalse(self.posix.logger.error.called)
 
     @patch("Bcfg2.Client.Tools.Tool.canInstall")
     def test_canInstall(self, mock_canInstall):
         entry = lxml.etree.Element("Path", name="test", type="file")
-        p = get_posix_object()
 
         # first, test superclass canInstall failure
         mock_canInstall.return_value = False
-        self.assertFalse(p.canInstall(entry))
-        mock_canInstall.assert_called_with(p, entry)
+        self.assertFalse(self.posix.canInstall(entry))
+        mock_canInstall.assert_called_with(self.posix, entry)
         
         # next, test fully_specified failure
-        p.logger.error.reset_mock()
+        self.posix.logger.error.reset_mock()
         mock_canInstall.reset_mock()
         mock_canInstall.return_value = True
         mock_fully_spec = Mock()
         mock_fully_spec.return_value = False
-        p._handlers[entry.get("type")].fully_specified = mock_fully_spec
-        self.assertFalse(p.canInstall(entry))
-        mock_canInstall.assert_called_with(p, entry)
+        self.posix._handlers[entry.get("type")].fully_specified = \
+            mock_fully_spec
+        self.assertFalse(self.posix.canInstall(entry))
+        mock_canInstall.assert_called_with(self.posix, entry)
         mock_fully_spec.assert_called_with(entry)
-        self.assertTrue(p.logger.error.called)
+        self.assertTrue(self.posix.logger.error.called)
         
         # finally, test success
-        p.logger.error.reset_mock()
+        self.posix.logger.error.reset_mock()
         mock_canInstall.reset_mock()
         mock_fully_spec.reset_mock()
         mock_fully_spec.return_value = True
-        self.assertTrue(p.canInstall(entry))
-        mock_canInstall.assert_called_with(p, entry)
+        self.assertTrue(self.posix.canInstall(entry))
+        mock_canInstall.assert_called_with(self.posix, entry)
         mock_fully_spec.assert_called_with(entry)
-        self.assertFalse(p.logger.error.called)
+        self.assertFalse(self.posix.logger.error.called)
 
     def test_InstallPath(self):
         entry = lxml.etree.Element("Path", name="test", type="file")
-        p = get_posix_object()
 
         mock_install = Mock()
         mock_install.return_value = True
-        p._handlers[entry.get("type")].install = mock_install
-        self.assertTrue(p.InstallPath(entry))
+        self.posix._handlers[entry.get("type")].install = mock_install
+        self.assertTrue(self.posix.InstallPath(entry))
         mock_install.assert_called_with(entry)
 
     def test_VerifyPath(self):
         entry = lxml.etree.Element("Path", name="test", type="file")
         modlist = []
-        p = get_posix_object()
 
         mock_verify = Mock()
         mock_verify.return_value = True
-        p._handlers[entry.get("type")].verify = mock_verify
-        self.assertTrue(p.VerifyPath(entry, modlist))
+        self.posix._handlers[entry.get("type")].verify = mock_verify
+        self.assertTrue(self.posix.VerifyPath(entry, modlist))
         mock_verify.assert_called_with(entry, modlist)
 
         mock_verify.reset_mock()
         mock_verify.return_value = False
-        p.setup.__getitem__.return_value = True
-        self.assertFalse(p.VerifyPath(entry, modlist))
+        self.posix.setup.__getitem__.return_value = True
+        self.assertFalse(self.posix.VerifyPath(entry, modlist))
         self.assertIsNotNone(entry.get('qtext'))
 
     @patch('os.remove')
@@ -147,7 +151,8 @@ class TestPOSIX(Bcfg2TestCase):
                 "_etc_test_2011-08-07T04:13:22.519978",
                 "_etc_foo_2012-08-07T04:13:22.519978",]
 
-        with patch('os.listdir') as mock_listdir:
+        @patch('os.listdir')
+        def inner(mock_listdir):
             mock_listdir.side_effect = OSError
             posix._prune_old_backups(entry)
             self.assertTrue(posix.logger.error.called)
@@ -178,9 +183,12 @@ class TestPOSIX(Bcfg2TestCase):
                                    for p in remove])
             self.assertTrue(posix.logger.error.called)
 
+        inner()
+
     @patch("shutil.copy")
+    @patch("os.path.isdir")
     @patch("Bcfg2.Client.Tools.POSIX.POSIX._prune_old_backups")
-    def test_paranoid_backup(self, mock_prune, mock_copy):
+    def test_paranoid_backup(self, mock_prune, mock_isdir, mock_copy):
         entry = lxml.etree.Element("Path", name="/etc/foo", type="file")
         setup = dict(ppath='/', max_copies=5, paranoid=False)
         posix = get_posix_object(setup=setup)
@@ -206,28 +214,26 @@ class TestPOSIX(Bcfg2TestCase):
         self.assertFalse(mock_prune.called)
         self.assertFalse(mock_copy.called)
 
-        with patch("os.path.isdir") as mock_isdir:
-            # entry is a directory on the filesystem
-            mock_prune.reset_mock()
-            entry.set("current_exists", "true")
-            mock_isdir.return_value = True
-            posix._paranoid_backup(entry)
-            self.assertFalse(mock_prune.called)
-            self.assertFalse(mock_copy.called)
-            mock_isdir.assert_called_with(entry.get("name"))
-
-            # test the actual backup now
-            mock_prune.reset_mock()
-            mock_isdir.return_value = False
-            posix._paranoid_backup(entry)
-            mock_isdir.assert_called_with(entry.get("name"))
-            mock_prune.assert_called_with(entry)
-            # it's basically impossible to test the shutil.copy() call
-            # exactly because the destination includes microseconds,
-            # so we just test it good enough
-            self.assertEqual(mock_copy.call_args[0][0],
-                             entry.get("name"))
-            bkupnam = os.path.join(setup['ppath'],
-                                   entry.get('name').replace('/', '_')) + '_'
-            self.assertEqual(bkupnam,
-                             mock_copy.call_args[0][1][:len(bkupnam)])
+        # entry is a directory on the filesystem
+        mock_prune.reset_mock()
+        entry.set("current_exists", "true")
+        mock_isdir.return_value = True
+        posix._paranoid_backup(entry)
+        self.assertFalse(mock_prune.called)
+        self.assertFalse(mock_copy.called)
+        mock_isdir.assert_called_with(entry.get("name"))
+
+        # test the actual backup now
+        mock_prune.reset_mock()
+        mock_isdir.return_value = False
+        posix._paranoid_backup(entry)
+        mock_isdir.assert_called_with(entry.get("name"))
+        mock_prune.assert_called_with(entry)
+        # it's basically impossible to test the shutil.copy() call
+        # exactly because the destination includes microseconds, so we
+        # just test it good enough
+        self.assertEqual(mock_copy.call_args[0][0],
+                         entry.get("name"))
+        bkupnam = os.path.join(setup['ppath'],
+                               entry.get('name').replace('/', '_')) + '_'
+        self.assertEqual(bkupnam, mock_copy.call_args[0][1][:len(bkupnam)])