diff options
Diffstat (limited to 'testsuite/Testlib/TestClient/TestTools')
9 files changed, 452 insertions, 469 deletions
diff --git a/testsuite/Testlib/TestClient/TestTools/TestPOSIX/TestDevice.py b/testsuite/Testlib/TestClient/TestTools/TestPOSIX/TestDevice.py index b737cfe1e..2a935fcbc 100644 --- a/testsuite/Testlib/TestClient/TestTools/TestPOSIX/TestDevice.py +++ b/testsuite/Testlib/TestClient/TestTools/TestPOSIX/TestDevice.py @@ -1,6 +1,5 @@ import os import copy -import unittest import lxml.etree from mock import Mock, MagicMock, patch from Bcfg2.Client.Tools.POSIX.Device import * diff --git a/testsuite/Testlib/TestClient/TestTools/TestPOSIX/TestDirectory.py b/testsuite/Testlib/TestClient/TestTools/TestPOSIX/TestDirectory.py index 79879afed..34d47d8d3 100644 --- a/testsuite/Testlib/TestClient/TestTools/TestPOSIX/TestDirectory.py +++ b/testsuite/Testlib/TestClient/TestTools/TestPOSIX/TestDirectory.py @@ -1,7 +1,6 @@ import os import stat import copy -import unittest import lxml.etree from mock import Mock, MagicMock, patch from Bcfg2.Client.Tools.POSIX.Directory import * @@ -12,81 +11,80 @@ from .....common import * class TestPOSIXDirectory(TestPOSIXTool): test_obj = POSIXDirectory + @patch("os.listdir") @patch("Bcfg2.Client.Tools.POSIX.base.POSIXTool.verify") @patch("Bcfg2.Client.Tools.POSIX.Directory.%s._exists" % test_obj.__name__) - def test_verify(self, mock_exists, mock_verify): + def test_verify(self, mock_exists, mock_verify, mock_listdir): entry = lxml.etree.Element("Path", name="/test", type="directory", perms='0644', owner='root', group='root') - ptool = self.get_obj() mock_exists.return_value = False - self.assertFalse(ptool.verify(entry, [])) + self.assertFalse(self.ptool.verify(entry, [])) mock_exists.assert_called_with(entry) mock_exists.reset_mock() exists_rv = MagicMock() exists_rv.__getitem__.return_value = stat.S_IFREG | 420 # 0o644 mock_exists.return_value = exists_rv - self.assertFalse(ptool.verify(entry, [])) + self.assertFalse(self.ptool.verify(entry, [])) mock_exists.assert_called_with(entry) mock_exists.reset_mock() mock_verify.return_value = False exists_rv.__getitem__.return_value = stat.S_IFDIR | 420 # 0o644 - self.assertFalse(ptool.verify(entry, [])) + self.assertFalse(self.ptool.verify(entry, [])) mock_exists.assert_called_with(entry) - mock_verify.assert_called_with(ptool, entry, []) + mock_verify.assert_called_with(self.ptool, entry, []) mock_exists.reset_mock() mock_verify.reset_mock() mock_verify.return_value = True - self.assertTrue(ptool.verify(entry, [])) + self.assertTrue(self.ptool.verify(entry, [])) mock_exists.assert_called_with(entry) - mock_verify.assert_called_with(ptool, entry, []) + mock_verify.assert_called_with(self.ptool, entry, []) - with patch("os.listdir") as mock_listdir: - mock_exists.reset_mock() - mock_verify.reset_mock() - entry.set("prune", "true") - orig_entry = copy.deepcopy(entry) + mock_exists.reset_mock() + mock_verify.reset_mock() + entry.set("prune", "true") + orig_entry = copy.deepcopy(entry) - entries = ["foo", "bar", "bar/baz"] - mock_listdir.return_value = entries - modlist = [os.path.join(entry.get("name"), entries[0])] - self.assertFalse(ptool.verify(entry, modlist)) - mock_exists.assert_called_with(entry) - mock_verify.assert_called_with(ptool, entry, modlist) - mock_listdir.assert_called_with(entry.get("name")) - expected = [os.path.join(entry.get("name"), e) - for e in entries - if os.path.join(entry.get("name"), e) not in modlist] - actual = [e.get("path") for e in entry.findall("Prune")] - self.assertItemsEqual(expected, actual) - - mock_verify.reset_mock() - mock_exists.reset_mock() - mock_listdir.reset_mock() - entry = copy.deepcopy(orig_entry) - modlist = [os.path.join(entry.get("name"), e) - for e in entries] - self.assertTrue(ptool.verify(entry, modlist)) - mock_exists.assert_called_with(entry) - mock_verify.assert_called_with(ptool, entry, modlist) - mock_listdir.assert_called_with(entry.get("name")) - self.assertEqual(len(entry.findall("Prune")), 0) + entries = ["foo", "bar", "bar/baz"] + mock_listdir.return_value = entries + modlist = [os.path.join(entry.get("name"), entries[0])] + self.assertFalse(self.ptool.verify(entry, modlist)) + mock_exists.assert_called_with(entry) + mock_verify.assert_called_with(self.ptool, entry, modlist) + mock_listdir.assert_called_with(entry.get("name")) + expected = [os.path.join(entry.get("name"), e) + for e in entries + if os.path.join(entry.get("name"), e) not in modlist] + actual = [e.get("path") for e in entry.findall("Prune")] + self.assertItemsEqual(expected, actual) + + mock_verify.reset_mock() + mock_exists.reset_mock() + mock_listdir.reset_mock() + entry = copy.deepcopy(orig_entry) + modlist = [os.path.join(entry.get("name"), e) + for e in entries] + self.assertTrue(self.ptool.verify(entry, modlist)) + mock_exists.assert_called_with(entry) + mock_verify.assert_called_with(self.ptool, entry, modlist) + mock_listdir.assert_called_with(entry.get("name")) + self.assertEqual(len(entry.findall("Prune")), 0) @patch("os.unlink") + @patch("os.path.isdir") @patch("shutil.rmtree") @patch("Bcfg2.Client.Tools.POSIX.base.POSIXTool.install") @patch("Bcfg2.Client.Tools.POSIX.Directory.%s._exists" % test_obj.__name__) @patch("Bcfg2.Client.Tools.POSIX.Directory.%s._makedirs" % test_obj.__name__) def test_install(self, mock_makedirs, mock_exists, mock_install, - mock_rmtree, mock_unlink): + mock_rmtree, mock_isdir, mock_unlink): entry = lxml.etree.Element("Path", name="/test/foo/bar", type="directory", perms='0644', owner='root', group='root') - ptool = self.get_obj() def reset(): mock_exists.reset_mock() @@ -98,32 +96,32 @@ class TestPOSIXDirectory(TestPOSIXTool): mock_makedirs.return_value = True mock_exists.return_value = False mock_install.return_value = True - self.assertTrue(ptool.install(entry)) + self.assertTrue(self.ptool.install(entry)) mock_exists.assert_called_with(entry) - mock_install.assert_called_with(ptool, entry) + mock_install.assert_called_with(self.ptool, entry) mock_makedirs.assert_called_with(entry) reset() exists_rv = MagicMock() exists_rv.__getitem__.return_value = stat.S_IFREG | 420 # 0o644 mock_exists.return_value = exists_rv - self.assertTrue(ptool.install(entry)) + self.assertTrue(self.ptool.install(entry)) mock_unlink.assert_called_with(entry.get("name")) mock_exists.assert_called_with(entry) mock_makedirs.assert_called_with(entry) - mock_install.assert_called_with(ptool, entry) + mock_install.assert_called_with(self.ptool, entry) reset() exists_rv.__getitem__.return_value = stat.S_IFDIR | 420 # 0o644 mock_install.return_value = True - self.assertTrue(ptool.install(entry)) + self.assertTrue(self.ptool.install(entry)) mock_exists.assert_called_with(entry) - mock_install.assert_called_with(ptool, entry) + mock_install.assert_called_with(self.ptool, entry) reset() mock_install.return_value = False - self.assertFalse(ptool.install(entry)) - mock_install.assert_called_with(ptool, entry) + self.assertFalse(self.ptool.install(entry)) + mock_install.assert_called_with(self.ptool, entry) entry.set("prune", "true") prune = ["/test/foo/bar/prune1", "/test/foo/bar/prune2"] @@ -132,17 +130,17 @@ class TestPOSIXDirectory(TestPOSIXTool): reset() mock_install.return_value = True - with patch("os.path.isdir") as mock_isdir: - def isdir_rv(path): - if path.endswith("prune2"): - return True - else: - return False - mock_isdir.side_effect = isdir_rv - self.assertTrue(ptool.install(entry)) - mock_exists.assert_called_with(entry) - mock_install.assert_called_with(ptool, entry) - self.assertItemsEqual(mock_isdir.call_args_list, - [call(p) for p in prune]) - mock_unlink.assert_called_with("/test/foo/bar/prune1") - mock_rmtree.assert_called_with("/test/foo/bar/prune2") + + def isdir_rv(path): + if path.endswith("prune2"): + return True + else: + return False + mock_isdir.side_effect = isdir_rv + self.assertTrue(self.ptool.install(entry)) + mock_exists.assert_called_with(entry) + mock_install.assert_called_with(self.ptool, entry) + self.assertItemsEqual(mock_isdir.call_args_list, + [call(p) for p in prune]) + mock_unlink.assert_called_with("/test/foo/bar/prune1") + mock_rmtree.assert_called_with("/test/foo/bar/prune2") diff --git a/testsuite/Testlib/TestClient/TestTools/TestPOSIX/TestFile.py b/testsuite/Testlib/TestClient/TestTools/TestPOSIX/TestFile.py index 084268959..51deeeb52 100644 --- a/testsuite/Testlib/TestClient/TestTools/TestPOSIX/TestFile.py +++ b/testsuite/Testlib/TestClient/TestTools/TestPOSIX/TestFile.py @@ -3,7 +3,6 @@ import os import copy import difflib import binascii -import unittest import lxml.etree from Bcfg2.Bcfg2Py3k import b64encode, b64decode from mock import Mock, MagicMock, patch @@ -22,30 +21,28 @@ class TestPOSIXFile(TestPOSIXTool): def test_fully_specified(self): entry = lxml.etree.Element("Path", name="/test", type="file") - ptool = self.get_obj() - self.assertFalse(ptool.fully_specified(entry)) + self.assertFalse(self.ptool.fully_specified(entry)) entry.set("empty", "true") - self.assertTrue(ptool.fully_specified(entry)) + self.assertTrue(self.ptool.fully_specified(entry)) entry.set("empty", "false") entry.text = "text" - self.assertTrue(ptool.fully_specified(entry)) + self.assertTrue(self.ptool.fully_specified(entry)) def test_is_string(self): - ptool = self.get_obj() for char in list(range(8)) + list(range(14, 32)): - self.assertFalse(ptool._is_string("foo" + chr(char) + "bar", + self.assertFalse(self.ptool._is_string("foo" + chr(char) + "bar", 'UTF-8')) for char in list(range(9, 14)) + list(range(33, 128)): - self.assertTrue(ptool._is_string("foo" + chr(char) + "bar", + self.assertTrue(self.ptool._is_string("foo" + chr(char) + "bar", 'UTF-8')) ustr = 'é' - self.assertTrue(ptool._is_string(ustr, 'UTF-8')) + self.assertTrue(self.ptool._is_string(ustr, 'UTF-8')) if not inPy3k: - self.assertFalse(ptool._is_string("foo" + chr(128) + "bar", + self.assertFalse(self.ptool._is_string("foo" + chr(128) + "bar", 'ascii')) - self.assertFalse(ptool._is_string(ustr, 'ascii')) + self.assertFalse(self.ptool._is_string(ustr, 'ascii')) def test_get_data(self): orig_entry = lxml.etree.Element("Path", name="/test", type="file") @@ -154,7 +151,6 @@ class TestPOSIXFile(TestPOSIXTool): def test_write_tmpfile(self, mock_get_data, mock_mkstemp, mock_fdopen): entry = lxml.etree.Element("Path", name="/test", type="file", perms='0644', owner='root', group='root') - ptool = self.get_obj() newfile = "/foo/bar" def reset(): @@ -164,7 +160,7 @@ class TestPOSIXFile(TestPOSIXTool): mock_get_data.return_value = ("test", False) mock_mkstemp.return_value = (5, newfile) - self.assertEqual(ptool._write_tmpfile(entry), newfile) + self.assertEqual(self.ptool._write_tmpfile(entry), newfile) mock_get_data.assert_called_with(entry) mock_mkstemp.assert_called_with(prefix='test', dir='/') mock_fdopen.assert_called_with(5, 'w') @@ -172,13 +168,13 @@ class TestPOSIXFile(TestPOSIXTool): reset() mock_mkstemp.side_effect = OSError - self.assertFalse(ptool._write_tmpfile(entry)) + self.assertFalse(self.ptool._write_tmpfile(entry)) mock_mkstemp.assert_called_with(prefix='test', dir='/') reset() mock_mkstemp.side_effect = None mock_fdopen.side_effect = OSError - self.assertFalse(ptool._write_tmpfile(entry)) + self.assertFalse(self.ptool._write_tmpfile(entry)) mock_mkstemp.assert_called_with(prefix='test', dir='/') mock_get_data.assert_called_with(entry) mock_fdopen.assert_called_with(5, 'w') @@ -188,16 +184,15 @@ class TestPOSIXFile(TestPOSIXTool): def test_rename_tmpfile(self, mock_unlink, mock_rename): entry = lxml.etree.Element("Path", name="/test", type="file", perms='0644', owner='root', group='root') - ptool = self.get_obj() newfile = "/foo/bar" - self.assertTrue(ptool._rename_tmpfile(newfile, entry)) + self.assertTrue(self.ptool._rename_tmpfile(newfile, entry)) mock_rename.assert_called_with(newfile, entry.get("name")) mock_rename.reset_mock() mock_unlink.reset_mock() mock_rename.side_effect = OSError - self.assertFalse(ptool._rename_tmpfile(newfile, entry)) + self.assertFalse(self.ptool._rename_tmpfile(newfile, entry)) mock_rename.assert_called_with(newfile, entry.get("name")) mock_unlink.assert_called_with(newfile) @@ -205,7 +200,7 @@ class TestPOSIXFile(TestPOSIXTool): mock_rename.reset_mock() mock_unlink.reset_mock() mock_unlink.side_effect = OSError - self.assertFalse(ptool._rename_tmpfile(newfile, entry)) + self.assertFalse(self.ptool._rename_tmpfile(newfile, entry)) mock_rename.assert_called_with(newfile, entry.get("name")) mock_unlink.assert_called_with(newfile) @@ -334,7 +329,6 @@ class TestPOSIXFile(TestPOSIXTool): mock_makedirs, mock_install, mock_exists): entry = lxml.etree.Element("Path", name="/test", type="file", perms='0644', owner='root', group='root') - ptool = self.get_obj() def reset(): mock_rename.reset_mock() @@ -346,14 +340,14 @@ class TestPOSIXFile(TestPOSIXTool): mock_exists.return_value = False mock_makedirs.return_value = False - self.assertFalse(ptool.install(entry)) + self.assertFalse(self.ptool.install(entry)) mock_exists.assert_called_with("/") mock_makedirs.assert_called_with(entry, path="/") reset() mock_makedirs.return_value = True mock_write.return_value = False - self.assertFalse(ptool.install(entry)) + self.assertFalse(self.ptool.install(entry)) mock_exists.assert_called_with("/") mock_makedirs.assert_called_with(entry, path="/") mock_write.assert_called_with(entry) @@ -363,7 +357,7 @@ class TestPOSIXFile(TestPOSIXTool): mock_write.return_value = newfile mock_set_perms.return_value = False mock_rename.return_value = False - self.assertFalse(ptool.install(entry)) + self.assertFalse(self.ptool.install(entry)) mock_exists.assert_called_with("/") mock_makedirs.assert_called_with(entry, path="/") mock_write.assert_called_with(entry) @@ -373,52 +367,51 @@ class TestPOSIXFile(TestPOSIXTool): reset() mock_rename.return_value = True mock_install.return_value = False - self.assertFalse(ptool.install(entry)) + self.assertFalse(self.ptool.install(entry)) mock_exists.assert_called_with("/") mock_makedirs.assert_called_with(entry, path="/") mock_write.assert_called_with(entry) mock_set_perms.assert_called_with(entry, path=newfile) mock_rename.assert_called_with(newfile, entry) - mock_install.assert_called_with(ptool, entry) + mock_install.assert_called_with(self.ptool, entry) reset() mock_install.return_value = True - self.assertFalse(ptool.install(entry)) + self.assertFalse(self.ptool.install(entry)) mock_exists.assert_called_with("/") mock_makedirs.assert_called_with(entry, path="/") mock_write.assert_called_with(entry) mock_set_perms.assert_called_with(entry, path=newfile) mock_rename.assert_called_with(newfile, entry) - mock_install.assert_called_with(ptool, entry) + mock_install.assert_called_with(self.ptool, entry) reset() mock_set_perms.return_value = True - self.assertTrue(ptool.install(entry)) + self.assertTrue(self.ptool.install(entry)) mock_exists.assert_called_with("/") mock_makedirs.assert_called_with(entry, path="/") mock_write.assert_called_with(entry) mock_set_perms.assert_called_with(entry, path=newfile) mock_rename.assert_called_with(newfile, entry) - mock_install.assert_called_with(ptool, entry) + mock_install.assert_called_with(self.ptool, entry) reset() mock_exists.return_value = True - self.assertTrue(ptool.install(entry)) + self.assertTrue(self.ptool.install(entry)) mock_exists.assert_called_with("/") self.assertFalse(mock_makedirs.called) mock_write.assert_called_with(entry) mock_set_perms.assert_called_with(entry, path=newfile) mock_rename.assert_called_with(newfile, entry) - mock_install.assert_called_with(ptool, entry) + mock_install.assert_called_with(self.ptool, entry) def test_diff(self): - ptool = self.get_obj() content1 = "line1\nline2" content2 = "line3" rv = ["line1", "line2", "line3"] func = Mock() func.return_value = rv - self.assertItemsEqual(ptool._diff(content1, content2, func), rv) + self.assertItemsEqual(self.ptool._diff(content1, content2, func), rv) func.assert_called_with(["line1", "line2"], ["line3"]) func.reset_mock() @@ -427,5 +420,5 @@ class TestPOSIXFile(TestPOSIXTool): time.sleep(5) yield "line%s" % i func.side_effect = slow_diff - self.assertFalse(ptool._diff(content1, content2, func), rv) + self.assertFalse(self.ptool._diff(content1, content2, func), rv) func.assert_called_with(["line1", "line2"], ["line3"]) diff --git a/testsuite/Testlib/TestClient/TestTools/TestPOSIX/TestHardlink.py b/testsuite/Testlib/TestClient/TestTools/TestPOSIX/TestHardlink.py index 221da9ea5..ae48bf04e 100644 --- a/testsuite/Testlib/TestClient/TestTools/TestPOSIX/TestHardlink.py +++ b/testsuite/Testlib/TestClient/TestTools/TestPOSIX/TestHardlink.py @@ -1,6 +1,5 @@ import os import copy -import unittest import lxml.etree from mock import Mock, MagicMock, patch from Bcfg2.Client.Tools.POSIX.Hardlink import * diff --git a/testsuite/Testlib/TestClient/TestTools/TestPOSIX/TestNonexistent.py b/testsuite/Testlib/TestClient/TestTools/TestPOSIX/TestNonexistent.py index 2b46bd9e6..fbd9a11ad 100644 --- a/testsuite/Testlib/TestClient/TestTools/TestPOSIX/TestNonexistent.py +++ b/testsuite/Testlib/TestClient/TestTools/TestPOSIX/TestNonexistent.py @@ -1,6 +1,5 @@ import os import copy -import unittest import lxml.etree from mock import Mock, MagicMock, patch from Bcfg2.Client.Tools.POSIX.Nonexistent import * @@ -14,68 +13,66 @@ class TestPOSIXNonexistent(TestPOSIXTool): @patch("os.path.lexists") def test_verify(self, mock_lexists): entry = lxml.etree.Element("Path", name="/test", type="nonexistent") - ptool = self.get_obj() for val in [True, False]: mock_lexists.reset_mock() mock_lexists.return_value = val - self.assertEqual(ptool.verify(entry, []), not val) + self.assertEqual(self.ptool.verify(entry, []), not val) mock_lexists.assert_called_with(entry.get("name")) @patch("os.rmdir") @patch("os.remove") + @patch("os.path.isdir") @patch("shutil.rmtree") - def test_install(self, mock_rmtree, mock_remove, mock_rmdir): + def test_install(self, mock_rmtree, mock_isdir, mock_remove, mock_rmdir): entry = lxml.etree.Element("Path", name="/test", type="nonexistent") - ptool = self.get_obj() - with patch("os.path.isdir") as mock_isdir: - def reset(): - mock_isdir.reset_mock() - mock_remove.reset_mock() - mock_rmdir.reset_mock() - mock_rmtree.reset_mock() + def reset(): + mock_isdir.reset_mock() + mock_remove.reset_mock() + mock_rmdir.reset_mock() + mock_rmtree.reset_mock() - mock_isdir.return_value = False - self.assertTrue(ptool.install(entry)) - mock_remove.assert_called_with(entry.get("name")) + mock_isdir.return_value = False + self.assertTrue(self.ptool.install(entry)) + mock_remove.assert_called_with(entry.get("name")) - reset() - mock_remove.side_effect = OSError - self.assertFalse(ptool.install(entry)) - mock_remove.assert_called_with(entry.get("name")) + reset() + mock_remove.side_effect = OSError + self.assertFalse(self.ptool.install(entry)) + mock_remove.assert_called_with(entry.get("name")) - reset() - mock_isdir.return_value = True - self.assertTrue(ptool.install(entry)) - mock_rmdir.assert_called_with(entry.get("name")) + reset() + mock_isdir.return_value = True + self.assertTrue(self.ptool.install(entry)) + mock_rmdir.assert_called_with(entry.get("name")) - reset() - mock_rmdir.side_effect = OSError - self.assertFalse(ptool.install(entry)) - mock_rmdir.assert_called_with(entry.get("name")) - - reset() - entry.set("recursive", "true") - self.assertTrue(ptool.install(entry)) - mock_rmtree.assert_called_with(entry.get("name")) + reset() + mock_rmdir.side_effect = OSError + self.assertFalse(self.ptool.install(entry)) + mock_rmdir.assert_called_with(entry.get("name")) - reset() - mock_rmtree.side_effect = OSError - self.assertFalse(ptool.install(entry)) - mock_rmtree.assert_called_with(entry.get("name")) - - reset() - child_entry = lxml.etree.Element("Path", name="/test/foo", - type="nonexistent") - ptool = self.get_obj(posix=get_posix_object(config=get_config([child_entry]))) - mock_rmtree.side_effect = None - self.assertTrue(ptool.install(entry)) - mock_rmtree.assert_called_with(entry.get("name")) + reset() + entry.set("recursive", "true") + self.assertTrue(self.ptool.install(entry)) + mock_rmtree.assert_called_with(entry.get("name")) - reset() - child_entry = lxml.etree.Element("Path", name="/test/foo", - type="file") - ptool = self.get_obj(posix=get_posix_object(config=get_config([child_entry]))) - mock_rmtree.side_effect = None - self.assertFalse(ptool.install(entry)) + reset() + mock_rmtree.side_effect = OSError + self.assertFalse(self.ptool.install(entry)) + mock_rmtree.assert_called_with(entry.get("name")) + + reset() + child_entry = lxml.etree.Element("Path", name="/test/foo", + type="nonexistent") + ptool = self.get_obj(posix=get_posix_object(config=get_config([child_entry]))) + mock_rmtree.side_effect = None + self.assertTrue(ptool.install(entry)) + mock_rmtree.assert_called_with(entry.get("name")) + + reset() + child_entry = lxml.etree.Element("Path", name="/test/foo", + type="file") + ptool = self.get_obj(posix=get_posix_object(config=get_config([child_entry]))) + mock_rmtree.side_effect = None + self.assertFalse(ptool.install(entry)) diff --git a/testsuite/Testlib/TestClient/TestTools/TestPOSIX/TestPermissions.py b/testsuite/Testlib/TestClient/TestTools/TestPOSIX/TestPermissions.py index 008f0c839..a9b71ec2c 100644 --- a/testsuite/Testlib/TestClient/TestTools/TestPOSIX/TestPermissions.py +++ b/testsuite/Testlib/TestClient/TestTools/TestPOSIX/TestPermissions.py @@ -1,11 +1,5 @@ -import os -import unittest -import lxml.etree -from mock import Mock, MagicMock, patch from Bcfg2.Client.Tools.POSIX.Permissions import * -from .Test__init import get_posix_object from .Testbase import TestPOSIXTool -from .....common import * class TestPOSIXPermissions(TestPOSIXTool): test_obj = POSIXPermissions diff --git a/testsuite/Testlib/TestClient/TestTools/TestPOSIX/TestSymlink.py b/testsuite/Testlib/TestClient/TestTools/TestPOSIX/TestSymlink.py index 7ce8a4437..2cd10f243 100644 --- a/testsuite/Testlib/TestClient/TestTools/TestPOSIX/TestSymlink.py +++ b/testsuite/Testlib/TestClient/TestTools/TestPOSIX/TestSymlink.py @@ -1,6 +1,5 @@ import os import copy -import unittest import lxml.etree from mock import Mock, MagicMock, patch from Bcfg2.Client.Tools.POSIX.Symlink import * 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)]) diff --git a/testsuite/Testlib/TestClient/TestTools/TestPOSIX/Testbase.py b/testsuite/Testlib/TestClient/TestTools/TestPOSIX/Testbase.py index e8e5dbe23..e7772d508 100644 --- a/testsuite/Testlib/TestClient/TestTools/TestPOSIX/Testbase.py +++ b/testsuite/Testlib/TestClient/TestTools/TestPOSIX/Testbase.py @@ -1,7 +1,6 @@ import os import copy import stat -import unittest import lxml.etree from mock import Mock, MagicMock, patch import Bcfg2.Client.Tools @@ -29,137 +28,140 @@ class TestPOSIXTool(Bcfg2TestCase): posix = get_posix_object() return self.test_obj(posix.logger, posix.setup, posix.config) + def setUp(self): + self.ptool = self.get_obj() + + def tearDown(self): + # just to guarantee that we start fresh each time + self.ptool = None + def test_fully_specified(self): # fully_specified should do no checking on the abstract # POSIXTool object - ptool = self.get_obj() - self.assertTrue(ptool.fully_specified(Mock())) + self.assertTrue(self.ptool.fully_specified(Mock())) + @patch('os.stat') + @patch('os.walk') @patch("Bcfg2.Client.Tools.POSIX.base.%s._verify_metadata" % test_obj.__name__) - def test_verify(self, mock_verify): + def test_verify(self, mock_verify, mock_walk, mock_stat): entry = lxml.etree.Element("Path", name="/test", type="file") - ptool = self.get_obj() - with patch('os.stat') as mock_stat, patch('os.walk') as mock_walk: - mock_stat.return_value = MagicMock() - - mock_verify.return_value = False - self.assertFalse(ptool.verify(entry, [])) - mock_verify.assert_called_with(entry) - - mock_verify.reset_mock() - mock_verify.return_value = True - self.assertTrue(ptool.verify(entry, [])) - mock_verify.assert_called_with(entry) - - mock_verify.reset_mock() - entry.set("recursive", "true") - walk_rv = [("/", ["dir1", "dir2"], ["file1", "file2"]), - ("/dir1", ["dir3"], []), - ("/dir2", [], ["file3", "file4"])] - mock_walk.return_value = walk_rv - self.assertTrue(ptool.verify(entry, [])) - mock_walk.assert_called_with(entry.get("name")) - all_verifies = [call(entry)] - for root, dirs, files in walk_rv: - all_verifies.extend([call(entry, path=os.path.join(root, p)) - for p in dirs + files]) - self.assertItemsEqual(mock_verify.call_args_list, all_verifies) - + + mock_stat.return_value = MagicMock() + mock_verify.return_value = False + self.assertFalse(self.ptool.verify(entry, [])) + mock_verify.assert_called_with(entry) + + mock_verify.reset_mock() + mock_verify.return_value = True + self.assertTrue(self.ptool.verify(entry, [])) + mock_verify.assert_called_with(entry) + + mock_verify.reset_mock() + entry.set("recursive", "true") + walk_rv = [("/", ["dir1", "dir2"], ["file1", "file2"]), + ("/dir1", ["dir3"], []), + ("/dir2", [], ["file3", "file4"])] + mock_walk.return_value = walk_rv + self.assertTrue(self.ptool.verify(entry, [])) + mock_walk.assert_called_with(entry.get("name")) + all_verifies = [call(entry)] + for root, dirs, files in walk_rv: + all_verifies.extend([call(entry, path=os.path.join(root, p)) + for p in dirs + files]) + self.assertItemsEqual(mock_verify.call_args_list, all_verifies) + + @patch('os.walk') @patch("Bcfg2.Client.Tools.POSIX.base.%s._set_perms" % test_obj.__name__) - def test_install(self, mock_set_perms): + def test_install(self, mock_set_perms, mock_walk): entry = lxml.etree.Element("Path", name="/test", type="file") - ptool = self.get_obj() mock_set_perms.return_value = True - self.assertTrue(ptool.install(entry)) + self.assertTrue(self.ptool.install(entry)) mock_set_perms.assert_called_with(entry) mock_set_perms.reset_mock() entry.set("recursive", "true") - with patch('os.walk') as mock_walk: - walk_rv = [("/", ["dir1", "dir2"], ["file1", "file2"]), - ("/dir1", ["dir3"], []), - ("/dir2", [], ["file3", "file4"])] - mock_walk.return_value = walk_rv - - mock_set_perms.return_value = True - self.assertTrue(ptool.install(entry)) - mock_walk.assert_called_with(entry.get("name")) - all_set_perms = [call(entry)] - for root, dirs, files in walk_rv: - all_set_perms.extend([call(entry, - path=os.path.join(root, p)) - for p in dirs + files]) - self.assertItemsEqual(mock_set_perms.call_args_list, - all_set_perms) - - mock_walk.reset_mock() - mock_set_perms.reset_mock() + walk_rv = [("/", ["dir1", "dir2"], ["file1", "file2"]), + ("/dir1", ["dir3"], []), + ("/dir2", [], ["file3", "file4"])] + mock_walk.return_value = walk_rv - def set_perms_rv(entry, path=None): - if path == '/dir2/file3': - return False - else: - return True - mock_set_perms.side_effect = set_perms_rv - - self.assertFalse(ptool.install(entry)) - mock_walk.assert_called_with(entry.get("name")) - self.assertItemsEqual(mock_set_perms.call_args_list, - all_set_perms) + mock_set_perms.return_value = True + self.assertTrue(self.ptool.install(entry)) + mock_walk.assert_called_with(entry.get("name")) + all_set_perms = [call(entry)] + for root, dirs, files in walk_rv: + all_set_perms.extend([call(entry, path=os.path.join(root, p)) + for p in dirs + files]) + self.assertItemsEqual(mock_set_perms.call_args_list, + all_set_perms) + + mock_walk.reset_mock() + mock_set_perms.reset_mock() + + def set_perms_rv(entry, path=None): + if path == '/dir2/file3': + return False + else: + return True + mock_set_perms.side_effect = set_perms_rv + + self.assertFalse(self.ptool.install(entry)) + mock_walk.assert_called_with(entry.get("name")) + self.assertItemsEqual(mock_set_perms.call_args_list, all_set_perms) + @patch('os.lstat') @patch("os.unlink") + @patch("os.path.isdir") @patch("shutil.rmtree") - def test_exists(self, mock_rmtree, mock_unlink): + def test_exists(self, mock_rmtree, mock_isdir, mock_unlink, mock_lstat): entry = lxml.etree.Element("Path", name="/etc/foo", type="file") - ptool = self.get_obj() - with patch('os.lstat') as mock_lstat, \ - patch("os.path.isdir") as mock_isdir: - mock_lstat.side_effect = OSError - self.assertFalse(ptool._exists(entry)) - mock_lstat.assert_called_with(entry.get('name')) - self.assertFalse(mock_unlink.called) - - mock_lstat.reset_mock() - mock_unlink.reset_mock() - rv = MagicMock() - mock_lstat.return_value = rv - mock_lstat.side_effect = None - self.assertEqual(ptool._exists(entry), rv) - mock_lstat.assert_called_with(entry.get('name')) - self.assertFalse(mock_unlink.called) - - mock_lstat.reset_mock() - mock_unlink.reset_mock() - mock_isdir.return_value = False - self.assertFalse(ptool._exists(entry, remove=True)) - mock_isdir.assert_called_with(entry.get('name')) - mock_lstat.assert_called_with(entry.get('name')) - mock_unlink.assert_called_with(entry.get('name')) - self.assertFalse(mock_rmtree.called) - - mock_lstat.reset_mock() - mock_isdir.reset_mock() - mock_unlink.reset_mock() - mock_rmtree.reset_mock() - mock_isdir.return_value = True - self.assertFalse(ptool._exists(entry, remove=True)) - mock_isdir.assert_called_with(entry.get('name')) - mock_lstat.assert_called_with(entry.get('name')) - mock_rmtree.assert_called_with(entry.get('name')) - self.assertFalse(mock_unlink.called) - - mock_isdir.reset_mock() - mock_lstat.reset_mock() - mock_unlink.reset_mock() - mock_rmtree.reset_mock() - mock_rmtree.side_effect = OSError - self.assertEqual(ptool._exists(entry, remove=True), rv) - mock_isdir.assert_called_with(entry.get('name')) - mock_lstat.assert_called_with(entry.get('name')) - mock_rmtree.assert_called_with(entry.get('name')) - self.assertFalse(mock_unlink.called) + + mock_lstat.side_effect = OSError + self.assertFalse(self.ptool._exists(entry)) + mock_lstat.assert_called_with(entry.get('name')) + self.assertFalse(mock_unlink.called) + + mock_lstat.reset_mock() + mock_unlink.reset_mock() + rv = MagicMock() + mock_lstat.return_value = rv + mock_lstat.side_effect = None + self.assertEqual(self.ptool._exists(entry), rv) + mock_lstat.assert_called_with(entry.get('name')) + self.assertFalse(mock_unlink.called) + + mock_lstat.reset_mock() + mock_unlink.reset_mock() + mock_isdir.return_value = False + self.assertFalse(self.ptool._exists(entry, remove=True)) + mock_isdir.assert_called_with(entry.get('name')) + mock_lstat.assert_called_with(entry.get('name')) + mock_unlink.assert_called_with(entry.get('name')) + self.assertFalse(mock_rmtree.called) + + mock_lstat.reset_mock() + mock_isdir.reset_mock() + mock_unlink.reset_mock() + mock_rmtree.reset_mock() + mock_isdir.return_value = True + self.assertFalse(self.ptool._exists(entry, remove=True)) + mock_isdir.assert_called_with(entry.get('name')) + mock_lstat.assert_called_with(entry.get('name')) + mock_rmtree.assert_called_with(entry.get('name')) + self.assertFalse(mock_unlink.called) + + mock_isdir.reset_mock() + mock_lstat.reset_mock() + mock_unlink.reset_mock() + mock_rmtree.reset_mock() + mock_rmtree.side_effect = OSError + self.assertEqual(self.ptool._exists(entry, remove=True), rv) + mock_isdir.assert_called_with(entry.get('name')) + mock_lstat.assert_called_with(entry.get('name')) + mock_rmtree.assert_called_with(entry.get('name')) + self.assertFalse(mock_unlink.called) @patch("os.chown") @patch("os.chmod") @@ -173,8 +175,6 @@ class TestPOSIXTool(Bcfg2TestCase): test_obj.__name__) def test_set_perms(self, mock_set_secontext, mock_set_acls, mock_norm_gid, mock_norm_uid, mock_utime, mock_chmod, mock_chown): - ptool = self.get_obj() - def reset(): mock_set_secontext.reset_mock() mock_set_acls.reset_mock() @@ -188,7 +188,7 @@ class TestPOSIXTool(Bcfg2TestCase): type="symlink") mock_set_acls.return_value = True mock_set_secontext.return_value = True - self.assertTrue(ptool._set_perms(entry)) + self.assertTrue(self.ptool._set_perms(entry)) mock_set_secontext.assert_called_with(entry, path=entry.get("name")) mock_set_acls.assert_called_with(entry, path=entry.get("name")) @@ -198,7 +198,7 @@ class TestPOSIXTool(Bcfg2TestCase): mock_norm_gid.return_value = 100 reset() - self.assertTrue(ptool._set_perms(entry)) + self.assertTrue(self.ptool._set_perms(entry)) mock_norm_uid.assert_called_with(entry) mock_norm_gid.assert_called_with(entry) mock_chown.assert_called_with(entry.get("name"), 10, 100) @@ -211,7 +211,7 @@ class TestPOSIXTool(Bcfg2TestCase): reset() mtime = 1344459042 entry.set("mtime", str(mtime)) - self.assertTrue(ptool._set_perms(entry)) + self.assertTrue(self.ptool._set_perms(entry)) mock_norm_uid.assert_called_with(entry) mock_norm_gid.assert_called_with(entry) mock_chown.assert_called_with(entry.get("name"), 10, 100) @@ -222,7 +222,7 @@ class TestPOSIXTool(Bcfg2TestCase): mock_set_acls.assert_called_with(entry, path=entry.get("name")) reset() - self.assertTrue(ptool._set_perms(entry, path='/etc/bar')) + self.assertTrue(self.ptool._set_perms(entry, path='/etc/bar')) mock_norm_uid.assert_called_with(entry) mock_norm_gid.assert_called_with(entry) mock_chown.assert_called_with('/etc/bar', 10, 100) @@ -241,7 +241,7 @@ class TestPOSIXTool(Bcfg2TestCase): os.chown.side_effect = chown_rv entry.set("type", "device") entry.set("dev_type", list(device_map.keys())[0]) - self.assertFalse(ptool._set_perms(entry)) + self.assertFalse(self.ptool._set_perms(entry)) mock_norm_uid.assert_called_with(entry) mock_norm_gid.assert_called_with(entry) mock_chown.assert_called_with(entry.get("name"), 0, 0) @@ -257,7 +257,7 @@ class TestPOSIXTool(Bcfg2TestCase): os.chmod.side_effect = OSError entry.set("type", "file") del entry.attrib["dev_type"] - self.assertFalse(ptool._set_perms(entry)) + self.assertFalse(self.ptool._set_perms(entry)) mock_norm_uid.assert_called_with(entry) mock_norm_gid.assert_called_with(entry) mock_chown.assert_called_with(entry.get("name"), 10, 100) @@ -275,7 +275,7 @@ class TestPOSIXTool(Bcfg2TestCase): os.utime.side_effect = OSError mock_set_acls.return_value = False mock_set_secontext.return_value = False - self.assertFalse(ptool._set_perms(entry)) + self.assertFalse(self.ptool._set_perms(entry)) mock_norm_uid.assert_called_with(entry) mock_norm_gid.assert_called_with(entry) mock_chown.assert_called_with(entry.get("name"), 10, 100) @@ -286,17 +286,18 @@ class TestPOSIXTool(Bcfg2TestCase): mock_set_acls.assert_called_with(entry, path=entry.get("name")) @skipUnless(has_acls, "ACLS not found, skipping") + @patch("os.path.isdir") @patch("Bcfg2.Client.Tools.POSIX.base.%s._norm_uid" % test_obj.__name__) @patch("Bcfg2.Client.Tools.POSIX.base.%s._norm_gid" % test_obj.__name__) @patch("Bcfg2.Client.Tools.POSIX.base.%s._list_entry_acls" % test_obj.__name__) - def test_set_acls(self, mock_list_entry_acls, mock_norm_gid, mock_norm_uid): + def test_set_acls(self, mock_list_entry_acls, mock_norm_gid, mock_norm_uid, + mock_isdir): entry = lxml.etree.Element("Path", name="/etc/foo", type="file") - ptool = self.get_obj() # disable acls for the initial test Bcfg2.Client.Tools.POSIX.base.has_acls = False - self.assertTrue(ptool._set_acls(entry)) + self.assertTrue(self.ptool._set_acls(entry)) Bcfg2.Client.Tools.POSIX.base.has_acls = True # build a set of file ACLs to return from posix1e.ACL(file=...) @@ -323,9 +324,9 @@ class TestPOSIXTool(Bcfg2TestCase): mock_norm_uid.return_value = 10 mock_norm_gid.return_value = 100 - with patch("posix1e.ACL") as mock_ACL, \ - patch("posix1e.Entry") as mock_Entry, \ - patch("os.path.isdir") as mock_isdir: + @patch("posix1e.ACL") + @patch("posix1e.Entry") + def inner(mock_Entry, mock_ACL): # set up the unreasonably complex return value for # posix1e.ACL(), which has three separate uses fileacl_rv = MagicMock() @@ -364,17 +365,17 @@ class TestPOSIXTool(Bcfg2TestCase): # test fs mounted noacl mock_ACL.side_effect = IOError(95, "Operation not permitted") - self.assertFalse(ptool._set_acls(entry)) + self.assertFalse(self.ptool._set_acls(entry)) # test other error reset() mock_ACL.side_effect = IOError - self.assertFalse(ptool._set_acls(entry)) + self.assertFalse(self.ptool._set_acls(entry)) reset() mock_ACL.side_effect = mock_acl_rv mock_isdir.return_value = True - self.assertTrue(ptool._set_acls(entry)) + self.assertTrue(self.ptool._set_acls(entry)) self.assertItemsEqual(mock_ACL.call_args_list, [call(file=entry.get("name")), call(filedef=entry.get("name"))]) @@ -412,7 +413,7 @@ class TestPOSIXTool(Bcfg2TestCase): mock_norm_gid.reset_mock() mock_isdir.return_value = False acl_entries = [] - self.assertTrue(ptool._set_acls(entry, path="/bin/bar")) + self.assertTrue(self.ptool._set_acls(entry, path="/bin/bar")) mock_ACL.assert_called_with(file="/bin/bar") self.assertItemsEqual(fileacl_rv.delete_entry.call_args_list, [call(a) for a in remove_acls]) @@ -429,27 +430,29 @@ class TestPOSIXTool(Bcfg2TestCase): self.assertItemsEqual(added_acls, [(fileacl_rv, posix1e.ACL_GROUP, 100, 5)]) + inner() + @skipUnless(has_selinux, "SELinux not found, skipping") def test_set_secontext(self): entry = lxml.etree.Element("Path", name="/etc/foo", type="file") - ptool = self.get_obj() # disable selinux for the initial test Bcfg2.Client.Tools.POSIX.base.has_selinux = False - self.assertTrue(ptool._set_secontext(entry)) + self.assertTrue(self.ptool._set_secontext(entry)) Bcfg2.Client.Tools.POSIX.base.has_selinux = True - with patch("selinux.restorecon") as mock_restorecon, \ - patch("selinux.lsetfilecon") as mock_lsetfilecon: + @patch("selinux.restorecon") + @patch("selinux.lsetfilecon") + def inner(mock_lsetfilecon, mock_restorecon): # no context given - self.assertTrue(ptool._set_secontext(entry)) + self.assertTrue(self.ptool._set_secontext(entry)) self.assertFalse(mock_restorecon.called) self.assertFalse(mock_lsetfilecon.called) mock_restorecon.reset_mock() mock_lsetfilecon.reset_mock() entry.set("secontext", "__default__") - self.assertTrue(ptool._set_secontext(entry)) + self.assertTrue(self.ptool._set_secontext(entry)) mock_restorecon.assert_called_with(entry.get("name")) self.assertFalse(mock_lsetfilecon.called) @@ -457,159 +460,152 @@ class TestPOSIXTool(Bcfg2TestCase): mock_lsetfilecon.reset_mock() mock_lsetfilecon.return_value = 0 entry.set("secontext", "foo_t") - self.assertTrue(ptool._set_secontext(entry)) + self.assertTrue(self.ptool._set_secontext(entry)) self.assertFalse(mock_restorecon.called) mock_lsetfilecon.assert_called_with(entry.get("name"), "foo_t") mock_restorecon.reset_mock() mock_lsetfilecon.reset_mock() mock_lsetfilecon.return_value = 1 - self.assertFalse(ptool._set_secontext(entry)) + self.assertFalse(self.ptool._set_secontext(entry)) self.assertFalse(mock_restorecon.called) mock_lsetfilecon.assert_called_with(entry.get("name"), "foo_t") + inner() + @patch("grp.getgrnam") def test_norm_gid(self, mock_getgrnam): - ptool = self.get_obj() - self.assertEqual(5, ptool._norm_gid("5")) + self.assertEqual(5, self.ptool._norm_gid("5")) self.assertFalse(mock_getgrnam.called) mock_getgrnam.reset_mock() mock_getgrnam.return_value = ("group", "x", 5, []) - self.assertEqual(5, ptool._norm_gid("group")) + self.assertEqual(5, self.ptool._norm_gid("group")) mock_getgrnam.assert_called_with("group") @patch("Bcfg2.Client.Tools.POSIX.base.%s._norm_gid" % test_obj.__name__) def test_norm_entry_gid(self, mock_norm_gid): entry = lxml.etree.Element("Path", name="/test", type="file", group="group", owner="user") - ptool = self.get_obj() mock_norm_gid.return_value = 10 - self.assertEqual(10, ptool._norm_entry_gid(entry)) + self.assertEqual(10, self.ptool._norm_entry_gid(entry)) mock_norm_gid.assert_called_with(entry.get("group")) mock_norm_gid.reset_mock() mock_norm_gid.side_effect = KeyError - self.assertEqual(0, ptool._norm_entry_gid(entry)) + self.assertEqual(0, self.ptool._norm_entry_gid(entry)) mock_norm_gid.assert_called_with(entry.get("group")) @patch("pwd.getpwnam") def test_norm_uid(self, mock_getpwnam): - ptool = self.get_obj() - self.assertEqual(5, ptool._norm_uid("5")) + self.assertEqual(5, self.ptool._norm_uid("5")) self.assertFalse(mock_getpwnam.called) mock_getpwnam.reset_mock() mock_getpwnam.return_value = ("user", "x", 5, 5, "User", "/home/user", "/bin/zsh") - self.assertEqual(5, ptool._norm_uid("user")) + self.assertEqual(5, self.ptool._norm_uid("user")) mock_getpwnam.assert_called_with("user") @patch("Bcfg2.Client.Tools.POSIX.base.%s._norm_uid" % test_obj.__name__) def test_norm_entry_uid(self, mock_norm_uid): entry = lxml.etree.Element("Path", name="/test", type="file", group="group", owner="user") - ptool = self.get_obj() mock_norm_uid.return_value = 10 - self.assertEqual(10, ptool._norm_entry_uid(entry)) + self.assertEqual(10, self.ptool._norm_entry_uid(entry)) mock_norm_uid.assert_called_with(entry.get("owner")) mock_norm_uid.reset_mock() mock_norm_uid.side_effect = KeyError - self.assertEqual(0, ptool._norm_entry_uid(entry)) + self.assertEqual(0, self.ptool._norm_entry_uid(entry)) mock_norm_uid.assert_called_with(entry.get("owner")) def test_norm_acl_perms(self): - ptool = self.get_obj() # there's basically no reasonably way to test the Permset # object parsing feature without writing our own Mock object # that re-implements Permset.test(). silly pylibacl won't let # us create standalone Entry or Permset objects. - ptool = self.get_obj() - self.assertEqual(5, ptool._norm_acl_perms("5")) - self.assertEqual(0, ptool._norm_acl_perms("55")) - self.assertEqual(5, ptool._norm_acl_perms("rx")) - self.assertEqual(5, ptool._norm_acl_perms("r-x")) - self.assertEqual(6, ptool._norm_acl_perms("wr-")) - self.assertEqual(0, ptool._norm_acl_perms("rwrw")) - self.assertEqual(0, ptool._norm_acl_perms("-")) - self.assertEqual(0, ptool._norm_acl_perms("a")) - self.assertEqual(6, ptool._norm_acl_perms("rwa")) - self.assertEqual(4, ptool._norm_acl_perms("rr")) - - def test__gather_data(self): + self.assertEqual(5, self.ptool._norm_acl_perms("5")) + self.assertEqual(0, self.ptool._norm_acl_perms("55")) + self.assertEqual(5, self.ptool._norm_acl_perms("rx")) + self.assertEqual(5, self.ptool._norm_acl_perms("r-x")) + self.assertEqual(6, self.ptool._norm_acl_perms("wr-")) + self.assertEqual(0, self.ptool._norm_acl_perms("rwrw")) + self.assertEqual(0, self.ptool._norm_acl_perms("-")) + self.assertEqual(0, self.ptool._norm_acl_perms("a")) + self.assertEqual(6, self.ptool._norm_acl_perms("rwa")) + self.assertEqual(4, self.ptool._norm_acl_perms("rr")) + + @patch('os.stat') + def test__gather_data(self, mock_stat): path = '/test' - ptool = self.get_obj() - - # have to use context manager version of patch here because - # os.stat must be unpatched when we instantiate the object to - # make pkgutil.walk_packages() work - with patch('os.stat') as mock_stat: - mock_stat.side_effect = OSError - self.assertFalse(ptool._gather_data(path)[0]) - mock_stat.assert_called_with(path) - - mock_stat.reset_mock() - mock_stat.side_effect = None - # create a return value - stat_rv = MagicMock() - def stat_getitem(key): - if int(key) == stat.ST_UID: - return 0 - elif int(key) == stat.ST_GID: - return 10 - elif int(key) == stat.ST_MODE: - # return extra bits in the mode to emulate a device - # and ensure that they're stripped - return int('060660', 8) - stat_rv.__getitem__ = Mock(side_effect=stat_getitem) - mock_stat.return_value = stat_rv - - # disable selinux and acls for this call -- we test them - # separately so that we can skip those tests as appropriate - states = (Bcfg2.Client.Tools.POSIX.base.has_selinux, - Bcfg2.Client.Tools.POSIX.base.has_acls) - Bcfg2.Client.Tools.POSIX.base.has_selinux = False - Bcfg2.Client.Tools.POSIX.base.has_acls = False - self.assertEqual(ptool._gather_data(path), - (stat_rv, '0', '10', '0660', None, None)) - Bcfg2.Client.Tools.POSIX.base.has_selinux, \ - Bcfg2.Client.Tools.POSIX.base.has_acls = states - mock_stat.assert_called_with(path) + mock_stat.side_effect = OSError + self.assertFalse(self.ptool._gather_data(path)[0]) + mock_stat.assert_called_with(path) + + mock_stat.reset_mock() + mock_stat.side_effect = None + # create a return value + stat_rv = MagicMock() + def stat_getitem(key): + if int(key) == stat.ST_UID: + return 0 + elif int(key) == stat.ST_GID: + return 10 + elif int(key) == stat.ST_MODE: + # return extra bits in the mode to emulate a device + # and ensure that they're stripped + return int('060660', 8) + stat_rv.__getitem__ = Mock(side_effect=stat_getitem) + mock_stat.return_value = stat_rv + + # disable selinux and acls for this call -- we test them + # separately so that we can skip those tests as appropriate + states = (Bcfg2.Client.Tools.POSIX.base.has_selinux, + Bcfg2.Client.Tools.POSIX.base.has_acls) + Bcfg2.Client.Tools.POSIX.base.has_selinux = False + Bcfg2.Client.Tools.POSIX.base.has_acls = False + self.assertEqual(self.ptool._gather_data(path), + (stat_rv, '0', '10', '0660', None, None)) + Bcfg2.Client.Tools.POSIX.base.has_selinux, \ + Bcfg2.Client.Tools.POSIX.base.has_acls = states + mock_stat.assert_called_with(path) @skipUnless(has_selinux, "SELinux not found, skipping") def test__gather_data_selinux(self): context = 'system_u:object_r:root_t:s0' path = '/test' - ptool = self.get_obj() - with patch("selinux.getfilecon") as mock_getfilecon, \ - patch('os.stat') as mock_stat: + + @patch("selinux.getfilecon") + @patch('os.stat') + def inner(mock_stat, mock_getfilecon): mock_getfilecon.return_value = [len(context) + 1, context] mock_stat.return_value = MagicMock() # disable acls for this call and test them separately state = Bcfg2.Client.Tools.POSIX.base.has_acls Bcfg2.Client.Tools.POSIX.base.has_acls = False - self.assertEqual(ptool._gather_data(path)[4], 'root_t') + self.assertEqual(self.ptool._gather_data(path)[4], 'root_t') Bcfg2.Client.Tools.POSIX.base.has_acls = state mock_getfilecon.assert_called_with(path) + + inner() + @skipUnless(has_acls, "ACLS not found, skipping") + @patch('os.stat') @patch("Bcfg2.Client.Tools.POSIX.base.%s._list_file_acls" % test_obj.__name__) - @skipUnless(has_acls, "ACLS not found, skipping") - def test__gather_data_acls(self, mock_list_file_acls): + def test__gather_data_acls(self, mock_list_file_acls, mock_stat): acls = {("default", posix1e.ACL_USER, "testuser"): "rwx", ("access", posix1e.ACL_GROUP, "testgroup"): "rx"} mock_list_file_acls.return_value = acls path = '/test' - ptool = self.get_obj() - with patch('os.stat') as mock_stat: - mock_stat.return_value = MagicMock() - # disable selinux for this call and test it separately - state = Bcfg2.Client.Tools.POSIX.base.has_selinux - Bcfg2.Client.Tools.POSIX.base.has_selinux = False - self.assertItemsEqual(ptool._gather_data(path)[5], acls) - Bcfg2.Client.Tools.POSIX.base.has_selinux = state - mock_list_file_acls.assert_called_with(path) + mock_stat.return_value = MagicMock() + # disable selinux for this call and test it separately + state = Bcfg2.Client.Tools.POSIX.base.has_selinux + Bcfg2.Client.Tools.POSIX.base.has_selinux = False + self.assertItemsEqual(self.ptool._gather_data(path)[5], acls) + Bcfg2.Client.Tools.POSIX.base.has_selinux = state + mock_list_file_acls.assert_called_with(path) @patch("Bcfg2.Client.Tools.POSIX.base.%s._verify_acls" % test_obj.__name__) @patch("Bcfg2.Client.Tools.POSIX.base.%s._gather_data" % test_obj.__name__) @@ -626,18 +622,16 @@ class TestPOSIXTool(Bcfg2TestCase): # can start fresh every time orig_entry = copy.deepcopy(entry) - ptool = self.get_obj() - def reset(): mock_gather_data.reset_mock() + mock_verify_acls.reset_mock() mock_norm_uid.reset_mock() mock_norm_gid.reset_mock() return copy.deepcopy(orig_entry) - # test nonexistent file mock_gather_data.return_value = (False, None, None, None, None, None) - self.assertFalse(ptool._verify_metadata(entry)) + self.assertFalse(self.ptool._verify_metadata(entry)) self.assertEqual(entry.get("current_exists", "").lower(), "false") mock_gather_data.assert_called_with(entry.get("name")) @@ -654,7 +648,7 @@ class TestPOSIXTool(Bcfg2TestCase): entry = reset() mock_gather_data.return_value = tuple(gather_data_rv) - self.assertTrue(ptool._verify_metadata(entry)) + self.assertTrue(self.ptool._verify_metadata(entry)) mock_gather_data.assert_called_with(entry.get("name")) mock_verify_acls.assert_called_with(entry, path=entry.get("name")) self.assertEqual(entry.get("current_exists", 'true'), 'true') @@ -667,7 +661,7 @@ class TestPOSIXTool(Bcfg2TestCase): sestate = Bcfg2.Client.Tools.POSIX.base.has_selinux Bcfg2.Client.Tools.POSIX.base.has_selinux = False mock_gather_data.return_value = tuple(gather_data_rv) - self.assertTrue(ptool._verify_metadata(entry)) + self.assertTrue(self.ptool._verify_metadata(entry)) mock_gather_data.assert_called_with(entry.get("name")) mock_verify_acls.assert_called_with(entry, path=entry.get("name")) self.assertEqual(entry.get("current_exists", 'true'), 'true') @@ -688,7 +682,7 @@ class TestPOSIXTool(Bcfg2TestCase): stat_rv.__getitem__.return_value = mtime gather_data_rv[0] = stat_rv mock_gather_data.return_value = tuple(gather_data_rv) - self.assertTrue(ptool._verify_metadata(entry)) + self.assertTrue(self.ptool._verify_metadata(entry)) mock_gather_data.assert_called_with(entry.get("name")) mock_verify_acls.assert_called_with(entry, path=entry.get("name")) self.assertEqual(entry.get("current_exists", 'true'), 'true') @@ -712,7 +706,7 @@ class TestPOSIXTool(Bcfg2TestCase): gather_data_rv[idx] = val gather_data_rv[fail_idx] = fail_val mock_gather_data.return_value = tuple(gather_data_rv) - self.assertFalse(ptool._verify_metadata(entry)) + self.assertFalse(self.ptool._verify_metadata(entry)) mock_gather_data.assert_called_with(entry.get("name")) mock_verify_acls.assert_called_with(entry, path=entry.get("name")) self.assertEqual(entry.get("current_exists", 'true'), 'true') @@ -732,7 +726,7 @@ class TestPOSIXTool(Bcfg2TestCase): for attr, idx, val in expected: gather_data_rv[idx] = val mock_gather_data.return_value = tuple(gather_data_rv) - self.assertFalse(ptool._verify_metadata(entry)) + self.assertFalse(self.ptool._verify_metadata(entry)) mock_gather_data.assert_called_with(entry.get("name")) mock_verify_acls.assert_called_with(entry, path=entry.get("name")) self.assertEqual(entry.get("current_exists", 'true'), 'true') @@ -745,7 +739,9 @@ class TestPOSIXTool(Bcfg2TestCase): entry = reset() entry.set("mtime", str(mtime)) entry.set("secontext", "__default__") - with patch("selinux.matchpathcon") as mock_matchpathcon: + + @patch("selinux.matchpathcon") + def inner(entry, mock_matchpathcon): context1 = "system_u:object_r:etc_t:s0" context2 = "system_u:object_r:root_t:s0" mock_matchpathcon.return_value = [1 + len(context1), @@ -754,7 +750,7 @@ class TestPOSIXTool(Bcfg2TestCase): for attr, idx, val in expected: gather_data_rv[idx] = val mock_gather_data.return_value = tuple(gather_data_rv) - self.assertTrue(ptool._verify_metadata(entry)) + self.assertTrue(self.ptool._verify_metadata(entry)) mock_gather_data.assert_called_with(entry.get("name")) mock_verify_acls.assert_called_with(entry, path=entry.get("name")) @@ -769,7 +765,7 @@ class TestPOSIXTool(Bcfg2TestCase): entry.set("secontext", "__default__") mock_matchpathcon.return_value = [1 + len(context2), context2] - self.assertFalse(ptool._verify_metadata(entry)) + self.assertFalse(self.ptool._verify_metadata(entry)) mock_gather_data.assert_called_with(entry.get("name")) mock_verify_acls.assert_called_with(entry, path=entry.get("name")) @@ -779,6 +775,8 @@ class TestPOSIXTool(Bcfg2TestCase): self.assertEqual(entry.get(attr), val) self.assertEqual(entry.get("current_mtime"), str(mtime)) + inner(entry) + @skipUnless(has_acls, "ACLS not found, skipping") def test_list_entry_acls(self): entry = lxml.etree.Element("Path", name="/test", type="file") @@ -786,19 +784,19 @@ class TestPOSIXTool(Bcfg2TestCase): user="user", perms="rwx") lxml.etree.SubElement(entry, "ACL", scope="group", type="access", group="group", perms="5") - ptool = self.get_obj() - self.assertItemsEqual(ptool._list_entry_acls(entry), + self.assertItemsEqual(self.ptool._list_entry_acls(entry), {("default", posix1e.ACL_USER, "user"): 7, ("access", posix1e.ACL_GROUP, "group"): 5}) @skipUnless(has_acls, "ACLS not found, skipping") @patch("pwd.getpwuid") @patch("grp.getgrgid") - def test_list_file_acls(self, mock_getgrgid, mock_getpwuid): + @patch("os.path.isdir") + def test_list_file_acls(self, mock_isdir, mock_getgrgid, mock_getpwuid): path = '/test' - ptool = self.get_obj() - with patch("posix1e.ACL") as mock_ACL, \ - patch("os.path.isdir") as mock_isdir: + + @patch("posix1e.ACL") + def inner(mock_ACL): # build a set of file ACLs to return from posix1e.ACL(file=...) file_acls = [] acl = Mock() @@ -845,15 +843,15 @@ class TestPOSIXTool(Bcfg2TestCase): mock_ACL.reset_mock() mock_ACL.side_effect = IOError(95, "Operation not supported") - self.assertItemsEqual(ptool._list_file_acls(path), dict()) + self.assertItemsEqual(self.ptool._list_file_acls(path), dict()) reset() mock_ACL.side_effect = IOError - self.assertItemsEqual(ptool._list_file_acls(path), dict()) + self.assertItemsEqual(self.ptool._list_file_acls(path), dict()) reset() mock_ACL.side_effect = mock_acl_rv - self.assertItemsEqual(ptool._list_file_acls(path), acls) + self.assertItemsEqual(self.ptool._list_file_acls(path), acls) mock_isdir.assert_called_with(path) mock_getgrgid.assert_called_with(100) mock_getpwuid.assert_called_with(10) @@ -867,7 +865,7 @@ class TestPOSIXTool(Bcfg2TestCase): defacls = acls for akey, perms in acls.items(): defacls[('default', akey[1], akey[2])] = perms - self.assertItemsEqual(ptool._list_file_acls(path), defacls) + self.assertItemsEqual(self.ptool._list_file_acls(path), defacls) mock_isdir.assert_called_with(path) self.assertItemsEqual(mock_getgrgid.call_args_list, [call(100), call(100)]) @@ -876,6 +874,8 @@ class TestPOSIXTool(Bcfg2TestCase): self.assertItemsEqual(mock_ACL.call_args_list, [call(file=path), call(filedef=path)]) + inner() + @skipUnless(has_acls, "ACLS not found, skipping") @patch("Bcfg2.Client.Tools.POSIX.base.%s._list_file_acls" % test_obj.__name__) @@ -883,7 +883,6 @@ class TestPOSIXTool(Bcfg2TestCase): test_obj.__name__) def test_verify_acls(self, mock_list_entry_acls, mock_list_file_acls): entry = lxml.etree.Element("Path", name="/test", type="file") - ptool = self.get_obj() # we can't test to make sure that errors get properly sorted # into (missing, extra, wrong) without refactoring the # _verify_acls code, and I don't feel like doing that, so eff @@ -897,7 +896,7 @@ class TestPOSIXTool(Bcfg2TestCase): mock_list_entry_acls.return_value = acls mock_list_file_acls.return_value = acls - self.assertTrue(ptool._verify_acls(entry)) + self.assertTrue(self.ptool._verify_acls(entry)) mock_list_entry_acls.assert_called_with(entry) mock_list_file_acls.assert_called_with(entry.get("name")) @@ -905,7 +904,7 @@ class TestPOSIXTool(Bcfg2TestCase): mock_list_entry_acls.reset_mock() mock_list_file_acls.reset_mock() mock_list_file_acls.return_value = extra_acls - self.assertFalse(ptool._verify_acls(entry)) + self.assertFalse(self.ptool._verify_acls(entry)) mock_list_entry_acls.assert_called_with(entry) mock_list_file_acls.assert_called_with(entry.get("name")) @@ -914,7 +913,7 @@ class TestPOSIXTool(Bcfg2TestCase): mock_list_file_acls.reset_mock() mock_list_entry_acls.return_value = extra_acls mock_list_file_acls.return_value = acls - self.assertFalse(ptool._verify_acls(entry)) + self.assertFalse(self.ptool._verify_acls(entry)) mock_list_entry_acls.assert_called_with(entry) mock_list_file_acls.assert_called_with(entry.get("name")) @@ -925,7 +924,7 @@ class TestPOSIXTool(Bcfg2TestCase): mock_list_file_acls.reset_mock() mock_list_entry_acls.return_value = extra_acls mock_list_file_acls.return_value = wrong_acls - self.assertFalse(ptool._verify_acls(entry)) + self.assertFalse(self.ptool._verify_acls(entry)) mock_list_entry_acls.assert_called_with(entry) mock_list_file_acls.assert_called_with(entry.get("name")) @@ -941,7 +940,6 @@ class TestPOSIXTool(Bcfg2TestCase): mock_set_perms.reset_mock() mock_makedirs.reset_mock() - ptool = self.get_obj() mock_set_perms.return_value = True def path_exists_rv(path): if path == "/test": @@ -949,7 +947,7 @@ class TestPOSIXTool(Bcfg2TestCase): else: return False mock_exists.side_effect = path_exists_rv - self.assertTrue(ptool._makedirs(entry)) + self.assertTrue(self.ptool._makedirs(entry)) self.assertItemsEqual(mock_exists.call_args_list, [call("/test"), call("/test/foo"), call("/test/foo/bar")]) @@ -960,7 +958,7 @@ class TestPOSIXTool(Bcfg2TestCase): reset() mock_makedirs.side_effect = OSError - self.assertFalse(ptool._makedirs(entry)) + self.assertFalse(self.ptool._makedirs(entry)) self.assertItemsEqual(mock_set_perms.call_args_list, [call(entry, path="/test/foo"), call(entry, path="/test/foo/bar")]) @@ -973,7 +971,7 @@ class TestPOSIXTool(Bcfg2TestCase): else: return True mock_set_perms.side_effect = set_perms_rv - self.assertFalse(ptool._makedirs(entry)) + self.assertFalse(self.ptool._makedirs(entry)) self.assertItemsEqual(mock_exists.call_args_list, [call("/test"), call("/test/foo"), call("/test/foo/bar")]) |