def test_flavor_update_metadata(self): """Test update flavor metadata * logs in as admin user * creates a new flavor * verifies the flavor appears in the flavors table * verifies that Metadata column of the table contains 'No' * invokes action 'Update Metadata' for the new flavor * adds custom filed 'metadata' * adds value 'flavor' for the custom filed 'metadata' * verifies that Metadata column of the table is updated to Yes * deletes the newly created flavor * verifies the flavor does not appear in the table after deletion """ new_metadata = {'metadata1': helpers.gen_random_resource_name("value"), 'metadata2': helpers.gen_random_resource_name("value")} flavors_page = self.flavor_create() self.assertTrue( flavors_page.get_metadata_column_value(self.FLAVOR_NAME) == 'No') flavors_page.add_custom_metadata(self.FLAVOR_NAME, new_metadata) self.assertTrue( flavors_page.get_metadata_column_value(self.FLAVOR_NAME) == 'Yes') results = flavors_page.check_flavor_metadata(self.FLAVOR_NAME, new_metadata) self.flavor_delete() self.assertSequenceTrue(results) # custom matcher
def test_update_image_metadata(self): """Test update image metadata * logs in as admin user * creates image from locally downloaded file * verifies the image appears in the images table as active * invokes action 'Update Metadata' for the image * adds custom filed 'metadata' * adds value 'image' for the custom filed 'metadata' * gets the actual description of the image * verifies that custom filed is present in the image description * deletes the image * verifies the image does not appear in the table after deletion """ new_metadata = {'metadata1': helpers.gen_random_resource_name("value"), 'metadata2': helpers.gen_random_resource_name("value")} with helpers.gen_temporary_file() as file_name: # TODO(tsufiev): had to add non-empty description to an image, # because description is now considered a metadata and we want # the metadata in a newly created image to be valid images_page = self.image_create(local_file=file_name, description='test description') images_page.add_custom_metadata(self.IMAGE_NAME, new_metadata) results = images_page.check_image_details(self.IMAGE_NAME, new_metadata) self.image_delete(self.IMAGE_NAME) self.assertSequenceTrue(results)
def test_edit_image_description_and_name(self): """tests that image description is editable * creates image from locally downloaded file * verifies the image appears in the images table as active * toggle edit action and adds some description * verifies that edit action was successful * verifies that new description is seen on image details page * toggle edit action and changes image name * verifies that edit action was successful * verifies that image with new name is seen on the page * deletes the image * verifies the image does not appear in the table after deletion """ new_description_text = helpers.gen_random_resource_name("description") new_image_name = helpers.gen_random_resource_name("image") with helpers.gen_temporary_file() as file_name: images_page = self.image_create(local_file=file_name) images_page.edit_image(self.IMAGE_NAME, description=new_description_text) self.assertTrue( images_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( images_page.find_message_and_dismiss(messages.ERROR)) results = images_page.check_image_details(self.IMAGE_NAME, {'Description': new_description_text}) self.assertSequenceTrue(results) # Just go back to the images page and toggle edit again images_page = self.images_page images_page.edit_image(self.IMAGE_NAME, new_name=new_image_name) self.assertTrue( images_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( images_page.find_message_and_dismiss(messages.ERROR)) results = images_page.check_image_details(new_image_name, {'Name': new_image_name}) self.assertSequenceTrue(results) self.image_delete(new_image_name)
def test_manage_volume_attachments(self): """This test case checks attach/detach actions for volume Steps: 1. Login to Horizon Dashboard as horizon user 2. Navigate to Project -> Compute -> Instances, create instance 3. Navigate to Project -> Volumes -> Volumes, create volume 4. Attach volume to instance from step2 5. Check that volume status and link to instance 6. Detach volume from instance 7. Check volume status 8. Delete volume and instance """ instance_name = helpers.gen_random_resource_name('instance') instances_page = self.home_pg.go_to_project_compute_instancespage() instances_page.create_instance(instance_name) instances_page.find_message_and_dismiss(messages.SUCCESS) self.assertFalse( instances_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(instances_page.is_instance_active(instance_name)) volumes_page = self.volumes_page volumes_page.create_volume(self.VOLUME_NAME) volumes_page.find_message_and_dismiss(messages.INFO) self.assertFalse(volumes_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(volumes_page.is_volume_status(self.VOLUME_NAME, 'Available')) volumes_page.attach_volume_to_instance(self.VOLUME_NAME, instance_name) volumes_page.find_message_and_dismiss(messages.INFO) self.assertFalse(volumes_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(volumes_page.is_volume_status(self.VOLUME_NAME, 'In-use')) self.assertTrue( volumes_page.is_volume_attached_to_instance(self.VOLUME_NAME, instance_name)) volumes_page.detach_volume_from_instance(self.VOLUME_NAME, instance_name) volumes_page.find_message_and_dismiss(messages.SUCCESS) self.assertFalse(volumes_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(volumes_page.is_volume_status(self.VOLUME_NAME, 'Available')) volumes_page.delete_volume(self.VOLUME_NAME) volumes_page.find_message_and_dismiss(messages.SUCCESS) self.assertFalse(volumes_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(volumes_page.is_volume_deleted(self.VOLUME_NAME)) instances_page = self.home_pg.go_to_project_compute_instancespage() instances_page.delete_instance(instance_name) instances_page.find_message_and_dismiss(messages.SUCCESS) self.assertFalse( instances_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(instances_page.is_instance_deleted(instance_name))
def test_manage_volume_attachments(self): """This test case checks attach/detach actions for volume Steps: 1. Login to Horizon Dashboard as horizon user 2. Navigate to Project -> Compute -> Instances, create instance 3. Navigate to Project -> Compute -> Volumes, create volume 4. Attach volume to instance from step2 5. Check that volume status and link to instance 6. Detach volume from instance 7. Check volume status 8. Delete volume and instance """ instance_name = helpers.gen_random_resource_name('instance') instances_page = self.home_pg.go_to_compute_instancespage() instances_page.create_instance(instance_name) instances_page.find_message_and_dismiss(messages.SUCCESS) self.assertFalse( instances_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(instances_page.is_instance_active(instance_name)) volumes_page = self.volumes_page volumes_page.create_volume(self.VOLUME_NAME) volumes_page.find_message_and_dismiss(messages.INFO) self.assertFalse(volumes_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue( volumes_page.is_volume_status(self.VOLUME_NAME, 'Available')) volumes_page.attach_volume_to_instance(self.VOLUME_NAME, instance_name) volumes_page.find_message_and_dismiss(messages.INFO) self.assertFalse(volumes_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue( volumes_page.is_volume_status(self.VOLUME_NAME, 'In-use')) self.assertTrue( volumes_page.is_volume_attached_to_instance( self.VOLUME_NAME, instance_name)) volumes_page.detach_volume_from_instance(self.VOLUME_NAME, instance_name) volumes_page.find_message_and_dismiss(messages.SUCCESS) self.assertFalse(volumes_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue( volumes_page.is_volume_status(self.VOLUME_NAME, 'Available')) volumes_page.delete_volume(self.VOLUME_NAME) volumes_page.find_message_and_dismiss(messages.SUCCESS) self.assertFalse(volumes_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(volumes_page.is_volume_deleted(self.VOLUME_NAME)) instances_page = self.home_pg.go_to_compute_instancespage() instances_page.delete_instance(instance_name) instances_page.find_message_and_dismiss(messages.SUCCESS) self.assertFalse( instances_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(instances_page.is_instance_deleted(instance_name))
def test_qos_spec_edit_consumer(self): """tests Edit Consumer of QoS Spec functionality * creates a new QoS Spec * verifies the QoS Spec appears in the QoS Specs table * edit consumer of created QoS Spec (check all options - front-end, both, back-end) * verifies current consumer of the QoS Spec in the QoS Specs table * deletes the newly created QoS Spec * verifies the QoS Spec does not appear in the table after deletion """ qos_spec_name = helpers.gen_random_resource_name("qos_spec") qos_spec_page = self.home_pg.go_to_system_volumes_volumetypespage() nova_compute_consumer = 'front-end' both_consumers = 'both' cinder_consumer = 'back-end' qos_spec_page.create_qos_spec(qos_spec_name) self.assertTrue( qos_spec_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( qos_spec_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(qos_spec_page.is_qos_spec_present(qos_spec_name)) qos_spec_page.edit_consumer(qos_spec_name, nova_compute_consumer) self.assertTrue( qos_spec_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( qos_spec_page.find_message_and_dismiss(messages.ERROR)) self.assertEqual( qos_spec_page.get_consumer(qos_spec_name), nova_compute_consumer) qos_spec_page.edit_consumer(qos_spec_name, both_consumers) self.assertTrue( qos_spec_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( qos_spec_page.find_message_and_dismiss(messages.ERROR)) self.assertEqual( qos_spec_page.get_consumer(qos_spec_name), both_consumers) qos_spec_page.edit_consumer(qos_spec_name, cinder_consumer) self.assertTrue( qos_spec_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( qos_spec_page.find_message_and_dismiss(messages.ERROR)) self.assertEqual( qos_spec_page.get_consumer(qos_spec_name), cinder_consumer) qos_spec_page.delete_qos_specs(qos_spec_name) self.assertTrue( qos_spec_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( qos_spec_page.find_message_and_dismiss(messages.ERROR)) self.assertFalse(qos_spec_page.is_qos_spec_present(qos_spec_name))
def test_qos_spec_edit_consumer(self): """tests Edit Consumer of QoS Spec functionality * creates a new QoS Spec * verifies the QoS Spec appears in the QoS Specs table * edit consumer of created QoS Spec (check all options - front-end, both, back-end) * verifies current consumer of the QoS Spec in the QoS Specs table * deletes the newly created QoS Spec * verifies the QoS Spec does not appear in the table after deletion """ qos_spec_name = helpers.gen_random_resource_name("qos_spec") qos_spec_page = self.home_pg.go_to_system_volumes_volumetypespage() nova_compute_consumer = 'front-end' both_consumers = 'both' cinder_consumer = 'back-end' qos_spec_page.create_qos_spec(qos_spec_name) self.assertTrue( qos_spec_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse(qos_spec_page.find_message_and_dismiss( messages.ERROR)) self.assertTrue(qos_spec_page.is_qos_spec_present(qos_spec_name)) qos_spec_page.edit_consumer(qos_spec_name, nova_compute_consumer) self.assertTrue( qos_spec_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse(qos_spec_page.find_message_and_dismiss( messages.ERROR)) self.assertEqual(qos_spec_page.get_consumer(qos_spec_name), nova_compute_consumer) qos_spec_page.edit_consumer(qos_spec_name, both_consumers) self.assertTrue( qos_spec_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse(qos_spec_page.find_message_and_dismiss( messages.ERROR)) self.assertEqual(qos_spec_page.get_consumer(qos_spec_name), both_consumers) qos_spec_page.edit_consumer(qos_spec_name, cinder_consumer) self.assertTrue( qos_spec_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse(qos_spec_page.find_message_and_dismiss( messages.ERROR)) self.assertEqual(qos_spec_page.get_consumer(qos_spec_name), cinder_consumer) qos_spec_page.delete_qos_specs(qos_spec_name) self.assertTrue( qos_spec_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse(qos_spec_page.find_message_and_dismiss( messages.ERROR)) self.assertFalse(qos_spec_page.is_qos_spec_present(qos_spec_name))
def test_edit_image_description_and_name(self): """tests that image description is editable * creates image from locally downloaded file * verifies the image appears in the images table as active * toggle edit action and adds some description * verifies that edit action was successful * verifies that new description is seen on image details page * toggle edit action and changes image name * verifies that edit action was successful * verifies that image with new name is seen on the page * deletes the image * verifies the image does not appear in the table after deletion """ new_description_text = helpers.gen_random_resource_name("description") new_image_name = helpers.gen_random_resource_name("image") with helpers.gen_temporary_file() as file_name: images_page = self.image_create(local_file=file_name) images_page.edit_image(self.IMAGE_NAME, description=new_description_text) self.assertTrue( images_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( images_page.find_message_and_dismiss(messages.ERROR)) results = images_page.check_image_details( self.IMAGE_NAME, {'Description': new_description_text}) self.assertSequenceTrue(results) # Just go back to the images page and toggle edit again images_page = self.images_page images_page.edit_image(self.IMAGE_NAME, new_name=new_image_name) self.assertTrue( images_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( images_page.find_message_and_dismiss(messages.ERROR)) results = images_page.check_image_details(new_image_name, {'Name': new_image_name}) self.assertSequenceTrue(results) self.image_delete(new_image_name)
class TestAdminInstances(helpers.AdminTestCase, TestInstances): INSTANCE_NAME = helpers.gen_random_resource_name('instance', timestamp=False) @property def instances_page(self): return self.home_pg.go_to_admin_compute_instancespage() @decorators.skip_because(bugs=['1774697']) def test_instances_pagination_and_filtration(self): super(TestAdminInstances, self).\ test_instances_pagination_and_filtration()
def test_floatingip_associate_disassociate(self): instance_name = helpers.gen_random_resource_name('instance', timestamp=False) instances_page = self.home_pg.go_to_project_compute_instancespage() instances_page.create_instance(instance_name) self.assertTrue( instances_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( instances_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(instances_page.is_instance_active(instance_name)) instance_ipv4 = instances_page.get_fixed_ipv4(instance_name) instance_info = "{} {}".format(instance_name, instance_ipv4) floatingip_page = \ self.home_pg.go_to_project_network_floatingipspage() floating_ip = floatingip_page.allocate_floatingip() self.assertTrue( floatingip_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( floatingip_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(floatingip_page.is_floatingip_present(floating_ip)) self.assertEqual('-', floatingip_page.get_fixed_ip(floating_ip)) floatingip_page.associate_floatingip(floating_ip, instance_name, instance_ipv4) self.assertTrue( floatingip_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( floatingip_page.find_message_and_dismiss(messages.ERROR)) self.assertEqual(instance_info, floatingip_page.get_fixed_ip(floating_ip)) floatingip_page.disassociate_floatingip(floating_ip) self.assertTrue( floatingip_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( floatingip_page.find_message_and_dismiss(messages.ERROR)) self.assertEqual('-', floatingip_page.get_fixed_ip(floating_ip)) floatingip_page.release_floatingip(floating_ip) self.assertTrue( floatingip_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( floatingip_page.find_message_and_dismiss(messages.ERROR)) self.assertFalse(floatingip_page.is_floatingip_present(floating_ip)) instances_page = self.home_pg.go_to_project_compute_instancespage() instances_page.delete_instance(instance_name) self.assertTrue( instances_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( instances_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(instances_page.is_instance_deleted(instance_name))
def test_floatingip_associate_disassociate(self): instance_name = helpers.gen_random_resource_name('instance', timestamp=False) instances_page = self.home_pg.go_to_compute_instancespage() instances_page.create_instance(instance_name) self.assertTrue( instances_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( instances_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(instances_page.is_instance_active(instance_name)) instance_ipv4 = instances_page.get_fixed_ipv4(instance_name) instance_info = "{} {}".format(instance_name, instance_ipv4) floatingip_page = \ self.home_pg.go_to_compute_accessandsecurity_floatingipspage() floating_ip = floatingip_page.allocate_floatingip() self.assertTrue( floatingip_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( floatingip_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(floatingip_page.is_floatingip_present(floating_ip)) self.assertEqual(floatingip_page.get_fixed_ip(floating_ip), '-') floatingip_page.associate_floatingip(floating_ip, instance_name, instance_ipv4) self.assertTrue( floatingip_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( floatingip_page.find_message_and_dismiss(messages.ERROR)) self.assertEqual(floatingip_page.get_fixed_ip(floating_ip), instance_info) floatingip_page.disassociate_floatingip(floating_ip) self.assertTrue( floatingip_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( floatingip_page.find_message_and_dismiss(messages.ERROR)) self.assertEqual(floatingip_page.get_fixed_ip(floating_ip), '-') floatingip_page.release_floatingip(floating_ip) self.assertTrue( floatingip_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( floatingip_page.find_message_and_dismiss(messages.ERROR)) self.assertFalse(floatingip_page.is_floatingip_present(floating_ip)) instances_page = self.home_pg.go_to_compute_instancespage() instances_page.delete_instance(instance_name) self.assertTrue( instances_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( instances_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(instances_page.is_instance_deleted(instance_name))
class TestAdminInstances(helpers.AdminTestCase, TestInstances): INSTANCE_NAME = helpers.gen_random_resource_name('instance', timestamp=False) @property def instances_page(self): return self.home_pg.go_to_admin_compute_instancespage() @pytest.mark.skip(reason="Bug 1774697") def test_instances_pagination_and_filtration(self): super(TestAdminInstances, self).\ test_instances_pagination_and_filtration()
class TestRouters(helpers.TestCase): ROUTER_NAME = helpers.gen_random_resource_name("router") @decorators.services_required("neutron") def test_router_create(self): """Checks create, clear/set gateway, delete router functionality Executed by non-admin user. Steps: 1. Login to Horizon Dashboard as horizon user 2. Navigate to Project -> Network -> Routers page 3. Create new router 4. Check that the router appears in the routers table as active 5. Check that no Error messages present 6. Clear the gateway 7. Check that the router is still in the routers table with no external network 8. Check that no Error messages present 9. Set the gateway to 'public' network 10. Check that no Error messages present 11. Check that router's external network is set to 'public' 12. Delete the router 13. Check that the router is absent in the routers table 14. Check that no Error messages present """ routers_page = self.home_pg.go_to_network_routerspage() routers_page.create_router(self.ROUTER_NAME) self.assertTrue(routers_page.find_message_and_dismiss( messages.SUCCESS)) self.assertFalse(routers_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(routers_page.is_router_present(self.ROUTER_NAME)) self.assertTrue(routers_page.is_router_active(self.ROUTER_NAME)) routers_page.clear_gateway(self.ROUTER_NAME) self.assertTrue(routers_page.find_message_and_dismiss( messages.SUCCESS)) self.assertFalse(routers_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(routers_page.is_gateway_cleared(self.ROUTER_NAME)) routers_page.set_gateway(self.ROUTER_NAME) self.assertTrue(routers_page.find_message_and_dismiss( messages.SUCCESS)) self.assertFalse(routers_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(routers_page.is_gateway_set(self.ROUTER_NAME)) routers_page.delete_router(self.ROUTER_NAME) self.assertTrue(routers_page.find_message_and_dismiss( messages.SUCCESS)) self.assertFalse(routers_page.find_message_and_dismiss(messages.ERROR)) self.assertFalse(routers_page.is_router_present(self.ROUTER_NAME))
class TestUser(helpers.AdminTestCase): USER_NAME = helpers.gen_random_resource_name("user") def test_create_delete_user(self): users_page = self.home_pg.go_to_identity_userspage() password = self.TEST_PASSWORD users_page.create_user(self.USER_NAME, password=password, project='admin', role='admin') self.assertTrue(users_page.is_user_present(self.USER_NAME)) users_page.delete_user(self.USER_NAME) self.assertFalse(users_page.is_user_present(self.USER_NAME))
class TestKeypair(helpers.TestCase): """Checks that the user is able to create/delete keypair.""" KEYPAIR_NAME = helpers.gen_random_resource_name("keypair") def test_keypair(self): keypair_page = self.home_pg.go_to_accessandsecurity_keypairspage() keypair_page.create_keypair(self.KEYPAIR_NAME) keypair_page = self.home_pg.go_to_accessandsecurity_keypairspage() self.assertTrue(keypair_page.is_keypair_present(self.KEYPAIR_NAME)) keypair_page.delete_keypair(self.KEYPAIR_NAME) self.assertFalse(keypair_page.is_keypair_present(self.KEYPAIR_NAME))
class TestStacks(helpers.AdminTestCase): KEYPAIR_NAME = 'keypair_for_stack' STACKS_NAME = helpers.gen_random_resource_name('stack', timestamp=False) STACK_TEMPLATE_PATH = os.path.join(os.path.dirname(__file__), 'test-data/stack_template') def setUp(self): super(TestStacks, self).setUp() keypair_page = self.home_pg.\ go_to_compute_accessandsecurity_keypairspage() keypair_page.create_keypair(self.KEYPAIR_NAME) keypair_page = self.home_pg.\ go_to_compute_accessandsecurity_keypairspage() self.assertTrue(keypair_page.is_keypair_present(self.KEYPAIR_NAME)) def cleanup(): keypair_page = self.home_pg.\ go_to_compute_accessandsecurity_keypairspage() keypair_page.delete_keypairs(self.KEYPAIR_NAME) keypair_page.find_message_and_dismiss(messages.SUCCESS) self.addCleanup(cleanup) @decorators.skip_because(bugs=['1584057']) @decorators.services_required("heat") def test_create_delete_stack(self): """tests the stack creation and deletion functionality * creates a new stack * verifies the stack appears in the stacks table in Create Complete state * deletes the newly created stack * verifies the stack does not appear in the table after deletion """ with open(self.STACK_TEMPLATE_PATH, 'r') as f: template = f.read() input_template = template.format(self.KEYPAIR_NAME, self.CONFIG.image.images_list[0], "public") stacks_page = self.home_pg.go_to_orchestration_stackspage() stacks_page.create_stack(self.STACKS_NAME, input_template) self.assertTrue(stacks_page.find_message_and_dismiss(messages.INFO)) self.assertFalse(stacks_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(stacks_page.is_stack_present(self.STACKS_NAME)) self.assertTrue(stacks_page.is_stack_create_complete(self.STACKS_NAME)) stacks_page.delete_stack(self.STACKS_NAME) self.assertTrue(stacks_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse(stacks_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(stacks_page.is_stack_deleted(self.STACKS_NAME))
class TestFlavors(helpers.AdminTestCase): FLAVOR_NAME = helpers.gen_random_resource_name("flavor") def setUp(self): super(TestFlavors, self).setUp() self.flavors_page = self.home_pg.go_to_admin_compute_flavorspage() def _create_flavor(self, flavor_name): self.flavors_page.create_flavor(name=flavor_name, vcpus=1, ram=1024, root_disk=20, ephemeral_disk=0, swap_disk=0) self.assertTrue( self.flavors_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( self.flavors_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(self.flavors_page.is_flavor_present(self.FLAVOR_NAME)) def _delete_flavor(self, flavor_name): self.flavors_page.delete_flavor_by_row(flavor_name) self.assertTrue( self.flavors_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( self.flavors_page.find_message_and_dismiss(messages.ERROR)) self.assertFalse(self.flavors_page.is_flavor_present(self.FLAVOR_NAME)) def test_flavor_header(self): header_text = self.driver.find_element_by_tag_name('h1').text self.assertEqual(header_text, 'Flavors') def test_flavor_module_exists(self): js_cmd = "$('html').append('<div id=\"testonly\">'"\ " + angular.module('horizon.app.core.flavors').name"\ " + '</div>');" self.driver.execute_script(js_cmd) value = self.driver.find_element_by_id('testonly').text self.assertEqual(value, 'horizon.app.core.flavors') def test_flavor_create(self): """tests the flavor creation and deletion functionalities: * creates a new flavor * verifies the flavor appears in the flavors table * deletes the newly created flavor * verifies the flavor does not appear in the table after deletion """ self._create_flavor(self.FLAVOR_NAME) self._delete_flavor(self.FLAVOR_NAME)
def test_update_image_metadata(self): """Test update image metadata * logs in as admin user * creates image from locally downloaded file * verifies the image appears in the images table as active * invokes action 'Update Metadata' for the image * adds custom filed 'metadata' * adds value 'image' for the custom filed 'metadata' * gets the actual description of the image * verifies that custom filed is present in the image description * deletes the image * verifies the image does not appear in the table after deletion """ new_metadata = {'metadata1': helpers.gen_random_resource_name("value"), 'metadata2': helpers.gen_random_resource_name("value")} with helpers.gen_temporary_file() as file_name: images_page = self.image_create(local_file=file_name) images_page.add_custom_metadata(self.IMAGE_NAME, new_metadata) results = images_page.check_image_details(self.IMAGE_NAME, new_metadata) self.image_delete() self.assertSequenceTrue(results) # custom matcher
class TestAdminVolumes(helpers.AdminTestCase): VOLUME_NAME = helpers.gen_random_resource_name("volume") def test_volume_create_edit_delete_through_admin(self): """This test case checks create, edit, delete volume functionality executed by admin user: Steps: 1. Login to Horizon Dashboard as admin user 2. Navigate to Project -> Compute -> Volumes page 3. Create new volume 4. Check that the volume is in the list 5. Check that no Error messages present 6. Edit the volume 7. Check that the volume is still in the list 8. Check that no Error messages present 9. Go to Admin/System/Volumes page 10. Delete the volume 11. Check that the volume is absent in the list 12. Check that no Error messages present """ volumes_page = self.home_pg.go_to_compute_volumes_volumespage() volumes_page.create_volume(self.VOLUME_NAME) self.assertTrue( volumes_page.find_message_and_dismiss(messages.INFO)) self.assertFalse( volumes_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(volumes_page.is_volume_present(self.VOLUME_NAME)) self.assertTrue(volumes_page.is_volume_status(self.VOLUME_NAME, 'Available')) new_name = "edited_" + self.VOLUME_NAME volumes_page.edit_volume(self.VOLUME_NAME, new_name, "description") self.VOLUME_NAME = new_name self.assertTrue( volumes_page.find_message_and_dismiss(messages.INFO)) self.assertFalse( volumes_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(volumes_page.is_volume_present(self.VOLUME_NAME)) self.assertTrue(volumes_page.is_volume_status(self.VOLUME_NAME, 'Available')) volumes_admin_page = self.home_pg.go_to_system_volumes_volumespage() volumes_admin_page.delete_volume(self.VOLUME_NAME) self.assertTrue( volumes_admin_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( volumes_admin_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(volumes_admin_page.is_volume_deleted(self.VOLUME_NAME))
class TestAdminRouters(helpers.AdminTestCase): ROUTER_NAME = helpers.gen_random_resource_name("router") @decorators.skip_because(bugs=['1792028']) @decorators.services_required("neutron") def test_router_create_admin(self): """tests the router creation and deletion functionalities: * creates a new router for public network * verifies the router appears in the routers table as active * edits router name * checks router name was updated properly * deletes the newly created router * verifies the router does not appear in the table after deletion """ routers_page = self.home_pg.go_to_project_network_routerspage() routers_page.create_router(self.ROUTER_NAME) self.assertTrue(routers_page.find_message_and_dismiss( messages.SUCCESS)) self.assertFalse(routers_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(routers_page.is_router_present(self.ROUTER_NAME)) self.assertTrue(routers_page.is_router_active(self.ROUTER_NAME)) self.home_pg.go_to_admin_overviewpage() admin_routers_page = self.home_pg.go_to_admin_network_routerspage() self.assertTrue(routers_page.is_router_present(self.ROUTER_NAME)) self.assertTrue(routers_page.is_router_active(self.ROUTER_NAME)) new_name = "edited_" + self.ROUTER_NAME admin_routers_page.edit_router(self.ROUTER_NAME, new_name=new_name) self.assertTrue( admin_routers_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( admin_routers_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(admin_routers_page.is_router_present(new_name)) self.assertTrue(admin_routers_page.is_router_active(new_name)) admin_routers_page.delete_router(new_name) self.assertTrue( admin_routers_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( admin_routers_page.find_message_and_dismiss(messages.ERROR)) self.assertFalse(admin_routers_page.is_router_present(new_name))
class TestImage(helpers.TestCase): IMAGE_NAME = helpers.gen_random_resource_name("image") def test_image_create_delete(self): """tests the image creation and deletion functionalities: * creates a new image from horizon.conf http_image * verifies the image appears in the images table as active * deletes the newly created image * verifies the image does not appear in the table after deletion """ images_page = self.home_pg.go_to_compute_imagespage() images_page.create_image(self.IMAGE_NAME) self.assertTrue(images_page.is_image_present(self.IMAGE_NAME)) self.assertTrue(images_page.is_image_active(self.IMAGE_NAME)) images_page.delete_image(self.IMAGE_NAME) self.assertFalse(images_page.is_image_present(self.IMAGE_NAME))
class TestFlavors(helpers.AdminTestCase): FLAVOR_NAME = helpers.gen_random_resource_name("flavor") def test_flavor_create(self): """tests the flavor creation and deletion functionalities: * creates a new flavor * verifies the flavor appears in the flavors table * deletes the newly created flavor * verifies the flavor does not appear in the table after deletion """ flavors_page = self.home_pg.go_to_system_flavorspage() flavors_page.create_flavor(name=self.FLAVOR_NAME, vcpus=1, ram=1024, root_disk=20, ephemeral_disk=0, swap_disk=0) self.assertTrue(flavors_page.is_flavor_present(self.FLAVOR_NAME)) flavors_page.delete_flavor(self.FLAVOR_NAME) self.assertFalse(flavors_page.is_flavor_present(self.FLAVOR_NAME))
class TestKeypair(helpers.TestCase): """Checks that the user is able to create/delete keypair.""" KEYPAIR_NAME = helpers.gen_random_resource_name("keypair") @decorators.skip_because(bugs=['1774697']) def test_keypair(self): keypair_page = self.home_pg.\ go_to_project_compute_keypairspage() keypair_page.create_keypair(self.KEYPAIR_NAME) self.assertFalse(keypair_page.find_message_and_dismiss(messages.ERROR)) keypair_page = self.home_pg.\ go_to_project_compute_keypairspage() self.assertTrue(keypair_page.is_keypair_present(self.KEYPAIR_NAME)) keypair_page.delete_keypair(self.KEYPAIR_NAME) self.assertTrue(keypair_page.find_message_and_dismiss( messages.SUCCESS)) self.assertFalse(keypair_page.find_message_and_dismiss(messages.ERROR)) self.assertFalse(keypair_page.is_keypair_present(self.KEYPAIR_NAME))
class TestKeypair(helpers.TestCase): """Checks that the user is able to create/delete keypair.""" KEYPAIR_NAME = helpers.gen_random_resource_name("keypair") @pytest.mark.skip(reason="Legacy Panel not tested") def test_keypair(self): keypair_page = self.home_pg.\ go_to_project_compute_keypairspage() keypair_page.create_keypair(self.KEYPAIR_NAME) self.assertFalse(keypair_page.find_message_and_dismiss(messages.ERROR)) keypair_page = self.home_pg.\ go_to_project_compute_keypairspage() self.assertTrue(keypair_page.is_keypair_present(self.KEYPAIR_NAME)) keypair_page.delete_keypair(self.KEYPAIR_NAME) self.assertTrue(keypair_page.find_message_and_dismiss( messages.SUCCESS)) self.assertFalse(keypair_page.find_message_and_dismiss(messages.ERROR)) self.assertFalse(keypair_page.is_keypair_present(self.KEYPAIR_NAME))
class TestUser(helpers.AdminTestCase): USER_NAME = helpers.gen_random_resource_name("user") @decorators.skip_because(bugs=['1774697']) def test_create_delete_user(self): users_page = self.home_pg.go_to_identity_userspage() password = self.TEST_PASSWORD users_page.create_user(self.USER_NAME, password=password, project='admin', role='admin') self.assertTrue(users_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse(users_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(users_page.is_user_present(self.USER_NAME)) users_page.delete_user(self.USER_NAME) self.assertTrue(users_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse(users_page.find_message_and_dismiss(messages.ERROR)) self.assertFalse(users_page.is_user_present(self.USER_NAME))
def test_create_distributed_router(self): router_name = helpers.gen_random_resource_name("router") routers_page = self.home_pg.go_to_network_routerspage() routers_page.create_router(router_name, admin_state_up=None, external_network=None) self.assertTrue( routers_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse(routers_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(routers_page.is_router_present(router_name)) self.assertTrue(routers_page.is_router_active(router_name)) self.home_pg.log_out() self.home_pg = self.login_pg.login(self.ADMIN_NAME, self.ADMIN_PASSWORD) self.home_pg.change_project(self.ADMIN_PROJECT) routers_page = self.home_pg.go_to_system_routerspage() def delete_router(): routers_page.delete_router(router_name) self.assertTrue( routers_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( routers_page.find_message_and_dismiss(messages.ERROR)) self.assertFalse(routers_page.is_router_present(router_name)) try: router_info = routers_page.get_router_info(router_name) except KeyError as e: if e.args[0] == 'mode': routers_page.refresh_page() delete_router() self.skipTest("Distributed mode is not supported") else: raise self.assertEqual(router_info['mode'], 'distributed') delete_router()
class TestImagesAdmin(helpers.AdminTestCase, TestImagesBasic): """Login as admin user""" IMAGE_NAME = helpers.gen_random_resource_name("image") @property def images_page(self): return self.home_pg.go_to_system_imagespage() @decorators.skip_because(bugs=['1584057']) def test_image_create_delete(self): super(TestImagesAdmin, self).test_image_create_delete() def test_filter_images(self): """This test checks filtering of images Steps: 1) Login to Horizon dashboard as admin user 2) Go to Admin -> System -> Images 3) Use filter by Image Name 4) Check that filtered table has one image only (which name is equal to filter value) 5) Check that no other images in the table 6) Clear filter and set nonexistent image name. Check that 0 rows are displayed """ images_list = self.CONFIG.image.images_list images_page = self.images_page images_page.images_table.filter(images_list[0]) self.assertTrue(images_page.is_image_present(images_list[0])) for image in images_list[1:]: self.assertFalse(images_page.is_image_present(image)) nonexistent_image_name = "{0}_test".format(self.IMAGE_NAME) images_page.images_table.filter(nonexistent_image_name) self.assertEqual(images_page.images_table.rows, []) images_page.images_table.filter('')
class TestRouters(helpers.TestCase): ROUTER_NAME = helpers.gen_random_resource_name("router") def test_router_create(self): """tests the router creation and deletion functionalities: * creates a new router for public network * verifies the router appears in the routers table as active * deletes the newly created router * verifies the router does not appear in the table after deletion """ routers_page = self.home_pg.go_to_network_routerspage() routers_page.create_router(self.ROUTER_NAME) self.assertTrue(routers_page.find_message_and_dismiss( messages.SUCCESS)) self.assertFalse(routers_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(routers_page.is_router_present(self.ROUTER_NAME)) self.assertTrue(routers_page.is_router_active(self.ROUTER_NAME)) routers_page.delete_router(self.ROUTER_NAME) self.assertTrue(routers_page.find_message_and_dismiss( messages.SUCCESS)) self.assertFalse(routers_page.find_message_and_dismiss(messages.ERROR)) self.assertFalse(routers_page.is_router_present(self.ROUTER_NAME))
class TestSecuritygroup(helpers.TestCase): SECURITYGROUP_NAME = helpers.gen_random_resource_name("securitygroup") def test_securitygroup_create_delete(self): """tests the security group creation and deletion functionalities: * creates a new security group * verifies the security group appears in the security groups table * deletes the newly created security group * verifies the security group does not appear in the table after deletion """ securitygroups_page = \ self.home_pg.go_to_compute_accessandsecurity_securitygroupspage() securitygroups_page.create_securitygroup(self.SECURITYGROUP_NAME) self.assertTrue( securitygroups_page.is_securitygroup_present( self.SECURITYGROUP_NAME)) securitygroups_page.delete_securitygroup(self.SECURITYGROUP_NAME) self.assertFalse( securitygroups_page.is_securitygroup_present( self.SECURITYGROUP_NAME))
def group_description(self): return helpers.gen_random_resource_name('description')
class TestImagesAdvanced(helpers.TestCase): """Login as demo user""" IMAGE_NAME = helpers.gen_random_resource_name("image") @property def images_page(self): return self.home_pg.go_to_compute_imagespage() def test_create_volume_from_image(self): """This test case checks create volume from image functionality: Steps: 1. Login to Horizon Dashboard as regular user 2. Navigate to Project -> Compute -> Images 3. Create new volume from image 4. Check that volume is created with expected name 5. Check that volume status is Available """ images_page = self.images_page source_image = self.CONFIG.image.images_list[0] target_volume = "created_from_{0}".format(source_image) volumes_page = images_page.create_volume_from_image( source_image, volume_name=target_volume) self.assertTrue(volumes_page.find_message_and_dismiss(messages.INFO)) self.assertFalse(volumes_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(volumes_page.is_volume_present(target_volume)) self.assertTrue( volumes_page.is_volume_status(target_volume, 'Available')) volumes_page.delete_volume(target_volume) volumes_page.find_message_and_dismiss(messages.SUCCESS) volumes_page.find_message_and_dismiss(messages.ERROR) self.assertTrue(volumes_page.is_volume_deleted(target_volume)) def test_launch_instance_from_image(self): """This test case checks launch instance from image functionality: Steps: 1. Login to Horizon Dashboard as regular user 2. Navigate to Project -> Compute -> Images 3. Launch new instance from image 4. Check that instance is create 5. Check that status of newly created instance is Active 6. Check that image_name in correct in instances table """ images_page = self.images_page source_image = self.CONFIG.image.images_list[0] target_instance = "created_from_{0}".format(source_image) instances_page = images_page.launch_instance_from_image( source_image, target_instance) self.assertTrue( instances_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( instances_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(instances_page.is_instance_active(target_instance)) actual_image_name = instances_page.get_image_name(target_instance) self.assertEqual(source_image, actual_image_name) instances_page.delete_instance(target_instance) self.assertTrue( instances_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( instances_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(instances_page.is_instance_deleted(target_instance))
class TestImagesBasic(helpers.TestCase): """Login as demo user""" IMAGE_NAME = helpers.gen_random_resource_name("image") @property def images_page(self): return self.home_pg.go_to_compute_imagespage() def image_create(self, local_file=None): images_page = self.images_page if local_file: images_page.create_image(self.IMAGE_NAME, image_source_type='file', image_file=local_file) else: images_page.create_image(self.IMAGE_NAME) self.assertTrue(images_page.find_message_and_dismiss(messages.INFO)) self.assertFalse(images_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(images_page.is_image_present(self.IMAGE_NAME)) self.assertTrue(images_page.is_image_active(self.IMAGE_NAME)) return images_page def image_delete(self): images_page = self.images_page images_page.delete_image(self.IMAGE_NAME) self.assertTrue(images_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse(images_page.find_message_and_dismiss(messages.ERROR)) self.assertFalse(images_page.is_image_present(self.IMAGE_NAME)) def test_image_create_delete(self): """tests the image creation and deletion functionalities: * creates a new image from horizon.conf http_image * verifies the image appears in the images table as active * deletes the newly created image * verifies the image does not appear in the table after deletion """ self.image_create() self.image_delete() def test_image_create_delete_from_local_file(self): """tests the image creation and deletion functionalities: * downloads image from horizon.conf stated in http_image * creates the image from the downloaded file * verifies the image appears in the images table as active * deletes the newly created image * verifies the image does not appear in the table after deletion """ with helpers.gen_temporary_file() as file_name: self.image_create(local_file=file_name) self.image_delete() def test_images_pagination(self): """This test checks images pagination Steps: 1) Login to Horizon Dashboard as horizon user 2) Navigate to user settings page 3) Change 'Items Per Page' value to 1 4) Go to Project -> Compute -> Images page 5) Check that only 'Next' link is available, only one image is available (and it has correct name) 6) Click 'Next' and check that both 'Prev' and 'Next' links are available, only one image is available (and it has correct name) 7) Click 'Next' and check that only 'Prev' link is available, only one image is visible (and it has correct name) 8) Click 'Prev' and check results (should be the same as for step6) 9) Click 'Prev' and check results (should be the same as for step5) 10) Go to user settings page and restore 'Items Per Page' """ default_image_list = self.CONFIG.image.images_list items_per_page = 1 first_page_definition = { 'Next': True, 'Prev': False, 'Count': items_per_page, 'Names': [default_image_list[0]] } second_page_definition = { 'Next': True, 'Prev': True, 'Count': items_per_page, 'Names': [default_image_list[1]] } third_page_definition = { 'Next': False, 'Prev': True, 'Count': items_per_page, 'Names': [default_image_list[2]] } settings_page = self.home_pg.go_to_settings_usersettingspage() settings_page.change_pagesize(items_per_page) settings_page.find_message_and_dismiss(messages.SUCCESS) images_page = self.images_page images_page.images_table.assert_definition(first_page_definition) images_page.images_table.turn_next_page() images_page.images_table.assert_definition(second_page_definition) images_page.images_table.turn_next_page() images_page.images_table.assert_definition(third_page_definition) images_page.images_table.turn_prev_page() images_page.images_table.assert_definition(second_page_definition) images_page.images_table.turn_prev_page() images_page.images_table.assert_definition(first_page_definition) settings_page = self.home_pg.go_to_settings_usersettingspage() settings_page.change_pagesize() settings_page.find_message_and_dismiss(messages.SUCCESS) def test_update_image_metadata(self): """Test update image metadata * logs in as admin user * creates image from locally downloaded file * verifies the image appears in the images table as active * invokes action 'Update Metadata' for the image * adds custom filed 'metadata' * adds value 'image' for the custom filed 'metadata' * gets the actual description of the image * verifies that custom filed is present in the image description * deletes the image * verifies the image does not appear in the table after deletion """ new_metadata = { 'metadata1': helpers.gen_random_resource_name("value"), 'metadata2': helpers.gen_random_resource_name("value") } with helpers.gen_temporary_file() as file_name: images_page = self.image_create(local_file=file_name) images_page.add_custom_metadata(self.IMAGE_NAME, new_metadata) results = images_page.check_image_details(self.IMAGE_NAME, new_metadata) self.image_delete() self.assertSequenceTrue(results) # custom matcher def test_remove_protected_image(self): """tests that protected image is not deletable * logs in as admin user * creates image from locally downloaded file * verifies the image appears in the images table as active * marks 'Protected' checkbox * verifies that edit action was successful * verifies that delete action is not available in the list * tries to delete the image * verifies that exception is generated for the protected image * unmarks 'Protected' checkbox * deletes the image * verifies the image does not appear in the table after deletion """ with helpers.gen_temporary_file() as file_name: images_page = self.image_create(local_file=file_name) images_page.edit_image(self.IMAGE_NAME, protected=True) self.assertTrue( images_page.find_message_and_dismiss(messages.SUCCESS)) # Check that Delete action is not available in the action list. # The below action will generate exception since the bind fails. # But only ValueError with message below is expected here. with self.assertRaisesRegexp(ValueError, 'Could not bind method'): images_page.delete_image_via_row_action(self.IMAGE_NAME) # Try to delete image. That should not be possible now. images_page.delete_image(self.IMAGE_NAME) self.assertFalse( images_page.find_message_and_dismiss(messages.SUCCESS)) self.assertTrue( images_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(images_page.is_image_present(self.IMAGE_NAME)) images_page.edit_image(self.IMAGE_NAME, protected=False) self.assertTrue( images_page.find_message_and_dismiss(messages.SUCCESS)) self.image_delete()
# Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. from openstack_dashboard.test.integration_tests import helpers INSTANCES_NAME = helpers.gen_random_resource_name('instance', timestamp=False) class TestInstances(helpers.AdminTestCase): """This is a basic scenario to test: * Create Instance and Delete Instance """ def test_create_delete_instance(self): instances_page = self.home_pg.go_to_compute_instancespage() instances_page.create_instance(INSTANCES_NAME) self.assertTrue(instances_page.is_instance_active(INSTANCES_NAME)) instances_page.delete_instance(INSTANCES_NAME) self.assertTrue(instances_page.is_instance_deleted(INSTANCES_NAME))
def project_name(self): return helpers.gen_random_resource_name("project")
class TestVolumeSnapshotsAdvanced(helpers.TestCase): """Login as demo user""" VOLUME_NAME = helpers.gen_random_resource_name("volume") VOLUME_SNAPSHOT_NAME = helpers.gen_random_resource_name("volume_snapshot") @property def volumes_snapshot_page(self): return self.home_pg.go_to_project_volumes_snapshotspage() def setUp(self): """Setup: create volume""" super(TestVolumeSnapshotsAdvanced, self).setUp() volumes_page = self.home_pg.go_to_project_volumes_volumespage() volumes_page.create_volume(self.VOLUME_NAME) volumes_page.find_message_and_dismiss(messages.INFO) self.assertTrue(volumes_page.is_volume_status(self.VOLUME_NAME, 'Available')) def cleanup(): volumes_page = self.home_pg.go_to_project_volumes_volumespage() volumes_page.delete_volume(self.VOLUME_NAME) self.assertTrue( volumes_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( volumes_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(volumes_page.is_volume_deleted(self.VOLUME_NAME)) self.addCleanup(cleanup) def test_create_volume_from_snapshot(self): """Test checks possibility to create volume from snapshot Steps: 1. Login to Horizon Dashboard as regular user 2. Navigate to Project -> Volumes -> Volumes page 3. Create snapshot for existed volume 4. Create new volume from snapshot 5. Check the volume is created and has 'Available' status 6. Delete volume snapshot 7. Delete volume """ volumes_page = self.home_pg.go_to_project_volumes_volumespage() volumes_snapshot_page = volumes_page.create_volume_snapshot( self.VOLUME_NAME, self.VOLUME_SNAPSHOT_NAME) self.assertTrue(volumes_page.find_message_and_dismiss(messages.INFO)) self.assertFalse(volumes_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(volumes_snapshot_page.is_volume_snapshot_available( self.VOLUME_SNAPSHOT_NAME)) new_volume = 'new_' + self.VOLUME_NAME volumes_snapshot_page.create_volume_from_snapshot( self.VOLUME_SNAPSHOT_NAME, new_volume) self.assertTrue(volumes_page.is_volume_present(new_volume)) self.assertTrue(volumes_page.is_volume_status(new_volume, 'Available')) volumes_snapshot_page = self.volumes_snapshot_page volumes_snapshot_page.delete_volume_snapshot(self.VOLUME_SNAPSHOT_NAME) self.assertTrue( volumes_snapshot_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( volumes_snapshot_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(volumes_snapshot_page.is_volume_snapshot_deleted( self.VOLUME_SNAPSHOT_NAME)) volumes_page = self.home_pg.go_to_project_volumes_volumespage() volumes_page.delete_volume(new_volume) self.assertTrue( volumes_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse(volumes_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(volumes_page.is_volume_deleted(new_volume))
class TestVolumeSnapshotsBasic(helpers.TestCase): """Login as demo user""" VOLUME_NAME = helpers.gen_random_resource_name("volume") VOLUME_SNAPSHOT_NAME = helpers.gen_random_resource_name("volume_snapshot") @property def volumes_snapshot_page(self): return self.home_pg.go_to_project_volumes_snapshotspage() def setUp(self): """Setup: create volume""" super(TestVolumeSnapshotsBasic, self).setUp() volumes_page = self.home_pg.go_to_project_volumes_volumespage() volumes_page.create_volume(self.VOLUME_NAME) volumes_page.find_message_and_dismiss(messages.INFO) self.assertTrue(volumes_page.is_volume_status(self.VOLUME_NAME, 'Available')) def cleanup(): volumes_page = self.home_pg.go_to_project_volumes_volumespage() volumes_page.delete_volume(self.VOLUME_NAME) volumes_page.find_message_and_dismiss(messages.SUCCESS) self.assertTrue(volumes_page.is_volume_deleted(self.VOLUME_NAME)) self.addCleanup(cleanup) def test_create_edit_delete_volume_snapshot(self): """Test checks create/delete volume snapshot action Steps: 1. Login to Horizon Dashboard 2. Navigate to Project -> Volumes -> Volumes page 3. Create snapshot for existed volume 4. Check that no ERROR appears 5. Check that snapshot is in the list 6. Check that snapshot has reference to correct volume 7. Edit snapshot name and description 8. Delete volume snapshot from proper page 9. Check that volume snapshot not in the list """ volumes_page = self.home_pg.go_to_project_volumes_volumespage() volumes_snapshot_page = volumes_page.create_volume_snapshot( self.VOLUME_NAME, self.VOLUME_SNAPSHOT_NAME) self.assertTrue(volumes_page.find_message_and_dismiss(messages.INFO)) self.assertFalse(volumes_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(volumes_snapshot_page.is_volume_snapshot_available( self.VOLUME_SNAPSHOT_NAME)) actual_volume_name = volumes_snapshot_page.get_volume_name( self.VOLUME_SNAPSHOT_NAME) self.assertEqual(self.VOLUME_NAME, actual_volume_name) new_name = "new_" + self.VOLUME_SNAPSHOT_NAME volumes_snapshot_page = \ self.home_pg.go_to_project_volumes_snapshotspage() volumes_snapshot_page.edit_snapshot(self.VOLUME_SNAPSHOT_NAME, new_name, "description") self.assertTrue( volumes_snapshot_page.find_message_and_dismiss(messages.INFO)) self.assertFalse( volumes_snapshot_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(volumes_snapshot_page. is_volume_snapshot_available(new_name)) volumes_snapshot_page.delete_volume_snapshot(new_name) self.assertTrue( volumes_snapshot_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( volumes_snapshot_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(volumes_snapshot_page.is_volume_snapshot_deleted( new_name)) def test_volume_snapshots_pagination(self): """This test checks volumes snapshots pagination Steps: 1) Login to Horizon Dashboard 2) Go to Project -> Volumes -> Volumes tab, create volumes and 3 snapshots 3) Navigate to user settings page 4) Change 'Items Per Page' value to 1 5) Go to Project -> Volumes -> Snapshots tab or Admin -> Volume -> Snapshots tab (depends on user) 6) Check that only 'Next' link is available, only one snapshot is available (and it has correct name) 7) Click 'Next' and check that both 'Prev' and 'Next' links are available, only one snapshot is available (and it has correct name) 8) Click 'Next' and check that only 'Prev' link is available, only one snapshot is visible (and it has correct name) 9) Click 'Prev' and check result (should be the same as for step7) 10) Click 'Prev' and check result (should be the same as for step6) 11) Go to user settings page and restore 'Items Per Page' 12) Delete created snapshots and volumes """ volumes_page = self.home_pg.go_to_project_volumes_volumespage() count = 3 items_per_page = 1 snapshot_names = ["{0}_{1}".format(self.VOLUME_SNAPSHOT_NAME, i) for i in range(count)] for i, name in enumerate(snapshot_names): volumes_snapshot_page = volumes_page.create_volume_snapshot( self.VOLUME_NAME, name) volumes_page.find_message_and_dismiss(messages.INFO) self.assertTrue( volumes_snapshot_page.is_volume_snapshot_available(name)) if i < count - 1: self.home_pg.go_to_project_volumes_volumespage() first_page_definition = {'Next': True, 'Prev': False, 'Count': items_per_page, 'Names': [snapshot_names[2]]} second_page_definition = {'Next': True, 'Prev': True, 'Count': items_per_page, 'Names': [snapshot_names[1]]} third_page_definition = {'Next': False, 'Prev': True, 'Count': items_per_page, 'Names': [snapshot_names[0]]} settings_page = self.home_pg.go_to_settings_usersettingspage() settings_page.change_pagesize(items_per_page) settings_page.find_message_and_dismiss(messages.SUCCESS) volumes_snapshot_page = self.volumes_snapshot_page volumes_snapshot_page.volumesnapshots_table.assert_definition( first_page_definition) volumes_snapshot_page.volumesnapshots_table.turn_next_page() volumes_snapshot_page.volumesnapshots_table.assert_definition( second_page_definition) volumes_snapshot_page.volumesnapshots_table.turn_next_page() volumes_snapshot_page.volumesnapshots_table.assert_definition( third_page_definition) volumes_snapshot_page.volumesnapshots_table.turn_prev_page() volumes_snapshot_page.volumesnapshots_table.assert_definition( second_page_definition) volumes_snapshot_page.volumesnapshots_table.turn_prev_page() volumes_snapshot_page.volumesnapshots_table.assert_definition( first_page_definition) settings_page = self.home_pg.go_to_settings_usersettingspage() settings_page.change_pagesize() settings_page.find_message_and_dismiss(messages.SUCCESS) volumes_snapshot_page = self.volumes_snapshot_page volumes_snapshot_page.delete_volume_snapshots(snapshot_names) volumes_snapshot_page.find_message_and_dismiss(messages.SUCCESS) for name in snapshot_names: volumes_snapshot_page.is_volume_snapshot_deleted(name)
def email(self): return helpers.gen_random_resource_name("email") + "@localhost"
class TestVolumesBasic(helpers.TestCase): """Login as demo user""" VOLUME_NAME = helpers.gen_random_resource_name("volume") @property def volumes_page(self): return self.home_pg.go_to_project_volumes_volumespage() def test_volume_create_edit_delete(self): """This test case checks create, edit, delete volume functionality: Steps: 1. Login to Horizon Dashboard 2. Navigate to Project -> Compute -> Volumes page 3. Create new volume 4. Check that the volume is in the list 5. Check that no Error messages present 6. Edit the volume 7. Check that the volume is still in the list 8. Check that no Error messages present 9. Delete the volume via proper page (depends on user) 10. Check that the volume is absent in the list 11. Check that no Error messages present """ volumes_page = self.home_pg.go_to_project_volumes_volumespage() volumes_page.create_volume(self.VOLUME_NAME) self.assertTrue( volumes_page.find_message_and_dismiss(messages.INFO)) self.assertFalse( volumes_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(volumes_page.is_volume_present(self.VOLUME_NAME)) self.assertTrue(volumes_page.is_volume_status(self.VOLUME_NAME, 'Available')) new_name = "edited_" + self.VOLUME_NAME volumes_page.edit_volume(self.VOLUME_NAME, new_name, "description") self.assertTrue( volumes_page.find_message_and_dismiss(messages.INFO)) self.assertFalse( volumes_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(volumes_page.is_volume_present(new_name)) self.assertTrue(volumes_page.is_volume_status(new_name, 'Available')) volumes_page = self.volumes_page volumes_page.delete_volume(new_name) self.assertTrue( volumes_page.find_message_and_dismiss(messages.INFO)) self.assertFalse( volumes_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(volumes_page.is_volume_deleted(new_name)) # NOTE(tsufiev): A short regression test on bug 1553314: we try to # re-open 'Create Volume' button after the volume was deleted. If the # regression occurs, the form won't appear (because link is going to be # invalid in this case). Give JavaScript callbacks an additional second # to do all the job and possibly cause the regression. if not isinstance(self, helpers.AdminTestCase): time.sleep(1) form = volumes_page.volumes_table.create_volume() form.cancel() def test_volumes_pagination(self): """This test checks volumes pagination Steps: 1) Login to Horizon Dashboard 2) Go to Project -> Volumes -> Volumes tab and create three volumes 3) Navigate to user settings page 4) Change 'Items Per Page' value to 1 5) Go to Project -> Volumes -> Volumes tab or Admin -> Volume -> Volumes tab (depends on user) 6) Check that only 'Next' link is available, only one volume is available (and it has correct name) 7) Click 'Next' and check that both 'Prev' and 'Next' links are available, only one volume is available (and it has correct name) 8) Click 'Next' and check that only 'Prev' link is available, only one volume is visible (and it has correct name) 9) Click 'Prev' and check result (should be the same as for step7) 10) Click 'Prev' and check result (should be the same as for step6) 11) Go to user settings page and restore 'Items Per Page' 12) Delete created volumes """ volumes_page = self.home_pg.go_to_project_volumes_volumespage() count = 3 items_per_page = 1 volumes_names = ["{0}_{1}".format(self.VOLUME_NAME, i) for i in range(count)] for volume_name in volumes_names: volumes_page.create_volume(volume_name) self.assertTrue( volumes_page.find_message_and_dismiss(messages.INFO)) self.assertFalse( volumes_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(volumes_page.is_volume_present(volume_name)) self.assertTrue(volumes_page.is_volume_status(volume_name, 'Available')) first_page_definition = {'Next': True, 'Prev': False, 'Count': items_per_page, 'Names': [volumes_names[2]]} second_page_definition = {'Next': True, 'Prev': True, 'Count': items_per_page, 'Names': [volumes_names[1]]} third_page_definition = {'Next': False, 'Prev': True, 'Count': items_per_page, 'Names': [volumes_names[0]]} settings_page = self.home_pg.go_to_settings_usersettingspage() settings_page.change_pagesize(items_per_page) settings_page.find_message_and_dismiss(messages.SUCCESS) volumes_page = self.volumes_page volumes_page.volumes_table.assert_definition(first_page_definition) volumes_page.volumes_table.turn_next_page() volumes_page.volumes_table.assert_definition(second_page_definition) volumes_page.volumes_table.turn_next_page() volumes_page.volumes_table.assert_definition(third_page_definition) volumes_page.volumes_table.turn_prev_page() volumes_page.volumes_table.assert_definition(second_page_definition) volumes_page.volumes_table.turn_prev_page() volumes_page.volumes_table.assert_definition(first_page_definition) settings_page = self.home_pg.go_to_settings_usersettingspage() settings_page.change_pagesize() settings_page.find_message_and_dismiss(messages.SUCCESS) volumes_page = self.volumes_page volumes_page.delete_volumes(volumes_names) self.assertTrue( volumes_page.find_message_and_dismiss(messages.INFO)) self.assertFalse( volumes_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(volumes_page.are_volumes_deleted(volumes_names))
def group_name(self): return helpers.gen_random_resource_name("group")
def __init__(self, *args, **kwgs): super(TestVolumes, self).__init__(*args, **kwgs) self.VOLUME_NAME = helpers.gen_random_resource_name("volume")
# Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. from openstack_dashboard.test.integration_tests import helpers from openstack_dashboard.test.integration_tests.regions import messages VOLUME_NAME = helpers.gen_random_resource_name("volume") VOLUME_SNAPSHOT_NAME = helpers.gen_random_resource_name("volume_snapshot") class TestVolumeSnapshots(helpers.TestCase): def setUp(self): """Setup for test_create_delete_volume_snapshot: create volume""" super(TestVolumeSnapshots, self).setUp() self.volumes_page = self.home_pg.go_to_compute_volumes_volumespage() self.volumes_page.create_volume(VOLUME_NAME) self.assertTrue( self.volumes_page.find_message_and_dismiss(messages.INFO)) self.assertFalse( self.volumes_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(self.volumes_page.is_volume_status(VOLUME_NAME, 'Available'))
# Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. from openstack_dashboard.test.integration_tests import helpers from openstack_dashboard.test.integration_tests.pages.project.data_processing\ import jobbinariespage from openstack_dashboard.test.integration_tests.tests import decorators JOB_BINARY_INTERNAL = { # Size of binary name is limited to 50 characters jobbinariespage.JobbinariesPage.BINARY_NAME: helpers.gen_random_resource_name(resource='jobbinary', timestamp=False)[0:50], jobbinariespage.JobbinariesPage.BINARY_STORAGE_TYPE: "Internal database", jobbinariespage.JobbinariesPage.BINARY_URL: None, jobbinariespage.JobbinariesPage.INTERNAL_BINARY: "*Create a script", jobbinariespage.JobbinariesPage.BINARY_PATH: None, jobbinariespage.JobbinariesPage.SCRIPT_NAME: helpers.gen_random_resource_name(resource='scriptname', timestamp=False), jobbinariespage.JobbinariesPage.SCRIPT_TEXT: "test_script_text", jobbinariespage.JobbinariesPage.USERNAME: None, jobbinariespage.JobbinariesPage.PASSWORD: None, jobbinariespage.JobbinariesPage.DESCRIPTION: "test description" }
def username(self): return helpers.gen_random_resource_name("user")
class TestRouters(helpers.TestCase): ROUTER_NAME = helpers.gen_random_resource_name("router") @property def routers_page(self): return self.home_pg.go_to_project_network_routerspage() def _create_router(self): routers_page = self.routers_page routers_page.create_router(self.ROUTER_NAME) self.assertTrue(routers_page.find_message_and_dismiss( messages.SUCCESS)) self.assertFalse(routers_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(routers_page.is_router_present(self.ROUTER_NAME)) self.assertTrue(routers_page.is_router_active(self.ROUTER_NAME)) def _delete_router(self): routers_page = self.routers_page routers_page.delete_router(self.ROUTER_NAME) self.assertTrue(routers_page.find_message_and_dismiss( messages.SUCCESS)) self.assertFalse(routers_page.find_message_and_dismiss(messages.ERROR)) self.assertFalse(routers_page.is_router_present(self.ROUTER_NAME)) def test_router_create(self): """tests the router creation and deletion functionalities: * creates a new router for public network * verifies the router appears in the routers table as active * deletes the newly created router * verifies the router does not appear in the table after deletion """ self._create_router() self._delete_router() def _create_interface(self, interfaces_page): interfaces_page.create_interface() interface_name = interfaces_page.interfaces_names[0] self.assertTrue( interfaces_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( interfaces_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(interfaces_page.is_interface_present(interface_name)) self.assertTrue( interfaces_page.is_interface_status(interface_name, 'Down')) def _delete_interface(self, interfaces_page, interface_name): interfaces_page.delete_interface(interface_name) self.assertTrue( interfaces_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( interfaces_page.find_message_and_dismiss(messages.ERROR)) self.assertFalse(interfaces_page.is_interface_present(interface_name)) @decorators.skip_because(bugs=['1792028']) def test_router_add_delete_interface(self): """Tests the router interface creation and deletion functionalities: * Follows the steps to create a new router * Clicks on the new router name from the routers table * Moves to the Interfaces page/tab * Adds a new Interface for the first subnet id available * Verifies the new interface is in the routers table by checking that the interface is present in the table * Deletes the newly created interface * Verifies the interface is no longer in the interfaces table * Switches to the routers view by clicking on the breadcrumb link * Follows the steps to delete the router """ self._create_router() routers_page = self.routers_page router_interfaces_page = routers_page. \ go_to_interfaces_page(self.ROUTER_NAME) self._create_interface(router_interfaces_page) interface_name = router_interfaces_page.interfaces_names[0] self._delete_interface(router_interfaces_page, interface_name) router_interfaces_page.switch_to_routers_page() self._delete_router() @decorators.skip_because(bugs=['1792028']) def test_router_delete_interface_by_row(self): """Tests the router interface creation and deletion by row action: * Follows the steps to create a new router * Clicks on the new router name from the routers table * Moves to the Interfaces page/tab * Adds a new Interface for the first subnet id available * Verifies the new interface is in the routers table * Deletes the newly created interface by row action * Verifies the interface is no longer in the interfaces table * Switches to the routers view by clicking on the breadcrumb link * Follows the steps to delete the router """ self._create_router() routers_page = self.routers_page router_interfaces_page = routers_page. \ go_to_interfaces_page(self.ROUTER_NAME) self._create_interface(router_interfaces_page) interface_name = router_interfaces_page.interfaces_names[0] router_interfaces_page.delete_interface_by_row_action(interface_name) router_interfaces_page.switch_to_routers_page() self._delete_router() @decorators.skip_because(bugs=['1792028']) def test_router_overview_data(self): self._create_router() routers_page = self.routers_page router_overview_page = routers_page.\ go_to_overview_page(self.ROUTER_NAME) self.assertTrue( router_overview_page.is_router_name_present(self.ROUTER_NAME)) self.assertTrue(router_overview_page.is_router_status("Active")) network_overview_page = router_overview_page.go_to_router_network() # By default the router is created in the 'public' network so the line # below checks that such name is present in the network # details/overview page self.assertTrue(network_overview_page.is_network_name_present()) self.assertTrue(network_overview_page.is_network_status("Active")) self._delete_router()
def keypair_name(self): return helpers.gen_random_resource_name("keypair")
def __init__(self, *args, **kwargs): super(TestImagesLegacy, self).__init__(*args, **kwargs) self.IMAGE_NAME = helpers.gen_random_resource_name("image")
# Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. from openstack_dashboard.test.integration_tests import helpers from openstack_dashboard.test.integration_tests.regions import messages PROJECT_NAME = helpers.gen_random_resource_name("project") class TestCreateDeleteProject(helpers.AdminTestCase): def setUp(self): super(TestCreateDeleteProject, self).setUp() self.projects_page = self.home_pg.go_to_identity_projectspage() def test_create_delete_project(self): self.projects_page.create_project(PROJECT_NAME) self.assertTrue( self.projects_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( self.projects_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(self.projects_page.is_project_present(PROJECT_NAME))
class TestVolumesActions(helpers.TestCase): VOLUME_NAME = helpers.gen_random_resource_name("volume") IMAGE_NAME = helpers.gen_random_resource_name("image") INSTANCE_NAME = helpers.gen_random_resource_name("instance") @property def volumes_page(self): return self.home_pg.go_to_project_volumes_volumespage() def setUp(self): super(TestVolumesActions, self).setUp() volumes_page = self.volumes_page volumes_page.create_volume(self.VOLUME_NAME) self.assertTrue( volumes_page.find_message_and_dismiss(messages.INFO)) self.assertFalse( volumes_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(volumes_page.is_volume_present(self.VOLUME_NAME)) self.assertTrue( volumes_page.is_volume_status(self.VOLUME_NAME, 'Available')) def cleanup(): volumes_page = self.volumes_page volumes_page.delete_volume(self.VOLUME_NAME) self.assertTrue( volumes_page.find_message_and_dismiss(messages.INFO)) self.assertFalse( volumes_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue( volumes_page.is_volume_deleted(self.VOLUME_NAME)) self.addCleanup(cleanup) def test_volume_extend(self): """This test case checks extend volume functionality: Steps: 1. Check current volume size 2. Extend volume 3. Check that no Error messages present 4. Check that the volume is still in the list 5. Check that the volume size is changed """ volumes_page = self.volumes_page orig_size = volumes_page.get_size(self.VOLUME_NAME) volumes_page.extend_volume(self.VOLUME_NAME, orig_size + 1) self.assertTrue( volumes_page.find_message_and_dismiss(messages.INFO)) self.assertFalse( volumes_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue( volumes_page.is_volume_status(self.VOLUME_NAME, 'Available')) new_size = volumes_page.get_size(self.VOLUME_NAME) self.assertLess(orig_size, new_size) @pytest.mark.skip(reason="Bug 1847715") def test_volume_upload_to_image(self): """This test case checks upload volume to image functionality: Steps: 1. Upload volume to image with some disk format 2. Check that image is created 3. Check that no Error messages present 4. Delete the image 5. Repeat actions for all disk formats """ self.volumes_page = self.home_pg.go_to_project_volumes_volumespage() all_formats = {"qcow2": u'QCOW2', "raw": u'Raw', "vdi": u'VDI', "vmdk": u'VMDK'} for disk_format in all_formats: self.volumes_page.upload_volume_to_image(self.VOLUME_NAME, self.IMAGE_NAME, disk_format) self.assertFalse( self.volumes_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(self.volumes_page.is_volume_status( self.VOLUME_NAME, 'Available')) images_page = self.home_pg.go_to_project_compute_imagespage() self.assertTrue(images_page.is_image_present(self.IMAGE_NAME)) self.assertTrue(images_page.is_image_active(self.IMAGE_NAME)) self.assertEqual(images_page.get_image_format(self.IMAGE_NAME), all_formats[disk_format]) images_page.delete_image(self.IMAGE_NAME) self.assertTrue(images_page.find_message_and_dismiss( messages.INFO)) self.assertFalse(images_page.find_message_and_dismiss( messages.ERROR)) self.assertFalse(images_page.is_image_present(self.IMAGE_NAME)) self.volumes_page = \ self.home_pg.go_to_project_volumes_volumespage() @pytest.mark.skip(reason="Bug 1774697") def test_volume_launch_as_instance(self): """This test case checks launch volume as instance functionality: Steps: 1. Launch volume as instance 2. Check that instance is created 3. Check that no Error messages present 4. Check that instance status is 'active' 5. Check that volume status is 'in use' 6. Delete instance """ self.volumes_page.launch_instance(self.VOLUME_NAME, self.INSTANCE_NAME) self.assertTrue( self.volumes_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( self.volumes_page.find_message_and_dismiss(messages.ERROR)) instances_page = self.home_pg.go_to_project_compute_instancespage() self.assertTrue(instances_page.is_instance_active(self.INSTANCE_NAME)) self.volumes_page = self.home_pg.go_to_project_volumes_volumespage() self.assertTrue(self.volumes_page.is_volume_status(self.VOLUME_NAME, 'In-use')) self.assertIn(self.INSTANCE_NAME, self.volumes_page.get_attach_instance(self.VOLUME_NAME)) instances_page = self.home_pg.go_to_project_compute_instancespage() instances_page.delete_instance(self.INSTANCE_NAME) self.assertTrue( instances_page.find_message_and_dismiss(messages.SUCCESS)) self.assertFalse( instances_page.find_message_and_dismiss(messages.ERROR)) self.assertTrue(instances_page.is_instance_deleted(self.INSTANCE_NAME)) self.volumes_page = self.home_pg.go_to_project_volumes_volumespage()
# Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. from openstack_dashboard.test.integration_tests import helpers from openstack_dashboard.test.integration_tests.regions import messages IMAGE_NAME = helpers.gen_random_resource_name("image") class TestImagesBasic(helpers.TestCase): @property def images_page(self): return self.home_pg.go_to_compute_imagespage() def test_image_create_delete(self): """tests the image creation and deletion functionalities: * creates a new image from horizon.conf http_image * verifies the image appears in the images table as active * deletes the newly created image * verifies the image does not appear in the table after deletion """