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):
|