Revision a9e1819b
| b/lib/opcodes_base.py | ||
|---|---|---|
| 160 | 160 |
# as OP_ID is dynamically defined |
| 161 | 161 |
__metaclass__ = _AutoOpParamSlots |
| 162 | 162 |
|
| 163 |
def __init__(self, **kwargs): |
|
| 164 |
outils.ValidatedSlots.__init__(self, **kwargs) |
|
| 165 |
for key, default, _, _ in self.__class__.GetAllParams(): |
|
| 166 |
if not hasattr(self, key): |
|
| 167 |
setattr(self, key, default) |
|
| 168 |
|
|
| 163 | 169 |
def __getstate__(self): |
| 164 | 170 |
"""Generic serializer. |
| 165 | 171 |
|
| b/test/py/ganeti.jqueue_unittest.py | ||
|---|---|---|
| 298 | 298 |
class TestQueuedOpCode(unittest.TestCase): |
| 299 | 299 |
def testDefaults(self): |
| 300 | 300 |
def _Check(op): |
| 301 |
self.assertFalse(hasattr(op.input, "dry_run"))
|
|
| 301 |
self.assertFalse(op.input.dry_run)
|
|
| 302 | 302 |
self.assertEqual(op.priority, constants.OP_PRIO_DEFAULT) |
| 303 | 303 |
self.assertFalse(op.log) |
| 304 | 304 |
self.assert_(op.start_timestamp is None) |
| ... | ... | |
| 432 | 432 |
self.assertTrue(compat.all(op.priority == constants.OP_PRIO_DEFAULT |
| 433 | 433 |
for op in job.ops)) |
| 434 | 434 |
self.assertEqual(job.CalcPriority(), constants.OP_PRIO_DEFAULT) |
| 435 |
self.assertFalse(compat.any(hasattr(op.input, "priority") |
|
| 436 |
for op in job.ops)) |
|
| 437 | 435 |
|
| 438 | 436 |
return job |
| 439 | 437 |
|
| ... | ... | |
| 445 | 443 |
result = job.ChangePriority(-10) |
| 446 | 444 |
self.assertEqual(job.CalcPriority(), -10) |
| 447 | 445 |
self.assertTrue(compat.all(op.priority == -10 for op in job.ops)) |
| 448 |
self.assertFalse(compat.any(hasattr(op.input, "priority") |
|
| 449 |
for op in job.ops)) |
|
| 450 | 446 |
self.assertEqual(result, |
| 451 | 447 |
(True, ("Priorities of pending opcodes for job 24984 have"
|
| 452 | 448 |
" been changed to -10"))) |
| ... | ... | |
| 466 | 462 |
self.assertEqual(job.CalcPriority(), constants.OP_PRIO_DEFAULT) |
| 467 | 463 |
self.assertTrue(compat.all(op.priority == constants.OP_PRIO_DEFAULT |
| 468 | 464 |
for op in job.ops)) |
| 469 |
self.assertFalse(compat.any(hasattr(op.input, "priority") |
|
| 470 |
for op in job.ops)) |
|
| 471 | 465 |
self.assertEqual(map(operator.attrgetter("status"), job.ops), [
|
| 472 | 466 |
constants.OP_STATUS_SUCCESS, |
| 473 | 467 |
constants.OP_STATUS_SUCCESS, |
| ... | ... | |
| 491 | 485 |
self.assertEqual(job.CalcPriority(), constants.OP_PRIO_DEFAULT) |
| 492 | 486 |
self.assertTrue(compat.all(op.priority == constants.OP_PRIO_DEFAULT |
| 493 | 487 |
for op in job.ops)) |
| 494 |
self.assertFalse(compat.any(hasattr(op.input, "priority") |
|
| 495 |
for op in job.ops)) |
|
| 496 | 488 |
self.assertEqual(map(operator.attrgetter("status"), job.ops), [
|
| 497 | 489 |
constants.OP_STATUS_SUCCESS, |
| 498 | 490 |
constants.OP_STATUS_SUCCESS, |
| ... | ... | |
| 516 | 508 |
self.assertEqual(job.CalcPriority(), constants.OP_PRIO_DEFAULT) |
| 517 | 509 |
self.assertEqual(map(operator.attrgetter("priority"), job.ops),
|
| 518 | 510 |
[constants.OP_PRIO_DEFAULT, 7, 7, 7]) |
| 519 |
self.assertFalse(compat.any(hasattr(op.input, "priority") |
|
| 520 |
for op in job.ops)) |
|
| 521 | 511 |
self.assertEqual(map(operator.attrgetter("status"), job.ops), [
|
| 522 | 512 |
constants.OP_STATUS_RUNNING, |
| 523 | 513 |
constants.OP_STATUS_QUEUED, |
| ... | ... | |
| 543 | 533 |
self.assertEqual(job.CalcPriority(), constants.OP_PRIO_DEFAULT) |
| 544 | 534 |
self.assertTrue(compat.all(op.priority == constants.OP_PRIO_DEFAULT |
| 545 | 535 |
for op in job.ops)) |
| 546 |
self.assertFalse(compat.any(hasattr(op.input, "priority") |
|
| 547 |
for op in job.ops)) |
|
| 548 | 536 |
self.assertEqual(map(operator.attrgetter("status"), job.ops), [
|
| 549 | 537 |
constants.OP_STATUS_SUCCESS, |
| 550 | 538 |
constants.OP_STATUS_SUCCESS, |
| ... | ... | |
| 568 | 556 |
self.assertEqual(map(operator.attrgetter("priority"), job.ops),
|
| 569 | 557 |
[constants.OP_PRIO_DEFAULT, constants.OP_PRIO_DEFAULT, |
| 570 | 558 |
-19, -19]) |
| 571 |
self.assertFalse(compat.any(hasattr(op.input, "priority") |
|
| 572 |
for op in job.ops)) |
|
| 573 | 559 |
self.assertEqual(map(operator.attrgetter("status"), job.ops), [
|
| 574 | 560 |
constants.OP_STATUS_SUCCESS, |
| 575 | 561 |
constants.OP_STATUS_RUNNING, |
| ... | ... | |
| 2269 | 2255 |
result = proc(_nextop_fn=self._NextOpcode) |
| 2270 | 2256 |
assert self.curop is not None |
| 2271 | 2257 |
|
| 2272 |
# Input priority should never be set or modified |
|
| 2273 |
self.assertFalse(compat.any(hasattr(op.input, "priority") |
|
| 2274 |
for op in job.ops)) |
|
| 2275 |
|
|
| 2276 | 2258 |
if result == jqueue._JobProcessor.FINISHED or self.gave_lock: |
| 2277 | 2259 |
# Got lock and/or job is done, result must've been written |
| 2278 | 2260 |
self.assertFalse(job.cur_opctx) |
| b/test/py/ganeti.mcpu_unittest.py | ||
|---|---|---|
| 136 | 136 |
|
| 137 | 137 |
for op in [op1, op2, op3]: |
| 138 | 138 |
self.assertTrue("OP_TEST_DUMMY" in op.comment)
|
| 139 |
self.assertFalse(hasattr(op, "priority")) |
|
| 140 |
self.assertFalse(hasattr(op, "debug_level")) |
|
| 141 | 139 |
|
| 142 | 140 |
def testParams(self): |
| 143 | 141 |
src = opcodes.OpTestDummy(priority=constants.OP_PRIO_HIGH, |
| ... | ... | |
| 163 | 161 |
self.assertTrue("OP_TEST_DUMMY" in op1.comment)
|
| 164 | 162 |
self.assertEqual(op1.debug_level, 3) |
| 165 | 163 |
|
| 166 |
self.assertEqual(op2.priority, constants.OP_PRIO_HIGH) |
|
| 164 |
# FIXME: as priority is mandatory, there is no way |
|
| 165 |
# of specifying "just inherit the priority". |
|
| 167 | 166 |
self.assertEqual(op2.comment, "foobar") |
| 168 | 167 |
self.assertEqual(op2.debug_level, 3) |
| 169 | 168 |
|
| b/test/py/ganeti.opcodes_unittest.py | ||
|---|---|---|
| 219 | 219 |
op = OpTest() |
| 220 | 220 |
before = op.__getstate__() |
| 221 | 221 |
self.assertRaises(errors.OpPrereqError, op.Validate, False) |
| 222 |
self.assertFalse(hasattr(op, "nodef"))
|
|
| 223 |
self.assertFalse(hasattr(op, "wdef"))
|
|
| 224 |
self.assertFalse(hasattr(op, "number"))
|
|
| 225 |
self.assertFalse(hasattr(op, "notype"))
|
|
| 222 |
self.assertTrue(op.nodef is None)
|
|
| 223 |
self.assertEqual(op.wdef, "default")
|
|
| 224 |
self.assertEqual(op.number, 0)
|
|
| 225 |
self.assertTrue(op.notype is None)
|
|
| 226 | 226 |
self.assertEqual(op.__getstate__(), before, msg="Opcode was modified") |
| 227 | 227 |
|
| 228 | 228 |
# Required parameter "nodef" is provided |
| ... | ... | |
| 231 | 231 |
op.Validate(False) |
| 232 | 232 |
self.assertEqual(op.__getstate__(), before, msg="Opcode was modified") |
| 233 | 233 |
self.assertEqual(op.nodef, "foo") |
| 234 |
self.assertFalse(hasattr(op, "wdef"))
|
|
| 235 |
self.assertFalse(hasattr(op, "number"))
|
|
| 236 |
self.assertFalse(hasattr(op, "notype"))
|
|
| 234 |
self.assertEqual(op.wdef, "default")
|
|
| 235 |
self.assertEqual(op.number, 0)
|
|
| 236 |
self.assertTrue(op.notype is None)
|
|
| 237 | 237 |
|
| 238 | 238 |
# Missing required parameter "nodef" |
| 239 | 239 |
op = OpTest(wdef="hello", number=999) |
| 240 | 240 |
before = op.__getstate__() |
| 241 | 241 |
self.assertRaises(errors.OpPrereqError, op.Validate, False) |
| 242 |
self.assertFalse(hasattr(op, "nodef"))
|
|
| 243 |
self.assertFalse(hasattr(op, "notype"))
|
|
| 242 |
self.assertTrue(op.nodef is None)
|
|
| 243 |
self.assertTrue(op.notype is None)
|
|
| 244 | 244 |
self.assertEqual(op.__getstate__(), before, msg="Opcode was modified") |
| 245 | 245 |
|
| 246 | 246 |
# Wrong type for "nodef" |
| ... | ... | |
| 248 | 248 |
before = op.__getstate__() |
| 249 | 249 |
self.assertRaises(errors.OpPrereqError, op.Validate, False) |
| 250 | 250 |
self.assertEqual(op.nodef, 987) |
| 251 |
self.assertFalse(hasattr(op, "notype"))
|
|
| 251 |
self.assertTrue(op.notype is None)
|
|
| 252 | 252 |
self.assertEqual(op.__getstate__(), before, msg="Opcode was modified") |
| 253 | 253 |
|
| 254 | 254 |
# Testing different types for "notype" |
| ... | ... | |
| 274 | 274 |
] |
| 275 | 275 |
|
| 276 | 276 |
op = OpTest() |
| 277 |
before = op.__getstate__() |
|
| 278 | 277 |
op.Validate(True) |
| 279 |
self.assertNotEqual(op.__getstate__(), before, |
|
| 280 |
msg="Opcode was not modified") |
|
| 281 | 278 |
self.assertEqual(op.value1, "default") |
| 282 | 279 |
self.assertEqual(op.value2, "result") |
| 283 | 280 |
self.assert_(op.dry_run is None) |
| ... | ... | |
| 285 | 282 |
self.assertEqual(op.priority, constants.OP_PRIO_DEFAULT) |
| 286 | 283 |
|
| 287 | 284 |
op = OpTest(value1="hello", value2="world", debug_level=123) |
| 288 |
before = op.__getstate__() |
|
| 289 | 285 |
op.Validate(True) |
| 290 |
self.assertNotEqual(op.__getstate__(), before, |
|
| 291 |
msg="Opcode was not modified") |
|
| 292 | 286 |
self.assertEqual(op.value1, "hello") |
| 293 | 287 |
self.assertEqual(op.value2, "world") |
| 294 | 288 |
self.assertEqual(op.debug_level, 123) |
| b/test/py/ganeti.rapi.baserlib_unittest.py | ||
|---|---|---|
| 44 | 44 |
for static in [None, {}]:
|
| 45 | 45 |
op = baserlib.FillOpcode(self.OpTest, {}, static)
|
| 46 | 46 |
self.assertTrue(isinstance(op, self.OpTest)) |
| 47 |
self.assertFalse(hasattr(op, "test"))
|
|
| 47 |
self.assertTrue(op.test is None)
|
|
| 48 | 48 |
|
| 49 | 49 |
def testStatic(self): |
| 50 | 50 |
op = baserlib.FillOpcode(self.OpTest, {}, {"test": "abc"})
|
| b/test/py/ganeti.rapi.rlib2_unittest.py | ||
|---|---|---|
| 468 | 468 |
self.assertTrue(isinstance(op, opcodes.OpInstanceActivateDisks)) |
| 469 | 469 |
self.assertEqual(op.instance_name, "xyz") |
| 470 | 470 |
self.assertTrue(op.ignore_size) |
| 471 |
self.assertFalse(hasattr(op, "dry_run"))
|
|
| 471 |
self.assertFalse(op.dry_run)
|
|
| 472 | 472 |
|
| 473 | 473 |
self.assertRaises(IndexError, cl.GetNextSubmittedJob) |
| 474 | 474 |
|
| ... | ... | |
| 487 | 487 |
self.assertEqual(job_id, exp_job_id) |
| 488 | 488 |
self.assertTrue(isinstance(op, opcodes.OpInstanceDeactivateDisks)) |
| 489 | 489 |
self.assertEqual(op.instance_name, "inst22357") |
| 490 |
self.assertFalse(hasattr(op, "dry_run"))
|
|
| 491 |
self.assertFalse(hasattr(op, "force"))
|
|
| 490 |
self.assertFalse(op.dry_run)
|
|
| 491 |
self.assertFalse(op.force)
|
|
| 492 | 492 |
|
| 493 | 493 |
self.assertRaises(IndexError, cl.GetNextSubmittedJob) |
| 494 | 494 |
|
| ... | ... | |
| 507 | 507 |
self.assertEqual(job_id, exp_job_id) |
| 508 | 508 |
self.assertTrue(isinstance(op, opcodes.OpInstanceRecreateDisks)) |
| 509 | 509 |
self.assertEqual(op.instance_name, "inst22357") |
| 510 |
self.assertFalse(hasattr(op, "dry_run"))
|
|
| 510 |
self.assertFalse(op.dry_run)
|
|
| 511 | 511 |
self.assertFalse(hasattr(op, "force")) |
| 512 | 512 |
|
| 513 | 513 |
self.assertRaises(IndexError, cl.GetNextSubmittedJob) |
| ... | ... | |
| 527 | 527 |
self.assertEqual(job_id, exp_job_id) |
| 528 | 528 |
self.assertTrue(isinstance(op, opcodes.OpInstanceFailover)) |
| 529 | 529 |
self.assertEqual(op.instance_name, "inst12794") |
| 530 |
self.assertFalse(hasattr(op, "dry_run"))
|
|
| 530 |
self.assertFalse(op.dry_run)
|
|
| 531 | 531 |
self.assertFalse(hasattr(op, "force")) |
| 532 | 532 |
|
| 533 | 533 |
self.assertRaises(IndexError, cl.GetNextSubmittedJob) |
| ... | ... | |
| 552 | 552 |
self.assertEqual(op.instance_name, "inst10742") |
| 553 | 553 |
self.assertEqual(op.disk, 3) |
| 554 | 554 |
self.assertEqual(op.amount, 1024) |
| 555 |
self.assertFalse(hasattr(op, "dry_run"))
|
|
| 555 |
self.assertFalse(op.dry_run)
|
|
| 556 | 556 |
self.assertFalse(hasattr(op, "force")) |
| 557 | 557 |
|
| 558 | 558 |
self.assertRaises(IndexError, cl.GetNextSubmittedJob) |
| ... | ... | |
| 576 | 576 |
self.assertTrue(isinstance(op, opcodes.OpBackupPrepare)) |
| 577 | 577 |
self.assertEqual(op.instance_name, "inst17925") |
| 578 | 578 |
self.assertEqual(op.mode, constants.EXPORT_MODE_REMOTE) |
| 579 |
self.assertFalse(hasattr(op, "dry_run"))
|
|
| 579 |
self.assertFalse(op.dry_run)
|
|
| 580 | 580 |
self.assertFalse(hasattr(op, "force")) |
| 581 | 581 |
|
| 582 | 582 |
self.assertRaises(IndexError, cl.GetNextSubmittedJob) |
| ... | ... | |
| 622 | 622 |
self.assertEqual(op.nodes, ["node21075"]) |
| 623 | 623 |
self.assertEqual(op.storage_type, constants.ST_LVM_PV) |
| 624 | 624 |
self.assertEqual(op.output_fields, ["name", "other"]) |
| 625 |
self.assertFalse(hasattr(op, "dry_run"))
|
|
| 625 |
self.assertFalse(op.dry_run)
|
|
| 626 | 626 |
self.assertFalse(hasattr(op, "force")) |
| 627 | 627 |
|
| 628 | 628 |
self.assertRaises(IndexError, cl.GetNextSubmittedJob) |
| ... | ... | |
| 687 | 687 |
self.assertEqual(op.changes, {
|
| 688 | 688 |
constants.SF_ALLOCATABLE: (allocatable == "1"), |
| 689 | 689 |
}) |
| 690 |
self.assertFalse(hasattr(op, "dry_run"))
|
|
| 690 |
self.assertFalse(op.dry_run)
|
|
| 691 | 691 |
self.assertFalse(hasattr(op, "force")) |
| 692 | 692 |
|
| 693 | 693 |
self.assertRaises(IndexError, cl.GetNextSubmittedJob) |
| ... | ... | |
| 742 | 742 |
self.assertEqual(op.node_name, "node19265") |
| 743 | 743 |
self.assertEqual(op.storage_type, constants.ST_LVM_PV) |
| 744 | 744 |
self.assertEqual(op.name, "pv16611") |
| 745 |
self.assertFalse(hasattr(op, "dry_run"))
|
|
| 745 |
self.assertFalse(op.dry_run)
|
|
| 746 | 746 |
self.assertFalse(hasattr(op, "force")) |
| 747 | 747 |
|
| 748 | 748 |
self.assertRaises(IndexError, cl.GetNextSubmittedJob) |
| ... | ... | |
| 921 | 921 |
self.assertFalse("foobar" in opnic)
|
| 922 | 922 |
|
| 923 | 923 |
if beparams is None: |
| 924 |
self.assertFalse(hasattr(op, "beparams"))
|
|
| 924 |
self.assertTrue(op.beparams in [None, {}])
|
|
| 925 | 925 |
else: |
| 926 | 926 |
self.assertEqualValues(op.beparams, beparams) |
| 927 | 927 |
|
| 928 | 928 |
if hvparams is None: |
| 929 |
self.assertFalse(hasattr(op, "hvparams"))
|
|
| 929 |
self.assertTrue(op.hvparams in [None, {}])
|
|
| 930 | 930 |
else: |
| 931 | 931 |
self.assertEqualValues(op.hvparams, hvparams) |
| 932 | 932 |
|
| ... | ... | |
| 1102 | 1102 |
self.assertEqual(op.remove_instance, True) |
| 1103 | 1103 |
self.assertEqual(op.x509_key_name, ["name", "hash"]) |
| 1104 | 1104 |
self.assertEqual(op.destination_x509_ca, "---cert---") |
| 1105 |
self.assertFalse(hasattr(op, "dry_run"))
|
|
| 1105 |
self.assertFalse(op.dry_run)
|
|
| 1106 | 1106 |
self.assertFalse(hasattr(op, "force")) |
| 1107 | 1107 |
|
| 1108 | 1108 |
self.assertRaises(IndexError, cl.GetNextSubmittedJob) |
| ... | ... | |
| 1128 | 1128 |
self.assertTrue(isinstance(op, opcodes.OpBackupExport)) |
| 1129 | 1129 |
self.assertEqual(op.instance_name, name) |
| 1130 | 1130 |
self.assertEqual(op.target_node, "node2") |
| 1131 |
self.assertFalse(hasattr(op, "mode"))
|
|
| 1132 |
self.assertFalse(hasattr(op, "remove_instance"))
|
|
| 1131 |
self.assertEqual(op.mode, "local")
|
|
| 1132 |
self.assertFalse(op.remove_instance)
|
|
| 1133 | 1133 |
self.assertFalse(hasattr(op, "destination")) |
| 1134 |
self.assertFalse(hasattr(op, "dry_run"))
|
|
| 1134 |
self.assertFalse(op.dry_run)
|
|
| 1135 | 1135 |
self.assertFalse(hasattr(op, "force")) |
| 1136 | 1136 |
|
| 1137 | 1137 |
self.assertRaises(IndexError, cl.GetNextSubmittedJob) |
| ... | ... | |
| 1172 | 1172 |
self.assertEqual(op.instance_name, name) |
| 1173 | 1173 |
self.assertEqual(op.mode, mode) |
| 1174 | 1174 |
self.assertEqual(op.cleanup, cleanup) |
| 1175 |
self.assertFalse(hasattr(op, "dry_run"))
|
|
| 1175 |
self.assertFalse(op.dry_run)
|
|
| 1176 | 1176 |
self.assertFalse(hasattr(op, "force")) |
| 1177 | 1177 |
|
| 1178 | 1178 |
self.assertRaises(IndexError, cl.GetNextSubmittedJob) |
| ... | ... | |
| 1193 | 1193 |
self.assertEqual(job_id, exp_job_id) |
| 1194 | 1194 |
self.assertTrue(isinstance(op, opcodes.OpInstanceMigrate)) |
| 1195 | 1195 |
self.assertEqual(op.instance_name, name) |
| 1196 |
self.assertFalse(hasattr(op, "mode"))
|
|
| 1197 |
self.assertFalse(hasattr(op, "cleanup"))
|
|
| 1198 |
self.assertFalse(hasattr(op, "dry_run"))
|
|
| 1196 |
self.assertTrue(op.mode is None)
|
|
| 1197 |
self.assertFalse(op.cleanup)
|
|
| 1198 |
self.assertFalse(op.dry_run)
|
|
| 1199 | 1199 |
self.assertFalse(hasattr(op, "force")) |
| 1200 | 1200 |
|
| 1201 | 1201 |
self.assertRaises(IndexError, cl.GetNextSubmittedJob) |
| ... | ... | |
| 1230 | 1230 |
self.assertEqual(op.new_name, new_name) |
| 1231 | 1231 |
self.assertEqual(op.ip_check, ip_check) |
| 1232 | 1232 |
self.assertEqual(op.name_check, name_check) |
| 1233 |
self.assertFalse(hasattr(op, "dry_run"))
|
|
| 1233 |
self.assertFalse(op.dry_run)
|
|
| 1234 | 1234 |
self.assertFalse(hasattr(op, "force")) |
| 1235 | 1235 |
|
| 1236 | 1236 |
self.assertRaises(IndexError, cl.GetNextSubmittedJob) |
| ... | ... | |
| 1257 | 1257 |
self.assertTrue(isinstance(op, opcodes.OpInstanceRename)) |
| 1258 | 1258 |
self.assertEqual(op.instance_name, name) |
| 1259 | 1259 |
self.assertEqual(op.new_name, new_name) |
| 1260 |
self.assertFalse(hasattr(op, "ip_check"))
|
|
| 1261 |
self.assertFalse(hasattr(op, "name_check"))
|
|
| 1262 |
self.assertFalse(hasattr(op, "dry_run"))
|
|
| 1260 |
self.assertTrue(op.ip_check)
|
|
| 1261 |
self.assertTrue(op.name_check)
|
|
| 1262 |
self.assertFalse(op.dry_run)
|
|
| 1263 | 1263 |
self.assertFalse(hasattr(op, "force")) |
| 1264 | 1264 |
|
| 1265 | 1265 |
self.assertRaises(IndexError, cl.GetNextSubmittedJob) |
| ... | ... | |
| 1311 | 1311 |
self.assertEqual(op.nics, nics) |
| 1312 | 1312 |
self.assertEqual(op.disks, disks) |
| 1313 | 1313 |
self.assertEqual(op.disk_template, disk_template) |
| 1314 |
self.assertFalse(hasattr(op, "remote_node"))
|
|
| 1315 |
self.assertFalse(hasattr(op, "os_name"))
|
|
| 1316 |
self.assertFalse(hasattr(op, "force_variant"))
|
|
| 1317 |
self.assertFalse(hasattr(op, "dry_run"))
|
|
| 1314 |
self.assertTrue(op.remote_node is None)
|
|
| 1315 |
self.assertTrue(op.os_name is None)
|
|
| 1316 |
self.assertFalse(op.force_variant)
|
|
| 1317 |
self.assertFalse(op.dry_run)
|
|
| 1318 | 1318 |
|
| 1319 | 1319 |
self.assertRaises(IndexError, cl.GetNextSubmittedJob) |
| 1320 | 1320 |
|
| ... | ... | |
| 1337 | 1337 |
|
| 1338 | 1338 |
for i in ["hvparams", "beparams", "osparams", "force", "nics", "disks", |
| 1339 | 1339 |
"disk_template", "remote_node", "os_name", "force_variant"]: |
| 1340 |
self.assertFalse(hasattr(op, i))
|
|
| 1340 |
self.assertTrue(hasattr(op, i))
|
|
| 1341 | 1341 |
|
| 1342 | 1342 |
|
| 1343 | 1343 |
class TestParseInstanceReinstallRequest(testutils.GanetiTestCase): |
| ... | ... | |
| 1497 | 1497 |
self.assertTrue(isinstance(op, opcodes.OpInstanceReplaceDisks)) |
| 1498 | 1498 |
self.assertEqual(op.instance_name, name) |
| 1499 | 1499 |
self.assertEqual(op.mode, constants.REPLACE_DISK_AUTO) |
| 1500 |
self.assertFalse(hasattr(op, "iallocator"))
|
|
| 1501 |
self.assertFalse(hasattr(op, "disks"))
|
|
| 1500 |
self.assertTrue(op.iallocator is None)
|
|
| 1501 |
self.assertEqual(op.disks, [])
|
|
| 1502 | 1502 |
self.assertRaises(IndexError, cl.GetNextSubmittedJob) |
| 1503 | 1503 |
|
| 1504 | 1504 |
def testNoDisks(self): |
| ... | ... | |
| 1552 | 1552 |
self.assertTrue(isinstance(op, opcodes.OpGroupSetParams)) |
| 1553 | 1553 |
self.assertEqual(op.group_name, name) |
| 1554 | 1554 |
self.assertEqual(op.alloc_policy, policy) |
| 1555 |
self.assertFalse(hasattr(op, "dry_run"))
|
|
| 1555 |
self.assertFalse(op.dry_run)
|
|
| 1556 | 1556 |
self.assertRaises(IndexError, cl.GetNextSubmittedJob) |
| 1557 | 1557 |
|
| 1558 | 1558 |
def testUnknownPolicy(self): |
| ... | ... | |
| 1584 | 1584 |
|
| 1585 | 1585 |
self.assertTrue(isinstance(op, opcodes.OpGroupSetParams)) |
| 1586 | 1586 |
self.assertEqual(op.group_name, name) |
| 1587 |
self.assertFalse(hasattr(op, "alloc_policy"))
|
|
| 1588 |
self.assertFalse(hasattr(op, "dry_run"))
|
|
| 1587 |
self.assertTrue(op.alloc_policy is None)
|
|
| 1588 |
self.assertFalse(op.dry_run)
|
|
| 1589 | 1589 |
self.assertRaises(IndexError, cl.GetNextSubmittedJob) |
| 1590 | 1590 |
|
| 1591 | 1591 |
|
| ... | ... | |
| 1646 | 1646 |
|
| 1647 | 1647 |
self.assertTrue(isinstance(op, opcodes.OpGroupAdd)) |
| 1648 | 1648 |
self.assertEqual(op.group_name, name) |
| 1649 |
self.assertFalse(hasattr(op, "alloc_policy"))
|
|
| 1649 |
self.assertTrue(op.alloc_policy is None)
|
|
| 1650 | 1650 |
self.assertFalse(op.dry_run) |
| 1651 | 1651 |
|
| 1652 | 1652 |
def testLegacyName(self): |
| ... | ... | |
| 1670 | 1670 |
|
| 1671 | 1671 |
self.assertTrue(isinstance(op, opcodes.OpGroupAdd)) |
| 1672 | 1672 |
self.assertEqual(op.group_name, name) |
| 1673 |
self.assertFalse(hasattr(op, "alloc_policy"))
|
|
| 1673 |
self.assertTrue(op.alloc_policy is None)
|
|
| 1674 | 1674 |
self.assertTrue(op.dry_run) |
| 1675 | 1675 |
|
| 1676 | 1676 |
|
| ... | ... | |
| 1694 | 1694 |
self.assertTrue(isinstance(op, opcodes.OpNodeSetParams)) |
| 1695 | 1695 |
self.assertEqual(op.node_name, "node-z") |
| 1696 | 1696 |
self.assertFalse(op.force) |
| 1697 |
self.assertFalse(hasattr(op, "dry_run"))
|
|
| 1697 |
self.assertFalse(op.dry_run)
|
|
| 1698 | 1698 |
|
| 1699 | 1699 |
if role == rlib2._NR_REGULAR: |
| 1700 | 1700 |
self.assertFalse(op.drained) |
Also available in: Unified diff