def testUnsetEmpty(self):
old_policy = {}
for key in constants.IPOLICY_ALL_KEYS:
diff_policy = {
key: constants.VALUE_DEFAULT,
}
new_policy = common.GetUpdatedIPolicy(old_policy, diff_policy,
group_policy=True)
self.assertEqual(new_policy, old_policy)
def _TestInvalidKeys(self, old_policy, isgroup):
INVALID_KEY = "this_key_shouldnt_be_allowed"
INVALID_DICT = {
INVALID_KEY: 3,
}
invalid_policy = INVALID_DICT
self.assertRaises(errors.OpPrereqError,
common.GetUpdatedIPolicy,
old_policy,
invalid_policy,
group_policy=isgroup)
invalid_ispecs = {
constants.ISPECS_MINMAX: [INVALID_DICT],
}
self.assertRaises(errors.TypeEnforcementError,
common.GetUpdatedIPolicy,
old_policy,
invalid_ispecs,
group_policy=isgroup)
if isgroup:
invalid_for_group = {
constants.ISPECS_STD:
constants.IPOLICY_DEFAULTS[constants.ISPECS_STD],
}
self.assertRaises(errors.OpPrereqError,
common.GetUpdatedIPolicy,
old_policy,
invalid_for_group,
group_policy=isgroup)
good_ispecs = self._OLD_CLUSTER_POLICY[constants.ISPECS_MINMAX]
invalid_ispecs = copy.deepcopy(good_ispecs)
invalid_policy = {
constants.ISPECS_MINMAX: invalid_ispecs,
}
for minmax in invalid_ispecs:
for key in constants.ISPECS_MINMAX_KEYS:
ispec = minmax[key]
ispec[INVALID_KEY] = None
self.assertRaises(errors.TypeEnforcementError,
common.GetUpdatedIPolicy,
old_policy,
invalid_policy,
group_policy=isgroup)
del ispec[INVALID_KEY]
for par in constants.ISPECS_PARAMETERS:
oldv = ispec[par]
ispec[par] = "this_is_not_good"
self.assertRaises(errors.TypeEnforcementError,
common.GetUpdatedIPolicy,
old_policy,
invalid_policy,
group_policy=isgroup)
ispec[par] = oldv
# This is to make sure that no two errors were present during the tests
common.GetUpdatedIPolicy(old_policy,
invalid_policy,
group_policy=isgroup)
def _TestSet(self, old_policy, diff_policy, isgroup):
new_policy = common.GetUpdatedIPolicy(old_policy, diff_policy,
group_policy=isgroup)
for key in diff_policy:
self.assertTrue(key in new_policy)
self.assertEqual(new_policy[key], diff_policy[key])
for key in old_policy:
if not key in diff_policy:
self.assertTrue(key in new_policy)
self.assertEqual(new_policy[key], old_policy[key])
def _TestSetSpecs(self, old_policy, isgroup):
diff_minmax = [{
constants.ISPECS_MIN: {
constants.ISPEC_MEM_SIZE: 64,
constants.ISPEC_CPU_COUNT: 1,
constants.ISPEC_DISK_COUNT: 2,
constants.ISPEC_DISK_SIZE: 64,
constants.ISPEC_NIC_COUNT: 1,
constants.ISPEC_SPINDLE_USE: 1,
},
constants.ISPECS_MAX: {
constants.ISPEC_MEM_SIZE: 16384,
constants.ISPEC_CPU_COUNT: 10,
constants.ISPEC_DISK_COUNT: 12,
constants.ISPEC_DISK_SIZE: 1024,
constants.ISPEC_NIC_COUNT: 9,
constants.ISPEC_SPINDLE_USE: 18,
},
}]
diff_std = {
constants.ISPEC_DISK_COUNT: 10,
constants.ISPEC_DISK_SIZE: 512,
}
diff_policy = {
constants.ISPECS_MINMAX: diff_minmax
}
if not isgroup:
diff_policy[constants.ISPECS_STD] = diff_std
new_policy = common.GetUpdatedIPolicy(old_policy, diff_policy,
group_policy=isgroup)
self.assertTrue(constants.ISPECS_MINMAX in new_policy)
self.assertEqual(new_policy[constants.ISPECS_MINMAX], diff_minmax)
for key in old_policy:
if not key in diff_policy:
self.assertTrue(key in new_policy)
self.assertEqual(new_policy[key], old_policy[key])
if not isgroup:
new_std = new_policy[constants.ISPECS_STD]
for key in diff_std:
self.assertTrue(key in new_std)
self.assertEqual(new_std[key], diff_std[key])
old_std = old_policy.get(constants.ISPECS_STD, {})
for key in old_std:
self.assertTrue(key in new_std)
if key not in diff_std:
self.assertEqual(new_std[key], old_std[key])
def testUnset(self):
old_policy = self._OLD_GROUP_POLICY
diff_policy = {
constants.IPOLICY_SPINDLE_RATIO: constants.VALUE_DEFAULT,
}
new_policy = common.GetUpdatedIPolicy(old_policy, diff_policy,
group_policy=True)
for key in diff_policy:
self.assertFalse(key in new_policy)
for key in old_policy:
if not key in diff_policy:
self.assertTrue(key in new_policy)
self.assertEqual(new_policy[key], old_policy[key])
self.assertRaises(errors.OpPrereqError, common.GetUpdatedIPolicy,
old_policy, diff_policy, group_policy=False)
