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