diff options
Diffstat (limited to 'testsuite/Testsrc/Testlib/TestClient/TestTools/TestPOSIX/Testbase.py')
| -rw-r--r-- | testsuite/Testsrc/Testlib/TestClient/TestTools/TestPOSIX/Testbase.py | 625 |
1 files changed, 344 insertions, 281 deletions
diff --git a/testsuite/Testsrc/Testlib/TestClient/TestTools/TestPOSIX/Testbase.py b/testsuite/Testsrc/Testlib/TestClient/TestTools/TestPOSIX/Testbase.py index b3599db83..49e9be2ba 100644 --- a/testsuite/Testsrc/Testlib/TestClient/TestTools/TestPOSIX/Testbase.py +++ b/testsuite/Testsrc/Testlib/TestClient/TestTools/TestPOSIX/Testbase.py @@ -16,7 +16,7 @@ while path != "/": if os.path.basename(path) == "testsuite": break path = os.path.dirname(path) -from Test__init import get_posix_object +from TestTools.Test_init import TestTool from common import * try: @@ -32,96 +32,86 @@ except ImportError: HAS_ACLS = False -class TestPOSIXTool(Bcfg2TestCase): +class TestPOSIXTool(TestTool): test_obj = POSIXTool - def get_obj(self, posix=None): - if posix is None: - 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 - self.assertTrue(self.ptool.fully_specified(Mock())) + ptool = self.get_obj() + self.assertTrue(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, mock_walk, mock_stat): + def test_verify(self, mock_walk, mock_stat): + ptool = self.get_obj() + ptool._verify_metadata = Mock() entry = lxml.etree.Element("Path", name="/test", type="file") mock_stat.return_value = MagicMock() - mock_verify.return_value = False - self.assertFalse(self.ptool.verify(entry, [])) - mock_verify.assert_called_with(entry) + ptool._verify_metadata.return_value = False + self.assertFalse(ptool.verify(entry, [])) + ptool._verify_metadata.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) + ptool._verify_metadata.reset_mock() + ptool._verify_metadata.return_value = True + self.assertTrue(ptool.verify(entry, [])) + ptool._verify_metadata.assert_called_with(entry) - mock_verify.reset_mock() + ptool._verify_metadata.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, [])) + 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) + self.assertItemsEqual(ptool._verify_metadata.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, mock_walk): + def test_install(self, mock_walk): + ptool = self.get_obj() + ptool._set_perms = Mock() entry = lxml.etree.Element("Path", name="/test", type="file") - mock_set_perms.return_value = True - self.assertTrue(self.ptool.install(entry)) - mock_set_perms.assert_called_with(entry) + ptool._set_perms.return_value = True + self.assertTrue(ptool.install(entry)) + ptool._set_perms.assert_called_with(entry) - mock_set_perms.reset_mock() + ptool._set_perms.reset_mock() entry.set("recursive", "true") 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(self.ptool.install(entry)) + ptool._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, + self.assertItemsEqual(ptool._set_perms.call_args_list, all_set_perms) mock_walk.reset_mock() - mock_set_perms.reset_mock() + ptool._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 + ptool._set_perms.side_effect = set_perms_rv - self.assertFalse(self.ptool.install(entry)) + self.assertFalse(ptool.install(entry)) mock_walk.assert_called_with(entry.get("name")) - self.assertItemsEqual(mock_set_perms.call_args_list, all_set_perms) + self.assertItemsEqual(ptool._set_perms.call_args_list, all_set_perms) @patch('os.rmdir') @patch('os.unlink') @@ -130,6 +120,7 @@ class TestPOSIXTool(Bcfg2TestCase): @patch('os.path.islink') def test_remove(self, mock_islink, mock_isdir, mock_rmtree, mock_unlink, mock_rmdir): + ptool = self.get_obj() entry = lxml.etree.Element("Path", name="/etc/foo") def reset(): @@ -141,7 +132,7 @@ class TestPOSIXTool(Bcfg2TestCase): mock_islink.return_value = True mock_isdir.return_value = False - self.ptool._remove(entry) + ptool._remove(entry) mock_unlink.assert_called_with(entry.get('name')) self.assertFalse(mock_rmtree.called) self.assertFalse(mock_rmdir.called) @@ -149,13 +140,13 @@ class TestPOSIXTool(Bcfg2TestCase): reset() mock_islink.return_value = False mock_isdir.return_value = True - self.ptool._remove(entry) + ptool._remove(entry) mock_rmtree.assert_called_with(entry.get('name')) self.assertFalse(mock_unlink.called) self.assertFalse(mock_rmdir.called) reset() - self.ptool._remove(entry, recursive=False) + ptool._remove(entry, recursive=False) mock_rmdir.assert_called_with(entry.get('name')) self.assertFalse(mock_unlink.called) self.assertFalse(mock_rmtree.called) @@ -163,7 +154,7 @@ class TestPOSIXTool(Bcfg2TestCase): reset() mock_islink.return_value = False mock_isdir.return_value = False - self.ptool._remove(entry, recursive=False) + ptool._remove(entry, recursive=False) mock_unlink.assert_called_with(entry.get('name')) self.assertFalse(mock_rmtree.called) self.assertFalse(mock_rmdir.called) @@ -172,103 +163,101 @@ class TestPOSIXTool(Bcfg2TestCase): def test_exists(self, mock_lstat): entry = lxml.etree.Element("Path", name="/etc/foo", type="file") - self.ptool._remove = Mock() + ptool = self.get_obj() + ptool._remove = Mock() def reset(): mock_lstat.reset_mock() - self.ptool._remove.reset_mock() + ptool._remove.reset_mock() mock_lstat.side_effect = OSError - self.assertFalse(self.ptool._exists(entry)) + self.assertFalse(ptool._exists(entry)) mock_lstat.assert_called_with(entry.get('name')) - self.assertFalse(self.ptool._remove.called) + self.assertFalse(ptool._remove.called) reset() rv = MagicMock() mock_lstat.return_value = rv mock_lstat.side_effect = None - self.assertEqual(self.ptool._exists(entry), rv) + self.assertEqual(ptool._exists(entry), rv) mock_lstat.assert_called_with(entry.get('name')) - self.assertFalse(self.ptool._remove.called) + self.assertFalse(ptool._remove.called) reset() - self.assertEqual(self.ptool._exists(entry, remove=True), None) + self.assertEqual(ptool._exists(entry, remove=True), None) mock_lstat.assert_called_with(entry.get('name')) - self.ptool._remove.assert_called_with(entry) + ptool._remove.assert_called_with(entry) reset() - self.ptool._remove.side_effect = OSError - self.assertEqual(self.ptool._exists(entry, remove=True), rv) + ptool._remove.side_effect = OSError + self.assertEqual(ptool._exists(entry, remove=True), rv) mock_lstat.assert_called_with(entry.get('name')) - self.ptool._remove.assert_called_with(entry) + ptool._remove.assert_called_with(entry) @patch("os.chown") @patch("os.chmod") @patch("os.utime") - @patch("Bcfg2.Client.Tools.POSIX.base.%s._norm_entry_uid" % - test_obj.__name__) - @patch("Bcfg2.Client.Tools.POSIX.base.%s._norm_entry_gid" % - test_obj.__name__) - @patch("Bcfg2.Client.Tools.POSIX.base.%s._set_acls" % test_obj.__name__) - @patch("Bcfg2.Client.Tools.POSIX.base.%s._set_secontext" % - 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): + def test_set_perms(self, mock_utime, mock_chmod, mock_chown): + ptool = self.get_obj() + ptool._norm_entry_uid = Mock() + ptool._norm_entry_gid = Mock() + ptool._set_acls = Mock() + ptool._set_secontext = Mock() def reset(): - mock_set_secontext.reset_mock() - mock_set_acls.reset_mock() - mock_norm_gid.reset_mock() - mock_norm_uid.reset_mock() + ptool._set_secontext.reset_mock() + ptool._set_acls.reset_mock() + ptool._norm_entry_gid.reset_mock() + ptool._norm_entry_uid.reset_mock() mock_chmod.reset_mock() mock_chown.reset_mock() mock_utime.reset_mock() entry = lxml.etree.Element("Path", name="/etc/foo", to="/etc/bar", type="symlink") - mock_set_acls.return_value = True - mock_set_secontext.return_value = True - 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")) + ptool._set_acls.return_value = True + ptool._set_secontext.return_value = True + self.assertTrue(ptool._set_perms(entry)) + ptool._set_secontext.assert_called_with(entry, path=entry.get("name")) + ptool._set_acls.assert_called_with(entry, path=entry.get("name")) entry = lxml.etree.Element("Path", name="/etc/foo", owner="owner", group="group", mode="644", type="file") - mock_norm_uid.return_value = 10 - mock_norm_gid.return_value = 100 + ptool._norm_entry_uid.return_value = 10 + ptool._norm_entry_gid.return_value = 100 reset() - self.assertTrue(self.ptool._set_perms(entry)) - mock_norm_uid.assert_called_with(entry) - mock_norm_gid.assert_called_with(entry) + self.assertTrue(ptool._set_perms(entry)) + ptool._norm_entry_uid.assert_called_with(entry) + ptool._norm_entry_gid.assert_called_with(entry) mock_chown.assert_called_with(entry.get("name"), 10, 100) mock_chmod.assert_called_with(entry.get("name"), int(entry.get("mode"), 8)) self.assertFalse(mock_utime.called) - mock_set_secontext.assert_called_with(entry, path=entry.get("name")) - mock_set_acls.assert_called_with(entry, path=entry.get("name")) + ptool._set_secontext.assert_called_with(entry, path=entry.get("name")) + ptool._set_acls.assert_called_with(entry, path=entry.get("name")) reset() mtime = 1344459042 entry.set("mtime", str(mtime)) - self.assertTrue(self.ptool._set_perms(entry)) - mock_norm_uid.assert_called_with(entry) - mock_norm_gid.assert_called_with(entry) + self.assertTrue(ptool._set_perms(entry)) + ptool._norm_entry_uid.assert_called_with(entry) + ptool._norm_entry_gid.assert_called_with(entry) mock_chown.assert_called_with(entry.get("name"), 10, 100) mock_chmod.assert_called_with(entry.get("name"), int(entry.get("mode"), 8)) mock_utime.assert_called_with(entry.get("name"), (mtime, mtime)) - mock_set_secontext.assert_called_with(entry, path=entry.get("name")) - mock_set_acls.assert_called_with(entry, path=entry.get("name")) + ptool._set_secontext.assert_called_with(entry, path=entry.get("name")) + ptool._set_acls.assert_called_with(entry, path=entry.get("name")) reset() - self.assertTrue(self.ptool._set_perms(entry, path='/etc/bar')) - mock_norm_uid.assert_called_with(entry) - mock_norm_gid.assert_called_with(entry) + self.assertTrue(ptool._set_perms(entry, path='/etc/bar')) + ptool._norm_entry_uid.assert_called_with(entry) + ptool._norm_entry_gid.assert_called_with(entry) mock_chown.assert_called_with('/etc/bar', 10, 100) mock_chmod.assert_called_with('/etc/bar', int(entry.get("mode"), 8)) mock_utime.assert_called_with(entry.get("name"), (mtime, mtime)) - mock_set_secontext.assert_called_with(entry, path='/etc/bar') - mock_set_acls.assert_called_with(entry, path='/etc/bar') + ptool._set_secontext.assert_called_with(entry, path='/etc/bar') + ptool._set_acls.assert_called_with(entry, path='/etc/bar') # test dev_type modification of perms, failure of chown reset() @@ -280,15 +269,15 @@ class TestPOSIXTool(Bcfg2TestCase): os.chown.side_effect = chown_rv entry.set("type", "device") entry.set("dev_type", list(device_map.keys())[0]) - self.assertFalse(self.ptool._set_perms(entry)) - mock_norm_uid.assert_called_with(entry) - mock_norm_gid.assert_called_with(entry) + self.assertFalse(ptool._set_perms(entry)) + ptool._norm_entry_uid.assert_called_with(entry) + ptool._norm_entry_gid.assert_called_with(entry) mock_chown.assert_called_with(entry.get("name"), 0, 0) mock_chmod.assert_called_with(entry.get("name"), int(entry.get("mode"), 8) | list(device_map.values())[0]) mock_utime.assert_called_with(entry.get("name"), (mtime, mtime)) - mock_set_secontext.assert_called_with(entry, path=entry.get("name")) - mock_set_acls.assert_called_with(entry, path=entry.get("name")) + ptool._set_secontext.assert_called_with(entry, path=entry.get("name")) + ptool._set_acls.assert_called_with(entry, path=entry.get("name")) # test failure of chmod reset() @@ -296,15 +285,15 @@ class TestPOSIXTool(Bcfg2TestCase): os.chmod.side_effect = OSError entry.set("type", "file") del entry.attrib["dev_type"] - self.assertFalse(self.ptool._set_perms(entry)) - mock_norm_uid.assert_called_with(entry) - mock_norm_gid.assert_called_with(entry) + self.assertFalse(ptool._set_perms(entry)) + ptool._norm_entry_uid.assert_called_with(entry) + ptool._norm_entry_gid.assert_called_with(entry) mock_chown.assert_called_with(entry.get("name"), 10, 100) mock_chmod.assert_called_with(entry.get("name"), int(entry.get("mode"), 8)) mock_utime.assert_called_with(entry.get("name"), (mtime, mtime)) - mock_set_secontext.assert_called_with(entry, path=entry.get("name")) - mock_set_acls.assert_called_with(entry, path=entry.get("name")) + ptool._set_secontext.assert_called_with(entry, path=entry.get("name")) + ptool._set_acls.assert_called_with(entry, path=entry.get("name")) # test that even when everything fails, we try to do it all. # e.g., when chmod fails, we still try to apply acls, set @@ -312,33 +301,32 @@ class TestPOSIXTool(Bcfg2TestCase): reset() os.chown.side_effect = OSError os.utime.side_effect = OSError - mock_set_acls.return_value = False - mock_set_secontext.return_value = False - self.assertFalse(self.ptool._set_perms(entry)) - mock_norm_uid.assert_called_with(entry) - mock_norm_gid.assert_called_with(entry) + ptool._set_acls.return_value = False + ptool._set_secontext.return_value = False + self.assertFalse(ptool._set_perms(entry)) + ptool._norm_entry_uid.assert_called_with(entry) + ptool._norm_entry_gid.assert_called_with(entry) mock_chown.assert_called_with(entry.get("name"), 10, 100) mock_chmod.assert_called_with(entry.get("name"), int(entry.get("mode"), 8)) mock_utime.assert_called_with(entry.get("name"), (mtime, mtime)) - mock_set_secontext.assert_called_with(entry, path=entry.get("name")) - mock_set_acls.assert_called_with(entry, path=entry.get("name")) + ptool._set_secontext.assert_called_with(entry, path=entry.get("name")) + ptool._set_acls.assert_called_with(entry, path=entry.get("name")) @skipUnless(HAS_ACLS, "ACLS not found, skipping") @patchIf(HAS_ACLS, "posix1e.ACL") @patchIf(HAS_ACLS, "posix1e.Entry") @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, - mock_isdir, mock_Entry, mock_ACL): + def test_set_acls(self, mock_isdir, mock_Entry, mock_ACL): + ptool = self.get_obj() + ptool._list_entry_acls = Mock() + ptool._norm_uid = Mock() + ptool._norm_gid = Mock() entry = lxml.etree.Element("Path", name="/etc/foo", type="file") # disable acls for the initial test Bcfg2.Client.Tools.POSIX.base.HAS_ACLS = False - self.assertTrue(self.ptool._set_acls(entry)) + self.assertTrue(ptool._set_acls(entry)) Bcfg2.Client.Tools.POSIX.base.HAS_ACLS = True # build a set of file ACLs to return from posix1e.ACL(file=...) @@ -361,9 +349,9 @@ class TestPOSIXTool(Bcfg2TestCase): # _list_entry_acls() entry_acls = {("default", posix1e.ACL_USER, "user"): 7, ("access", posix1e.ACL_GROUP, "group"): 5} - mock_list_entry_acls.return_value = entry_acls - mock_norm_uid.return_value = 10 - mock_norm_gid.return_value = 100 + ptool._list_entry_acls.return_value = entry_acls + ptool._norm_uid.return_value = 10 + ptool._norm_gid.return_value = 100 # set up the unreasonably complex return value for # posix1e.ACL(), which has three separate uses @@ -403,17 +391,17 @@ class TestPOSIXTool(Bcfg2TestCase): # test fs mounted noacl mock_ACL.side_effect = IOError(95, "Operation not permitted") - self.assertFalse(self.ptool._set_acls(entry)) + self.assertFalse(ptool._set_acls(entry)) # test other error reset() mock_ACL.side_effect = IOError - self.assertFalse(self.ptool._set_acls(entry)) + self.assertFalse(ptool._set_acls(entry)) reset() mock_ACL.side_effect = mock_acl_rv mock_isdir.return_value = True - self.assertTrue(self.ptool._set_acls(entry)) + self.assertTrue(ptool._set_acls(entry)) self.assertItemsEqual(mock_ACL.call_args_list, [call(file=entry.get("name")), call(filedef=entry.get("name"))]) @@ -421,9 +409,9 @@ class TestPOSIXTool(Bcfg2TestCase): [call(a) for a in remove_acls]) self.assertItemsEqual(filedef_rv.delete_entry.call_args_list, [call(a) for a in remove_acls]) - mock_list_entry_acls.assert_called_with(entry) - mock_norm_uid.assert_called_with("user") - mock_norm_gid.assert_called_with("group") + ptool._list_entry_acls.assert_called_with(entry) + ptool._norm_uid.assert_called_with("user") + ptool._norm_gid.assert_called_with("group") fileacl_rv.calc_mask.assert_any_call() fileacl_rv.applyto.assert_called_with(entry.get("name"), posix1e.ACL_TYPE_ACCESS) @@ -432,7 +420,7 @@ class TestPOSIXTool(Bcfg2TestCase): posix1e.ACL_TYPE_DEFAULT) # build tuples of the Entry objects that were added to acl - # and defaacl so they're easier to compare for equality + # and defacl so they're easier to compare for equality added_acls = [] for acl in acl_entries: added_acls.append((acl.acl, acl.tag_type, acl.qualifier, @@ -446,17 +434,17 @@ class TestPOSIXTool(Bcfg2TestCase): # they've already been iterated over once fileacl_rv.__iter__.return_value = iter(file_acls) filedef_rv.__iter__.return_value = iter(file_acls) - mock_list_entry_acls.reset_mock() - mock_norm_uid.reset_mock() - mock_norm_gid.reset_mock() + ptool._list_entry_acls.reset_mock() + ptool._norm_uid.reset_mock() + ptool._norm_gid.reset_mock() mock_isdir.return_value = False acl_entries = [] - self.assertTrue(self.ptool._set_acls(entry, path="/bin/bar")) + self.assertTrue(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]) - mock_list_entry_acls.assert_called_with(entry) - mock_norm_gid.assert_called_with("group") + ptool._list_entry_acls.assert_called_with(entry) + ptool._norm_gid.assert_called_with("group") fileacl_rv.calc_mask.assert_any_call() fileacl_rv.applyto.assert_called_with("/bin/bar", posix1e.ACL_TYPE_ACCESS) @@ -472,22 +460,23 @@ class TestPOSIXTool(Bcfg2TestCase): @patchIf(HAS_SELINUX, "selinux.restorecon") @patchIf(HAS_SELINUX, "selinux.lsetfilecon") def test_set_secontext(self, mock_lsetfilecon, mock_restorecon): + ptool = self.get_obj() entry = lxml.etree.Element("Path", name="/etc/foo", type="file") # disable selinux for the initial test Bcfg2.Client.Tools.POSIX.base.HAS_SELINUX = False - self.assertTrue(self.ptool._set_secontext(entry)) + self.assertTrue(ptool._set_secontext(entry)) Bcfg2.Client.Tools.POSIX.base.HAS_SELINUX = True # no context given - self.assertTrue(self.ptool._set_secontext(entry)) + self.assertTrue(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(self.ptool._set_secontext(entry)) + self.assertTrue(ptool._set_secontext(entry)) mock_restorecon.assert_called_with(entry.get("name")) self.assertFalse(mock_lsetfilecon.called) @@ -495,85 +484,91 @@ class TestPOSIXTool(Bcfg2TestCase): mock_lsetfilecon.reset_mock() mock_lsetfilecon.return_value = 0 entry.set("secontext", "foo_t") - self.assertTrue(self.ptool._set_secontext(entry)) + self.assertTrue(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(self.ptool._set_secontext(entry)) + self.assertFalse(ptool._set_secontext(entry)) self.assertFalse(mock_restorecon.called) mock_lsetfilecon.assert_called_with(entry.get("name"), "foo_t") @patch("grp.getgrnam") def test_norm_gid(self, mock_getgrnam): - self.assertEqual(5, self.ptool._norm_gid("5")) + ptool = self.get_obj() + self.assertEqual(5, ptool._norm_gid("5")) self.assertFalse(mock_getgrnam.called) mock_getgrnam.reset_mock() mock_getgrnam.return_value = ("group", "x", 5, []) - self.assertEqual(5, self.ptool._norm_gid("group")) + self.assertEqual(5, 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): + def test_norm_entry_gid(self): + ptool = self.get_obj() + ptool._norm_gid = Mock() entry = lxml.etree.Element("Path", name="/test", type="file", group="group", owner="user") - mock_norm_gid.return_value = 10 - self.assertEqual(10, self.ptool._norm_entry_gid(entry)) - mock_norm_gid.assert_called_with(entry.get("group")) + self.assertEqual(ptool._norm_entry_gid(entry), + ptool._norm_gid.return_value) + ptool._norm_gid.assert_called_with(entry.get("group")) - mock_norm_gid.reset_mock() - mock_norm_gid.side_effect = KeyError - self.assertEqual(0, self.ptool._norm_entry_gid(entry)) - mock_norm_gid.assert_called_with(entry.get("group")) + ptool._norm_gid.reset_mock() + ptool._norm_gid.side_effect = KeyError + self.assertEqual(ptool._norm_entry_gid(entry), 0) + ptool._norm_gid.assert_called_with(entry.get("group")) @patch("pwd.getpwnam") def test_norm_uid(self, mock_getpwnam): - self.assertEqual(5, self.ptool._norm_uid("5")) + ptool = self.get_obj() + self.assertEqual(5, 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, self.ptool._norm_uid("user")) + self.assertEqual(5, 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): + def test_norm_entry_uid(self): + ptool = self.get_obj() + ptool._norm_uid = Mock() entry = lxml.etree.Element("Path", name="/test", type="file", group="group", owner="user") - mock_norm_uid.return_value = 10 - self.assertEqual(10, self.ptool._norm_entry_uid(entry)) - mock_norm_uid.assert_called_with(entry.get("owner")) + self.assertEqual(ptool._norm_entry_uid(entry), + ptool._norm_uid.return_value) + ptool._norm_uid.assert_called_with(entry.get("owner")) - mock_norm_uid.reset_mock() - mock_norm_uid.side_effect = KeyError - self.assertEqual(0, self.ptool._norm_entry_uid(entry)) - mock_norm_uid.assert_called_with(entry.get("owner")) + ptool._norm_uid.reset_mock() + ptool._norm_uid.side_effect = KeyError + self.assertEqual(ptool._norm_entry_uid(entry), 0) + ptool._norm_uid.assert_called_with(entry.get("owner")) def test_norm_acl_perms(self): - # there's basically no reasonably way to test the Permset + # there's basically no reasonable 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. - 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")) + 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")) @patch('os.stat') def test__gather_data(self, mock_stat): + ptool = self.get_obj() path = '/test' mock_stat.side_effect = OSError - self.assertFalse(self.ptool._gather_data(path)[0]) + self.assertFalse(ptool._gather_data(path)[0]) mock_stat.assert_called_with(path) mock_stat.reset_mock() @@ -598,7 +593,7 @@ class TestPOSIXTool(Bcfg2TestCase): 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), + 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 @@ -606,6 +601,7 @@ class TestPOSIXTool(Bcfg2TestCase): @skipUnless(HAS_SELINUX, "SELinux not found, skipping") def test__gather_data_selinux(self): + ptool = self.get_obj() context = 'system_u:object_r:root_t:s0' path = '/test' @@ -620,7 +616,7 @@ class TestPOSIXTool(Bcfg2TestCase): Bcfg2.Client.Tools.POSIX.base.HAS_SELINUX) Bcfg2.Client.Tools.POSIX.base.HAS_ACLS = False Bcfg2.Client.Tools.POSIX.base.HAS_SELINUX = True - self.assertEqual(self.ptool._gather_data(path)[4], 'root_t') + self.assertEqual(ptool._gather_data(path)[4], 'root_t') Bcfg2.Client.Tools.POSIX.base.HAS_ACLS, \ Bcfg2.Client.Tools.POSIX.base.HAS_SELINUX = state mock_getfilecon.assert_called_with(path) @@ -629,12 +625,12 @@ class TestPOSIXTool(Bcfg2TestCase): @skipUnless(HAS_ACLS, "ACLS not found, skipping") @patch('os.stat') - @patch("Bcfg2.Client.Tools.POSIX.base.%s._list_file_acls" % - test_obj.__name__) - def test__gather_data_acls(self, mock_list_file_acls, mock_stat): + def test__gather_data_acls(self, mock_stat): + ptool = self.get_obj() + ptool._list_file_acls = Mock() acls = {("default", posix1e.ACL_USER, "testuser"): "rwx", ("access", posix1e.ACL_GROUP, "testgroup"): "rx"} - mock_list_file_acls.return_value = acls + ptool._list_file_acls.return_value = acls path = '/test' mock_stat.return_value = MagicMock() mock_stat.return_value.__getitem__.return_value = MagicMock() @@ -643,21 +639,18 @@ class TestPOSIXTool(Bcfg2TestCase): Bcfg2.Client.Tools.POSIX.base.HAS_SELINUX) Bcfg2.Client.Tools.POSIX.base.HAS_ACLS = True Bcfg2.Client.Tools.POSIX.base.HAS_SELINUX = False - self.assertItemsEqual(self.ptool._gather_data(path)[5], acls) + self.assertItemsEqual(ptool._gather_data(path)[5], acls) Bcfg2.Client.Tools.POSIX.base.HAS_ACLS, \ Bcfg2.Client.Tools.POSIX.base.HAS_SELINUX = state - mock_list_file_acls.assert_called_with(path) + ptool._list_file_acls.assert_called_with(path) @patchIf(HAS_SELINUX, "selinux.matchpathcon") - @patch("Bcfg2.Client.Tools.POSIX.base.%s._verify_acls" % test_obj.__name__) - @patch("Bcfg2.Client.Tools.POSIX.base.%s._gather_data" % test_obj.__name__) - @patch("Bcfg2.Client.Tools.POSIX.base.%s._norm_entry_uid" % - test_obj.__name__) - @patch("Bcfg2.Client.Tools.POSIX.base.%s._norm_entry_gid" % - test_obj.__name__) - def test_verify_metadata(self, mock_norm_gid, mock_norm_uid, - mock_gather_data, mock_verify_acls, - mock_matchpathcon): + def test_verify_metadata(self, mock_matchpathcon): + ptool = self.get_obj() + ptool._norm_entry_uid = Mock() + ptool._norm_entry_gid = Mock() + ptool._verify_acls = Mock() + ptool._gather_data = Mock() entry = lxml.etree.Element("Path", name="/test", type="file", group="group", owner="user", mode="664", secontext='etc_t') @@ -666,34 +659,34 @@ class TestPOSIXTool(Bcfg2TestCase): orig_entry = copy.deepcopy(entry) def reset(): - mock_gather_data.reset_mock() - mock_verify_acls.reset_mock() - mock_norm_uid.reset_mock() - mock_norm_gid.reset_mock() + ptool._gather_data.reset_mock() + ptool._verify_acls.reset_mock() + ptool._norm_entry_uid.reset_mock() + ptool._norm_entry_gid.reset_mock() return copy.deepcopy(orig_entry) # test nonexistent file - mock_gather_data.return_value = (False, None, None, None, None, None) - self.assertFalse(self.ptool._verify_metadata(entry)) + ptool._gather_data.return_value = (False, None, None, None, None, None) + self.assertFalse(ptool._verify_metadata(entry)) self.assertEqual(entry.get("current_exists", "").lower(), "false") - mock_gather_data.assert_called_with(entry.get("name")) + ptool._gather_data.assert_called_with(entry.get("name")) # expected data. tuple of attr, return value index, value expected = [('current_owner', 1, '0'), ('current_group', 2, '10'), ('current_mode', 3, '0664'), ('current_secontext', 4, 'etc_t')] - mock_norm_uid.return_value = 0 - mock_norm_gid.return_value = 10 + ptool._norm_entry_uid.return_value = 0 + ptool._norm_entry_gid.return_value = 10 gather_data_rv = [MagicMock(), None, None, None, None, []] for attr, idx, val in expected: gather_data_rv[idx] = val entry = reset() - mock_gather_data.return_value = tuple(gather_data_rv) - 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")) + ptool._gather_data.return_value = tuple(gather_data_rv) + self.assertTrue(ptool._verify_metadata(entry)) + ptool._gather_data.assert_called_with(entry.get("name")) + ptool._verify_acls.assert_called_with(entry, path=entry.get("name")) self.assertEqual(entry.get("current_exists", 'true'), 'true') for attr, idx, val in expected: self.assertEqual(entry.get(attr), val) @@ -703,10 +696,10 @@ class TestPOSIXTool(Bcfg2TestCase): gather_data_rv[4] = None 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(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")) + ptool._gather_data.return_value = tuple(gather_data_rv) + self.assertTrue(ptool._verify_metadata(entry)) + ptool._gather_data.assert_called_with(entry.get("name")) + ptool._verify_acls.assert_called_with(entry, path=entry.get("name")) self.assertEqual(entry.get("current_exists", 'true'), 'true') for attr, idx, val in expected: if attr != 'current_secontext': @@ -716,7 +709,7 @@ class TestPOSIXTool(Bcfg2TestCase): gather_data_rv = [MagicMock(), None, None, None, None, []] for attr, idx, val in expected: gather_data_rv[idx] = val - mock_gather_data.return_value = tuple(gather_data_rv) + ptool._gather_data.return_value = tuple(gather_data_rv) mtime = 1344430414 entry = reset() @@ -724,10 +717,10 @@ class TestPOSIXTool(Bcfg2TestCase): stat_rv = MagicMock() stat_rv.__getitem__.return_value = mtime gather_data_rv[0] = stat_rv - mock_gather_data.return_value = tuple(gather_data_rv) - 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")) + ptool._gather_data.return_value = tuple(gather_data_rv) + self.assertTrue(ptool._verify_metadata(entry)) + ptool._gather_data.assert_called_with(entry.get("name")) + ptool._verify_acls.assert_called_with(entry, path=entry.get("name")) self.assertEqual(entry.get("current_exists", 'true'), 'true') for attr, idx, val in expected: self.assertEqual(entry.get(attr), val) @@ -748,10 +741,10 @@ class TestPOSIXTool(Bcfg2TestCase): for attr, idx, val in expected: gather_data_rv[idx] = val gather_data_rv[fail_idx] = fail_val - mock_gather_data.return_value = tuple(gather_data_rv) - 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")) + ptool._gather_data.return_value = tuple(gather_data_rv) + self.assertFalse(ptool._verify_metadata(entry)) + ptool._gather_data.assert_called_with(entry.get("name")) + ptool._verify_acls.assert_called_with(entry, path=entry.get("name")) self.assertEqual(entry.get("current_exists", 'true'), 'true') self.assertEqual(entry.get(fail_attr), fail_val) for attr, idx, val in expected: @@ -768,10 +761,10 @@ class TestPOSIXTool(Bcfg2TestCase): gather_data_rv = [fail_stat_rv, None, None, None, None, []] for attr, idx, val in expected: gather_data_rv[idx] = val - mock_gather_data.return_value = tuple(gather_data_rv) - 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")) + ptool._gather_data.return_value = tuple(gather_data_rv) + self.assertFalse(ptool._verify_metadata(entry)) + ptool._gather_data.assert_called_with(entry.get("name")) + ptool._verify_acls.assert_called_with(entry, path=entry.get("name")) self.assertEqual(entry.get("current_exists", 'true'), 'true') for attr, idx, val in expected: self.assertEqual(entry.get(attr), val) @@ -790,10 +783,10 @@ class TestPOSIXTool(Bcfg2TestCase): gather_data_rv = [stat_rv, None, None, None, None, []] for attr, idx, val in expected: gather_data_rv[idx] = val - mock_gather_data.return_value = tuple(gather_data_rv) - self.assertTrue(self.ptool._verify_metadata(entry)) - mock_gather_data.assert_called_with(entry.get("name")) - mock_verify_acls.assert_called_with(entry, + ptool._gather_data.return_value = tuple(gather_data_rv) + self.assertTrue(ptool._verify_metadata(entry)) + ptool._gather_data.assert_called_with(entry.get("name")) + ptool._verify_acls.assert_called_with(entry, path=entry.get("name")) mock_matchpathcon.assert_called_with(entry.get("name"), 0) self.assertEqual(entry.get("current_exists", 'true'), 'true') @@ -806,9 +799,9 @@ class TestPOSIXTool(Bcfg2TestCase): entry.set("secontext", "__default__") mock_matchpathcon.return_value = [1 + len(context2), context2] - self.assertFalse(self.ptool._verify_metadata(entry)) - mock_gather_data.assert_called_with(entry.get("name")) - mock_verify_acls.assert_called_with(entry, + self.assertFalse(ptool._verify_metadata(entry)) + ptool._gather_data.assert_called_with(entry.get("name")) + ptool._verify_acls.assert_called_with(entry, path=entry.get("name")) mock_matchpathcon.assert_called_with(entry.get("name"), 0) self.assertEqual(entry.get("current_exists", 'true'), 'true') @@ -818,21 +811,24 @@ class TestPOSIXTool(Bcfg2TestCase): @skipUnless(HAS_ACLS, "ACLS not found, skipping") def test_list_entry_acls(self): + ptool = self.get_obj() entry = lxml.etree.Element("Path", name="/test", type="file") lxml.etree.SubElement(entry, "ACL", scope="user", type="default", user="user", perms="rwx") lxml.etree.SubElement(entry, "ACL", scope="group", type="access", group="group", perms="5") - self.assertItemsEqual(self.ptool._list_entry_acls(entry), + self.assertItemsEqual(ptool._list_entry_acls(entry), {("default", posix1e.ACL_USER, "user"): 7, ("access", posix1e.ACL_GROUP, "group"): 5}) @skipUnless(HAS_ACLS, "ACLS not found, skipping") + @patchIf(HAS_ACLS, "posix1e.ACL") @patch("pwd.getpwuid") @patch("grp.getgrgid") @patch("os.path.isdir") def test_list_file_acls(self, mock_isdir, mock_getgrgid, mock_getpwuid, mock_ACL): + ptool = self.get_obj() path = '/test' # build a set of file ACLs to return from posix1e.ACL(file=...) @@ -881,15 +877,15 @@ class TestPOSIXTool(Bcfg2TestCase): mock_ACL.reset_mock() mock_ACL.side_effect = IOError(95, "Operation not supported") - self.assertItemsEqual(self.ptool._list_file_acls(path), dict()) + self.assertItemsEqual(ptool._list_file_acls(path), dict()) reset() mock_ACL.side_effect = IOError - self.assertItemsEqual(self.ptool._list_file_acls(path), dict()) + self.assertItemsEqual(ptool._list_file_acls(path), dict()) reset() mock_ACL.side_effect = mock_acl_rv - self.assertItemsEqual(self.ptool._list_file_acls(path), acls) + self.assertItemsEqual(ptool._list_file_acls(path), acls) mock_isdir.assert_called_with(path) mock_getgrgid.assert_called_with(100) mock_getpwuid.assert_called_with(10) @@ -903,7 +899,7 @@ class TestPOSIXTool(Bcfg2TestCase): defacls = acls for akey, perms in acls.items(): defacls[('default', akey[1], akey[2])] = perms - self.assertItemsEqual(self.ptool._list_file_acls(path), defacls) + self.assertItemsEqual(ptool._list_file_acls(path), defacls) mock_isdir.assert_called_with(path) self.assertItemsEqual(mock_getgrgid.call_args_list, [call(100), call(100)]) @@ -912,20 +908,11 @@ class TestPOSIXTool(Bcfg2TestCase): self.assertItemsEqual(mock_ACL.call_args_list, [call(file=path), call(filedef=path)]) - if HAS_ACLS: - # python 2.6 applies decorators at compile-time, not at - # run-time, so we can't do these as decorators because - # pylibacl might not be installed. (If it's not, this test - # will be skipped, so as long as this is done at run-time - # we're safe.) - test_list_file_acls = patch("posix1e.ACL")(test_list_file_acls) - @skipUnless(HAS_ACLS, "ACLS not found, skipping") - @patch("Bcfg2.Client.Tools.POSIX.base.%s._list_file_acls" % - test_obj.__name__) - @patch("Bcfg2.Client.Tools.POSIX.base.%s._list_entry_acls" % - test_obj.__name__) - def test_verify_acls(self, mock_list_entry_acls, mock_list_file_acls): + def test_verify_acls(self): + ptool = self.get_obj() + ptool._list_file_acls = Mock() + ptool._list_entry_acls = Mock() entry = lxml.etree.Element("Path", name="/test", type="file") # we can't test to make sure that errors get properly sorted # into (missing, extra, wrong) without refactoring the @@ -938,44 +925,45 @@ class TestPOSIXTool(Bcfg2TestCase): extra_acls = copy.deepcopy(acls) extra_acls[("access", posix1e.ACL_USER, "user2")] = 4 - mock_list_entry_acls.return_value = acls - mock_list_file_acls.return_value = acls - 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")) + ptool._list_entry_acls.return_value = acls + ptool._list_file_acls.return_value = acls + self.assertTrue(ptool._verify_acls(entry)) + ptool._list_entry_acls.assert_called_with(entry) + ptool._list_file_acls.assert_called_with(entry.get("name")) # test missing - mock_list_entry_acls.reset_mock() - mock_list_file_acls.reset_mock() - mock_list_file_acls.return_value = extra_acls - 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")) + ptool._list_entry_acls.reset_mock() + ptool._list_file_acls.reset_mock() + ptool._list_file_acls.return_value = extra_acls + self.assertFalse(ptool._verify_acls(entry)) + ptool._list_entry_acls.assert_called_with(entry) + ptool._list_file_acls.assert_called_with(entry.get("name")) # test extra - mock_list_entry_acls.reset_mock() - mock_list_file_acls.reset_mock() - mock_list_entry_acls.return_value = extra_acls - mock_list_file_acls.return_value = acls - 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")) + ptool._list_entry_acls.reset_mock() + ptool._list_file_acls.reset_mock() + ptool._list_entry_acls.return_value = extra_acls + ptool._list_file_acls.return_value = acls + self.assertFalse(ptool._verify_acls(entry)) + ptool._list_entry_acls.assert_called_with(entry) + ptool._list_file_acls.assert_called_with(entry.get("name")) # test wrong wrong_acls = copy.deepcopy(extra_acls) wrong_acls[("access", posix1e.ACL_USER, "user2")] = 5 - mock_list_entry_acls.reset_mock() - mock_list_file_acls.reset_mock() - mock_list_entry_acls.return_value = extra_acls - mock_list_file_acls.return_value = wrong_acls - 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")) + ptool._list_entry_acls.reset_mock() + ptool._list_file_acls.reset_mock() + ptool._list_entry_acls.return_value = extra_acls + ptool._list_file_acls.return_value = wrong_acls + self.assertFalse(ptool._verify_acls(entry)) + ptool._list_entry_acls.assert_called_with(entry) + ptool._list_file_acls.assert_called_with(entry.get("name")) @patch("os.makedirs") @patch("os.path.exists") - @patch("Bcfg2.Client.Tools.POSIX.base.%s._set_perms" % test_obj.__name__) - def test_makedirs(self, mock_set_perms, mock_exists, mock_makedirs): + def test_makedirs(self, mock_exists, mock_makedirs): + ptool = self.get_obj() + ptool._set_perms = Mock() entry = lxml.etree.Element("Path", name="/test/foo/bar", type="directory", mode="0644") parent_entry = lxml.etree.Element("Path", name="/test/foo/bar", @@ -983,33 +971,33 @@ class TestPOSIXTool(Bcfg2TestCase): def reset(): mock_exists.reset_mock() - mock_set_perms.reset_mock() + ptool._set_perms.reset_mock() mock_makedirs.reset_mock() - mock_set_perms.return_value = True + ptool._set_perms.return_value = True def path_exists_rv(path): if path == "/test": return True else: return False mock_exists.side_effect = path_exists_rv - self.assertTrue(self.ptool._makedirs(entry)) + self.assertTrue(ptool._makedirs(entry)) self.assertItemsEqual(mock_exists.call_args_list, [call("/test"), call("/test/foo"), call("/test/foo/bar")]) - for args in mock_set_perms.call_args_list: + for args in ptool._set_perms.call_args_list: self.assertXMLEqual(args[0][0], parent_entry) - self.assertItemsEqual([a[1] for a in mock_set_perms.call_args_list], + self.assertItemsEqual([a[1] for a in ptool._set_perms.call_args_list], [dict(path="/test/foo"), dict(path="/test/foo/bar")]) mock_makedirs.assert_called_with(entry.get("name")) reset() mock_makedirs.side_effect = OSError - self.assertFalse(self.ptool._makedirs(entry)) - for args in mock_set_perms.call_args_list: + self.assertFalse(ptool._makedirs(entry)) + for args in ptool._set_perms.call_args_list: self.assertXMLEqual(args[0][0], parent_entry) - self.assertItemsEqual([a[1] for a in mock_set_perms.call_args_list], + self.assertItemsEqual([a[1] for a in ptool._set_perms.call_args_list], [dict(path="/test/foo"), dict(path="/test/foo/bar")]) @@ -1020,14 +1008,89 @@ class TestPOSIXTool(Bcfg2TestCase): return False else: return True - mock_set_perms.side_effect = set_perms_rv - self.assertFalse(self.ptool._makedirs(entry)) + ptool._set_perms.side_effect = set_perms_rv + self.assertFalse(ptool._makedirs(entry)) self.assertItemsEqual(mock_exists.call_args_list, [call("/test"), call("/test/foo"), call("/test/foo/bar")]) - for args in mock_set_perms.call_args_list: + for args in ptool._set_perms.call_args_list: self.assertXMLEqual(args[0][0], parent_entry) - self.assertItemsEqual([a[1] for a in mock_set_perms.call_args_list], + self.assertItemsEqual([a[1] for a in ptool._set_perms.call_args_list], [dict(path="/test/foo"), dict(path="/test/foo/bar")]) mock_makedirs.assert_called_with(entry.get("name")) + + +class TestPOSIXLinkTool(TestPOSIXTool): + test_obj = POSIXLinkTool + + @patch("Bcfg2.Client.Tools.POSIX.base.POSIXTool.verify") + def test_verify(self, mock_verify): + entry = lxml.etree.Element("Path", name="/test", type="testlink", + to="/dest") + ptool = self.get_obj() + linktype = ptool.__linktype__ + ptool.__linktype__ = "test" + ptool._verify = Mock() + + ptool._verify.return_value = True + mock_verify.return_value = False + self.assertFalse(ptool.verify(entry, [])) + ptool._verify.assert_called_with(entry) + mock_verify.assert_called_with(ptool, entry, []) + + ptool._verify.reset_mock() + mock_verify.reset_mock() + mock_verify.return_value = True + self.assertTrue(ptool.verify(entry, [])) + ptool._verify.assert_called_with(entry) + mock_verify.assert_called_with(ptool, entry, []) + + ptool._verify.reset_mock() + mock_verify.reset_mock() + ptool._verify.return_value = False + self.assertFalse(ptool.verify(entry, [])) + ptool._verify.assert_called_with(entry) + mock_verify.assert_called_with(ptool, entry, []) + + ptool._verify.reset_mock() + mock_verify.reset_mock() + ptool._verify.side_effect = OSError + self.assertFalse(ptool.verify(entry, [])) + ptool._verify.assert_called_with(entry) + ptool.__linktype__ = linktype + + def test__verify(self): + ptool = self.get_obj() + self.assertRaises(NotImplementedError, ptool._verify, Mock()) + + @patch("Bcfg2.Client.Tools.POSIX.base.POSIXTool.install") + def test_install(self, mock_install): + entry = lxml.etree.Element("Path", name="/test", type="symlink", + to="/dest") + ptool = self.get_obj() + linktype = ptool.__linktype__ + ptool.__linktype__ = "test" + ptool._exists = Mock() + ptool._link = Mock() + + ptool._exists.return_value = False + mock_install.return_value = True + self.assertTrue(ptool.install(entry)) + ptool._exists.assert_called_with(entry, remove=True) + ptool._link.assert_called_with(entry) + mock_install.assert_called_with(ptool, entry) + + ptool._link.reset_mock() + ptool._exists.reset_mock() + mock_install.reset_mock() + ptool._link.side_effect = OSError + self.assertFalse(ptool.install(entry)) + ptool._exists.assert_called_with(entry, remove=True) + ptool._link.assert_called_with(entry) + mock_install.assert_called_with(ptool, entry) + ptool.__linktype__ = linktype + + def test__link(self): + ptool = self.get_obj() + self.assertRaises(NotImplementedError, ptool._link, Mock()) |