Revision 22b7f6f8 test/py/ganeti.cmdlib_unittest.py
b/test/py/ganeti.cmdlib_unittest.py | ||
---|---|---|
24 | 24 |
|
25 | 25 |
import os |
26 | 26 |
import unittest |
27 |
import time |
|
28 | 27 |
import tempfile |
29 | 28 |
import shutil |
30 | 29 |
import operator |
... | ... | |
36 | 35 |
from ganeti import cmdlib |
37 | 36 |
from ganeti.cmdlib import cluster |
38 | 37 |
from ganeti.cmdlib import group |
38 |
from ganeti.cmdlib import instance |
|
39 | 39 |
from ganeti.cmdlib import common |
40 | 40 |
from ganeti import opcodes |
41 | 41 |
from ganeti import errors |
... | ... | |
173 | 173 |
for i in constants.QR_VIA_OP: |
174 | 174 |
self.assert_(cmdlib._GetQueryImplementation(i)) |
175 | 175 |
|
176 |
self.assertRaises(errors.OpPrereqError, cmdlib._GetQueryImplementation, "") |
|
176 |
self.assertRaises(errors.OpPrereqError, cmdlib._GetQueryImplementation, |
|
177 |
"") |
|
177 | 178 |
self.assertRaises(errors.OpPrereqError, cmdlib._GetQueryImplementation, |
178 | 179 |
"xyz") |
179 | 180 |
|
... | ... | |
181 | 182 |
class TestLUGroupAssignNodes(unittest.TestCase): |
182 | 183 |
|
183 | 184 |
def testCheckAssignmentForSplitInstances(self): |
184 |
node_data = dict((name, objects.Node(name=name, group=group))
|
|
185 |
for (name, group) in [("n1a", "g1"), ("n1b", "g1"),
|
|
186 |
("n2a", "g2"), ("n2b", "g2"),
|
|
187 |
("n3a", "g3"), ("n3b", "g3"),
|
|
188 |
("n3c", "g3"),
|
|
189 |
])
|
|
185 |
node_data = dict((n, objects.Node(name=n, group=g))
|
|
186 |
for (n, g) in [("n1a", "g1"), ("n1b", "g1"),
|
|
187 |
("n2a", "g2"), ("n2b", "g2"), |
|
188 |
("n3a", "g3"), ("n3b", "g3"), |
|
189 |
("n3c", "g3"), |
|
190 |
]) |
|
190 | 191 |
|
191 | 192 |
def Instance(name, pnode, snode): |
192 | 193 |
if snode is None: |
... | ... | |
865 | 866 |
} |
866 | 867 |
stub = _StubComputeIPolicySpecViolation(2048, 2, 1, 0, [512], 1, |
867 | 868 |
constants.DT_PLAIN) |
868 |
ret = cmdlib._ComputeIPolicyInstanceSpecViolation(NotImplemented, ispec,
|
|
869 |
constants.DT_PLAIN, |
|
870 |
_compute_fn=stub) |
|
869 |
ret = instance._ComputeIPolicyInstanceSpecViolation(NotImplemented, ispec,
|
|
870 |
constants.DT_PLAIN,
|
|
871 |
_compute_fn=stub)
|
|
871 | 872 |
self.assertEqual(ret, []) |
872 | 873 |
|
873 | 874 |
|
... | ... | |
886 | 887 |
self.recorder = _CallRecorder(return_value=[]) |
887 | 888 |
|
888 | 889 |
def testSameGroup(self): |
889 |
ret = cmdlib._ComputeIPolicyNodeViolation(NotImplemented, NotImplemented, |
|
890 |
"foo", "foo", NotImplemented, |
|
891 |
_compute_fn=self.recorder) |
|
890 |
ret = instance._ComputeIPolicyNodeViolation(NotImplemented, |
|
891 |
NotImplemented, |
|
892 |
"foo", "foo", NotImplemented, |
|
893 |
_compute_fn=self.recorder) |
|
892 | 894 |
self.assertFalse(self.recorder.called) |
893 | 895 |
self.assertEqual(ret, []) |
894 | 896 |
|
895 | 897 |
def testDifferentGroup(self): |
896 |
ret = cmdlib._ComputeIPolicyNodeViolation(NotImplemented, NotImplemented, |
|
897 |
"foo", "bar", NotImplemented, |
|
898 |
_compute_fn=self.recorder) |
|
898 |
ret = instance._ComputeIPolicyNodeViolation(NotImplemented, |
|
899 |
NotImplemented, |
|
900 |
"foo", "bar", NotImplemented, |
|
901 |
_compute_fn=self.recorder) |
|
899 | 902 |
self.assertTrue(self.recorder.called) |
900 | 903 |
self.assertEqual(ret, []) |
901 | 904 |
|
... | ... | |
918 | 921 |
|
919 | 922 |
def testNoViolation(self): |
920 | 923 |
compute_recoder = _CallRecorder(return_value=[]) |
921 |
cmdlib._CheckTargetNodeIPolicy(self.lu, NotImplemented, self.instance,
|
|
922 |
self.target_node, NotImplemented, |
|
923 |
_compute_fn=compute_recoder) |
|
924 |
instance._CheckTargetNodeIPolicy(self.lu, NotImplemented, self.instance,
|
|
925 |
self.target_node, NotImplemented,
|
|
926 |
_compute_fn=compute_recoder)
|
|
924 | 927 |
self.assertTrue(compute_recoder.called) |
925 | 928 |
self.assertEqual(self.lu.warning_log, []) |
926 | 929 |
|
927 | 930 |
def testNoIgnore(self): |
928 | 931 |
compute_recoder = _CallRecorder(return_value=["mem_size not in range"]) |
929 |
self.assertRaises(errors.OpPrereqError, cmdlib._CheckTargetNodeIPolicy, |
|
930 |
self.lu, NotImplemented, self.instance, self.target_node, |
|
931 |
NotImplemented, _compute_fn=compute_recoder) |
|
932 |
self.assertRaises(errors.OpPrereqError, instance._CheckTargetNodeIPolicy, |
|
933 |
self.lu, NotImplemented, self.instance, |
|
934 |
self.target_node, NotImplemented, |
|
935 |
_compute_fn=compute_recoder) |
|
932 | 936 |
self.assertTrue(compute_recoder.called) |
933 | 937 |
self.assertEqual(self.lu.warning_log, []) |
934 | 938 |
|
935 | 939 |
def testIgnoreViolation(self): |
936 | 940 |
compute_recoder = _CallRecorder(return_value=["mem_size not in range"]) |
937 |
cmdlib._CheckTargetNodeIPolicy(self.lu, NotImplemented, self.instance,
|
|
938 |
self.target_node, NotImplemented, |
|
939 |
ignore=True, _compute_fn=compute_recoder) |
|
941 |
instance._CheckTargetNodeIPolicy(self.lu, NotImplemented, self.instance,
|
|
942 |
self.target_node, NotImplemented,
|
|
943 |
ignore=True, _compute_fn=compute_recoder)
|
|
940 | 944 |
self.assertTrue(compute_recoder.called) |
941 | 945 |
msg = ("Instance does not meet target node group's (bar) instance policy:" |
942 | 946 |
" mem_size not in range") |
... | ... | |
947 | 951 |
def testEmptyContainer(self): |
948 | 952 |
container = [] |
949 | 953 |
chgdesc = [] |
950 |
cmdlib.ApplyContainerMods("test", container, chgdesc, [], None, None, None) |
|
954 |
instance.ApplyContainerMods("test", container, chgdesc, [], None, None, |
|
955 |
None) |
|
951 | 956 |
self.assertEqual(container, []) |
952 | 957 |
self.assertEqual(chgdesc, []) |
953 | 958 |
|
954 | 959 |
def testAdd(self): |
955 | 960 |
container = [] |
956 | 961 |
chgdesc = [] |
957 |
mods = cmdlib.PrepareContainerMods([
|
|
962 |
mods = instance.PrepareContainerMods([
|
|
958 | 963 |
(constants.DDM_ADD, -1, "Hello"), |
959 | 964 |
(constants.DDM_ADD, -1, "World"), |
960 | 965 |
(constants.DDM_ADD, 0, "Start"), |
961 | 966 |
(constants.DDM_ADD, -1, "End"), |
962 | 967 |
], None) |
963 |
cmdlib.ApplyContainerMods("test", container, chgdesc, mods,
|
|
964 |
None, None, None) |
|
968 |
instance.ApplyContainerMods("test", container, chgdesc, mods,
|
|
969 |
None, None, None)
|
|
965 | 970 |
self.assertEqual(container, ["Start", "Hello", "World", "End"]) |
966 | 971 |
self.assertEqual(chgdesc, []) |
967 | 972 |
|
968 |
mods = cmdlib.PrepareContainerMods([
|
|
973 |
mods = instance.PrepareContainerMods([
|
|
969 | 974 |
(constants.DDM_ADD, 0, "zero"), |
970 | 975 |
(constants.DDM_ADD, 3, "Added"), |
971 | 976 |
(constants.DDM_ADD, 5, "four"), |
972 | 977 |
(constants.DDM_ADD, 7, "xyz"), |
973 | 978 |
], None) |
974 |
cmdlib.ApplyContainerMods("test", container, chgdesc, mods,
|
|
975 |
None, None, None) |
|
979 |
instance.ApplyContainerMods("test", container, chgdesc, mods,
|
|
980 |
None, None, None)
|
|
976 | 981 |
self.assertEqual(container, |
977 | 982 |
["zero", "Start", "Hello", "Added", "World", "four", |
978 | 983 |
"End", "xyz"]) |
979 | 984 |
self.assertEqual(chgdesc, []) |
980 | 985 |
|
981 | 986 |
for idx in [-2, len(container) + 1]: |
982 |
mods = cmdlib.PrepareContainerMods([
|
|
987 |
mods = instance.PrepareContainerMods([
|
|
983 | 988 |
(constants.DDM_ADD, idx, "error"), |
984 | 989 |
], None) |
985 |
self.assertRaises(IndexError, cmdlib.ApplyContainerMods,
|
|
990 |
self.assertRaises(IndexError, instance.ApplyContainerMods,
|
|
986 | 991 |
"test", container, None, mods, None, None, None) |
987 | 992 |
|
988 | 993 |
def testRemoveError(self): |
989 | 994 |
for idx in [0, 1, 2, 100, -1, -4]: |
990 |
mods = cmdlib.PrepareContainerMods([
|
|
995 |
mods = instance.PrepareContainerMods([
|
|
991 | 996 |
(constants.DDM_REMOVE, idx, None), |
992 | 997 |
], None) |
993 |
self.assertRaises(IndexError, cmdlib.ApplyContainerMods,
|
|
998 |
self.assertRaises(IndexError, instance.ApplyContainerMods,
|
|
994 | 999 |
"test", [], None, mods, None, None, None) |
995 | 1000 |
|
996 |
mods = cmdlib.PrepareContainerMods([
|
|
1001 |
mods = instance.PrepareContainerMods([
|
|
997 | 1002 |
(constants.DDM_REMOVE, 0, object()), |
998 | 1003 |
], None) |
999 |
self.assertRaises(AssertionError, cmdlib.ApplyContainerMods,
|
|
1004 |
self.assertRaises(AssertionError, instance.ApplyContainerMods,
|
|
1000 | 1005 |
"test", [""], None, mods, None, None, None) |
1001 | 1006 |
|
1002 | 1007 |
def testAddError(self): |
1003 | 1008 |
for idx in range(-100, -1) + [100]: |
1004 |
mods = cmdlib.PrepareContainerMods([
|
|
1009 |
mods = instance.PrepareContainerMods([
|
|
1005 | 1010 |
(constants.DDM_ADD, idx, None), |
1006 | 1011 |
], None) |
1007 |
self.assertRaises(IndexError, cmdlib.ApplyContainerMods,
|
|
1012 |
self.assertRaises(IndexError, instance.ApplyContainerMods,
|
|
1008 | 1013 |
"test", [], None, mods, None, None, None) |
1009 | 1014 |
|
1010 | 1015 |
def testRemove(self): |
1011 | 1016 |
container = ["item 1", "item 2"] |
1012 |
mods = cmdlib.PrepareContainerMods([
|
|
1017 |
mods = instance.PrepareContainerMods([
|
|
1013 | 1018 |
(constants.DDM_ADD, -1, "aaa"), |
1014 | 1019 |
(constants.DDM_REMOVE, -1, None), |
1015 | 1020 |
(constants.DDM_ADD, -1, "bbb"), |
1016 | 1021 |
], None) |
1017 | 1022 |
chgdesc = [] |
1018 |
cmdlib.ApplyContainerMods("test", container, chgdesc, mods,
|
|
1019 |
None, None, None) |
|
1023 |
instance.ApplyContainerMods("test", container, chgdesc, mods,
|
|
1024 |
None, None, None)
|
|
1020 | 1025 |
self.assertEqual(container, ["item 1", "item 2", "bbb"]) |
1021 | 1026 |
self.assertEqual(chgdesc, [ |
1022 | 1027 |
("test/2", "remove"), |
... | ... | |
1024 | 1029 |
|
1025 | 1030 |
def testModify(self): |
1026 | 1031 |
container = ["item 1", "item 2"] |
1027 |
mods = cmdlib.PrepareContainerMods([
|
|
1032 |
mods = instance.PrepareContainerMods([
|
|
1028 | 1033 |
(constants.DDM_MODIFY, -1, "a"), |
1029 | 1034 |
(constants.DDM_MODIFY, 0, "b"), |
1030 | 1035 |
(constants.DDM_MODIFY, 1, "c"), |
1031 | 1036 |
], None) |
1032 | 1037 |
chgdesc = [] |
1033 |
cmdlib.ApplyContainerMods("test", container, chgdesc, mods,
|
|
1034 |
None, None, None) |
|
1038 |
instance.ApplyContainerMods("test", container, chgdesc, mods,
|
|
1039 |
None, None, None)
|
|
1035 | 1040 |
self.assertEqual(container, ["item 1", "item 2"]) |
1036 | 1041 |
self.assertEqual(chgdesc, []) |
1037 | 1042 |
|
1038 | 1043 |
for idx in [-2, len(container) + 1]: |
1039 |
mods = cmdlib.PrepareContainerMods([
|
|
1044 |
mods = instance.PrepareContainerMods([
|
|
1040 | 1045 |
(constants.DDM_MODIFY, idx, "error"), |
1041 | 1046 |
], None) |
1042 |
self.assertRaises(IndexError, cmdlib.ApplyContainerMods,
|
|
1047 |
self.assertRaises(IndexError, instance.ApplyContainerMods,
|
|
1043 | 1048 |
"test", container, None, mods, None, None, None) |
1044 | 1049 |
|
1045 | 1050 |
class _PrivateData: |
... | ... | |
1067 | 1072 |
def testAddWithCreateFunction(self): |
1068 | 1073 |
container = [] |
1069 | 1074 |
chgdesc = [] |
1070 |
mods = cmdlib.PrepareContainerMods([
|
|
1075 |
mods = instance.PrepareContainerMods([
|
|
1071 | 1076 |
(constants.DDM_ADD, -1, "Hello"), |
1072 | 1077 |
(constants.DDM_ADD, -1, "World"), |
1073 | 1078 |
(constants.DDM_ADD, 0, "Start"), |
... | ... | |
1077 | 1082 |
(constants.DDM_REMOVE, 2, None), |
1078 | 1083 |
(constants.DDM_ADD, 1, "More"), |
1079 | 1084 |
], self._PrivateData) |
1080 |
cmdlib.ApplyContainerMods("test", container, chgdesc, mods, |
|
1081 |
self._CreateTestFn, self._ModifyTestFn, self._RemoveTestFn) |
|
1085 |
instance.ApplyContainerMods("test", container, chgdesc, mods, |
|
1086 |
self._CreateTestFn, self._ModifyTestFn, |
|
1087 |
self._RemoveTestFn) |
|
1082 | 1088 |
self.assertEqual(container, [ |
1083 | 1089 |
(000, "Start"), |
1084 | 1090 |
(100, "More"), |
... | ... | |
1156 | 1162 |
return copy.deepcopy(constants.DISK_DT_DEFAULTS) |
1157 | 1163 |
|
1158 | 1164 |
def testWrongDiskTemplate(self): |
1159 |
gdt = cmdlib._GenerateDiskTemplate
|
|
1165 |
gdt = instance._GenerateDiskTemplate
|
|
1160 | 1166 |
disk_template = "##unknown##" |
1161 | 1167 |
|
1162 | 1168 |
assert disk_template not in constants.DISK_TEMPLATES |
... | ... | |
1167 | 1173 |
self.GetDiskParams()) |
1168 | 1174 |
|
1169 | 1175 |
def testDiskless(self): |
1170 |
gdt = cmdlib._GenerateDiskTemplate
|
|
1176 |
gdt = instance._GenerateDiskTemplate
|
|
1171 | 1177 |
|
1172 | 1178 |
result = gdt(self.lu, constants.DT_DISKLESS, "inst27734.example.com", |
1173 | 1179 |
"node30113.example.com", [], [], |
... | ... | |
1180 | 1186 |
file_driver=NotImplemented, |
1181 | 1187 |
req_file_storage=NotImplemented, |
1182 | 1188 |
req_shr_file_storage=NotImplemented): |
1183 |
gdt = cmdlib._GenerateDiskTemplate
|
|
1189 |
gdt = instance._GenerateDiskTemplate
|
|
1184 | 1190 |
|
1185 | 1191 |
map(lambda params: utils.ForceDictType(params, |
1186 | 1192 |
constants.IDISK_PARAMS_TYPES), |
... | ... | |
1210 | 1216 |
self.assertTrue(disk.children is None) |
1211 | 1217 |
|
1212 | 1218 |
self._CheckIvNames(result, base_index, base_index + len(disk_info)) |
1213 |
cmdlib._UpdateIvNames(base_index, result)
|
|
1219 |
instance._UpdateIvNames(base_index, result)
|
|
1214 | 1220 |
self._CheckIvNames(result, base_index, base_index + len(disk_info)) |
1215 | 1221 |
|
1216 | 1222 |
return result |
... | ... | |
1309 | 1315 |
]) |
1310 | 1316 |
|
1311 | 1317 |
def testDrbd8(self): |
1312 |
gdt = cmdlib._GenerateDiskTemplate
|
|
1318 |
gdt = instance._GenerateDiskTemplate
|
|
1313 | 1319 |
drbd8_defaults = constants.DISK_LD_DEFAULTS[constants.LD_DRBD8] |
1314 | 1320 |
drbd8_default_metavg = drbd8_defaults[constants.LDP_DEFAULT_METAVG] |
1315 | 1321 |
|
... | ... | |
1374 | 1380 |
self.assertEqual(disk.children[1].size, constants.DRBD_META_SIZE) |
1375 | 1381 |
|
1376 | 1382 |
self._CheckIvNames(result, 0, len(disk_info)) |
1377 |
cmdlib._UpdateIvNames(0, result)
|
|
1383 |
instance._UpdateIvNames(0, result)
|
|
1378 | 1384 |
self._CheckIvNames(result, 0, len(disk_info)) |
1379 | 1385 |
|
1380 | 1386 |
self.assertEqual(map(operator.attrgetter("logical_id"), result), [ |
... | ... | |
1475 | 1481 |
objects.Disk(dev_type=constants.LD_LV), |
1476 | 1482 |
] |
1477 | 1483 |
|
1478 |
instance = objects.Instance(name="inst21201",
|
|
1479 |
primary_node=node_name,
|
|
1480 |
disk_template=constants.DT_PLAIN,
|
|
1481 |
disks=disks)
|
|
1484 |
inst = objects.Instance(name="inst21201", |
|
1485 |
primary_node=node_name, |
|
1486 |
disk_template=constants.DT_PLAIN, |
|
1487 |
disks=disks) |
|
1482 | 1488 |
|
1483 |
self.assertRaises(errors.OpExecError, cmdlib._WipeDisks, lu, instance)
|
|
1489 |
self.assertRaises(errors.OpExecError, instance._WipeDisks, lu, inst)
|
|
1484 | 1490 |
|
1485 | 1491 |
def _FailingWipeCb(self, (disk, _), offset, size): |
1486 | 1492 |
# This should only ever be called for the first disk |
... | ... | |
1502 | 1508 |
objects.Disk(dev_type=constants.LD_LV, logical_id="disk2", size=256), |
1503 | 1509 |
] |
1504 | 1510 |
|
1505 |
instance = objects.Instance(name="inst562",
|
|
1506 |
primary_node=node_name,
|
|
1507 |
disk_template=constants.DT_PLAIN,
|
|
1508 |
disks=disks)
|
|
1511 |
inst = objects.Instance(name="inst562", |
|
1512 |
primary_node=node_name, |
|
1513 |
disk_template=constants.DT_PLAIN, |
|
1514 |
disks=disks) |
|
1509 | 1515 |
|
1510 | 1516 |
try: |
1511 |
cmdlib._WipeDisks(lu, instance)
|
|
1517 |
instance._WipeDisks(lu, inst)
|
|
1512 | 1518 |
except errors.OpExecError, err: |
1513 | 1519 |
self.assertTrue(str(err), "Could not wipe disk 0 at offset 0 ") |
1514 | 1520 |
else: |
... | ... | |
1549 | 1555 |
size=constants.MAX_WIPE_CHUNK), |
1550 | 1556 |
] |
1551 | 1557 |
|
1552 |
(lu, instance, pauset, progresst) = self._PrepareWipeTest(0, disks)
|
|
1558 |
(lu, inst, pauset, progresst) = self._PrepareWipeTest(0, disks) |
|
1553 | 1559 |
|
1554 |
cmdlib._WipeDisks(lu, instance)
|
|
1560 |
instance._WipeDisks(lu, inst)
|
|
1555 | 1561 |
|
1556 | 1562 |
self.assertEqual(pauset.history, [ |
1557 | 1563 |
("disk0", 1024, True), |
... | ... | |
1577 | 1583 |
size=start_offset + (100 * 1024)), |
1578 | 1584 |
] |
1579 | 1585 |
|
1580 |
(lu, instance, pauset, progresst) = \
|
|
1586 |
(lu, inst, pauset, progresst) = \ |
|
1581 | 1587 |
self._PrepareWipeTest(start_offset, disks) |
1582 | 1588 |
|
1583 | 1589 |
# Test start offset with only one disk |
1584 |
cmdlib._WipeDisks(lu, instance,
|
|
1585 |
disks=[(1, disks[1], start_offset)]) |
|
1590 |
instance._WipeDisks(lu, inst,
|
|
1591 |
disks=[(1, disks[1], start_offset)])
|
|
1586 | 1592 |
|
1587 | 1593 |
# Only the second disk may have been paused and wiped |
1588 | 1594 |
self.assertEqual(pauset.history, [ |
... | ... | |
1598 | 1604 |
def testLessThanOneMebibyte(self): |
1599 | 1605 |
for i in [1, 2, 7, 512, 1000, 1023]: |
1600 | 1606 |
lu = _FakeLU() |
1601 |
result = cmdlib._DiskSizeInBytesToMebibytes(lu, i)
|
|
1607 |
result = instance._DiskSizeInBytesToMebibytes(lu, i)
|
|
1602 | 1608 |
self.assertEqual(result, 1) |
1603 | 1609 |
self.assertEqual(len(lu.warning_log), 1) |
1604 | 1610 |
self.assertEqual(len(lu.warning_log[0]), 2) |
... | ... | |
1608 | 1614 |
def testEven(self): |
1609 | 1615 |
for i in [1, 2, 7, 512, 1000, 1023]: |
1610 | 1616 |
lu = _FakeLU() |
1611 |
result = cmdlib._DiskSizeInBytesToMebibytes(lu, i * 1024 * 1024)
|
|
1617 |
result = instance._DiskSizeInBytesToMebibytes(lu, i * 1024 * 1024)
|
|
1612 | 1618 |
self.assertEqual(result, i) |
1613 | 1619 |
self.assertFalse(lu.warning_log) |
1614 | 1620 |
|
... | ... | |
1617 | 1623 |
for j in [1, 2, 486, 326, 986, 1023]: |
1618 | 1624 |
lu = _FakeLU() |
1619 | 1625 |
size = (1024 * 1024 * i) + j |
1620 |
result = cmdlib._DiskSizeInBytesToMebibytes(lu, size)
|
|
1626 |
result = instance._DiskSizeInBytesToMebibytes(lu, size)
|
|
1621 | 1627 |
self.assertEqual(result, i + 1, msg="Amount was not rounded up") |
1622 | 1628 |
self.assertEqual(len(lu.warning_log), 1) |
1623 | 1629 |
self.assertEqual(len(lu.warning_log[0]), 2) |
... | ... | |
1627 | 1633 |
|
1628 | 1634 |
class TestCopyLockList(unittest.TestCase): |
1629 | 1635 |
def test(self): |
1630 |
self.assertEqual(cmdlib._CopyLockList([]), [])
|
|
1631 |
self.assertEqual(cmdlib._CopyLockList(None), None)
|
|
1632 |
self.assertEqual(cmdlib._CopyLockList(locking.ALL_SET), locking.ALL_SET)
|
|
1636 |
self.assertEqual(instance._CopyLockList([]), [])
|
|
1637 |
self.assertEqual(instance._CopyLockList(None), None)
|
|
1638 |
self.assertEqual(instance._CopyLockList(locking.ALL_SET), locking.ALL_SET)
|
|
1633 | 1639 |
|
1634 | 1640 |
names = ["foo", "bar"] |
1635 |
output = cmdlib._CopyLockList(names)
|
|
1641 |
output = instance._CopyLockList(names)
|
|
1636 | 1642 |
self.assertEqual(names, output) |
1637 | 1643 |
self.assertNotEqual(id(names), id(output), msg="List was not copied") |
1638 | 1644 |
|
... | ... | |
1651 | 1657 |
return op |
1652 | 1658 |
|
1653 | 1659 |
def testMissingAttributes(self): |
1654 |
self.assertRaises(AttributeError, cmdlib._CheckOpportunisticLocking,
|
|
1660 |
self.assertRaises(AttributeError, instance._CheckOpportunisticLocking,
|
|
1655 | 1661 |
object()) |
1656 | 1662 |
|
1657 | 1663 |
def testDefaults(self): |
1658 | 1664 |
op = self._MakeOp() |
1659 |
cmdlib._CheckOpportunisticLocking(op)
|
|
1665 |
instance._CheckOpportunisticLocking(op)
|
|
1660 | 1666 |
|
1661 | 1667 |
def test(self): |
1662 | 1668 |
for iallocator in [None, "something", "other"]: |
1663 | 1669 |
for opplock in [False, True]: |
1664 |
op = self._MakeOp(iallocator=iallocator, opportunistic_locking=opplock) |
|
1670 |
op = self._MakeOp(iallocator=iallocator, |
|
1671 |
opportunistic_locking=opplock) |
|
1665 | 1672 |
if opplock and not iallocator: |
1666 | 1673 |
self.assertRaises(errors.OpPrereqError, |
1667 |
cmdlib._CheckOpportunisticLocking, op)
|
|
1674 |
instance._CheckOpportunisticLocking, op)
|
|
1668 | 1675 |
else: |
1669 |
cmdlib._CheckOpportunisticLocking(op)
|
|
1676 |
instance._CheckOpportunisticLocking(op)
|
|
1670 | 1677 |
|
1671 | 1678 |
|
1672 | 1679 |
class _OpTestVerifyErrors(opcodes.OpCode): |
Also available in: Unified diff