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_cooldown,
gc_min_entities,
lc_name,
lc_image_ref,
lc_flavor_ref)
return create_response
def setUpClass(cls):
"""
Initialize autoscale configs, behaviors and client
"""
super(AutoscaleFixture, cls).setUpClass()
cls.resources = ResourcePool()
cls.autoscale_config = AutoscaleConfig()
cls.endpoint_config = UserAuthConfig()
user_config = UserConfig()
access_data = AuthProvider.get_access_data(cls.endpoint_config,
user_config)
autoscale_service = access_data.get_service(
cls.autoscale_config.autoscale_endpoint_name)
server_service = access_data.get_service(
cls.autoscale_config.server_endpoint_name)
server_url = server_service.get_endpoint(
cls.autoscale_config.region).public_url
cls.tenant_id = cls.autoscale_config.tenant_id
env = os.environ['OSTNG_CONFIG_FILE']
if 'dev' in env.lower():
url = 'http://localhost:9000/v1.0/{0}'.format(cls.tenant_id)
elif 'prod' in env.lower():
url = 'https://autoscale.api.rackspacecloud.com/v1.0/{0}'.format(
cls.tenant_id)
else:
url = autoscale_service.get_endpoint(
cls.autoscale_config.region).public_url
cls.autoscale_client = AutoscalingAPIClient(
url, access_data.token.id_,
'json', 'json')
cls.server_client = ServersClient(
server_url, access_data.token.id_,
'json', 'json')
cls.autoscale_behaviors = AutoscaleBehaviors(cls.autoscale_config,
cls.autoscale_client)
cls.gc_name = cls.autoscale_config.gc_name
cls.gc_cooldown = int(cls.autoscale_config.gc_cooldown)
cls.gc_min_entities = int(cls.autoscale_config.gc_min_entities)
cls.gc_min_entities_alt = int(cls.autoscale_config.gc_min_entities_alt)
cls.gc_max_entities = int(cls.autoscale_config.gc_max_entities)
cls.lc_name = cls.autoscale_config.lc_name
cls.lc_flavor_ref = cls.autoscale_config.lc_flavor_ref
cls.lc_image_ref = cls.autoscale_config.lc_image_ref
cls.lc_image_ref_alt = cls.autoscale_config.lc_image_ref_alt
cls.sp_name = rand_name(cls.autoscale_config.sp_name)
cls.sp_cooldown = int(cls.autoscale_config.sp_cooldown)
cls.sp_change = int(cls.autoscale_config.sp_change)
cls.sp_change_percent = int(cls.autoscale_config.sp_change_percent)
cls.sp_desired_capacity = int(cls.autoscale_config.sp_desired_capacity)
cls.sp_policy_type = cls.autoscale_config.sp_policy_type
cls.upd_sp_change = int(cls.autoscale_config.upd_sp_change)
cls.lc_load_balancers = cls.autoscale_config.lc_load_balancers
cls.sp_list = cls.autoscale_config.sp_list
cls.wb_name = rand_name(cls.autoscale_config.wb_name)
cls.interval_time = int(cls.autoscale_config.interval_time)
cls.timeout = int(cls.autoscale_config.timeout)
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(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(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(AuthorizationTests, cls).setUpClass()
cls.metadata = {'meta_key_1': 'meta_value_1',
'meta_key_2': 'meta_value_2'}
cls.server = cls.server_behaviors.create_active_server(
metadata=cls.metadata).entity
cls.resources.add(cls.server.id, cls.servers_client.delete_server)
image_name = rand_name('testimage')
cls.image_meta = {'key1': 'value1', 'key2': 'value2'}
image_resp = cls.servers_client.create_image(cls.server.id,
image_name,
cls.image_meta)
assert image_resp.status_code == 202
cls.image_id = cls.parse_image_id(image_resp)
cls.image_behaviors.wait_for_image_status(
cls.image_id, NovaImageStatusTypes.ACTIVE)
cls.resources.add(cls.image_id, cls.images_client.delete_image)
secondary_user = ComputeAuthorizationConfig()
access_data = AuthProvider.get_access_data(cls.endpoint_config,
secondary_user)
compute_service = access_data.get_service(
cls.compute_endpoint.compute_endpoint_name)
url = compute_service.get_endpoint(
cls.compute_endpoint.region).public_url
cls.flavors_client = FlavorsClient(url, access_data.token.id_,
'json', 'json')
cls.servers_client = ServersClient(url, access_data.token.id_,
'json', 'json')
cls.images_client = ImagesClient(url, access_data.token.id_,
'json', 'json')
cls.flavors_client.add_exception_handler(ExceptionHandler())
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(CreateKeypairTest, cls).setUpClass()
cls.name = rand_name("key")
cls.create_resp = cls.keypairs_client.create_keypair(cls.name)
cls.keypair = cls.keypairs_client.get_keypair(cls.name).entity
cls.resources.add(cls.name,
cls.keypairs_client.delete_keypair)
def setUpClass(cls):
super(RebuildServerTests, cls).setUpClass()
response = cls.server_behaviors.create_active_server()
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)
cls.server_behaviors.wait_for_server_status(
cls.server.id, NovaServerStatusTypes.ACTIVE)
def test_create_server_with_image_and_flavor_bookmark_link(self):
"""Create a server using image and flavor bookmark links"""
name = rand_name("testserver")
image = self.images_client.get_image(self.image_ref)
image_bookmark_link = image.entity.links.links.get('bookmark')
flavor = self.flavors_client.get_flavor_details(self.flavor_ref)
flavor_bookmark_link = flavor.entity.links.links.get('bookmark')
create_server_response = self.servers_client.create_server(name,
image_bookmark_link,
flavor_bookmark_link)
created_server = create_server_response.entity
'''Verify the parameters are correct in the initial response'''
self.assertTrue(created_server.id is not None,
msg="The server id was not set in the response")
self.assertTrue(created_server.admin_pass is not None,
msg="Admin password was not set in the response")
self.assertTrue(created_server.links is not None,
msg="Server links were not set in the response")
'''Wait for the server to become active'''
active_server_response = self.server_behaviors.wait_for_server_status(created_server.id,
NovaServerStatusTypes.ACTIVE)
active_server = active_server_response.entity
get_server_info_response = self.servers_client.get_server(created_server.id)
get_server_info = get_server_info_response.entity
'''Verify that the correct image and flavor refs were used'''
self.assertEqual(get_server_info.image.id, self._parse_link_to_retrieve_id(image_bookmark_link),
msg="The image does not match to the image mentioned during create")
self.assertEqual(get_server_info.flavor.id, self._parse_link_to_retrieve_id(flavor_bookmark_link),
msg="The flavor does not match to the flavor mentioned during create")
self.servers_client.delete_server(active_server.id)
def setUpClass(cls):
super(CreateFlavorsAdminTest, cls).setUpClass()
cls.flavor_id = randint(1, 99999)
cls.flavor_name = rand_name('flavor')
cls.admin_flavors_client.create_flavor(
name=cls.flavor_name, ram='64',vcpus='1', disk='10',
id=cls.flavor_id, is_public=True)
def setUpClass(cls):
super(ResizeServerUpRevertTests, cls).setUpClass()
cls.key = cls.keypairs_client.create_keypair(rand_name("key")).entity
server_response = cls.server_behaviors.create_active_server(
key_name=cls.key.name)
server_to_resize = server_response.entity
cls.resources.add(
server_to_resize.id, cls.servers_client.delete_server)
# resize server and confirm
cls.resize_resp = cls.servers_client.resize(
server_to_resize.id, cls.flavor_ref_alt)
cls.server_behaviors.wait_for_server_status(
server_to_resize.id, NovaServerStatusTypes.VERIFY_RESIZE)
cls.revert_resize_resp = cls.servers_client.revert_resize(
server_to_resize.id)
cls.server_behaviors.wait_for_server_status(
server_to_resize.id, NovaServerStatusTypes.ACTIVE)
resized_server_response = cls.servers_client.get_server(
server_to_resize.id)
cls.server = resized_server_response.entity
cls.server.admin_pass = server_to_resize.admin_pass
cls.flavor = cls.flavors_client.get_flavor_details(
cls.flavor_ref).entity
def test_invalid_ip_v6_access_address(self):
"""Negative test: Server should not get created with invalid ipv6 address"""
accessIPv6 = '2.2.2.2'
name = rand_name("testserver")
with self.assertRaises(BadRequest):
server_response = self.servers_client.create_server(
name, self.image_ref, self.flavor_ref, accessIPv6=accessIPv6)
def create_policy_given(self, group_id, sp_name=None, sp_cooldown=None,
sp_change=None, sp_change_percent=None,
sp_desired_capacity=None, sp_policy_type=None,
schedule_at=None, schedule_cron=None):
"""
:summary: creates the specified policy for the given change type
:params: group_id
:return: returns the newly created policy object with change set
to config's default
:rtype: returns the policy object
"""
sp_name = sp_name and str(sp_name) or rand_name('testsp_')
if sp_cooldown is None:
sp_cooldown = int(self.autoscale_config.sp_cooldown)
if sp_policy_type is None:
sp_policy_type = self.autoscale_config.sp_policy_type
if sp_change is not None:
create_response = self.autoscale_client.create_policy(
group_id=group_id,
name=sp_name, cooldown=sp_cooldown,
change=sp_change, policy_type=sp_policy_type)
elif sp_change_percent is not None:
create_response = self.autoscale_client.create_policy(
group_id=group_id,
name=sp_name, cooldown=sp_cooldown,
change_percent=sp_change_percent, policy_type=sp_policy_type)
elif sp_desired_capacity is not None:
create_response = self.autoscale_client.create_policy(
group_id=group_id,
name=sp_name, cooldown=sp_cooldown,
desired_capacity=sp_desired_capacity, policy_type=sp_policy_type)
policy = AutoscaleBehaviors.get_policy_properties(
self, create_response.entity)
return policy
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 = '%s/servers/%s/action' % (self.url, self.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 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.create_resp = cls.servers_client.create_server(
cls.name,
cls.image_ref,
cls.flavor_ref,
metadata=cls.metadata,
personality=files)
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(DeleteFlavorTest, cls).setUpClass()
cls.flavor_name = rand_name('flavor')
cls.flavor = cls.admin_flavors_client.create_flavor(
name=cls.flavor_name, ram='64', vcpus='1', disk='10',
is_public=True).entity
cls.admin_flavors_client.delete_flavor(cls.flavor.id)
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 setUpClass(cls,
name=None,
imageRef=None,
flavorRef=None,
personality=None,
metadata=None,
diskConfig=None,
networks=None):
"""
@summary:Creates a server and waits for server to reach active status
@param name: The name of the server.
@type name: String
@param image_ref: The reference to the image used to build the server.
@type image_ref: String
@param flavor_ref: The flavor used to build the server.
@type flavor_ref: String
@param meta: A dictionary of values to be used as metadata.
@type meta: Dictionary. The limit is 5 key/values.
@param personality: A list of dictionaries for files to be
injected into the server.
@type personality: List
@param disk_config: MANUAL/AUTO/None
@type disk_config: String
@param networks:The networks to which you want to attach the server
@type networks: String
"""
super(CreateServerFixture, cls).setUpClass()
if name is None:
name = rand_name('testserver')
if imageRef is None:
imageRef = cls.image_ref
if flavorRef is None:
flavorRef = cls.flavor_ref
cls.flavor_ref = flavorRef
cls.image_ref = imageRef
resp = cls.servers_client.create_server(name,
imageRef,
flavorRef,
personality=personality,
metadata=metadata,
disk_config=diskConfig,
networks=networks)
cls.created_server = resp.entity
try:
wait_response = cls.server_behaviors.wait_for_server_status(
cls.created_server.id, ServerStates.ACTIVE)
wait_response.entity.admin_pass = cls.created_server.admin_pass
except TimeoutException as exception:
cls.assertClassSetupFailure(exception.message)
except BuildErrorException as exception:
cls.assertClassSetupFailure(exception.message)
finally:
cls.resources.add(cls.created_server.id,
cls.servers_client.delete_server)
cls.server_response = wait_response
if cls.server_response.entity.status != ServerStates.ACTIVE:
cls.assertClassSetupFailure('Server %s did not reach active state',
cls.created_server.id)
def setUpClass(cls):
super(DeleteImageTest, cls).setUpClass()
cls.name = rand_name('server')
cls.server = cls.server_response.entity
cls.image = cls.image_behaviors.create_active_image(
cls.server.id).entity
cls.resp = cls.images_client.delete_image(cls.image.id)
cls.image_behaviors.wait_for_image_to_be_deleted(cls.image.id)
def test_invalid_ip_v6_access_address(self):
"""Negative test: Server should not get created with invalid ipv6 address"""
accessIPv6 = '2.2.2.2'
name = rand_name("testserver")
with self.assertRaises(BadRequest):
server_response = self.servers_client.create_server(name,
self.image_ref,
self.flavor_ref,
accessIPv6=accessIPv6)
def setUpClass(cls, name=None,
imageRef=None, flavorRef=None,
personality=None, metadata=None,
diskConfig=None, networks=None):
"""
@summary:Creates a server and waits for server to reach active status
@param name: The name of the server.
@type name: String
@param image_ref: The reference to the image used to build the server.
@type image_ref: String
@param flavor_ref: The flavor used to build the server.
@type flavor_ref: String
@param meta: A dictionary of values to be used as metadata.
@type meta: Dictionary. The limit is 5 key/values.
@param personality: A list of dictionaries for files to be
injected into the server.
@type personality: List
@param disk_config: MANUAL/AUTO/None
@type disk_config: String
@param networks:The networks to which you want to attach the server
@type networks: String
"""
super(CreateServerFixture, cls).setUpClass()
if name is None:
name = rand_name('testserver')
if imageRef is None:
imageRef = cls.image_ref
if flavorRef is None:
flavorRef = cls.flavor_ref
cls.flavor_ref = flavorRef
cls.image_ref = imageRef
resp = cls.servers_client.create_server(name, imageRef,
flavorRef,
personality=personality,
metadata=metadata,
disk_config=diskConfig,
networks=networks)
cls.created_server = resp.entity
try:
wait_response = cls.server_behaviors.wait_for_server_status(
cls.created_server.id,
ServerStates.ACTIVE)
wait_response.entity.admin_pass = cls.created_server.admin_pass
except TimeoutException as exception:
cls.assertClassSetupFailure(exception.message)
except BuildErrorException as exception:
cls.assertClassSetupFailure(exception.message)
finally:
cls.resources.add(cls.created_server.id,
cls.servers_client.delete_server)
cls.server_response = wait_response
if cls.server_response.entity.status != ServerStates.ACTIVE:
cls.assertClassSetupFailure('Server %s did not reach active state',
cls.created_server.id)
def setUpClass(cls):
super(ResizeServerUpRevertTests, cls).setUpClass()
response = cls.compute_provider.create_active_server()
cls.server = response.entity
cls.remote_instance = cls.compute_provider.get_remote_instance_client(cls.server)
file_name = rand_name('file') + '.txt'
file_content = 'This is a test file'
cls.file_details = cls. remote_instance.create_file(file_name, file_content)
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)
def setUpClass(cls):
super(RebuildServerTests, cls).setUpClass()
cls.key = cls.keypairs_client.create_keypair(rand_name("key")).entity
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 test_create_delete_image(self):
"""An image for the provided server should be created"""
name = rand_name('testimage')
server_id = self.server.id
image_response = self.servers_client.create_image(server_id, name)
image_id = self.parse_image_id(image_response)
self.image_behaviors.wait_for_image_status(image_id,
NovaImageStatusTypes.ACTIVE)
# Delete image and wait for image to be deleted
self.image_behaviors.wait_for_image_to_be_deleted(image_id)
def setUp(self):
super(ImagesMetadataTest, self).setUp()
self.server_resp = self.server_behaviors.create_active_server()
self.server_id = self.server_resp.entity.id
self.resources.add(self.server_id, self.servers_client.delete_server)
meta = {'key1': 'value1', 'key2': 'value2'}
name = rand_name('testimage')
image_resp = self.servers_client.create_image(self.server_id, name, meta)
self.image_id = self.parse_image_id(image_resp)
self.resources.add(self.image_id, self.images_client.delete_image)
self.image_behaviors.wait_for_image_resp_code(self.image_id, 200)
self.image_behaviors.wait_for_image_status(self.image_id, NovaImageStatusTypes.ACTIVE)
self.image = self.images_client.get_image(self.image_id)
def test_create_server_with_admin_password(self):
"""
If an admin password is provided on server creation, the server's root
password should be set to that password.
"""
name = rand_name("testserver")
admin_password = '******'
create_server_response = self.servers_client.create_server(name, self.image_ref, self.flavor_ref, admin_pass=admin_password)
created_server = create_server_response.entity
self.assertEqual(admin_password, created_server.admin_pass,
msg='Verify that given adminPass equals with actual one')
active_server = self.server_behaviors.wait_for_server_status(created_server.id, NovaServerStatusTypes.ACTIVE)
def setUpClass(cls):
super(CreateServerTest, cls).setUpClass()
cls.name = rand_name("cctestserver")
cls.metadata = {"meta_key_1": "meta_value_1", "meta_key_2": "meta_value_2"}
cls.create_resp = cls.servers_client.create_server(
cls.name, cls.image_ref, cls.flavor_ref, metadata=cls.metadata
)
created_server = cls.create_resp.entity
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(ImagesMetadataTest, cls).setUpClass()
cls.server_resp = cls.server_behaviors.create_active_server()
cls.server_id = cls.server_resp.entity.id
cls.resources.add(cls.server_id, cls.servers_client.delete_server)
meta = {'key1': 'value1', 'key2': 'value2'}
name = rand_name('testimage')
image_resp = cls.servers_client.create_image(cls.server_id, name, meta)
cls.image_id = cls.parse_image_id(image_resp)
cls.resources.add(cls.image_id, cls.images_client.delete_image)
cls.image_behaviors.wait_for_image_resp_code(cls.image_id, 200)
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(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.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, gc_name=None, gc_cooldown=None, gc_min_entities=None,
gc_max_entities=None, gc_metadata=None, lc_name=None,
lc_image_ref=None, lc_flavor_ref=None,
lc_personality=None, lc_metadata=None,
lc_disk_config=None, lc_networks=None,
lc_load_balancers=None):
"""
Creates a scaling group with config values
"""
super(ScalingGroupFixture, cls).setUpClass()
if gc_name is None:
gc_name = rand_name('test_sgroup_fixt_')
if gc_cooldown is None:
gc_cooldown = cls.gc_cooldown
if gc_min_entities is None:
gc_min_entities = cls.gc_min_entities
if lc_name is None:
lc_name = rand_name('test_sg_fixt_srv')
if lc_flavor_ref is None:
lc_flavor_ref = cls.lc_flavor_ref
if lc_image_ref is None:
lc_image_ref = cls.lc_image_ref
cls.create_group_response = cls.autoscale_client.\
create_scaling_group(
gc_name, gc_cooldown,
gc_min_entities,
lc_name, lc_image_ref,
lc_flavor_ref,
gc_max_entities=gc_max_entities,
gc_metadata=gc_metadata,
lc_personality=lc_personality,
lc_metadata=lc_metadata,
lc_disk_config=lc_disk_config,
lc_networks=lc_networks,
lc_load_balancers=lc_load_balancers)
cls.group = cls.create_group_response.entity
cls.resources.add(cls.group.id,
cls.autoscale_client.delete_scaling_group)
def setUpClass(cls):
super(ImagesMetadataTest, cls).setUpClass()
cls.server_resp = cls.server_behaviors.create_active_server()
cls.server_id = cls.server_resp.entity.id
cls.resources.add(cls.server_id, cls.servers_client.delete_server)
meta = {'key1': 'value1', 'key2': 'value2'}
name = rand_name('testimage')
image_resp = cls.servers_client.create_image(cls.server_id, name, meta)
cls.image_id = cls.parse_image_id(image_resp)
cls.resources.add(cls.image_id, cls.images_client.delete_image)
cls.image_behaviors.wait_for_image_resp_code(cls.image_id, 200)
cls.image_behaviors.wait_for_image_status(cls.image_id,
NovaImageStatusTypes.ACTIVE)
cls.image = cls.images_client.get_image(cls.image_id).entity
def create_policy_webhook(self, group_id, policy_data,
execute_webhook=None, execute_policy=None):
"""
:summary: wrapper for create_policy_given. Given a dict with
change type, the change number, cooldown(optional),
sets the parameters in create_policy_min and
creates a webhook for the policy
:param: group id
:param: dict of policy details such as change type,
change integer/number, cooldown(optional)
Eg: {'change_percent': 100, 'cooldown': 200}
:param: execute_webhook. Executes the newly created webhook
:param: execute_policy. Executes the newly created policy
:return: dict containing policy id and its webhook id and
capability url
:rtype: dict
"""
sp_change = sp_change_percent = sp_desired_capacity = sp_cooldown = None
response_code = None
if policy_data.get('change_percent'):
sp_change_percent = policy_data['change_percent']
if policy_data.get('change'):
sp_change = policy_data['change']
if policy_data.get('desired_capacity'):
sp_desired_capacity = policy_data['desired_capacity']
if policy_data.get('cooldown'):
sp_cooldown = policy_data['cooldown']
policy = AutoscaleBehaviors.create_policy_given(
self, group_id=group_id, sp_cooldown=sp_cooldown,
sp_change=sp_change, sp_change_percent=sp_change_percent,
sp_desired_capacity=sp_desired_capacity)
wb_name = rand_name('test_wb_')
create_webhook = self.autoscale_client.create_webhook(
group_id=group_id,
policy_id=policy['id'],
name=wb_name)
webhook = AutoscaleBehaviors.get_webhooks_properties(
self, create_webhook.entity)
if execute_webhook is True:
execute_webhook_response = self.autoscale_client.execute_webhook(
webhook['links'].capability)
response_code = execute_webhook_response.status_code
if execute_policy is True:
execute_policy_response = self.autoscale_client.execute_policy(
group_id=group_id,
policy_id=policy['id'])
response_code = execute_policy_response.status_code
rdata = dict(policy_id=policy['id'], webhook_id=webhook['id'],
webhook_url=webhook['links'].capability, execute_response=response_code)
return rdata
def create_scaling_group_given(self, gc_name=None, gc_cooldown=None,
gc_min_entities=None, gc_max_entities=None,
gc_metadata=None, lc_name=None,
lc_image_ref=None, lc_flavor_ref=None,
lc_personality=None, lc_metadata=None,
lc_disk_config=None, lc_networks=None,
lc_load_balancers=None, sp_list=None):
"""
Creates a scaling group with given parameters and default the other
required fields if not already given
"""
gc_name = gc_name and str(gc_name) or rand_name('test_sgroup_bhv_')
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_sg_bhv_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_cooldown,
gc_min_entities,
lc_name,
lc_image_ref,
lc_flavor_ref,
gc_max_entities=gc_max_entities,
gc_metadata=gc_metadata,
lc_personality=lc_personality,
lc_metadata=lc_metadata,
lc_disk_config=lc_disk_config,
lc_networks=lc_networks,
lc_load_balancers=lc_load_balancers,
sp_list=sp_list)
return create_response
def create_active_server(self, name=None, image_ref=None, flavor_ref=None,
personality=None, metadata=None, accessIPv4=None,
accessIPv6=None, disk_config=None, networks=None):
"""
@summary:Creates a server and waits for server to reach active status
@param name: The name of the server.
@type name: String
@param image_ref: The reference to the image used to build the server.
@type image_ref: String
@param flavor_ref: The flavor used to build the server.
@type flavor_ref: String
@param metadata: A dictionary of values to be used as metadata.
@type metadata: Dictionary. The limit is 5 key/values.
@param personality: A list of dictionaries for files to be
injected into the server.
@type personality: List
@param accessIPv4: IPv4 address for the server.
@type accessIPv4: String
@param accessIPv6: IPv6 address for the server.
@type accessIPv6: String
@param disk_config: MANUAL/AUTO/None
@type disk_config: String
@return: Response Object containing response code and
the server domain object
@rtype: Request Response Object
"""
if name is None:
name = rand_name('testserver')
if image_ref is None:
image_ref = self.images_config.primary_image
if flavor_ref is None:
flavor_ref = self.flavors_config.primary_flavor
resp = self.servers_client.create_server(name, image_ref,
flavor_ref,
personality=personality,
metadata=metadata,
accessIPv4=accessIPv4,
accessIPv6=accessIPv6,
disk_config=disk_config,
networks=networks)
server_obj = resp.entity
resp = self.wait_for_server_status(server_obj.id,
ServerStates.ACTIVE)
# Add the password from the create request into the final response
resp.entity.admin_pass = server_obj.admin_pass
return resp
def create_active_server(self, name=None, image_ref=None, flavor_ref=None,
personality=None, metadata=None, accessIPv4=None,
accessIPv6=None, disk_config=None, networks=None):
'''
@summary:Creates a server and waits for server to reach active status
@param name: The name of the server.
@type name: String
@param image_ref: The reference to the image used to build the server.
@type image_ref: String
@param flavor_ref: The flavor used to build the server.
@type flavor_ref: String
@param metadata: A dictionary of values to be used as metadata.
@type metadata: Dictionary. The limit is 5 key/values.
@param personality: A list of dictionaries for files to be
injected into the server.
@type personality: List
@param accessIPv4: IPv4 address for the server.
@type accessIPv4: String
@param accessIPv6: IPv6 address for the server.
@type accessIPv6: String
@param disk_config: MANUAL/AUTO/None
@type disk_config: String
@return: Response Object containing response code and
the server domain object
@rtype: Request Response Object
'''
if name is None:
name = rand_name('testserver')
if image_ref is None:
image_ref = self.images_config.primary_image
if flavor_ref is None:
flavor_ref = self.flavors_config.primary_flavor
resp = self.servers_client.create_server(name, image_ref,
flavor_ref,
personality=personality,
metadata=metadata,
accessIPv4=accessIPv4,
accessIPv6=accessIPv6,
disk_config=disk_config,
networks=networks)
server_obj = resp.entity
resp = self.wait_for_server_status(server_obj.id,
ServerStates.ACTIVE)
# Add the password from the create request into the final response
resp.entity.admin_pass = server_obj.admin_pass
return resp
def setUpClass(cls):
super(UpdateServerTest, cls).setUpClass()
cls.original_server = cls.server_behaviors.create_active_server().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 setUpClass(cls):
"""
Create a scaling group.
"""
super(UpdateGroupConfigTest, cls).setUpClass()
create_resp = cls.autoscale_behaviors.create_scaling_group_given(
gc_min_entities=2,
gc_max_entities=10)
cls.group = create_resp.entity
cls.resources.add(cls.group.id,
cls.autoscale_client.delete_scaling_group)
cls.gc_name = rand_name('updgroupconfig')
cls.gc_min_entities = cls.group.groupConfiguration.minEntities
cls.gc_cooldown = 800
cls.gc_max_entities = 15
cls.gc_metadata = {'upd_key1': 'upd_value1'}
def test_create_server_with_admin_password(self):
"""
If an admin password is provided on server creation, the server's root
password should be set to that password.
"""
name = rand_name("testserver")
admin_password = '******'
create_server_response = self.servers_client.create_server(
name, self.image_ref, self.flavor_ref, admin_pass=admin_password)
created_server = create_server_response.entity
self.assertEqual(
admin_password,
created_server.admin_pass,
msg='Verify that given adminPass equals with actual one')
active_server = self.server_behaviors.wait_for_server_status(
created_server.id, NovaServerStatusTypes.ACTIVE)
def setUpClass(cls):
super(TokenRequiredTests, cls).setUpClass()
cls.metadata = {'meta_key_1': 'meta_value_1',
'meta_key_2': 'meta_value_2'}
cls.server = cls.server_behaviors.create_active_server(
metadata=cls.metadata).entity
cls.resources.add(cls.server.id, cls.servers_client.delete_server)
image_name = rand_name('testimage')
cls.image_meta = {'key1': 'value1', 'key2': 'value2'}
image_resp = cls.servers_client.create_image(cls.server.id,
image_name,
cls.image_meta)
assert image_resp.status_code == 202
cls.image_id = cls.parse_image_id(image_resp)
cls.image_behaviors.wait_for_image_status(cls.image_id, NovaImageStatusTypes.ACTIVE)
cls.resources.add(cls.image_id, cls.images_client.delete_image)
cls.auth_token = {'headers':{'X-Auth-Token': None}}
def test_update_server_using_server_bookmark_link(self):
"""Update a server using the server bookmark link"""
name = rand_name("testserver")
stored_name = name
# Create an active server
active_server_response = self.server_behaviors.create_active_server()
active_server = active_server_response.entity
'''Need to ensure there is atleast one second gap between creating
and updating a server. The test failed once without the sleep.'''
time.sleep(1)
#Some processing
link = str(active_server.links.bookmark)
link_list = link.split('/')
server_id = link_list[5]
'''Use server bookmark's link to update the server'''
updated_server_response = self.servers_client.update_server(
server_id,
name,
accessIPv4=self.accessIPv4,
accessIPv6=self.accessIPv6)
updated_server = updated_server_response.entity
self.server_behaviors.wait_for_server_status(
updated_server.id, NovaServerStatusTypes.ACTIVE)
'''Verify the name and access ips of the server have changed'''
get_server_info = self.servers_client.get_server(updated_server.id)
self.assertEqual(stored_name,
get_server_info.entity.name,
msg="The name was not updated")
self.assertEqual(self.accessIPv4,
get_server_info.entity.accessIPv4,
msg="AccessIPv4 was not updated")
self.assertEqual(self.accessIPv6,
get_server_info.entity.accessIPv6,
msg="AccessIPv6 was not updated")
self.assertEqual(active_server.created,
get_server_info.entity.created,
msg="The creation date was updated")
self.assertTrue(
active_server.updated != get_server_info.entity.updated,
msg=
"Server %s updated time did not change after a modification to the server."
% updated_server.id)
self.servers_client.delete_server(get_server_info.entity.id)
def create_active_image(self, server_id):
"""
@summary: Creates an image from a server and waits for
the image to become active
@param server_id: The uuid of the image
@type server_id: String
@return: Response object containing response and the image
domain object
@rtype: requests.Response
"""
name = rand_name('image')
resp = self.servers_client.create_image(server_id, name)
assert resp.status_code == 202
# Retrieve the image id from the response header
image_id = resp.headers['location'].rsplit('/')[-1]
resp = self.wait_for_image_status(image_id, ImageStates.ACTIVE)
return resp
def setUpClass(cls):
super(UpdateServerTest, cls).setUpClass()
cls.original_server = cls.server_behaviors.create_active_server(
).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 setUpClass(cls):
super(TokenRequiredTests, cls).setUpClass()
cls.metadata = {
'meta_key_1': 'meta_value_1',
'meta_key_2': 'meta_value_2'
}
cls.server = cls.server_behaviors.create_active_server(
metadata=cls.metadata).entity
cls.resources.add(cls.server.id, cls.servers_client.delete_server)
image_name = rand_name('testimage')
cls.image_meta = {'key1': 'value1', 'key2': 'value2'}
image_resp = cls.servers_client.create_image(cls.server.id, image_name,
cls.image_meta)
assert image_resp.status_code == 202
cls.image_id = cls.parse_image_id(image_resp)
cls.image_behaviors.wait_for_image_status(cls.image_id,
NovaImageStatusTypes.ACTIVE)
cls.resources.add(cls.image_id, cls.images_client.delete_image)
cls.auth_token = {'headers': {'X-Auth-Token': None}}
def test_create_server_with_image_and_flavor_self_link(self):
"""Create a server using image and flavor self links"""
name = rand_name("testserver")
image = self.images_client.get_image(self.image_ref)
image_self_link = image.entity.id
flavor = self.flavors_client.get_flavor_details(self.flavor_ref)
flavor_self_link = flavor.entity.id
create_server_response = self.servers_client.create_server(
name, image_self_link, flavor_self_link)
created_server = create_server_response.entity
#Verify the parameters are correct in the initial response
self.assertTrue(created_server.id is not None,
msg="The server id was not set in response")
self.assertTrue(created_server.admin_pass is not None,
msg="Admin password was not set in response")
self.assertTrue(created_server.links is not None,
msg="Server links were not set in response")
'''Wait for the server to become active'''
active_server_response = self.server_behaviors.wait_for_server_status(
created_server.id, NovaServerStatusTypes.ACTIVE)
active_server = active_server_response.entity
get_server_info_response = self.servers_client.get_server(
created_server.id)
get_server_info = get_server_info_response.entity
'''Verify that the image Id of the image ref link which is used to create server
is same as the image id of the created server'''
self.assertEqual(
get_server_info.image.id,
self._parse_link_to_retrieve_id(image_self_link),
msg="The image does not match to the image mentioned during create"
)
'''Verify that the flavor Id of the flavor ref link which is used to create server
is same as the flavor id of the created server'''
self.assertEqual(
get_server_info.flavor.id,
self._parse_link_to_retrieve_id(flavor_self_link),
msg=
"The flavor does not match to the flavor mentioned during create")
self.servers_client.delete_server(active_server.id)
def create_image(self, server_id, name=None, metadata=None,
requestslib_kwargs=None):
"""
@summary: Creates snapshot of the server
@param server_id: The id of an existing server.
@type server_id: String
@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
"""
if name is None:
name = rand_name("TestImage")
url = '{base_url}/servers/{server_id}/action'.format(
base_url=self.url, server_id=server_id)
create_image_request_object = CreateImage(name, metadata)
resp = self.request('POST', url,
request_entity=create_image_request_object,
requestslib_kwargs=requestslib_kwargs)
return resp
def create_active_backup(self, server_id, backup_type, backup_rotation):
"""
@summary: Creates a backup from a server and waits for
the backup to become active
@param server_id: The uuid of the 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
@return: Response object containing response and the image
domain object
@rtype: requests.Response
"""
name = rand_name('backup')
resp = self.servers_client.create_backup(server_id, backup_type,
backup_rotation, name)
assert resp.status_code == 202
# Retrieve the backup id from the response header
backup_id = resp.headers['location'].rsplit('/')[-1]
resp = self.wait_for_image_status(backup_id, ImageStates.ACTIVE)
return resp
def test_set_blank_metadata_dict(self):
blank_meta = {'': ''}
create_server_response = self.servers_client.create_server(rand_name('testserver'), self.image_ref, self.flavor_ref, metadata=blank_meta)
server_response = self.servers_client.get_server(create_server_response.entity.id)
server = server_response.entity
self.assertEqual("", server.metadata[''])
