Revision 6d6d5141 kamaki/clients/compute/test.py
| b/kamaki/clients/compute/test.py | ||
|---|---|---|
| 478 | 478 |
FR.status_code = 200 |
| 479 | 479 |
FR.json = vm_recv |
| 480 | 480 |
|
| 481 |
@patch( |
|
| 482 |
'%s.get_image_details' % compute_pkg, |
|
| 483 |
return_value=img_recv['image']) |
|
| 484 |
def test_create_server(self, GID): |
|
| 481 |
def test_create_server(self): |
|
| 485 | 482 |
with patch.object( |
| 486 | 483 |
compute.ComputeClient, 'servers_post', |
| 487 | 484 |
side_effect=ClientError( |
| ... | ... | |
| 492 | 489 |
self.client.create_server, |
| 493 | 490 |
vm_name, fid, img_ref) |
| 494 | 491 |
|
| 495 |
with patch.object( |
|
| 496 |
compute.ComputeClient, 'servers_post', |
|
| 497 |
return_value=FR()) as post: |
|
| 498 |
r = self.client.create_server(vm_name, fid, img_ref) |
|
| 499 |
self.assertEqual(r, FR.json['server']) |
|
| 500 |
self.assertEqual(GID.mock_calls[-1], call(img_ref)) |
|
| 501 |
self.assertEqual(post.mock_calls[-1], call(json_data=vm_send)) |
|
| 502 |
prsn = 'Personality string (does not work with real servers)' |
|
| 503 |
self.client.create_server(vm_name, fid, img_ref, prsn) |
|
| 504 |
expected = dict(server=dict(vm_send['server'])) |
|
| 505 |
expected['server']['personality'] = prsn |
|
| 506 |
self.assertEqual(post.mock_calls[-1], call(json_data=expected)) |
|
| 492 |
for params in product( |
|
| 493 |
('security_group', None),
|
|
| 494 |
('user_data', None),
|
|
| 495 |
('availability_zone', None),
|
|
| 496 |
(None, {'os': 'debian', 'users': 'root'})):
|
|
| 497 |
kwargs = dict() |
|
| 498 |
for i, k in enumerate(( |
|
| 499 |
'security_group', 'user_data', 'availability_zone')): |
|
| 500 |
if params[i]: |
|
| 501 |
kwargs[k] = params[i] |
|
| 502 |
with patch.object( |
|
| 503 |
compute.ComputeClient, 'servers_post', |
|
| 504 |
return_value=FR()) as post: |
|
| 505 |
r = self.client.create_server(vm_name, fid, img_ref, **kwargs) |
|
| 506 |
self.assertEqual(r, FR.json['server']) |
|
| 507 |
exp_json = dict(server=dict( |
|
| 508 |
flavorRef=fid, name=vm_name, imageRef=img_ref)) |
|
| 509 |
for k in set([ |
|
| 510 |
'security_group', |
|
| 511 |
'user_data', |
|
| 512 |
'availability_zone']).difference(kwargs): |
|
| 513 |
kwargs[k] = None |
|
| 514 |
self.assertEqual( |
|
| 515 |
post.mock_calls[-1], call(json_data=exp_json, **kwargs)) |
|
| 516 |
prsn = 'Personality string (does not work with real servers)' |
|
| 517 |
self.client.create_server( |
|
| 518 |
vm_name, fid, img_ref, personality=prsn, **kwargs) |
|
| 519 |
exp_json['server']['personality'] = prsn |
|
| 520 |
self.assertEqual( |
|
| 521 |
post.mock_calls[-1], call(json_data=exp_json, **kwargs)) |
|
| 522 |
kwargs.pop('personality', None)
|
|
| 523 |
exp_json['server'].pop('personality', None)
|
|
| 524 |
mtdt = 'Metadata dict here' |
|
| 525 |
self.client.create_server( |
|
| 526 |
vm_name, fid, img_ref, metadata=mtdt, **kwargs) |
|
| 527 |
exp_json['server']['metadata'] = mtdt |
|
| 528 |
self.assertEqual( |
|
| 529 |
post.mock_calls[-1], call(json_data=exp_json, **kwargs)) |
|
| 507 | 530 |
|
| 508 | 531 |
@patch('%s.servers_get' % compute_pkg, return_value=FR())
|
| 509 | 532 |
def test_list_servers(self, SG): |
| 510 | 533 |
FR.json = vm_list |
| 511 |
for detail in (False, True): |
|
| 512 |
r = self.client.list_servers(detail) |
|
| 513 |
self.assertEqual(SG.mock_calls[-1], call( |
|
| 514 |
command='detail' if detail else '')) |
|
| 534 |
for args in product( |
|
| 535 |
(False, True), |
|
| 536 |
({}, dict(status='status')),
|
|
| 537 |
({}, dict(name='name')),
|
|
| 538 |
({}, dict(image='image')),
|
|
| 539 |
({}, dict(flavor='flavor')),
|
|
| 540 |
({}, dict(host='host')),
|
|
| 541 |
({}, dict(limit='limit')),
|
|
| 542 |
({}, dict(marker='marker')),
|
|
| 543 |
({}, dict(changes_since='changes_since'))):
|
|
| 544 |
detail = args[0] |
|
| 545 |
kwargs = dict() |
|
| 546 |
for param in args[1:]: |
|
| 547 |
kwargs.update(param) |
|
| 548 |
r = self.client.list_servers(detail, **kwargs) |
|
| 549 |
for k in set([ |
|
| 550 |
'status', 'name', |
|
| 551 |
'image', 'flavor', |
|
| 552 |
'host', 'limit', |
|
| 553 |
'marker', 'changes_since']).difference(kwargs): |
|
| 554 |
kwargs[k] = None |
|
| 555 |
self.assertEqual(SG.mock_calls[-1], call(detail=detail, **kwargs)) |
|
| 515 | 556 |
for i, vm in enumerate(vm_list['servers']): |
| 516 | 557 |
self.assert_dicts_are_equal(r[i], vm) |
| 517 | 558 |
self.assertEqual(i + 1, len(r)) |
| ... | ... | |
| 519 | 560 |
@patch('%s.servers_get' % compute_pkg, return_value=FR())
|
| 520 | 561 |
def test_get_server_details(self, SG): |
| 521 | 562 |
vm_id = vm_recv['server']['id'] |
| 522 |
r = self.client.get_server_details(vm_id) |
|
| 523 |
SG.assert_called_once_with(vm_id) |
|
| 524 |
self.assert_dicts_are_equal(r, vm_recv['server']) |
|
| 563 |
for args in product( |
|
| 564 |
({}, dict(status='status')),
|
|
| 565 |
({}, dict(name='name')),
|
|
| 566 |
({}, dict(image='image')),
|
|
| 567 |
({}, dict(flavor='flavor')),
|
|
| 568 |
({}, dict(host='host')),
|
|
| 569 |
({}, dict(limit='limit')),
|
|
| 570 |
({}, dict(marker='marker')),
|
|
| 571 |
({}, dict(changes_since='changes_since'))):
|
|
| 572 |
kwargs = dict() |
|
| 573 |
for param in args: |
|
| 574 |
kwargs.update(param) |
|
| 575 |
r = self.client.get_server_details(vm_id, **kwargs) |
|
| 576 |
for k in set([ |
|
| 577 |
'status', 'name', |
|
| 578 |
'image', 'flavor', |
|
| 579 |
'host', 'limit', |
|
| 580 |
'marker', 'changes_since']).difference(kwargs): |
|
| 581 |
kwargs[k] = None |
|
| 582 |
self.assertEqual(SG.mock_calls[-1], call(vm_id, **kwargs)) |
|
| 583 |
self.assert_dicts_are_equal(r, vm_recv['server']) |
|
| 525 | 584 |
|
| 526 | 585 |
@patch('%s.servers_put' % compute_pkg, return_value=FR())
|
| 527 | 586 |
def test_update_server_name(self, SP): |
| ... | ... | |
| 531 | 590 |
SP.assert_called_once_with(vm_id, json_data=dict( |
| 532 | 591 |
server=dict(name=new_name))) |
| 533 | 592 |
|
| 534 |
@patch('%s.servers_post' % compute_pkg, return_value=FR())
|
|
| 593 |
@patch('%s.servers_action_post' % compute_pkg, return_value=FR())
|
|
| 535 | 594 |
def test_reboot_server(self, SP): |
| 536 | 595 |
vm_id = vm_recv['server']['id'] |
| 537 | 596 |
for hard in (None, True): |
| 538 | 597 |
self.client.reboot_server(vm_id, hard=hard) |
| 539 |
self.assertEqual(SP.mock_calls[-1], call( |
|
| 540 |
vm_id, 'action', |
|
| 541 |
json_data=dict(reboot=dict(type='HARD' if hard else 'SOFT')))) |
|
| 598 |
self.assertEqual(SP.mock_calls[-1], call(vm_id, json_data=dict( |
|
| 599 |
reboot=dict(type='HARD' if hard else 'SOFT')))) |
|
| 542 | 600 |
|
| 543 |
@patch('%s.servers_post' % compute_pkg, return_value=FR())
|
|
| 601 |
@patch('%s.servers_action_post' % compute_pkg, return_value=FR())
|
|
| 544 | 602 |
def test_resize_server(self, SP): |
| 545 | 603 |
vm_id, flavor = vm_recv['server']['id'], flavor_list['flavors'][1] |
| 546 | 604 |
self.client.resize_server(vm_id, flavor['id']) |
| 547 | 605 |
exp = dict(resize=dict(flavorRef=flavor['id'])) |
| 548 |
SP.assert_called_once_with(vm_id, 'action', json_data=exp)
|
|
| 606 |
SP.assert_called_once_with(vm_id, json_data=exp) |
|
| 549 | 607 |
|
| 550 |
@patch('%s.servers_put' % compute_pkg, return_value=FR())
|
|
| 608 |
@patch('%s.servers_metadata_put' % compute_pkg, return_value=FR())
|
|
| 551 | 609 |
def test_create_server_metadata(self, SP): |
| 552 | 610 |
vm_id = vm_recv['server']['id'] |
| 553 | 611 |
metadata = dict(m1='v1', m2='v2', m3='v3') |
| ... | ... | |
| 556 | 614 |
r = self.client.create_server_metadata(vm_id, k, v) |
| 557 | 615 |
self.assert_dicts_are_equal(r, vm_recv['server']) |
| 558 | 616 |
self.assertEqual(SP.mock_calls[-1], call( |
| 559 |
vm_id, 'metadata/%s' % k,
|
|
| 617 |
vm_id, '%s' % k, |
|
| 560 | 618 |
json_data=dict(meta={k: v}), success=201))
|
| 561 | 619 |
|
| 562 |
@patch('%s.servers_get' % compute_pkg, return_value=FR())
|
|
| 620 |
@patch('%s.servers_metadata_get' % compute_pkg, return_value=FR())
|
|
| 563 | 621 |
def test_get_server_metadata(self, SG): |
| 564 | 622 |
vm_id = vm_recv['server']['id'] |
| 565 | 623 |
metadata = dict(m1='v1', m2='v2', m3='v3') |
| 566 | 624 |
FR.json = dict(metadata=metadata) |
| 567 | 625 |
r = self.client.get_server_metadata(vm_id) |
| 568 | 626 |
FR.json = dict(meta=metadata) |
| 569 |
SG.assert_called_once_with(vm_id, '/metadata')
|
|
| 627 |
SG.assert_called_once_with(vm_id, '') |
|
| 570 | 628 |
self.assert_dicts_are_equal(r, metadata) |
| 571 | 629 |
|
| 572 | 630 |
for k, v in metadata.items(): |
| ... | ... | |
| 574 | 632 |
r = self.client.get_server_metadata(vm_id, k) |
| 575 | 633 |
self.assert_dicts_are_equal(r, {k: v})
|
| 576 | 634 |
self.assertEqual( |
| 577 |
SG.mock_calls[-1], call(vm_id, '/metadata/%s' % k))
|
|
| 635 |
SG.mock_calls[-1], call(vm_id, '%s' % k)) |
|
| 578 | 636 |
|
| 579 |
@patch('%s.servers_post' % compute_pkg, return_value=FR())
|
|
| 637 |
@patch('%s.servers_metadata_post' % compute_pkg, return_value=FR())
|
|
| 580 | 638 |
def test_update_server_metadata(self, SP): |
| 581 | 639 |
vm_id = vm_recv['server']['id'] |
| 582 | 640 |
metadata = dict(m1='v1', m2='v2', m3='v3') |
| ... | ... | |
| 584 | 642 |
r = self.client.update_server_metadata(vm_id, **metadata) |
| 585 | 643 |
self.assert_dicts_are_equal(r, metadata) |
| 586 | 644 |
SP.assert_called_once_with( |
| 587 |
vm_id, 'metadata', |
|
| 588 |
json_data=dict(metadata=metadata), success=201) |
|
| 645 |
vm_id, json_data=dict(metadata=metadata), success=201) |
|
| 589 | 646 |
|
| 590 |
@patch('%s.servers_delete' % compute_pkg, return_value=FR())
|
|
| 647 |
@patch('%s.servers_metadata_delete' % compute_pkg, return_value=FR())
|
|
| 591 | 648 |
def test_delete_server_metadata(self, SD): |
| 592 | 649 |
vm_id = vm_recv['server']['id'] |
| 593 | 650 |
key = 'metakey' |
| 594 | 651 |
self.client.delete_server_metadata(vm_id, key) |
| 595 |
SD.assert_called_once_with(vm_id, 'metadata/' + key)
|
|
| 652 |
SD.assert_called_once_with(vm_id, key) |
|
| 596 | 653 |
|
| 597 | 654 |
@patch('%s.flavors_get' % compute_pkg, return_value=FR())
|
| 598 | 655 |
def test_list_flavors(self, FG): |
| 599 | 656 |
FR.json = flavor_list |
| 600 |
for cmd in ('', 'detail'):
|
|
| 601 |
r = self.client.list_flavors(detail=(cmd == 'detail'))
|
|
| 602 |
self.assertEqual(FG.mock_calls[-1], call(command=cmd))
|
|
| 657 |
for detail in ('', 'detail'):
|
|
| 658 |
r = self.client.list_flavors(detail=bool(detail))
|
|
| 659 |
self.assertEqual(FG.mock_calls[-1], call(detail=bool(detail)))
|
|
| 603 | 660 |
self.assertEqual(r, flavor_list['flavors']) |
| 604 | 661 |
|
| 605 | 662 |
@patch('%s.flavors_get' % compute_pkg, return_value=FR())
|
| ... | ... | |
| 612 | 669 |
@patch('%s.images_get' % compute_pkg, return_value=FR())
|
| 613 | 670 |
def test_list_images(self, IG): |
| 614 | 671 |
FR.json = img_list |
| 615 |
for cmd in ('', 'detail'):
|
|
| 616 |
r = self.client.list_images(detail=(cmd == 'detail'))
|
|
| 617 |
self.assertEqual(IG.mock_calls[-1], call(command=cmd))
|
|
| 672 |
for detail in ('', 'detail'):
|
|
| 673 |
r = self.client.list_images(detail=detail)
|
|
| 674 |
self.assertEqual(IG.mock_calls[-1], call(detail=bool(detail)))
|
|
| 618 | 675 |
expected = img_list['images'] |
| 619 | 676 |
for i in range(len(r)): |
| 620 | 677 |
self.assert_dicts_are_equal(expected[i], r[i]) |
| ... | ... | |
| 626 | 683 |
IG.assert_called_once_with(img_ref) |
| 627 | 684 |
self.assert_dicts_are_equal(r, img_recv['image']) |
| 628 | 685 |
|
| 629 |
@patch('%s.images_get' % compute_pkg, return_value=FR())
|
|
| 686 |
@patch('%s.images_metadata_get' % compute_pkg, return_value=FR())
|
|
| 630 | 687 |
def test_get_image_metadata(self, IG): |
| 631 | 688 |
for key in ('', '50m3k3y'):
|
| 632 | 689 |
FR.json = dict(meta=img_recv['image']) if ( |
| 633 | 690 |
key) else dict(metadata=img_recv['image']) |
| 634 | 691 |
r = self.client.get_image_metadata(img_ref, key) |
| 635 |
self.assertEqual(IG.mock_calls[-1], call( |
|
| 636 |
'%s' % img_ref, |
|
| 637 |
'/metadata%s' % (('/%s' % key) if key else '')))
|
|
| 692 |
self.assertEqual(IG.mock_calls[-1], call(img_ref, key or '')) |
|
| 638 | 693 |
self.assert_dicts_are_equal(img_recv['image'], r) |
| 639 | 694 |
|
| 640 | 695 |
@patch('%s.servers_delete' % compute_pkg, return_value=FR())
|
| ... | ... | |
| 648 | 703 |
self.client.delete_image(img_ref) |
| 649 | 704 |
ID.assert_called_once_with(img_ref) |
| 650 | 705 |
|
| 651 |
@patch('%s.images_put' % compute_pkg, return_value=FR())
|
|
| 706 |
@patch('%s.images_metadata_put' % compute_pkg, return_value=FR())
|
|
| 652 | 707 |
def test_create_image_metadata(self, IP): |
| 653 | 708 |
(key, val) = ('k1', 'v1')
|
| 654 | 709 |
FR.json = dict(meta=img_recv['image']) |
| 655 | 710 |
r = self.client.create_image_metadata(img_ref, key, val) |
| 656 | 711 |
IP.assert_called_once_with( |
| 657 |
img_ref, 'metadata/%s' % key,
|
|
| 712 |
img_ref, '%s' % key, |
|
| 658 | 713 |
json_data=dict(meta={key: val}))
|
| 659 | 714 |
self.assert_dicts_are_equal(r, img_recv['image']) |
| 660 | 715 |
|
| 661 |
@patch('%s.images_post' % compute_pkg, return_value=FR())
|
|
| 716 |
@patch('%s.images_metadata_post' % compute_pkg, return_value=FR())
|
|
| 662 | 717 |
def test_update_image_metadata(self, IP): |
| 663 | 718 |
metadata = dict(m1='v1', m2='v2', m3='v3') |
| 664 | 719 |
FR.json = dict(metadata=metadata) |
| 665 | 720 |
r = self.client.update_image_metadata(img_ref, **metadata) |
| 666 | 721 |
IP.assert_called_once_with( |
| 667 |
img_ref, 'metadata', |
|
| 668 |
json_data=dict(metadata=metadata)) |
|
| 722 |
img_ref, json_data=dict(metadata=metadata)) |
|
| 669 | 723 |
self.assert_dicts_are_equal(r, metadata) |
| 670 | 724 |
|
| 671 |
@patch('%s.images_delete' % compute_pkg, return_value=FR())
|
|
| 725 |
@patch('%s.images_metadata_delete' % compute_pkg, return_value=FR())
|
|
| 672 | 726 |
def test_delete_image_metadata(self, ID): |
| 673 | 727 |
key = 'metakey' |
| 674 | 728 |
self.client.delete_image_metadata(img_ref, key) |
| 675 |
ID.assert_called_once_with(img_ref, '/metadata/%s' % key)
|
|
| 729 |
ID.assert_called_once_with(img_ref, '%s' % key) |
|
| 676 | 730 |
|
| 677 | 731 |
@patch('%s.floating_ip_pools_get' % compute_pkg, return_value=FR())
|
| 678 | 732 |
def test_get_floating_ip_pools(self, get): |
Also available in: Unified diff