Revision 41044e04 test/py/ganeti.objects_unittest.py
| b/test/py/ganeti.objects_unittest.py | ||
|---|---|---|
| 22 | 22 |
"""Script for unittesting the objects module""" |
| 23 | 23 |
|
| 24 | 24 |
|
| 25 |
import copy |
|
| 25 | 26 |
import unittest |
| 26 | 27 |
|
| 27 | 28 |
from ganeti import constants |
| ... | ... | |
| 414 | 415 |
|
| 415 | 416 |
def _AssertIPolicyIsFull(self, policy): |
| 416 | 417 |
self.assertEqual(frozenset(policy.keys()), constants.IPOLICY_ALL_KEYS) |
| 417 |
minmax = policy[constants.ISPECS_MINMAX] |
|
| 418 |
self.assertEqual(frozenset(minmax.keys()), constants.ISPECS_MINMAX_KEYS) |
|
| 419 |
for key in constants.ISPECS_MINMAX_KEYS: |
|
| 420 |
self.assertEqual(frozenset(minmax[key].keys()), |
|
| 421 |
constants.ISPECS_PARAMETERS) |
|
| 418 |
self.assertTrue(len(policy[constants.ISPECS_MINMAX]) > 0) |
|
| 419 |
for minmax in policy[constants.ISPECS_MINMAX]: |
|
| 420 |
self.assertEqual(frozenset(minmax.keys()), constants.ISPECS_MINMAX_KEYS) |
|
| 421 |
for key in constants.ISPECS_MINMAX_KEYS: |
|
| 422 |
self.assertEqual(frozenset(minmax[key].keys()), |
|
| 423 |
constants.ISPECS_PARAMETERS) |
|
| 422 | 424 |
self.assertEqual(frozenset(policy[constants.ISPECS_STD].keys()), |
| 423 | 425 |
constants.ISPECS_PARAMETERS) |
| 424 | 426 |
|
| ... | ... | |
| 427 | 429 |
True) |
| 428 | 430 |
self._AssertIPolicyIsFull(constants.IPOLICY_DEFAULTS) |
| 429 | 431 |
|
| 432 |
def _AssertPolicyIsBad(self, ipolicy, do_check_std=None): |
|
| 433 |
if do_check_std is None: |
|
| 434 |
check_std_vals = [False, True] |
|
| 435 |
else: |
|
| 436 |
check_std_vals = [do_check_std] |
|
| 437 |
for check_std in check_std_vals: |
|
| 438 |
self.assertRaises(errors.ConfigurationError, |
|
| 439 |
objects.InstancePolicy.CheckISpecSyntax, |
|
| 440 |
ipolicy, check_std) |
|
| 441 |
|
|
| 430 | 442 |
def testCheckISpecSyntax(self): |
| 431 | 443 |
default_stdspec = constants.IPOLICY_DEFAULTS[constants.ISPECS_STD] |
| 432 | 444 |
incomplete_ipolicies = [ |
| 433 | 445 |
{
|
| 434 |
constants.ISPECS_MINMAX: {},
|
|
| 446 |
constants.ISPECS_MINMAX: [],
|
|
| 435 | 447 |
constants.ISPECS_STD: default_stdspec, |
| 436 | 448 |
}, |
| 437 | 449 |
{
|
| 438 |
constants.ISPECS_MINMAX: {
|
|
| 450 |
constants.ISPECS_MINMAX: [{}],
|
|
| 451 |
constants.ISPECS_STD: default_stdspec, |
|
| 452 |
}, |
|
| 453 |
{
|
|
| 454 |
constants.ISPECS_MINMAX: [{
|
|
| 439 | 455 |
constants.ISPECS_MIN: NotImplemented, |
| 440 |
}, |
|
| 456 |
}],
|
|
| 441 | 457 |
constants.ISPECS_STD: default_stdspec, |
| 442 | 458 |
}, |
| 443 | 459 |
{
|
| 444 |
constants.ISPECS_MINMAX: {
|
|
| 460 |
constants.ISPECS_MINMAX: [{
|
|
| 445 | 461 |
constants.ISPECS_MAX: NotImplemented, |
| 446 |
}, |
|
| 462 |
}],
|
|
| 447 | 463 |
constants.ISPECS_STD: default_stdspec, |
| 448 | 464 |
}, |
| 449 | 465 |
{
|
| 450 |
constants.ISPECS_MINMAX: {
|
|
| 466 |
constants.ISPECS_MINMAX: [{
|
|
| 451 | 467 |
constants.ISPECS_MIN: NotImplemented, |
| 452 | 468 |
constants.ISPECS_MAX: NotImplemented, |
| 453 |
}, |
|
| 469 |
}],
|
|
| 454 | 470 |
}, |
| 455 | 471 |
] |
| 456 | 472 |
for ipol in incomplete_ipolicies: |
| 457 | 473 |
self.assertRaises(errors.ConfigurationError, |
| 458 | 474 |
objects.InstancePolicy.CheckISpecSyntax, |
| 459 | 475 |
ipol, True) |
| 476 |
oldminmax = ipol[constants.ISPECS_MINMAX] |
|
| 477 |
if oldminmax: |
|
| 478 |
# Prepending valid specs shouldn't change the error |
|
| 479 |
ipol[constants.ISPECS_MINMAX] = ([constants.ISPECS_MINMAX_DEFAULTS] + |
|
| 480 |
oldminmax) |
|
| 481 |
self.assertRaises(errors.ConfigurationError, |
|
| 482 |
objects.InstancePolicy.CheckISpecSyntax, |
|
| 483 |
ipol, True) |
|
| 484 |
|
|
| 485 |
good_ipolicy = {
|
|
| 486 |
constants.ISPECS_MINMAX: [ |
|
| 487 |
{
|
|
| 488 |
constants.ISPECS_MIN: {
|
|
| 489 |
constants.ISPEC_MEM_SIZE: 64, |
|
| 490 |
constants.ISPEC_CPU_COUNT: 1, |
|
| 491 |
constants.ISPEC_DISK_COUNT: 2, |
|
| 492 |
constants.ISPEC_DISK_SIZE: 64, |
|
| 493 |
constants.ISPEC_NIC_COUNT: 1, |
|
| 494 |
constants.ISPEC_SPINDLE_USE: 1, |
|
| 495 |
}, |
|
| 496 |
constants.ISPECS_MAX: {
|
|
| 497 |
constants.ISPEC_MEM_SIZE: 16384, |
|
| 498 |
constants.ISPEC_CPU_COUNT: 5, |
|
| 499 |
constants.ISPEC_DISK_COUNT: 12, |
|
| 500 |
constants.ISPEC_DISK_SIZE: 1024, |
|
| 501 |
constants.ISPEC_NIC_COUNT: 9, |
|
| 502 |
constants.ISPEC_SPINDLE_USE: 18, |
|
| 503 |
}, |
|
| 504 |
}, |
|
| 505 |
{
|
|
| 506 |
constants.ISPECS_MIN: {
|
|
| 507 |
constants.ISPEC_MEM_SIZE: 32768, |
|
| 508 |
constants.ISPEC_CPU_COUNT: 8, |
|
| 509 |
constants.ISPEC_DISK_COUNT: 1, |
|
| 510 |
constants.ISPEC_DISK_SIZE: 1024, |
|
| 511 |
constants.ISPEC_NIC_COUNT: 1, |
|
| 512 |
constants.ISPEC_SPINDLE_USE: 1, |
|
| 513 |
}, |
|
| 514 |
constants.ISPECS_MAX: {
|
|
| 515 |
constants.ISPEC_MEM_SIZE: 65536, |
|
| 516 |
constants.ISPEC_CPU_COUNT: 10, |
|
| 517 |
constants.ISPEC_DISK_COUNT: 5, |
|
| 518 |
constants.ISPEC_DISK_SIZE: 1024 * 1024, |
|
| 519 |
constants.ISPEC_NIC_COUNT: 3, |
|
| 520 |
constants.ISPEC_SPINDLE_USE: 12, |
|
| 521 |
}, |
|
| 522 |
}, |
|
| 523 |
], |
|
| 524 |
} |
|
| 525 |
good_ipolicy[constants.ISPECS_STD] = copy.deepcopy( |
|
| 526 |
good_ipolicy[constants.ISPECS_MINMAX][0][constants.ISPECS_MAX]) |
|
| 527 |
# Check that it's really good before making it bad |
|
| 528 |
objects.InstancePolicy.CheckISpecSyntax(good_ipolicy, True) |
|
| 529 |
|
|
| 530 |
bad_ipolicy = copy.deepcopy(good_ipolicy) |
|
| 531 |
for minmax in bad_ipolicy[constants.ISPECS_MINMAX]: |
|
| 532 |
for (key, spec) in minmax.items(): |
|
| 533 |
for param in spec: |
|
| 534 |
oldv = spec[param] |
|
| 535 |
del spec[param] |
|
| 536 |
self._AssertPolicyIsBad(bad_ipolicy) |
|
| 537 |
if key == constants.ISPECS_MIN: |
|
| 538 |
spec[param] = minmax[constants.ISPECS_MAX][param] + 1 |
|
| 539 |
self._AssertPolicyIsBad(bad_ipolicy) |
|
| 540 |
spec[param] = oldv |
|
| 541 |
assert bad_ipolicy == good_ipolicy |
|
| 542 |
|
|
| 543 |
stdspec = bad_ipolicy[constants.ISPECS_STD] |
|
| 544 |
for param in stdspec: |
|
| 545 |
oldv = stdspec[param] |
|
| 546 |
del stdspec[param] |
|
| 547 |
self._AssertPolicyIsBad(bad_ipolicy, True) |
|
| 548 |
# Note that std spec is the same as a max spec |
|
| 549 |
stdspec[param] = oldv + 1 |
|
| 550 |
self._AssertPolicyIsBad(bad_ipolicy, True) |
|
| 551 |
stdspec[param] = oldv |
|
| 552 |
assert bad_ipolicy == good_ipolicy |
|
| 553 |
|
|
| 554 |
for minmax in good_ipolicy[constants.ISPECS_MINMAX]: |
|
| 555 |
for spec in minmax.values(): |
|
| 556 |
good_ipolicy[constants.ISPECS_STD] = spec |
|
| 557 |
objects.InstancePolicy.CheckISpecSyntax(good_ipolicy, True) |
|
| 460 | 558 |
|
| 461 | 559 |
def testCheckISpecParamSyntax(self): |
| 462 | 560 |
par = "my_parameter" |
| ... | ... | |
| 558 | 656 |
def _AssertIPolicyMerged(self, default_pol, diff_pol, merged_pol): |
| 559 | 657 |
for (key, value) in merged_pol.items(): |
| 560 | 658 |
if key in diff_pol: |
| 561 |
if key == constants.ISPECS_MINMAX: |
|
| 562 |
self.assertEqual(frozenset(value), constants.ISPECS_MINMAX_KEYS) |
|
| 563 |
for k in constants.ISPECS_MINMAX_KEYS: |
|
| 564 |
self._AssertISpecsMerged(default_pol[key][k], diff_pol[key][k], |
|
| 565 |
value[k]) |
|
| 566 |
elif key == constants.ISPECS_STD: |
|
| 659 |
if key == constants.ISPECS_STD: |
|
| 567 | 660 |
self._AssertISpecsMerged(default_pol[key], diff_pol[key], value) |
| 568 | 661 |
else: |
| 569 | 662 |
self.assertEqual(value, diff_pol[key]) |
| ... | ... | |
| 575 | 668 |
{constants.IPOLICY_VCPU_RATIO: 3.14},
|
| 576 | 669 |
{constants.IPOLICY_SPINDLE_RATIO: 2.72},
|
| 577 | 670 |
{constants.IPOLICY_DTS: [constants.DT_FILE]},
|
| 671 |
{constants.ISPECS_STD: {constants.ISPEC_DISK_COUNT: 3}},
|
|
| 672 |
{constants.ISPECS_MINMAX: [constants.ISPECS_MINMAX_DEFAULTS,
|
|
| 673 |
constants.ISPECS_MINMAX_DEFAULTS]} |
|
| 578 | 674 |
] |
| 579 | 675 |
for diff_pol in partial_policies: |
| 580 | 676 |
policy = objects.FillIPolicy(constants.IPOLICY_DEFAULTS, diff_pol) |
Also available in: Unified diff