def setUpClass(cls):
super(RebuildServerTests, cls).setUpClass()
cls.key = cls.keypairs_client.create_keypair(rand_name("key")).entity
cls.resources.add(cls.key.name, cls.keypairs_client.delete_keypair)
response = cls.server_behaviors.create_active_server(
key_name=cls.key.name)
cls.server = response.entity
response = cls.flavors_client.get_flavor_details(cls.flavor_ref)
cls.flavor = response.entity
cls.resources.add(cls.server.id, cls.servers_client.delete_server)
cls.metadata = {'key': 'value'}
cls.name = rand_name('testserver')
cls.file_contents = 'Test server rebuild.'
personality = [{
'path': '/rebuild.txt',
'contents': base64.b64encode(cls.file_contents)
}]
cls.password = '******'
cls.rebuilt_server_response = cls.servers_client.rebuild(
cls.server.id,
cls.image_ref_alt,
name=cls.name,
metadata=cls.metadata,
personality=personality,
admin_pass=cls.password,
key_name=cls.key.name)
cls.server_behaviors.wait_for_server_status(
cls.server.id, NovaServerStatusTypes.ACTIVE)
def setUpClass(cls):
super(ServerFromImageCreateServerTests, cls).setUpClass()
cls.name = rand_name("server")
cls.metadata = {'meta_key_1': 'meta_value_1',
'meta_key_2': 'meta_value_2'}
networks = None
if cls.servers_config.default_network:
networks = [{'uuid': cls.servers_config.default_network}]
cls.file_contents = 'This is a test file.'
if cls.file_injection_enabled:
cls.file_contents = 'This is a test file.'
separator = cls.images_config.primary_image_path_separator
cls.file_path = separator.join(
[cls.servers_config.default_file_path, 'test.txt'])
files = [{'path': cls.file_path, 'contents': base64.b64encode(
cls.file_contents)}]
cls.key = cls.keypairs_client.create_keypair(rand_name("key")).entity
cls.resources.add(cls.key.name,
cls.keypairs_client.delete_keypair)
cls.create_resp = cls.servers_client.create_server(
cls.name, cls.image_ref, cls.flavor_ref, metadata=cls.metadata,
personality=files, key_name=cls.key.name, networks=networks)
created_server = cls.create_resp.entity
cls.resources.add(created_server.id,
cls.servers_client.delete_server)
wait_response = cls.server_behaviors.wait_for_server_status(
created_server.id, NovaServerStatusTypes.ACTIVE)
wait_response.entity.admin_pass = created_server.admin_pass
cls.image = cls.images_client.get_image(cls.image_ref).entity
cls.flavor = cls.flavors_client.get_flavor_details(
cls.flavor_ref).entity
cls.server = wait_response.entity
def test_update_image_replace_additional_property(self):
"""
@summary: Update image replace additional property
1) Create image
2) Update image adding a new property
3) Verify that the response code is 200
4) Update image again replacing the value of the new property
5) Verify that the response code is 200
6) Verify that the new property is in the response
7) Verify that the new property's value is correct
"""
new_prop = 'user_prop'
new_prop_value = rand_name('new_prop_value')
updated_new_prop_value = rand_name('updated_new_prop_value')
image = self.images_behavior.create_image_via_task()
response = self.images_client.update_image(
image.id_, add={new_prop: new_prop_value})
self.assertEqual(response.status_code, 200)
response = self.images_client.update_image(
image.id_, replace={new_prop: updated_new_prop_value})
self.assertEqual(response.status_code, 200)
updated_image = response.entity
self.assertIn(new_prop, updated_image.additional_properties)
for prop, prop_val in updated_image.additional_properties.iteritems():
if prop == new_prop:
self.assertEqual(prop_val, updated_new_prop_value)
def setUpClass(cls):
super(ImageListTest, cls).setUpClass()
cls.server1 = cls.server_behaviors.create_active_server()
cls.server2 = cls.server_behaviors.create_active_server()
cls.server1_id = cls.server1.entity.id
cls.server2_id = cls.server2.entity.id
cls.resources.add(cls.server1_id, cls.servers_client.delete_server)
cls.resources.add(cls.server2_id, cls.servers_client.delete_server)
image1_name = rand_name('testimage')
image1_resp = cls.servers_client.create_image(cls.server1_id,
image1_name)
assert image1_resp.status_code == 202
cls.image1_id = cls.parse_image_id(image1_resp)
cls.image_behaviors.wait_for_image_status(cls.image1_id,
NovaImageStatusTypes.ACTIVE)
image2_name = rand_name('testimage')
image2_resp = cls.servers_client.create_image(cls.server2_id,
image2_name)
assert image2_resp.status_code == 202
cls.image2_id = cls.parse_image_id(image2_resp)
cls.image_behaviors.wait_for_image_status(cls.image2_id,
NovaImageStatusTypes.ACTIVE)
cls.image_1 = cls.images_client.get_image(cls.image1_id).entity
cls.image_2 = cls.images_client.get_image(cls.image2_id).entity
cls.resources.add(cls.image1_id, cls.images_client.delete_image)
cls.resources.add(cls.image2_id, cls.images_client.delete_image)
def test_create_image_using_optional_properties(self):
"""
@summary: Create image using optional properties
1) Create image using optional properties
2) Verify that the response contains the correct core properties
3) Verify that the response contains the correct remaining properties
"""
name = rand_name('image')
tag = rand_name('tag')
image = self.images_behavior.create_new_image(
container_format=ImageContainerFormat.BARE,
disk_format=ImageDiskFormat.RAW, name=name, tags=[tag],
visibility=ImageVisibility.PUBLIC)
image_creation_time_in_sec = calendar.timegm(time.gmtime())
errors = self._validate_core_image_properties(
image, image_creation_time_in_sec)
if image.container_format != ImageContainerFormat.BARE:
errors.append(self.error_msg.format(
'container_format', ImageContainerFormat.BARE,
image.container_format))
if image.disk_format != ImageDiskFormat.RAW:
errors.append(self.error_msg.format(
'disk_format', ImageDiskFormat.RAW, image.disk_format))
if image.name != name:
errors.append(self.error_msg.format('name', name, image.name))
if set(image.tags) != set([tag]):
errors.append(self.error_msg.format('tags', tag, image.tags))
self.assertListEqual(errors, [])
def test_update_image_replace_core_properties(self):
"""
@summary: Replace values of core properties
1) Given a previously created image, update image replacing all allowed
core properties
2) Verify that the response code is 200
3) Verify that the updated properties are correct
4) Revert protected property
5) Verify that the response code is 200
"""
updated_container_format = ImageContainerFormat.AKI
updated_disk_format = ImageDiskFormat.ISO
updated_name = rand_name('updated_image')
updated_tags = rand_name('updated_tag')
errors = []
image = self.image
response = self.images_client.update_image(
image.id_,
replace={
'container_format': updated_container_format,
'disk_format': updated_disk_format,
'name': updated_name,
'protected': True,
'tags': [updated_tags]
})
self.assertEqual(response.status_code, 200)
updated_image = response.entity
attributes = [
'checksum', 'created_at', 'file_', 'id_', 'min_disk', 'min_ram',
'schema', 'self_', 'size', 'status', 'visibility'
]
for attribute in attributes:
if getattr(updated_image, attribute) != getattr(image, attribute):
errors.append(
self.error_msg.format(attribute, getattr(image, attribute),
getattr(updated_image, attribute)))
attributes = [
'container_format', 'disk_format', 'name', 'protected', 'tags'
]
for attribute in attributes:
if getattr(updated_image, attribute) == getattr(image, attribute):
errors.append(
self.error_msg.format(attribute, getattr(image, attribute),
getattr(updated_image, attribute)))
if updated_image.updated_at < image.updated_at:
errors.append(
self.error_msg.format('updated_at', image.updated_at,
updated_image.updated_at))
# Need to revert protected property so that the image can be torn down
response = self.images_client.update_image(
image.id_, replace={'protected': False})
self.assertEqual(response.status_code, 200)
self.assertListEqual(errors, [])
def setUpClass(cls):
super(ImageListTest, cls).setUpClass()
cls.server1 = cls.server_behaviors.create_active_server()
cls.server2 = cls.server_behaviors.create_active_server()
cls.server1_id = cls.server1.entity.id
cls.server2_id = cls.server2.entity.id
cls.resources.add(cls.server1_id, cls.servers_client.delete_server)
cls.resources.add(cls.server2_id, cls.servers_client.delete_server)
image1_name = rand_name('testimage')
image1_resp = cls.servers_client.create_image(cls.server1_id,
image1_name)
assert image1_resp.status_code == 202
cls.image1_id = cls.parse_image_id(image1_resp)
cls.image_behaviors.wait_for_image_status(
cls.image1_id, NovaImageStatusTypes.ACTIVE)
image2_name = rand_name('testimage')
image2_resp = cls.servers_client.create_image(cls.server2_id,
image2_name)
assert image2_resp.status_code == 202
cls.image2_id = cls.parse_image_id(image2_resp)
cls.image_behaviors.wait_for_image_status(
cls.image2_id, NovaImageStatusTypes.ACTIVE)
cls.image_1 = cls.images_client.get_image(cls.image1_id).entity
cls.image_2 = cls.images_client.get_image(cls.image2_id).entity
cls.resources.add(cls.image1_id, cls.images_client.delete_image)
cls.resources.add(cls.image2_id, cls.images_client.delete_image)
def setUpClass(cls):
super(DeleteImageTag, cls).setUpClass()
cls.tag = rand_name('tag')
number_of_tags = 3
cls.tags_to_add = [rand_name('tag') for x in range(number_of_tags)]
# Count set to number of images required for this module
created_images = cls.images.behaviors.create_images_via_task(
image_properties={'name': rand_name('delete_image_tag')}, count=5)
cls.created_image = created_images.pop()
cls.multiple_tags_image = created_images.pop()
for tag in cls.tags_to_add:
cls.images.client.add_image_tag(cls.multiple_tags_image.id_, tag)
cls.alt_single_tag_image = created_images.pop()
cls.images.client.add_image_tag(cls.alt_single_tag_image.id_, cls.tag)
cls.deactivated_image = created_images.pop()
cls.images.client.add_image_tag(cls.deactivated_image.id_, cls.tag)
cls.images_admin.client.deactivate_image(cls.deactivated_image.id_)
cls.reactivated_image = created_images.pop()
cls.images.client.add_image_tag(cls.reactivated_image.id_, cls.tag)
cls.images_admin.client.deactivate_image(cls.reactivated_image.id_)
cls.images_admin.client.reactivate_image(cls.reactivated_image.id_)
def create_image_via_task(self, image_properties=None, import_from=None):
"""
@summary: Create new image via task
@param image_properties: Properties to use for the image creation
@type image_properties: Dictionary
@param import_from: Location of image
@type import_from: String
@return: Image
@rtype: Object
"""
image_properties = image_properties or {'name': rand_name('image')}
import_from = import_from or self.config.import_from
input_ = {
'image_properties': image_properties,
'import_from': import_from
}
task = self.create_new_task(input_=input_, type_=TaskTypes.IMPORT)
image_id = task.result.image_id
self.client.add_image_tag(image_id=image_id, tag=rand_name('tag'))
response = self.client.get_image_details(image_id=image_id)
image = response.entity
return image
def test_create_bobby_policy_response(self):
"""
Create a policy in bobby, and verify the response code is 201,
the headers and the response object.
"""
group_id = rand_name("0123GROUP-78f3-4543-85bc1-")
policy_id = rand_name("0123POLICY-78f3-4543-85bc1-")
alarm_template = "8787978"
check_template = "9987987"
create_bobby_policy_response = self.bobby_behaviors.create_bobby_policy_given(
group_id=group_id, policy_id=policy_id, alarm_template=alarm_template, check_template=check_template
)
self.assertEquals(
create_bobby_policy_response.status_code,
201,
msg="The response code for create policy in bobby "
"resulted in {0}".format(create_bobby_policy_response.status_code),
)
self.validate_headers(create_bobby_policy_response.headers)
bobby_policy = create_bobby_policy_response.entity
self.assertEquals(bobby_policy.groupId, group_id, msg="The groupId in the response does not match")
self.assertEquals(bobby_policy.policyId, policy_id, msg="The policyId in the response does not match")
self.assertEquals(
bobby_policy.alarmTemplate, alarm_template, msg="The alarmTemplate in the response does not match"
)
self.assertEquals(
bobby_policy.checkTemplate, check_template, msg="The checkTemplate in the response does not match"
)
def setUpClass(cls):
super(ContainerFlavorsNegativeTest, cls).setUpClass()
container_flavor_config = ContainersConfig()
cls.container_flavor_id = container_flavor_config.primary_flavor
# Create a server with a normal flavor
cls.name = rand_name("server")
cls.create_resp = cls.servers_client.create_server(
cls.name, cls.image_ref, cls.flavor_ref)
cls.server = cls.create_resp.entity
cls.resources.add(cls.server.id,
cls.servers_client.delete_server)
# Create a container from the container flavor class
cls.name = rand_name("container")
cls.create_resp = cls.servers_client.create_server(
cls.name, cls.image_ref, cls.container_flavor_id)
cls.container = cls.create_resp.entity
cls.resources.add(cls.container.id,
cls.servers_client.delete_server)
# Wait for both instances to become active
cls.server_behaviors.wait_for_server_status(
cls.server.id, NovaServerStatusTypes.ACTIVE)
cls.server_behaviors.wait_for_server_status(
cls.container.id, NovaServerStatusTypes.ACTIVE)
def create_image_via_task(self, image_properties=None, import_from=None):
"""
@summary: Create new image via task
@param image_properties: Properties to use for the image creation
@type image_properties: Dictionary
@param import_from: Location of image
@type import_from: String
@return: Image
@rtype: Object
"""
image_properties = image_properties or {"name": rand_name("image")}
import_from = import_from or self.config.import_from
input_ = {"image_properties": image_properties, "import_from": import_from}
task = self.create_new_task(input_=input_, type_=TaskTypes.IMPORT)
image_id = task.result.image_id
self.client.add_image_tag(image_id=image_id, tag=rand_name("tag"))
resp = self.client.get_image_details(image_id=image_id)
image = self.verify_resp(resp, "get image details", image_id)
return image
def setUpClass(cls):
super(ImageSharing, cls).setUpClass()
cls.alt_one_member_id = cls.images_alt_one.auth.tenant_id
cls.alt_two_member_id = cls.images_alt_two.auth.tenant_id
# Count set to number of images required for this module
created_images = cls.images.behaviors.create_images_via_task(
image_properties={'name': rand_name('image_sharing')}, count=6)
cls.single_member_image = created_images.pop()
cls.multiple_members_image = created_images.pop()
cls.delete_access_image = created_images.pop()
cls.images.client.create_image_member(
cls.delete_access_image.id_, cls.alt_one_member_id)
cls.shared_image = created_images.pop()
cls.images.client.create_image_member(
cls.shared_image.id_, cls.alt_one_member_id)
cls.images_alt_one.client.update_image_member(
cls.shared_image.id_, cls.alt_one_member_id,
ImageMemberStatus.ACCEPTED)
image = created_images.pop()
cls.images.client.create_image_member(image.id_, cls.alt_one_member_id)
cls.images_alt_one.client.update_image_member(
image.id_, cls.alt_one_member_id, ImageMemberStatus.ACCEPTED)
cls.images_admin.client.deactivate_image(image.id_)
cls.shared_deactivated_image = (
cls.images.client.get_image_details(image.id_).entity)
alt_image = created_images.pop()
cls.images.client.create_image_member(
alt_image.id_, cls.alt_one_member_id)
cls.images_alt_one.client.update_image_member(
alt_image.id_, cls.alt_one_member_id, ImageMemberStatus.ACCEPTED)
cls.images_admin.client.deactivate_image(alt_image.id_)
cls.images_admin.client.reactivate_image(alt_image.id_)
cls.shared_reactivated_image = (
cls.images.client.get_image_details(alt_image.id_).entity)
cls.imported_image = cls.images.behaviors.create_image_via_task(
image_properties={'name': rand_name('image_sharing')},
import_from=cls.images.config.import_from_bootable)
cls.images.client.create_image_member(
cls.imported_image.id_, cls.alt_one_member_id)
cls.snapshot_image = cls.images.behaviors.create_image_via_task(
image_properties={'name': rand_name('image_sharing')},
import_from=cls.images.config.import_from_bootable)
cls.images.client.create_image_member(
cls.snapshot_image.id_, cls.alt_one_member_id)
cls.snapshot_server = (
cls.compute_alt_one_servers_behaviors.create_active_server(
name=rand_name('image_sharing_server'),
image_ref=cls.snapshot_image.id_)).entity
cls.resources.add(
cls.snapshot_server.id,
cls.compute_alt_one_servers_client.delete_server)
def create_scaling_group_min(self,
gc_name=None,
gc_cooldown=None,
gc_min_entities=None,
lc_name=None,
lc_image_ref=None,
lc_flavor_ref=None):
"""
Creates a scaling group with only the required fields
"""
gc_name = gc_name and str(gc_name) or rand_name('test_sgroup')
if gc_cooldown is None:
gc_cooldown = int(self.autoscale_config.gc_cooldown)
if gc_min_entities is None:
gc_min_entities = int(self.autoscale_config.gc_min_entities)
lc_name = lc_name and str(lc_name) or rand_name('test_min_srv')
if lc_image_ref is None:
lc_image_ref = self.autoscale_config.lc_image_ref
if lc_flavor_ref is None:
lc_flavor_ref = self.autoscale_config.lc_flavor_ref
create_response = self.autoscale_client.create_scaling_group(
gc_name=gc_name,
gc_cooldown=gc_cooldown,
gc_min_entities=gc_min_entities,
lc_name=lc_name,
lc_image_ref=lc_image_ref,
lc_flavor_ref=lc_flavor_ref)
return create_response
def setUpClass(cls):
super(CreateServerTest, cls).setUpClass()
cls.name = rand_name("server")
cls.metadata = {
'meta_key_1': 'meta_value_1',
'meta_key_2': 'meta_value_2'
}
cls.file_contents = 'This is a test file.'
files = [{
'path': '/test.txt',
'contents': base64.b64encode(cls.file_contents)
}]
cls.key = cls.keypairs_client.create_keypair(rand_name("key")).entity
cls.resources.add(cls.key.name, cls.keypairs_client.delete_keypair)
cls.create_resp = cls.servers_client.create_server(
cls.name,
cls.image_ref,
cls.flavor_ref,
metadata=cls.metadata,
personality=files,
key_name=cls.key.name)
created_server = cls.create_resp.entity
cls.resources.add(created_server.id, cls.servers_client.delete_server)
wait_response = cls.server_behaviors.wait_for_server_status(
created_server.id, NovaServerStatusTypes.ACTIVE)
wait_response.entity.admin_pass = created_server.admin_pass
cls.image = cls.images_client.get_image(cls.image_ref).entity
cls.flavor = cls.flavors_client.get_flavor_details(
cls.flavor_ref).entity
cls.server = wait_response.entity
def setUpClass(cls):
super(DeleteImageTag, cls).setUpClass()
cls.tag = rand_name('tag')
number_of_tags = 3
cls.tags_to_add = [rand_name('tag') for x in range(number_of_tags)]
# Count set to number of images required for this module
created_images = cls.images.behaviors.create_images_via_task(
image_properties={'name': rand_name('delete_image_tag')}, count=5)
cls.created_image = created_images.pop()
cls.multiple_tags_image = created_images.pop()
for tag in cls.tags_to_add:
cls.images.client.add_image_tag(cls.multiple_tags_image.id_, tag)
cls.alt_single_tag_image = created_images.pop()
cls.images.client.add_image_tag(cls.alt_single_tag_image.id_, cls.tag)
cls.deactivated_image = created_images.pop()
cls.images.client.add_image_tag(cls.deactivated_image.id_, cls.tag)
cls.images_admin.client.deactivate_image(cls.deactivated_image.id_)
cls.reactivated_image = created_images.pop()
cls.images.client.add_image_tag(cls.reactivated_image.id_, cls.tag)
cls.images_admin.client.deactivate_image(cls.reactivated_image.id_)
cls.images_admin.client.reactivate_image(cls.reactivated_image.id_)
def create_scaling_group_min(self, gc_name=None,
gc_cooldown=None,
gc_min_entities=None,
lc_name=None,
lc_image_ref=None,
lc_flavor_ref=None):
"""
Creates a scaling group with only the required fields
"""
gc_name = gc_name and str(gc_name) or rand_name('test_sgroup')
if gc_cooldown is None:
gc_cooldown = int(self.autoscale_config.gc_cooldown)
if gc_min_entities is None:
gc_min_entities = int(self.autoscale_config.gc_min_entities)
lc_name = lc_name and str(lc_name) or rand_name('test_min_srv')
if lc_image_ref is None:
lc_image_ref = self.autoscale_config.lc_image_ref
if lc_flavor_ref is None:
lc_flavor_ref = self.autoscale_config.lc_flavor_ref
create_response = self.autoscale_client.create_scaling_group(
gc_name=gc_name,
gc_cooldown=gc_cooldown,
gc_min_entities=gc_min_entities,
lc_name=lc_name,
lc_image_ref=lc_image_ref,
lc_flavor_ref=lc_flavor_ref)
return create_response
def test_update_image_with_data_of_another_image(self):
"""
@summary: Update image with data of another image (update ignores
duplication)
1) Create an image (first_image)
2) Create another image (second_image)
3) Update first_image with data of second_image
4) Verify that response code is 200
5) Verify that the response contains an image entity with
correct properties
"""
first_image = self.images_behavior.create_new_image()
second_image = self.images_behavior.create_new_image(
name=rand_name("second_image"),
container_format=ImageContainerFormat.AMI,
disk_format=ImageDiskFormat.ISO, tags=[rand_name("tag")])
response = self.images_client.update_image(
image_id=first_image.id_,
replace={"name": second_image.name,
"container_format": second_image.container_format,
"disk_format": second_image.disk_format,
"tags": second_image.tags})
self.assertEqual(response.status_code, 200)
updated_image = response.entity
self.assertEqual(updated_image.id_, first_image.id_)
self.assertEqual(updated_image.name, second_image.name)
self.assertEqual(updated_image.visibility, second_image.visibility)
self.assertEqual(
updated_image.container_format, second_image.container_format)
self.assertEqual(updated_image.disk_format, second_image.disk_format)
self.assertEqual(updated_image.tags, second_image.tags)
def test_update_image_replace_additional_property(self):
"""
@summary: Update image replace additional property
1) Create image
2) Update image adding a new property
3) Verify that the response code is 200
4) Update image again replacing the value of the new property
5) Verify that the response code is 200
6) Verify that the new property is in the response
7) Verify that the new property's value is correct
"""
new_prop = 'user_prop'
new_prop_value = rand_name('new_prop_value')
updated_new_prop_value = rand_name('updated_new_prop_value')
image = self.images_behavior.create_image_via_task()
response = self.images_client.update_image(
image.id_, add={new_prop: new_prop_value})
self.assertEqual(response.status_code, 200)
response = self.images_client.update_image(
image.id_, replace={new_prop: updated_new_prop_value})
self.assertEqual(response.status_code, 200)
updated_image = response.entity
self.assertIn(new_prop, updated_image.additional_properties)
for prop, prop_val in updated_image.additional_properties.iteritems():
if prop == new_prop:
self.assertEqual(prop_val, updated_new_prop_value)
def setUpClass(cls):
super(GetImageDetails, cls).setUpClass()
member_id = cls.images_alt_one.auth.tenant_id
cls.name = rand_name('get_image_details')
cls.created_image = cls.images.behaviors.create_image_via_task(
image_properties={'name': cls.name})
cls.image_created_at_time_in_sec = calendar.timegm(time.gmtime())
cls.images.client.create_image_member(
cls.created_image.id_, member_id)
# Count set to number of images required for this module
created_images = cls.images.behaviors.create_images_via_task(
image_properties={'name': rand_name('get_image_details')}, count=4)
cls.rejected_image = created_images.pop()
cls.images.client.create_image_member(
cls.rejected_image.id_, member_id)
cls.images_alt_one.client.update_image_member(
cls.rejected_image.id_, member_id, ImageMemberStatus.REJECTED)
cls.deleted_image = created_images.pop()
cls.images.client.delete_image(cls.deleted_image.id_)
cls.deactivated_image = created_images.pop()
cls.images_admin.client.deactivate_image(cls.deactivated_image.id_)
cls.reactivated_image = created_images.pop()
cls.images_admin.client.deactivate_image(cls.reactivated_image.id_)
cls.images_admin.client.reactivate_image(cls.reactivated_image.id_)
def test_create_image_using_optional_properties(self):
"""
@summary: Create image using optional properties
1) Create image using optional properties
2) Verify that the response contains the correct core properties
3) Verify that the response contains the correct remaining properties
"""
name = rand_name('image')
tag = rand_name('tag')
response = self.images_client.create_image(
container_format=ImageContainerFormat.BARE,
disk_format=ImageDiskFormat.RAW, name=name, tags=[tag])
image_creation_time_in_sec = calendar.timegm(time.gmtime())
self.assertEqual(response.status_code, 201)
image = response.entity
self.resources.add(image.id_, self.images_client.delete_image)
errors = self._validate_core_image_properties(
image, image_creation_time_in_sec)
if image.container_format != ImageContainerFormat.BARE:
errors.append(self.error_msg.format(
'container_format', ImageContainerFormat.BARE,
image.container_format))
if image.disk_format != ImageDiskFormat.RAW:
errors.append(self.error_msg.format(
'disk_format', ImageDiskFormat.RAW, image.disk_format))
if image.name != name:
errors.append(self.error_msg.format('name', name, image.name))
if set(image.tags) != set([tag]):
errors.append(self.error_msg.format('tags', tag, image.tags))
self.assertListEqual(errors, [])
def setUpClass(cls):
"""
Perform actions that setup the necessary resources for testing.
The following resources are created during this setup:
- Creates a keypair.
- Creates an available volume.
- Creates block device mapping.
- Creates an active server.
"""
super(ServerFromVolumeV1CreateServerTests, cls).setUpClass()
# Initialzing instance name, metadata, files, keys, networking
cls.name = rand_name("server")
cls.metadata = {'meta_key_1': 'meta_value_1',
'meta_key_2': 'meta_value_2'}
networks = None
if cls.servers_config.default_network:
networks = [{'uuid': cls.servers_config.default_network}]
files = []
if cls.file_injection_enabled:
cls.file_contents = 'This is a test file.'
separator = cls.images_config.primary_image_path_separator
cls.file_path = separator.join(
[cls.servers_config.default_file_path, 'test.txt'])
files = [{'path': cls.file_path, 'contents': base64.b64encode(
cls.file_contents)}]
key_response = cls.keypairs_client.create_keypair(rand_name("key"))
if key_response.entity is None:
raise Exception(
"Response entity of create key was not set. "
"Response was: {0}".format(key_response.content))
cls.key = key_response.entity
cls.resources.add(cls.key.name,
cls.keypairs_client.delete_keypair)
# Creating a volume for the block device mapping
cls.volume = cls.blockstorage_behavior.create_available_volume(
size=cls.volume_size,
volume_type=cls.volume_type,
image_ref=cls.image_ref)
cls.resources.add(cls.volume.id_,
cls.blockstorage_client.delete_volume)
# Creating block device mapping used for server creation
cls.block_data = cls.server_behaviors.create_block_device_mapping_v1(
device_name=cls.images_config.primary_image_default_device,
size=cls.volume_size, volume_id=cls.volume.id_, type='',
delete_on_termination=True)
# Creating Instance from Volume V1
cls.create_resp = cls.server_behaviors.create_active_server(
name=cls.name, flavor_ref=cls.flavors_config.primary_flavor,
metadata=cls.metadata, personality=files, key_name=cls.key.name,
networks=networks, block_device_mapping=cls.block_data)
cls.server = cls.create_resp.entity
cls.resources.add(cls.server.id,
cls.servers_client.delete_server)
cls.flavor = cls.flavors_client.get_flavor_details(
cls.flavor_ref).entity
def setUpClass(cls):
super(ImageSharing, cls).setUpClass()
cls.alt_one_member_id = cls.images_alt_one.auth.tenant_id
cls.alt_two_member_id = cls.images_alt_two.auth.tenant_id
# Count set to number of images required for this module
created_images = cls.images.behaviors.create_images_via_task(
image_properties={'name': rand_name('image_sharing')}, count=6)
cls.single_member_image = created_images.pop()
cls.multiple_members_image = created_images.pop()
cls.delete_access_image = created_images.pop()
cls.images.client.create_image_member(cls.delete_access_image.id_,
cls.alt_one_member_id)
cls.shared_image = created_images.pop()
cls.images.client.create_image_member(cls.shared_image.id_,
cls.alt_one_member_id)
cls.images_alt_one.client.update_image_member(
cls.shared_image.id_, cls.alt_one_member_id,
ImageMemberStatus.ACCEPTED)
image = created_images.pop()
cls.images.client.create_image_member(image.id_, cls.alt_one_member_id)
cls.images_alt_one.client.update_image_member(
image.id_, cls.alt_one_member_id, ImageMemberStatus.ACCEPTED)
cls.images_admin.client.deactivate_image(image.id_)
cls.shared_deactivated_image = (cls.images.client.get_image_details(
image.id_).entity)
alt_image = created_images.pop()
cls.images.client.create_image_member(alt_image.id_,
cls.alt_one_member_id)
cls.images_alt_one.client.update_image_member(
alt_image.id_, cls.alt_one_member_id, ImageMemberStatus.ACCEPTED)
cls.images_admin.client.deactivate_image(alt_image.id_)
cls.images_admin.client.reactivate_image(alt_image.id_)
cls.shared_reactivated_image = (cls.images.client.get_image_details(
alt_image.id_).entity)
cls.imported_image = cls.images.behaviors.create_image_via_task(
image_properties={'name': rand_name('image_sharing')},
import_from=cls.images.config.import_from_bootable)
cls.images.client.create_image_member(cls.imported_image.id_,
cls.alt_one_member_id)
cls.snapshot_image = cls.images.behaviors.create_image_via_task(
image_properties={'name': rand_name('image_sharing')},
import_from=cls.images.config.import_from_bootable)
cls.images.client.create_image_member(cls.snapshot_image.id_,
cls.alt_one_member_id)
cls.snapshot_server = (
cls.compute_alt_one_servers_behaviors.create_active_server(
name=rand_name('image_sharing_server'),
image_ref=cls.snapshot_image.id_)).entity
cls.resources.add(cls.snapshot_server.id,
cls.compute_alt_one_servers_client.delete_server)
def setUpClass(cls):
super(TenantsTest, cls).setUpClass()
cls.tenant_name = rand_name("tenant-test-")
cls.tenant_desc = rand_name("desc-test-")
cls.tenant_enabled = True
cls.updated_name = rand_name("tenant-updated-name-")
cls.updated_desc = rand_name("tenant-updated-desc")
cls.updated_enabled = False
def setUpClass(cls):
super(TenantsTest, cls).setUpClass()
cls.tenant_name = rand_name("tenant-test-")
cls.tenant_desc = rand_name("desc-test-")
cls.tenant_enabled = True
cls.updated_name = rand_name("tenant-updated-name-")
cls.updated_desc = rand_name("tenant-updated-desc")
cls.updated_enabled = False
def test_update_image_replace_additional_property(self):
"""
@summary: Update image by replacing an additional image property
1) Update image adding a new image property
2) Verify that the response code is 200
3) Update the image replacing the new image property's value
4) Verify that the response code is 200
5) Verify that the update image response shows that the new property's
value has been updated as expected
6) Get image details for the image
7) Verify that the response code is ok
8) Verify that the get image response shows that the new
property's value has been updated as expected
"""
new_prop = 'alt_two_new_property'
new_prop_value = rand_name('alt_two_new_property_value')
updated_prop_value = rand_name('updated_new_property_value')
resp = self.images.client.update_image(self.created_image.id_,
add={new_prop: new_prop_value})
self.assertEqual(
resp.status_code, 200,
Messages.STATUS_CODE_MSG.format(200, resp.status_code))
resp = self.images.client.update_image(
self.created_image.id_, replace={new_prop: updated_prop_value})
self.assertEqual(
resp.status_code, 200,
Messages.STATUS_CODE_MSG.format(200, resp.status_code))
updated_image = resp.entity
replaced_prop_value = (updated_image.additional_properties.get(
new_prop, None))
self.assertEqual(
replaced_prop_value,
updated_prop_value,
msg=('Unexpected updated image property value received. '
'Expected: {0} '
'Received: {1}').format(updated_prop_value,
replaced_prop_value))
resp = self.images.client.get_image_details(self.created_image.id_)
self.assertTrue(resp.ok, Messages.OK_RESP_MSG.format(resp.status_code))
get_image = resp.entity
get_replaced_prop_value = (get_image.additional_properties.get(
new_prop, None))
self.assertEqual(
get_replaced_prop_value,
updated_prop_value,
msg=('Unexpected updated image property value received.'
'Expected: {0} '
'Received: {1}').format(new_prop_value,
get_replaced_prop_value))
def setUpClass(cls):
super(TestGetImagesSort, cls).setUpClass()
cls.image = cls.images_behavior.create_image_via_task(
image_properties={'name': rand_name('image')})
cls.alt_image = cls.images_behavior.create_image_via_task(
image_properties={'name': rand_name('altimage')})
cls.third_image = cls.images_behavior.create_image_via_task(
image_properties={'name': rand_name('thirdimage')})
cls.owner = cls.tenant_id
def setUpClass(cls):
"""
Perform actions that setup the necessary resources for testing.
The following resources are created during the setup
- Networking, default network from ComputeFixture
- 2 servers with the same configuration (waits for active)
- Image creation from first server (waits for active)
- 3rd server from image created in step above (waits for active)
"""
super(ServerListTest, cls).setUpClass()
networks = None
if cls.servers_config.default_network:
networks = [{'uuid': cls.servers_config.default_network}]
cls.name = rand_name("server")
first_response = cls.servers_client.create_server(
name=cls.name,
image_ref=cls.image_ref,
flavor_ref=cls.flavor_ref,
networks=networks).entity
cls.resources.add(first_response.id, cls.servers_client.delete_server)
cls.name = rand_name("server")
second_response = cls.servers_client.create_server(
name=cls.name,
image_ref=cls.image_ref,
flavor_ref=cls.flavor_ref,
networks=networks).entity
cls.resources.add(second_response.id, cls.servers_client.delete_server)
cls.server = cls.server_behaviors.wait_for_server_status(
first_response.id, NovaServerStatusTypes.ACTIVE).entity
cls.second_server = cls.server_behaviors.wait_for_server_status(
second_response.id, NovaServerStatusTypes.ACTIVE).entity
# Create a unique image
other_image_name = rand_name('image')
resp = cls.servers_client.create_image(cls.second_server.id,
other_image_name)
assert resp.status_code == 202
cls.other_image_id = cls.parse_image_id(resp)
cls.resources.add(cls.other_image_id, cls.images_client.delete_image)
cls.image_behaviors.wait_for_image_status(cls.other_image_id,
NovaImageStatusTypes.ACTIVE)
cls.name = rand_name("server")
third_response = cls.servers_client.create_server(
name=cls.name,
image_ref=cls.other_image_id,
flavor_ref=cls.flavor_ref_alt,
networks=networks).entity
cls.resources.add(third_response.id, cls.servers_client.delete_server)
cls.third_server = cls.server_behaviors.wait_for_server_status(
third_response.id, NovaServerStatusTypes.ACTIVE).entity
def setUpClass(cls):
super(TestGetImagesSort, cls).setUpClass()
cls.image = cls.images_behavior.create_image_via_task(
image_properties={'name': rand_name('image')})
cls.alt_image = cls.images_behavior.create_image_via_task(
image_properties={'name': rand_name('altimage')})
cls.third_image = cls.images_behavior.create_image_via_task(
image_properties={'name': rand_name('thirdimage')})
cls.owner = cls.tenant_id
def setUpClass(cls):
super(UpdateImage, cls).setUpClass()
cls.new_prop = rand_name('new_property')
cls.new_prop_value = rand_name('new_property_value')
cls.updated_prop_value = rand_name('updated_new_property_value')
# Count set to number of images required for this module
created_images = cls.images.behaviors.create_images_via_task(
image_properties={'name': rand_name('update_image')}, count=9)
cls.created_image = created_images.pop()
cls.alt_created_image = created_images.pop()
cls.quota_image = created_images.pop()
cls.add_prop_deactivated_image = created_images.pop()
cls.images_admin.client.deactivate_image(
cls.add_prop_deactivated_image.id_)
cls.replace_prop_deactivated_image = created_images.pop()
cls.images.client.update_image(
cls.replace_prop_deactivated_image.id_,
add={cls.new_prop: cls.new_prop_value})
cls.images_admin.client.deactivate_image(
cls.replace_prop_deactivated_image.id_)
cls.remove_prop_deactivated_image = created_images.pop()
cls.images.client.update_image(
cls.remove_prop_deactivated_image.id_,
add={cls.new_prop: cls.new_prop_value})
cls.images_admin.client.deactivate_image(
cls.remove_prop_deactivated_image.id_)
cls.add_prop_reactivated_image = created_images.pop()
cls.images_admin.client.deactivate_image(
cls.add_prop_reactivated_image.id_)
cls.images_admin.client.reactivate_image(
cls.add_prop_reactivated_image.id_)
cls.replace_prop_reactivated_image = created_images.pop()
cls.images.client.update_image(
cls.replace_prop_reactivated_image.id_,
add={cls.new_prop: cls.new_prop_value})
cls.images_admin.client.deactivate_image(
cls.replace_prop_reactivated_image.id_)
cls.images_admin.client.reactivate_image(
cls.replace_prop_reactivated_image.id_)
cls.remove_prop_reactivated_image = created_images.pop()
cls.images.client.update_image(
cls.remove_prop_reactivated_image.id_,
add={cls.new_prop: cls.new_prop_value})
cls.images_admin.client.deactivate_image(
cls.remove_prop_reactivated_image.id_)
cls.images_admin.client.deactivate_image(
cls.remove_prop_reactivated_image.id_)
def setUpClass(cls):
"""
Creates a bobby policy with the given policy id for given group id
"""
super(DeleteBobbyPolicyTest, cls).setUpClass()
cls.group_id = rand_name('TEST-GROUP-78f3-4543-85bc1')
cls.policy_id = rand_name('TEST-POLICY-78f3-4543-85bc1')
cls.bobby_policy = cls.bobby_behaviors.create_bobby_policy_given(
group_id=cls.group_id,
policy_id=cls.policy_id)
def setUpClass(cls):
"""
Creates a server group with the given server id for given group id
"""
super(DeleteServerGroupTest, cls).setUpClass()
cls.group_id = rand_name('TEST-GROUP-78f3-4543-85bc1')
cls.server_id = rand_name('TEST-SERVER-GROUP-78f3-4543-85bc1')
cls.server_group = cls.bobby_behaviors.create_bobby_server_group_given(
group_id=cls.group_id,
server_id=cls.server_id)
def test_update_image_replace_core_properties(self):
"""
@summary: Replace values of core properties
1) Given a previously created image, update image replacing all allowed
core properties
2) Verify that the response code is 200
3) Verify that the updated properties are correct
4) Revert protected property
5) Verify that the response code is 200
"""
updated_container_format = ImageContainerFormat.AKI
updated_disk_format = ImageDiskFormat.ISO
updated_name = rand_name('updated_image')
updated_tags = rand_name('updated_tag')
errors = []
image = self.image
response = self.images_client.update_image(
image.id_, replace={'container_format': updated_container_format,
'disk_format': updated_disk_format,
'name': updated_name,
'protected': True,
'tags': [updated_tags]})
self.assertEqual(response.status_code, 200)
updated_image = response.entity
attributes = ['checksum', 'created_at', 'file_', 'id_', 'min_disk',
'min_ram', 'schema', 'self_', 'size', 'status',
'visibility']
for attribute in attributes:
if getattr(updated_image, attribute) != getattr(image, attribute):
errors.append(self.error_msg.format(
attribute, getattr(image, attribute),
getattr(updated_image, attribute)))
attributes = ['container_format', 'disk_format', 'name', 'protected',
'tags']
for attribute in attributes:
if getattr(updated_image, attribute) == getattr(image, attribute):
errors.append(self.error_msg.format(
attribute, getattr(image, attribute),
getattr(updated_image, attribute)))
if updated_image.updated_at < image.updated_at:
errors.append(self.error_msg.format(
'updated_at', image.updated_at, updated_image.updated_at))
# Need to revert protected property so that the image can be torn down
response = self.images_client.update_image(
image.id_, replace={'protected': False})
self.assertEqual(response.status_code, 200)
self.assertListEqual(errors, [])
def setUpClass(cls):
"""
Perform actions that setup the necessary resources for testing.
The following resources are created during the setup
- Networking, default network from ComputeFixture
- 2 servers with the same configuration (waits for active)
- Image creation from first server (waits for active)
- 3rd server from image created in step above (waits for active)
"""
super(ServerListTest, cls).setUpClass()
networks = None
if cls.servers_config.default_network:
networks = [{'uuid': cls.servers_config.default_network}]
cls.name = rand_name("server")
first_response = cls.servers_client.create_server(
name=cls.name, image_ref=cls.image_ref,
flavor_ref=cls.flavor_ref, networks=networks).entity
cls.resources.add(first_response.id,
cls.servers_client.delete_server)
cls.name = rand_name("server")
second_response = cls.servers_client.create_server(
name=cls.name, image_ref=cls.image_ref,
flavor_ref=cls.flavor_ref, networks=networks).entity
cls.resources.add(second_response.id,
cls.servers_client.delete_server)
cls.server = cls.server_behaviors.wait_for_server_status(
first_response.id, NovaServerStatusTypes.ACTIVE).entity
cls.second_server = cls.server_behaviors.wait_for_server_status(
second_response.id, NovaServerStatusTypes.ACTIVE).entity
# Create a unique image
other_image_name = rand_name('image')
resp = cls.servers_client.create_image(
cls.second_server.id, other_image_name)
assert resp.status_code == 202
cls.other_image_id = cls.parse_image_id(resp)
cls.resources.add(cls.other_image_id, cls.images_client.delete_image)
#cls.image_behaviors.wait_for_image_status(
# cls.other_image_id, NovaImageStatusTypes.ACTIVE)
cls.name = rand_name("server")
third_response = cls.servers_client.create_server(
name=cls.name, image_ref=cls.image_ref,
flavor_ref=cls.flavor_ref_alt, networks=networks).entity
cls.resources.add(third_response.id,
cls.servers_client.delete_server)
cls.third_server = cls.server_behaviors.wait_for_server_status(
third_response.id, NovaServerStatusTypes.ACTIVE).entity
def test_create_image_member_quota_limit(self):
"""
@summary: Validate create image member quota limit
1) While the number of image members is not equal to the create image
member quota, create image member
2) Verify that the response code is 200
3) When the number of image members is equal to the create image member
quota, create another image member
4) Verify that the response code is 413
5) List image members
6) Verify that the response is ok
7) Verify that the number of image members matches the create image
member quota limit
"""
number_of_image_members = 0
quota_limit = self.images.config.image_members_limit
while number_of_image_members != quota_limit:
member_id = '{0}{1}'.format(rand_name('member'),
str(random.randint(9999, 100000)))
resp = self.images.client.create_image_member(
self.quota_image.id_, member_id)
self.assertEqual(
resp.status_code, 200,
Messages.STATUS_CODE_MSG.format(200, resp.status_code))
resp = self.images.client.list_image_members(self.quota_image.id_)
self.assertTrue(resp.ok,
Messages.OK_RESP_MSG.format(resp.status_code))
listed_members = resp.entity
number_of_image_members = len(listed_members)
member_id = '{0}{1}'.format(rand_name('member'),
str(random.randint(9999, 100000)))
resp = self.images.client.create_image_member(self.quota_image.id_,
member_id)
self.assertEqual(
resp.status_code, 413,
Messages.STATUS_CODE_MSG.format(413, resp.status_code))
resp = self.images.client.list_image_members(self.quota_image.id_)
self.assertTrue(resp.ok, Messages.OK_RESP_MSG.format(resp.status_code))
listed_members = resp.entity
self.assertEqual(
len(listed_members),
quota_limit,
msg='Unexpected number of image members returned. Expected: {0} '
'Received: {1}'.format(quota_limit, len(listed_members)))
def setUpClass(cls):
super(CreateServerFromNewImageTest, cls).setUpClass()
cls.name = rand_name('image')
cls.tag = rand_name('tag')
resp = cls.images_client.create_image(name=cls.name, container_format=ImageContainerFormat.BARE,
disk_format=ImageDiskFormat.QCOW2, tags=[cls.tag])
cls.image = resp.entity
cls.resources.add(cls.image.id_, cls.images_client.delete_image)
with open(cls.images_config.test_image_name, 'rb') as image_file:
cls.images_client.store_image_file(image_id=cls.image.id_, file_data=image_file)
cls.image = cls.images_client.get_image(cls.image.id_).entity
def setUpClass(cls):
super(TaskToImportImage, cls).setUpClass()
cls.container_name = rand_name('task_to_import_image_container_')
cls.object_name = rand_name('task_to_import_image_object')
copy_from = cls.images.config.import_from_bootable
headers = {'X-Copy-From': copy_from}
cls.object_storage_behaviors.create_container(cls.container_name)
cls.object_storage_client.copy_object(cls.container_name,
cls.object_name, headers)
def test_create_image_member_quota_limit(self):
"""
@summary: Validate create image member quota limit
1) While the number of image members is not equal to the create image
member quota, create image member
2) Verify that the response code is 200
3) When the number of image members is equal to the create image member
quota, create another image member
4) Verify that the response code is 413
5) List image members
6) Verify that the response is ok
7) Verify that the number of image members matches the create image
member quota limit
"""
number_of_image_members = 0
quota_limit = self.images.config.image_members_limit
while number_of_image_members != quota_limit:
member_id = '{0}{1}'.format(rand_name('member'),
str(random.randint(9999, 100000)))
resp = self.images.client.create_image_member(
self.quota_image.id_, member_id)
self.assertEqual(
resp.status_code, 200,
Messages.STATUS_CODE_MSG.format(200, resp.status_code))
resp = self.images.client.list_image_members(self.quota_image.id_)
self.assertTrue(resp.ok,
Messages.OK_RESP_MSG.format(resp.status_code))
listed_members = resp.entity
number_of_image_members = len(listed_members)
member_id = '{0}{1}'.format(rand_name('member'),
str(random.randint(9999, 100000)))
resp = self.images.client.create_image_member(
self.quota_image.id_, member_id)
self.assertEqual(
resp.status_code, 413,
Messages.STATUS_CODE_MSG.format(413, resp.status_code))
resp = self.images.client.list_image_members(self.quota_image.id_)
self.assertTrue(resp.ok, Messages.OK_RESP_MSG.format(resp.status_code))
listed_members = resp.entity
self.assertEqual(
len(listed_members), quota_limit,
msg='Unexpected number of image members returned. Expected: {0} '
'Received: {1}'.format(quota_limit, len(listed_members)))
def setUpClass(cls):
super(TaskToImportImage, cls).setUpClass()
cls.container_name = rand_name('task_to_import_image_container_')
cls.object_name = rand_name('task_to_import_image_object')
copy_from = cls.images.config.import_from_bootable
headers = {'X-Copy-From': copy_from}
cls.object_storage_behaviors.create_container(cls.container_name)
cls.object_storage_client.copy_object(
cls.container_name, cls.object_name, headers)
def setUpClass(cls):
"""
Perform actions that setup the necessary resources for testing.
The following resources are created during this setup:
- Creates a keypair.
- Creates an available volume.
- Creates block device mapping.
- Creates an active server.
"""
super(ServerFromVolumeV2CreateServerTests, cls).setUpClass()
# Initialzing instance name, metadata, files, keys, networking
cls.name = rand_name("server")
cls.metadata = {
'meta_key_1': 'meta_value_1',
'meta_key_2': 'meta_value_2'
}
networks = None
if cls.servers_config.default_network:
networks = [{'uuid': cls.servers_config.default_network}]
cls.file_contents = 'This is a test file.'
if cls.file_injection_enabled:
cls.file_contents = 'This is a test file.'
separator = cls.images_config.primary_image_path_separator
cls.file_path = separator.join(
[cls.servers_config.default_file_path, 'test.txt'])
files = [{
'path': cls.file_path,
'contents': base64.b64encode(cls.file_contents)
}]
cls.key = cls.keypairs_client.create_keypair(rand_name("key")).entity
cls.resources.add(cls.key.name, cls.keypairs_client.delete_keypair)
# Creating block device with snapshot data inside
cls.block_data = cls.server_behaviors.create_block_device_mapping_v2(
boot_index=0,
uuid=cls.image_ref,
volume_size=cls.volume_size,
source_type='image',
destination_type='volume',
delete_on_termination=True)
# Creating Instance from Volume V2
cls.create_resp = cls.volume_server_behaviors.create_active_server(
name=cls.name,
flavor_ref=cls.flavors_config.primary_flavor,
metadata=cls.metadata,
personality=files,
key_name=cls.key.name,
networks=networks,
block_device=cls.block_data)
cls.server = cls.create_resp.entity
cls.resources.add(cls.server.id, cls.servers_client.delete_server)
cls.flavor = cls.flavors_client.get_flavor_details(
cls.flavor_ref).entity
def create_bobby_server_group_given(self, group_id=None, server_id=None, entity_id=None):
"""
Creates a bobby group with the given values
"""
group_id = group_id or self.bobby_config.group_id
server_id = server_id or rand_name("0123SERVER-78f3-4543-85bc1-")
entity_id = entity_id or rand_name("0123ENTITY-78f3-4543-85bc1-")
bobby_server_group = self.bobby_client.create_server_group(
group_id=group_id, entity_id=entity_id, server_id=server_id
)
self.resources.add(group_id, self.bobby_client.delete_group)
return bobby_server_group
def setUpClass(cls):
"""
Perform actions that setup the necessary resources for testing
The following data is generated during this setup:
- A name value that is a random name starting with the word 'server'
- A dictionary of metadata with the values:
{'user_key1': 'value1',
'user_key2': 'value2'}
- If default file injection is enabled, a file path for a file named
'test.txt' with the contents 'This is a test file.'
The following resources are created during this setup:
- A keypair with a random name starting with 'key'
- A server with the following settings:
- The name value previously generated
- The keypair previously created
- if injected files are enabled, files to be injected at server
creation including the 'test.txt' data previously generated
- Remaining values required for creating a server will come
from test configuration.
"""
super(ServerFromImageCreateServerTests, cls).setUpClass()
cls.name = rand_name("server")
cls.metadata = {
'meta_key_1': 'meta_value_1',
'meta_key_2': 'meta_value_2'
}
files = None
if cls.file_injection_enabled:
cls.file_contents = 'This is a test file.'
separator = cls.images_config.primary_image_path_separator
cls.file_path = separator.join(
[cls.servers_config.default_file_path, 'test.txt'])
files = [{
'path': cls.file_path,
'contents': base64.b64encode(cls.file_contents)
}]
cls.key = cls.keypairs_client.create_keypair(rand_name("key")).entity
cls.resources.add(cls.key.name, cls.keypairs_client.delete_keypair)
cls.create_resp = cls.server_behaviors.create_active_server(
cls.name,
cls.image_ref,
cls.flavor_ref,
metadata=cls.metadata,
personality=files,
key_name=cls.key.name)
cls.server = cls.create_resp.entity
cls.resources.add(cls.server.id, cls.servers_client.delete_server)
cls.image = cls.images_client.get_image(cls.image_ref).entity
cls.flavor = cls.flavors_client.get_flavor_details(
cls.flavor_ref).entity
def setUpClass(cls):
super(UpdateImage, cls).setUpClass()
cls.new_prop = rand_name('new_property')
cls.new_prop_value = rand_name('new_property_value')
cls.updated_prop_value = rand_name('updated_new_property_value')
# Count set to number of images required for this module
created_images = cls.images.behaviors.create_images_via_task(
image_properties={'name': rand_name('update_image')}, count=9)
cls.created_image = created_images.pop()
cls.alt_created_image = created_images.pop()
cls.quota_image = created_images.pop()
cls.add_prop_deactivated_image = created_images.pop()
cls.images_admin.client.deactivate_image(
cls.add_prop_deactivated_image.id_)
cls.replace_prop_deactivated_image = created_images.pop()
cls.images.client.update_image(cls.replace_prop_deactivated_image.id_,
add={cls.new_prop: cls.new_prop_value})
cls.images_admin.client.deactivate_image(
cls.replace_prop_deactivated_image.id_)
cls.remove_prop_deactivated_image = created_images.pop()
cls.images.client.update_image(cls.remove_prop_deactivated_image.id_,
add={cls.new_prop: cls.new_prop_value})
cls.images_admin.client.deactivate_image(
cls.remove_prop_deactivated_image.id_)
cls.add_prop_reactivated_image = created_images.pop()
cls.images_admin.client.deactivate_image(
cls.add_prop_reactivated_image.id_)
cls.images_admin.client.reactivate_image(
cls.add_prop_reactivated_image.id_)
cls.replace_prop_reactivated_image = created_images.pop()
cls.images.client.update_image(cls.replace_prop_reactivated_image.id_,
add={cls.new_prop: cls.new_prop_value})
cls.images_admin.client.deactivate_image(
cls.replace_prop_reactivated_image.id_)
cls.images_admin.client.reactivate_image(
cls.replace_prop_reactivated_image.id_)
cls.remove_prop_reactivated_image = created_images.pop()
cls.images.client.update_image(cls.remove_prop_reactivated_image.id_,
add={cls.new_prop: cls.new_prop_value})
cls.images_admin.client.deactivate_image(
cls.remove_prop_reactivated_image.id_)
cls.images_admin.client.deactivate_image(
cls.remove_prop_reactivated_image.id_)
def setUpClass(cls):
super(CreateServerBurnIn, cls).setUpClass()
name = rand_name("server")
networks = None
if cls.servers_config.default_network:
networks = [{"uuid": cls.servers_config.default_network}]
cls.key = cls.keypairs_client.create_keypair(rand_name("key")).entity
cls.resources.add(cls.key.name, cls.keypairs_client.delete_keypair)
cls.create_resp = cls.servers_client.create_server(
name, cls.image_ref, cls.flavor_ref, key_name=cls.key.name, networks=networks
)
cls.server = cls.create_resp.entity
cls.resources.add(cls.server.id, cls.servers_client.delete_server)
def setUpClass(cls):
super(ImageListTest, cls).setUpClass()
networks = None
if cls.servers_config.default_network:
networks = [{'uuid': cls.servers_config.default_network}]
cls.name = rand_name("server")
first_response = cls.servers_client.create_server(
name=cls.name,
image_ref=cls.image_ref,
flavor_ref=cls.flavor_ref,
networks=networks).entity
cls.resources.add(first_response.id, cls.servers_client.delete_server)
cls.name = rand_name("server")
second_response = cls.servers_client.create_server(
name=cls.name,
image_ref=cls.image_ref,
flavor_ref=cls.flavor_ref,
networks=networks).entity
cls.resources.add(second_response.id, cls.servers_client.delete_server)
cls.server1 = cls.server_behaviors.wait_for_server_status(
first_response.id, NovaServerStatusTypes.ACTIVE).entity
cls.server2 = cls.server_behaviors.wait_for_server_status(
second_response.id, NovaServerStatusTypes.ACTIVE).entity
cls.server1_id = cls.server1.id
cls.server2_id = cls.server2.id
image1_name = rand_name('testimage')
image1_resp = cls.servers_client.create_image(cls.server1_id,
image1_name)
assert image1_resp.status_code == 202
cls.image1_id = cls.parse_image_id(image1_resp)
cls.resources.add(cls.image1_id, cls.images_client.delete_image)
image2_name = rand_name('testimage')
image2_resp = cls.servers_client.create_image(cls.server2_id,
image2_name)
assert image2_resp.status_code == 202
cls.image2_id = cls.parse_image_id(image2_resp)
cls.resources.add(cls.image2_id, cls.images_client.delete_image)
cls.image_behaviors.wait_for_image_status(cls.image1_id,
NovaImageStatusTypes.ACTIVE)
cls.image_behaviors.wait_for_image_status(cls.image2_id,
NovaImageStatusTypes.ACTIVE)
cls.image_1 = cls.images_client.get_image(cls.image1_id).entity
cls.image_2 = cls.images_client.get_image(cls.image2_id).entity
def setUpClass(cls):
super(ImageTagOperationsActions, cls).setUpClass()
cls.tag = rand_name("tag")
# Count set to number of images required for this module
created_images = cls.images.behaviors.create_images_via_task(
image_properties={"name": rand_name("image_tag_operations_actions")}, count=2
)
cls.add_image_tag_image = created_images.pop()
cls.delete_image_tag_image = created_images.pop()
cls.images.client.add_image_tag(cls.delete_image_tag_image.id_, cls.tag)
def setUpClass(cls):
"""
Creates a server group with the given server id for given group id
"""
super(GetServerGroupTest, cls).setUpClass()
cls.group_id = rand_name('TEST-GROUP-LINKS-78f3-4543-85bc1')
cls.server_id = rand_name('TEST-SERVER-GROUP-LINKS-78f3-4543-85bc1')
cls.server_group = cls.bobby_behaviors.create_bobby_server_group_given(
group_id=cls.group_id,
server_id=cls.server_id)
cls.get_server_group_response = cls.bobby_client.get_server_group(
cls.group_id,
cls.server_id)
cls.get_server_group = cls.get_server_group_response.entity
def test_add_image_tag_quota_limit(self):
"""
@summary: Validate add image tag quota limit
1) While the number of image tags is not equal to the add image tag
quota, add image tag
2) Verify that the response code is 204
3) When the number of image tags is equal to the add image tag quota,
create another image tag
4) Verify that the response code is 413
5) Get image details
6) Verify that the response is ok
7) Verify that the number of image tags matches the add image quota
limit
"""
number_of_image_tags = 0
quota_limit = self.images.config.image_tags_limit
while number_of_image_tags != quota_limit:
tag = rand_name('tag')
resp = self.images.client.add_image_tag(self.quota_image.id_, tag)
self.assertEqual(
resp.status_code, 204,
Messages.STATUS_CODE_MSG.format(204, resp.status_code))
resp = self.images.client.get_image_details(self.quota_image.id_)
self.assertTrue(resp.ok,
Messages.OK_RESP_MSG.format(resp.status_code))
get_image = resp.entity
number_of_image_tags = len(getattr(get_image, 'tags'))
tag = rand_name('tag')
resp = self.images.client.add_image_tag(self.quota_image.id_, tag)
self.assertEqual(
resp.status_code, 413,
Messages.STATUS_CODE_MSG.format(413, resp.status_code))
resp = self.images.client.get_image_details(self.quota_image.id_)
self.assertTrue(resp.ok, Messages.OK_RESP_MSG.format(resp.status_code))
get_image = resp.entity
self.assertEqual(
len(getattr(get_image, 'tags')), quota_limit,
msg='Unexpected number of image tags returned. Expected: {0} '
'Received: {1}'.format(quota_limit,
len(getattr(get_image, 'tags'))))
def setUpClass(cls):
super(ImageTagOperationsSmoke, cls).setUpClass()
cls.tag = rand_name('tag')
# Count set to number of images required for this module
created_images = cls.images.behaviors.create_images_via_task(
image_properties={'name': rand_name('image_tag_operations_smoke')},
count=2)
cls.add_tag_image = created_images.pop()
cls.delete_tag_image = created_images.pop()
cls.images.client.add_image_tag(cls.delete_tag_image.id_, cls.tag)
def setUpClass(cls):
super(ImageTagOperationsSmoke, cls).setUpClass()
cls.tag = rand_name('tag')
# Count set to number of images required for this module
created_images = cls.images.behaviors.create_images_via_task(
image_properties={'name': rand_name('image_tag_operations_smoke')},
count=2)
cls.add_tag_image = created_images.pop()
cls.delete_tag_image = created_images.pop()
cls.images.client.add_image_tag(cls.delete_tag_image.id_, cls.tag)
def setUpClass(cls):
super(CreateImageTest, cls).setUpClass()
cls.name = rand_name('testserver')
cls.server = cls.server_response.entity
cls.image_name = rand_name('image')
cls.metadata = {'key1': 'value1', 'key2': 'value2'}
server_id = cls.server.id
cls.image_response = cls.servers_client.create_image(
server_id, cls.image_name, metadata=cls.metadata)
cls.image_id = cls.parse_image_id(cls.image_response)
cls.resources.add(cls.image_id, cls.images_client.delete_image)
cls.image_behaviors.wait_for_image_status(cls.image_id,
NovaImageStatusTypes.ACTIVE)
cls.image = cls.images_client.get_image(cls.image_id).entity
def setUpClass(cls):
super(ImageOperationsActions, cls).setUpClass()
cls.get_image = cls.images.behaviors.create_image_via_task(
image_properties={'name': rand_name('image_operations_actions')})
cls.image_created_at_time_in_sec = calendar.timegm(time.gmtime())
# Count set to number of images required for this module
created_images = cls.images.behaviors.create_images_via_task(
image_properties={'name': rand_name('image_operations_actions')},
count=3)
cls.delete_image = created_images.pop()
cls.list_image = created_images.pop()
cls.update_image = created_images.pop()
def setUpClass(cls):
super(ServerListTest, cls).setUpClass()
networks = None
if cls.servers_config.default_network:
networks = [{'uuid': cls.servers_config.default_network}]
cls.name = rand_name("server")
first_response = cls.servers_client.create_server(
name=cls.name,
image_ref=cls.image_ref,
flavor_ref=cls.flavor_ref,
networks=networks).entity
cls.resources.add(first_response.id, cls.servers_client.delete_server)
cls.name = rand_name("server")
second_response = cls.servers_client.create_server(
name=cls.name,
image_ref=cls.image_ref,
flavor_ref=cls.flavor_ref,
networks=networks).entity
cls.resources.add(second_response.id, cls.servers_client.delete_server)
cls.server = cls.server_behaviors.wait_for_server_status(
first_response.id, NovaServerStatusTypes.ACTIVE).entity
cls.second_server = cls.server_behaviors.wait_for_server_status(
second_response.id, NovaServerStatusTypes.ACTIVE).entity
# Create a unique image
other_image_name = rand_name('image')
resp = cls.servers_client.create_image(cls.second_server.id,
other_image_name)
assert resp.status_code == 202
cls.other_image_id = cls.parse_image_id(resp)
cls.resources.add(cls.other_image_id, cls.images_client.delete_image)
cls.image_behaviors.wait_for_image_status(cls.other_image_id,
NovaImageStatusTypes.ACTIVE)
cls.name = rand_name("server")
third_response = cls.servers_client.create_server(
name=cls.name,
image_ref=cls.other_image_id,
flavor_ref=cls.flavor_ref_alt,
networks=networks).entity
cls.resources.add(third_response.id, cls.servers_client.delete_server)
cls.third_server = cls.server_behaviors.wait_for_server_status(
third_response.id, NovaServerStatusTypes.ACTIVE).entity
def create_backup(self,
server_id,
backup_type,
backup_rotation,
name=None,
metadata=None,
requestslib_kwargs=None):
"""
@summary: Creates backup of the server
@param server_id: The id of an existing server.
@type server_id: String
@param backup_type: The type of the backup, either daily or weekly.
@type backup_type: String
@param backup_rotation: Number of backups to maintain.
@type backup_type: Integer
@param: metadata: A metadata key and value pair.
@type: Metadata Object
@return: Response Object containing response code and the empty body
after the server resize is applied
@rtype: Requests.response
"""
self.server_id = server_id
if name is None:
name = rand_name("TestBackup")
url = '{base_url}/servers/{server_id}/action'.format(
base_url=self.url, server_id=server_id)
create_backup_request_object = CreateBackup(name, backup_type,
backup_rotation, metadata)
resp = self.request('POST',
url,
request_entity=create_backup_request_object,
requestslib_kwargs=requestslib_kwargs)
return resp
def _create_router(self):
# TODO remove return and self.destination_network from call to
# _create_server when dev team completes functionallity to attach vif's
# to nova instances using device_id during port create / update
self.router = self._create_server('router', [self.network_with_route,
self.destination_network])
# Verify a network cannot be deleted if it has an instance attached to
# it
resp = self.networks_client.delete_network(self.network_with_route.id)
msg = ('Attempt to delete a network with an active instance should '
'return 409, Conflict. Instead, it returned {}')
msg = msg.format(str(resp.status_code))
self.assertEqual(resp.status_code, 409, msg)
return
# Attach router to a port in the destination network
port = self.ports_behaviors.create_port(
self.destination_network.id,
name='{}_{}'.format(rand_name(self.NAMES_PREFIX), 'attached_port'),
device_id=self.router.entity.id,
use_exact_name=True).response.entity
self.delete_ports.append(port.id)
msg = ("Port not attached to nova instance after port creation. Port "
"creation request specified instance uuid in device_id "
"attribute")
self.assertEqual(self.router.entity.id, port.device_id, msg)
def setUpClass(cls):
"""
Perform actions that setup the necessary resources for testing.
The following resources are created during the setup:
- Networking, default network from ComputeFixture.
- 1 Server via create_active_server.
- Server gets updated with AccessIPv4, AccessIPv6 and name.
- Uses the get_server call to set member variable.
"""
super(UpdateServerTest, cls).setUpClass()
create_response = cls.server_behaviors.create_active_server()
cls.original_server = create_response.entity
cls.resources.add(cls.original_server.id,
cls.servers_client.delete_server)
cls.accessIPv4 = '192.168.32.16'
cls.accessIPv6 = '3ffe:1900:4545:3:200:f8ff:fe21:67cf'
cls.new_name = rand_name("newname")
cls.resp = cls.servers_client.update_server(cls.original_server.id,
name=cls.new_name,
accessIPv4=cls.accessIPv4,
accessIPv6=cls.accessIPv6)
cls.server_behaviors.wait_for_server_status(
cls.original_server.id, NovaServerStatusTypes.ACTIVE)
cls.server = cls.servers_client.get_server(
cls.original_server.id).entity
def test_post_request_accept_xml_ignored(self):
"""
A POST request passing only the accept header as xml is ignored
Request a new server creation passing only the accept header as
xml and ensure that the header is ignored returning a valid json
response.
The following assertions occur:
- The response code is 202
- The response content does not contain xml content
- The server status is active
"""
name = rand_name('testserver')
self.servers_client.default_headers['Accept'] = 'application/xml'
self.servers_client.default_headers['Content-Type'] = (
'application/json')
response = self.servers_client.create_server(name, self.image_ref,
self.flavor_ref)
self.assertEqual(
response.status_code, 202, 'Unexpected status code returned. '
'Expected: {0} Received: '
'{1}'.format(202, response.status_code))
content = response.content
self.assertNotIn('xml version', content,
'Unexpected xml content was found in the response')
server = response.entity
self.resources.add(server.id, self.servers_client.delete_server)
get_server = self.server_behaviors.wait_for_server_creation(server.id)
self.assertEqual(
get_server.status, NovaServerStatusTypes.ACTIVE,
'Unexpected server status returned. '
'Expected: {0} Received: '
'{1}'.format(NovaServerStatusTypes.ACTIVE, get_server.status))
