From 556ac5660c22eb8316bff03cc3ccec5c82005b7c Mon Sep 17 00:00:00 2001 From: "Chris St. Pierre" Date: Tue, 21 Aug 2012 17:06:35 -0400 Subject: removed context managers from unit tests --- .../TestClient/TestTools/TestPOSIX/Test__init.py | 140 +++++++++++---------- 1 file changed, 73 insertions(+), 67 deletions(-) (limited to 'testsuite/Testlib/TestClient/TestTools/TestPOSIX/Test__init.py') 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)]) -- cgit v1.2.3-1-g7c22