Revision 919db916 test/py/ganeti.cli_unittest.py
| b/test/py/ganeti.cli_unittest.py | ||
|---|---|---|
| 21 | 21 |
|
| 22 | 22 |
"""Script for unittesting the cli module""" |
| 23 | 23 |
|
| 24 |
import unittest |
|
| 24 |
import copy |
|
| 25 |
import testutils |
|
| 25 | 26 |
import time |
| 27 |
import unittest |
|
| 26 | 28 |
from cStringIO import StringIO |
| 27 | 29 |
|
| 28 |
import ganeti |
|
| 29 |
import testutils |
|
| 30 |
|
|
| 31 | 30 |
from ganeti import constants |
| 32 | 31 |
from ganeti import cli |
| 33 | 32 |
from ganeti import errors |
| ... | ... | |
| 1181 | 1180 |
|
| 1182 | 1181 |
class TestCreateIPolicyFromOpts(unittest.TestCase): |
| 1183 | 1182 |
"""Test case for cli.CreateIPolicyFromOpts.""" |
| 1183 |
def setUp(self): |
|
| 1184 |
# Policies are big, and we want to see the difference in case of an error |
|
| 1185 |
self.maxDiff = None |
|
| 1186 |
|
|
| 1184 | 1187 |
def _RecursiveCheckMergedDicts(self, default_pol, diff_pol, merged_pol): |
| 1185 | 1188 |
self.assertTrue(type(default_pol) is dict) |
| 1186 | 1189 |
self.assertTrue(type(diff_pol) is dict) |
| ... | ... | |
| 1197 | 1200 |
self.assertEqual(val, default_pol[key]) |
| 1198 | 1201 |
|
| 1199 | 1202 |
def testClusterPolicy(self): |
| 1200 |
exp_pol0 = {
|
|
| 1201 |
constants.ISPECS_MINMAX: {
|
|
| 1202 |
constants.ISPECS_MIN: {},
|
|
| 1203 |
constants.ISPECS_MAX: {},
|
|
| 1204 |
}, |
|
| 1205 |
constants.ISPECS_STD: {},
|
|
| 1206 |
} |
|
| 1203 |
pol0 = cli.CreateIPolicyFromOpts( |
|
| 1204 |
ispecs_mem_size={},
|
|
| 1205 |
ispecs_cpu_count={},
|
|
| 1206 |
ispecs_disk_count={},
|
|
| 1207 |
ispecs_disk_size={},
|
|
| 1208 |
ispecs_nic_count={},
|
|
| 1209 |
ipolicy_disk_templates=None, |
|
| 1210 |
ipolicy_vcpu_ratio=None, |
|
| 1211 |
ipolicy_spindle_ratio=None, |
|
| 1212 |
fill_all=True |
|
| 1213 |
) |
|
| 1214 |
self.assertEqual(pol0, constants.IPOLICY_DEFAULTS) |
|
| 1215 |
|
|
| 1207 | 1216 |
exp_pol1 = {
|
| 1208 | 1217 |
constants.ISPECS_MINMAX: {
|
| 1209 | 1218 |
constants.ISPECS_MIN: {
|
| ... | ... | |
| 1221 | 1230 |
}, |
| 1222 | 1231 |
constants.IPOLICY_VCPU_RATIO: 3.1, |
| 1223 | 1232 |
} |
| 1233 |
pol1 = cli.CreateIPolicyFromOpts( |
|
| 1234 |
ispecs_mem_size={"max": "12g"},
|
|
| 1235 |
ispecs_cpu_count={"min": 2, "std": 2},
|
|
| 1236 |
ispecs_disk_count={"min": 1, "max": 2, "std": 2},
|
|
| 1237 |
ispecs_disk_size={},
|
|
| 1238 |
ispecs_nic_count={},
|
|
| 1239 |
ipolicy_disk_templates=None, |
|
| 1240 |
ipolicy_vcpu_ratio=3.1, |
|
| 1241 |
ipolicy_spindle_ratio=None, |
|
| 1242 |
fill_all=True |
|
| 1243 |
) |
|
| 1244 |
self._RecursiveCheckMergedDicts(constants.IPOLICY_DEFAULTS, |
|
| 1245 |
exp_pol1, pol1) |
|
| 1246 |
|
|
| 1224 | 1247 |
exp_pol2 = {
|
| 1225 | 1248 |
constants.ISPECS_MINMAX: {
|
| 1226 | 1249 |
constants.ISPECS_MIN: {
|
| ... | ... | |
| 1238 | 1261 |
constants.IPOLICY_SPINDLE_RATIO: 1.3, |
| 1239 | 1262 |
constants.IPOLICY_DTS: ["templates"], |
| 1240 | 1263 |
} |
| 1241 |
for fillall in [False, True]: |
|
| 1242 |
pol0 = cli.CreateIPolicyFromOpts( |
|
| 1243 |
ispecs_mem_size={},
|
|
| 1244 |
ispecs_cpu_count={},
|
|
| 1245 |
ispecs_disk_count={},
|
|
| 1246 |
ispecs_disk_size={},
|
|
| 1247 |
ispecs_nic_count={},
|
|
| 1264 |
pol2 = cli.CreateIPolicyFromOpts( |
|
| 1265 |
ispecs_mem_size={},
|
|
| 1266 |
ispecs_cpu_count={"std": 2},
|
|
| 1267 |
ispecs_disk_count={},
|
|
| 1268 |
ispecs_disk_size={"min": "0.5g"},
|
|
| 1269 |
ispecs_nic_count={"min": 2, "max": 3, "std": 3},
|
|
| 1270 |
ipolicy_disk_templates=["templates"], |
|
| 1271 |
ipolicy_vcpu_ratio=None, |
|
| 1272 |
ipolicy_spindle_ratio=1.3, |
|
| 1273 |
fill_all=True |
|
| 1274 |
) |
|
| 1275 |
self._RecursiveCheckMergedDicts(constants.IPOLICY_DEFAULTS, |
|
| 1276 |
exp_pol2, pol2) |
|
| 1277 |
|
|
| 1278 |
for fill_all in [False, True]: |
|
| 1279 |
exp_pol3 = {
|
|
| 1280 |
constants.ISPECS_STD: {
|
|
| 1281 |
constants.ISPEC_CPU_COUNT: 2, |
|
| 1282 |
constants.ISPEC_NIC_COUNT: 3, |
|
| 1283 |
}, |
|
| 1284 |
} |
|
| 1285 |
pol3 = cli.CreateIPolicyFromOpts( |
|
| 1286 |
std_ispecs={
|
|
| 1287 |
constants.ISPEC_CPU_COUNT: "2", |
|
| 1288 |
constants.ISPEC_NIC_COUNT: "3", |
|
| 1289 |
}, |
|
| 1248 | 1290 |
ipolicy_disk_templates=None, |
| 1249 | 1291 |
ipolicy_vcpu_ratio=None, |
| 1250 | 1292 |
ipolicy_spindle_ratio=None, |
| 1251 |
fill_all=fillall |
|
| 1252 |
) |
|
| 1253 |
if fillall: |
|
| 1254 |
self.assertEqual(pol0, constants.IPOLICY_DEFAULTS) |
|
| 1255 |
else: |
|
| 1256 |
self.assertEqual(pol0, exp_pol0) |
|
| 1257 |
pol1 = cli.CreateIPolicyFromOpts( |
|
| 1258 |
ispecs_mem_size={"max": "12g"},
|
|
| 1259 |
ispecs_cpu_count={"min": 2, "std": 2},
|
|
| 1260 |
ispecs_disk_count={"min": 1, "max": 2, "std": 2},
|
|
| 1261 |
ispecs_disk_size={},
|
|
| 1262 |
ispecs_nic_count={},
|
|
| 1263 |
ipolicy_disk_templates=None, |
|
| 1264 |
ipolicy_vcpu_ratio=3.1, |
|
| 1265 |
ipolicy_spindle_ratio=None, |
|
| 1266 |
fill_all=fillall |
|
| 1293 |
fill_all=fill_all |
|
| 1267 | 1294 |
) |
| 1268 |
if fillall: |
|
| 1295 |
if fill_all:
|
|
| 1269 | 1296 |
self._RecursiveCheckMergedDicts(constants.IPOLICY_DEFAULTS, |
| 1270 |
exp_pol1, pol1)
|
|
| 1297 |
exp_pol3, pol3)
|
|
| 1271 | 1298 |
else: |
| 1272 |
self.assertEqual(pol1, exp_pol1) |
|
| 1273 |
pol2 = cli.CreateIPolicyFromOpts( |
|
| 1274 |
ispecs_mem_size={},
|
|
| 1275 |
ispecs_cpu_count={"std": 2},
|
|
| 1276 |
ispecs_disk_count={},
|
|
| 1277 |
ispecs_disk_size={"min": "0.5g"},
|
|
| 1278 |
ispecs_nic_count={"min": 2, "max": 3, "std": 3},
|
|
| 1279 |
ipolicy_disk_templates=["templates"], |
|
| 1280 |
ipolicy_vcpu_ratio=None, |
|
| 1281 |
ipolicy_spindle_ratio=1.3, |
|
| 1282 |
fill_all=fillall |
|
| 1283 |
) |
|
| 1284 |
if fillall: |
|
| 1285 |
self._RecursiveCheckMergedDicts(constants.IPOLICY_DEFAULTS, |
|
| 1286 |
exp_pol2, pol2) |
|
| 1299 |
self.assertEqual(pol3, exp_pol3) |
|
| 1300 |
|
|
| 1301 |
def testPartialPolicy(self): |
|
| 1302 |
exp_pol0 = objects.MakeEmptyIPolicy() |
|
| 1303 |
pol0 = cli.CreateIPolicyFromOpts( |
|
| 1304 |
minmax_ispecs=None, |
|
| 1305 |
std_ispecs=None, |
|
| 1306 |
ipolicy_disk_templates=None, |
|
| 1307 |
ipolicy_vcpu_ratio=None, |
|
| 1308 |
ipolicy_spindle_ratio=None, |
|
| 1309 |
fill_all=False |
|
| 1310 |
) |
|
| 1311 |
self.assertEqual(pol0, exp_pol0) |
|
| 1312 |
|
|
| 1313 |
exp_pol1 = {
|
|
| 1314 |
constants.IPOLICY_VCPU_RATIO: 3.1, |
|
| 1315 |
} |
|
| 1316 |
pol1 = cli.CreateIPolicyFromOpts( |
|
| 1317 |
minmax_ispecs=None, |
|
| 1318 |
std_ispecs=None, |
|
| 1319 |
ipolicy_disk_templates=None, |
|
| 1320 |
ipolicy_vcpu_ratio=3.1, |
|
| 1321 |
ipolicy_spindle_ratio=None, |
|
| 1322 |
fill_all=False |
|
| 1323 |
) |
|
| 1324 |
self.assertEqual(pol1, exp_pol1) |
|
| 1325 |
|
|
| 1326 |
exp_pol2 = {
|
|
| 1327 |
constants.IPOLICY_SPINDLE_RATIO: 1.3, |
|
| 1328 |
constants.IPOLICY_DTS: ["templates"], |
|
| 1329 |
} |
|
| 1330 |
pol2 = cli.CreateIPolicyFromOpts( |
|
| 1331 |
minmax_ispecs=None, |
|
| 1332 |
std_ispecs=None, |
|
| 1333 |
ipolicy_disk_templates=["templates"], |
|
| 1334 |
ipolicy_vcpu_ratio=None, |
|
| 1335 |
ipolicy_spindle_ratio=1.3, |
|
| 1336 |
fill_all=False |
|
| 1337 |
) |
|
| 1338 |
self.assertEqual(pol2, exp_pol2) |
|
| 1339 |
|
|
| 1340 |
def _TestInvalidISpecs(self, minmax_ispecs, std_ispecs, fail=True): |
|
| 1341 |
for fill_all in [False, True]: |
|
| 1342 |
if fail: |
|
| 1343 |
self.assertRaises((errors.OpPrereqError, |
|
| 1344 |
errors.UnitParseError, |
|
| 1345 |
errors.TypeEnforcementError), |
|
| 1346 |
cli.CreateIPolicyFromOpts, |
|
| 1347 |
minmax_ispecs=minmax_ispecs, |
|
| 1348 |
std_ispecs=std_ispecs, |
|
| 1349 |
fill_all=fill_all) |
|
| 1287 | 1350 |
else: |
| 1288 |
self.assertEqual(pol2, exp_pol2) |
|
| 1351 |
cli.CreateIPolicyFromOpts(minmax_ispecs=minmax_ispecs, |
|
| 1352 |
std_ispecs=std_ispecs, |
|
| 1353 |
fill_all=fill_all) |
|
| 1289 | 1354 |
|
| 1290 | 1355 |
def testInvalidPolicies(self): |
| 1291 |
self.assertRaises(errors.TypeEnforcementError, cli.CreateIPolicyFromOpts, |
|
| 1292 |
ispecs_mem_size={}, ispecs_cpu_count={},
|
|
| 1293 |
ispecs_disk_count={}, ispecs_disk_size={"std": 1},
|
|
| 1294 |
ispecs_nic_count={}, ipolicy_disk_templates=None,
|
|
| 1295 |
ipolicy_vcpu_ratio=None, ipolicy_spindle_ratio=None, |
|
| 1296 |
group_ipolicy=True) |
|
| 1356 |
self.assertRaises(AssertionError, cli.CreateIPolicyFromOpts, |
|
| 1357 |
std_ispecs={constants.ISPEC_MEM_SIZE: 1024},
|
|
| 1358 |
ipolicy_disk_templates=None, ipolicy_vcpu_ratio=None, |
|
| 1359 |
ipolicy_spindle_ratio=None, group_ipolicy=True) |
|
| 1297 | 1360 |
self.assertRaises(errors.OpPrereqError, cli.CreateIPolicyFromOpts, |
| 1298 | 1361 |
ispecs_mem_size={"wrong": "x"}, ispecs_cpu_count={},
|
| 1299 | 1362 |
ispecs_disk_count={}, ispecs_disk_size={},
|
| 1300 | 1363 |
ispecs_nic_count={}, ipolicy_disk_templates=None,
|
| 1301 |
ipolicy_vcpu_ratio=None, ipolicy_spindle_ratio=None) |
|
| 1364 |
ipolicy_vcpu_ratio=None, ipolicy_spindle_ratio=None, |
|
| 1365 |
fill_all=True) |
|
| 1302 | 1366 |
self.assertRaises(errors.TypeEnforcementError, cli.CreateIPolicyFromOpts, |
| 1303 | 1367 |
ispecs_mem_size={}, ispecs_cpu_count={"min": "default"},
|
| 1304 | 1368 |
ispecs_disk_count={}, ispecs_disk_size={},
|
| 1305 | 1369 |
ispecs_nic_count={}, ipolicy_disk_templates=None,
|
| 1306 |
ipolicy_vcpu_ratio=None, ipolicy_spindle_ratio=None) |
|
| 1370 |
ipolicy_vcpu_ratio=None, ipolicy_spindle_ratio=None, |
|
| 1371 |
fill_all=True) |
|
| 1372 |
|
|
| 1373 |
good_mmspecs = constants.ISPECS_MINMAX_DEFAULTS |
|
| 1374 |
self._TestInvalidISpecs(good_mmspecs, None, fail=False) |
|
| 1375 |
broken_mmspecs = copy.deepcopy(good_mmspecs) |
|
| 1376 |
for key in constants.ISPECS_MINMAX_KEYS: |
|
| 1377 |
for par in constants.ISPECS_PARAMETERS: |
|
| 1378 |
old = broken_mmspecs[key][par] |
|
| 1379 |
del broken_mmspecs[key][par] |
|
| 1380 |
self._TestInvalidISpecs(broken_mmspecs, None) |
|
| 1381 |
broken_mmspecs[key][par] = "invalid" |
|
| 1382 |
self._TestInvalidISpecs(broken_mmspecs, None) |
|
| 1383 |
broken_mmspecs[key][par] = old |
|
| 1384 |
broken_mmspecs[key]["invalid_key"] = None |
|
| 1385 |
self._TestInvalidISpecs(broken_mmspecs, None) |
|
| 1386 |
del broken_mmspecs[key]["invalid_key"] |
|
| 1387 |
assert broken_mmspecs == good_mmspecs |
|
| 1388 |
|
|
| 1389 |
good_stdspecs = constants.IPOLICY_DEFAULTS[constants.ISPECS_STD] |
|
| 1390 |
self._TestInvalidISpecs(None, good_stdspecs, fail=False) |
|
| 1391 |
broken_stdspecs = copy.deepcopy(good_stdspecs) |
|
| 1392 |
for par in constants.ISPECS_PARAMETERS: |
|
| 1393 |
old = broken_stdspecs[par] |
|
| 1394 |
broken_stdspecs[par] = "invalid" |
|
| 1395 |
self._TestInvalidISpecs(None, broken_stdspecs) |
|
| 1396 |
broken_stdspecs[par] = old |
|
| 1397 |
broken_stdspecs["invalid_key"] = None |
|
| 1398 |
self._TestInvalidISpecs(None, broken_stdspecs) |
|
| 1399 |
del broken_stdspecs["invalid_key"] |
|
| 1400 |
assert broken_stdspecs == good_stdspecs |
|
| 1307 | 1401 |
|
| 1308 | 1402 |
def testAllowedValues(self): |
| 1309 | 1403 |
allowedv = "blah" |
| 1310 | 1404 |
exp_pol1 = {
|
| 1311 |
constants.ISPECS_MINMAX: {
|
|
| 1312 |
constants.ISPECS_MIN: {
|
|
| 1313 |
constants.ISPEC_CPU_COUNT: allowedv, |
|
| 1314 |
}, |
|
| 1315 |
constants.ISPECS_MAX: {
|
|
| 1316 |
}, |
|
| 1317 |
}, |
|
| 1318 |
constants.ISPECS_STD: {
|
|
| 1319 |
}, |
|
| 1405 |
constants.ISPECS_MINMAX: allowedv, |
|
| 1320 | 1406 |
constants.IPOLICY_DTS: allowedv, |
| 1321 | 1407 |
constants.IPOLICY_VCPU_RATIO: allowedv, |
| 1322 | 1408 |
constants.IPOLICY_SPINDLE_RATIO: allowedv, |
| 1323 | 1409 |
} |
| 1324 |
pol1 = cli.CreateIPolicyFromOpts(ispecs_mem_size={},
|
|
| 1325 |
ispecs_cpu_count={"min": allowedv},
|
|
| 1326 |
ispecs_disk_count={},
|
|
| 1327 |
ispecs_disk_size={},
|
|
| 1328 |
ispecs_nic_count={},
|
|
| 1410 |
pol1 = cli.CreateIPolicyFromOpts(minmax_ispecs={allowedv: {}},
|
|
| 1411 |
std_ispecs=None, |
|
| 1329 | 1412 |
ipolicy_disk_templates=allowedv, |
| 1330 | 1413 |
ipolicy_vcpu_ratio=allowedv, |
| 1331 | 1414 |
ipolicy_spindle_ratio=allowedv, |
| ... | ... | |
| 1357 | 1440 |
exp_ipol[constants.ISPECS_MINMAX] = exp_minmax |
| 1358 | 1441 |
else: |
| 1359 | 1442 |
minmax_ispecs = None |
| 1360 |
if constants.ISPECS_MINMAX not in exp_ipol: |
|
| 1361 |
empty_minmax = dict((k, {}) for k in constants.ISPECS_MINMAX_KEYS)
|
|
| 1362 |
exp_ipol[constants.ISPECS_MINMAX] = empty_minmax |
|
| 1363 | 1443 |
if exp_std is not None: |
| 1364 | 1444 |
std_ispecs = self._ConvertSpecToStrings(exp_std) |
| 1365 | 1445 |
exp_ipol[constants.ISPECS_STD] = exp_std |
| 1366 | 1446 |
else: |
| 1367 | 1447 |
std_ispecs = None |
| 1368 |
if constants.ISPECS_STD not in exp_ipol: |
|
| 1369 |
exp_ipol[constants.ISPECS_STD] = {}
|
|
| 1370 | 1448 |
|
| 1371 | 1449 |
self._CheckNewStyleSpecsCall(exp_ipol, minmax_ispecs, std_ispecs, |
| 1372 | 1450 |
group_ipolicy, fill_all) |
Also available in: Unified diff