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