def create_object(cli_object, args): """ Creates <object> with dictionary of arguments. @param cli_object: A valid CLI object. @param args: A python dictionary containing all valid attributes for creating a new object. @raise Exception: Raise an exception if object cannot be created. @rtype: dict @return: A dictionary representing the newly created resource. """ result = cli_object.create(args) # Some methods require a bit of waiting sleep_for_seconds(5) # If the object is not created, raise exception, stop the show. if result.return_code != 0: logger.debug(result.stderr) # Show why creation failed. raise Exception( 'Failed to create %s with %r data.' % (cli_object.__name__, args)) # Sometimes we get a list with a dictionary and not # a dictionary. if type(result.stdout) is list and len(result.stdout) > 0: result.stdout = result.stdout[0] return result.stdout
def create_object(cli_object, args): """ Creates <object> with dictionary of arguments. @param cli_object: A valid CLI object. @param args: A python dictionary containing all valid attributes for creating a new object. @raise Exception: Raise an exception if object cannot be created. @rtype: dict @return: A dictionary representing the newly created resource. """ result = cli_object.create(args) # Some methods require a bit of waiting sleep_for_seconds(5) # If the object is not created, raise exception, stop the show. if result.return_code != 0: logger.debug(result.stderr) # Show why creation failed. raise Exception('Failed to create %s with %r data.' % (cli_object.__name__, args)) # Sometimes we get a list with a dictionary and not # a dictionary. if type(result.stdout) is list and len(result.stdout) > 0: result.stdout = result.stdout[0] return result.stdout
def create(self, name, description=None, prior=None): """ Creates new life cycle environment """ if prior == 'Library' or 'None': self.wait_until_element(locators["content_env.new"]).click() self.wait_until_element(locators ["content_env.create_initial"] ).click() else: strategy = locators["content_env.env_link"][0] value = locators["content_env.env_link"][1] element = self.wait_until_element((strategy, value % prior)) if element: element.click() if self.wait_until_element(common_locators["name"]): self.text_field_update(common_locators["name"], name) if description: self.text_field_update(common_locators ["description"], description) sleep_for_seconds(5) self.wait_until_element(common_locators["create"]).click() self.wait_for_ajax() else: raise Exception( "Could not create new environment '%s'" % name)
def poll(self, delay, timeout): """Busy wait for task to complete""" current = 0 finished = False while (not finished) and current < timeout: sleep_for_seconds(delay) current += delay self.refresh() finished = (self.json["result"] != 'pending')
def test_delete(self): name = generate_name(8, 8) Environment().create({'name': name}) result = Environment().delete({'name': name}) self.assertTrue(result.return_code == 0, "Environment delete - retcode") sleep_for_seconds(5) # sleep for about 5 sec. result = Environment().list({'search': name}) self.assertTrue(len(result.stdout) == 0, "Environment list - does not have deleted name")
def test_info(self): name = generate_name() Environment().create({'name': name}) sleep_for_seconds(5) # give time to appear in the list result = Environment().info({'name': name}) self.assertEquals( len(result.stdout), 1, "Environment info - return count" ) self.assertEquals(result.stdout[0]['Name'], name, "Environment info - stdout contains 'Name'")
def test_info(self): """ `compute_resource info` basic test """ result_create = make_compute_resource( { "provider": FOREMAN_PROVIDERS["libvirt"], "url": "qemu+tcp://%s:16509/system" % conf.properties["main.server.hostname"], } ) self.assertTrue(result_create["name"], "ComputeResource create - has name") sleep_for_seconds(5) result_info = ComputeResource().info({"name": result_create["name"]}) self.assertEquals(result_info.return_code, 0, "ComputeResource info - exit code") self.assertEquals(result_info.stdout["Name"], result_create["name"], "ComputeResource info - check name")
def delete(self, repo, really=True): """ Delete a repository from UI """ strategy = locators["repo.select"][0] value = locators["repo.select"][1] self.wait_until_element((strategy, value % repo)).click() sleep_for_seconds(5) self.wait_until_element(locators["repo.remove"]).click() if really: self.wait_until_element(common_locators["confirm_remove"]).click() else: self.wait_until_element(common_locators["cancel"]).click()
def create(self, name, product=None, gpg_key=None, http=False, url=None, repo_type=REPO_TYPE['yum']): """ Creates new repository from UI """ prd_element = self.search_entity(product, locators["prd.select"], katello=True) if prd_element: prd_element.click() sleep_for_seconds(5) self.wait_until_element(locators["repo.new"]).click() sleep_for_seconds(5) self.text_field_update(common_locators["name"], name) sleep_for_seconds(3) if repo_type: type_ele = self.find_element(locators["repo.type"]) Select(type_ele).select_by_visible_text(repo_type) if gpg_key: type_ele = self.find_element(common_locators["gpg_key"]) Select(type_ele).select_by_visible_text(gpg_key) if url: self.text_field_update(locators["repo.url"], url) if http: self.find_element(locators["repo.via_http"]).click() self.find_element(common_locators["create"]).click() sleep_for_seconds(5)
def delete(self, product, really): """ Delete a product from UI """ strategy = locators["prd.select"][0] value = locators["prd.select"][1] self.wait_until_element((strategy, value % product)).click() sleep_for_seconds(5) self.wait_until_element(locators["prd.remove"]).click() if really: self.wait_until_element(common_locators["confirm_remove"]).click() sleep_for_seconds(2) else: self.wait_until_element(common_locators["cancel"]).click()
def delete(self, name, really): """ Deletes an existing gpg key. """ element = self.search(name) if element: element.click() sleep_for_seconds(3) self.wait_until_element(locators["gpgkey.remove"]).click() sleep_for_seconds(2) if really: self.wait_until_element(common_locators["confirm_remove"]).click() else: raise Exception("Could not delete the selected key '%s'." % name)
def test_info(self): """`subnet info` basic test """ options = {} options['name'] = generate_name(8, 8) options['network'] = generate_ipaddr(ip3=True) options['mask'] = '255.255.255.0' Subnet().create(options) sleep_for_seconds(5) result = Subnet().info({'name': options['name']}) self.assertTrue(len(result.stdout) > 1, "Subnet info - returns 1 record") self.assertEquals(result.stdout['name'], options['name'], "Subnet info - check name")
def test_delete(self): """ `compute_resource delete` basic test """ result_create = make_compute_resource( { "provider": FOREMAN_PROVIDERS["libvirt"], "url": "qemu+tcp://%s:16509/system" % conf.properties["main.server.hostname"], } ) self.assertTrue(result_create["name"], "ComputeResource create - has name") sleep_for_seconds(5) result_delete = ComputeResource().delete({"name": result_create["name"]}) self.assertEquals(result_delete.return_code, 0, "ComputeResource delete - exit code") sleep_for_seconds(5) self.assertFalse( ComputeResource().exists(("name", result_create["name"])), "ComputeResource list - does not exist name" )
def test_info(self): """ @Feature: Environment - Info @Test: Test Environment Info @Assert: Environment Info is displayed """ name = generate_name() Environment().create({'name': name}) sleep_for_seconds(5) # give time to appear in the list result = Environment().info({'name': name}) self.assertTrue(result.return_code == 0, "Environment info - retcode") self.assertEquals(result.stdout['name'], name, "Environment info - stdout contains 'Name'")
def search(self, element_name): """ Uses the search box to locate an element from a list of elements. """ element = None strategy = locators["gpgkey.key_name"][0] value = locators["gpgkey.key_name"][1] searchbox = self.wait_until_element(common_locators["kt_search"]) if searchbox: searchbox.clear() searchbox.send_keys(element_name) sleep_for_seconds(5) self.find_element(common_locators["kt_search_button"]).click() element = self.wait_until_element((strategy, value % element_name)) return element
def test_info(self): """ @Feature: Compute Resource - Info @Test: Test Compute Resource Info @Assert: Compute resource Info is displayed """ result_create = make_compute_resource({ 'provider': FOREMAN_PROVIDERS['libvirt'], 'url': "qemu+tcp://%s:16509/system" % conf.properties['main.server.hostname']}) self.assertTrue(result_create['name'], "ComputeResource create - has name") sleep_for_seconds(5) result_info = ComputeResource.info({'name': result_create['name']}) self.assertEquals(result_info.return_code, 0, "ComputeResource info - exit code") self.assertEquals(result_info.stdout['name'], result_create['name'], "ComputeResource info - check name")
def test_delete(self): """ `global_parameter delete` basic test """ name = "opt-%s" % generate_name(8, 8) value = "val-%s" % generate_name(12, 12) + " " + generate_name() result = GlobalParameter().set({ 'name': name, 'value': value}) self.assertEquals(result.return_code, 0, "GlobalParameter set - exit code %d" % result.return_code) result = GlobalParameter().delete({'name': name}) self.assertEquals(result.return_code, 0, "GlobalParameter delete - exit code %d" % result.return_code) sleep_for_seconds(5) result = GlobalParameter().list({'search': name}) self.assertTrue(len(result.stdout) == 0, "GlobalParameter list - deleted item is not listed")
def update(self, name, new_name=None, new_key=None): """ Updates an existing GPG key """ element = self.search(name) if element: element.click() sleep_for_seconds(5) if new_name: self.edit_entity("gpgkey.edit_name", "gpgkey.edit_name_text", new_name, "gpgkey.save_name") self.wait_for_ajax() if new_key: self.wait_until_element(locators["gpgkey.file_path"]).send_keys(new_key) self.wait_until_element(locators["gpgkey.upload_button"]).click() else: raise Exception("Could not update the gpg key '%s'" % name)
def assert_key_from_product(self, key_name, product): """ Assert the key association after deletion from product tab """ nav = Navigator(self.browser) nav.go_to_products() prd_element = self.search_entity(product, locators["prd.select"], katello=True) if prd_element: prd_element.click() sleep_for_seconds(2) self.wait_until_element(tab_locators["prd.tab_details"]).click() element = self.find_element(locators["prd.gpg_key"]).get_attribute("innerHTML") if element is None: return None else: raise Exception("GPGKey '%s' is still associated with product" % key_name) else: raise Exception("Couldn't find the product '%s'" % product)
def test_info(self): """ @Feature: Subnet - Info @Test: Check if Subnet Info is displayed @Assert: Subnet Info is displayed """ options = {} options['name'] = generate_name(8, 8) options['network'] = generate_ipaddr(ip3=True) options['mask'] = '255.255.255.0' Subnet.create(options) sleep_for_seconds(5) result = Subnet.info({'name': options['name']}) self.assertTrue(len(result.stdout) > 1, "Subnet info - returns 1 record") self.assertEquals(result.stdout['name'], options['name'], "Subnet info - check name")
def test_delete(self): """ `compute_resource delete` basic test """ result_create = make_compute_resource({ 'provider': FOREMAN_PROVIDERS['libvirt'], 'url': "qemu+tcp://%s:16509/system" % conf.properties['main.server.hostname']}) self.assertTrue(result_create['name'], "ComputeResource create - has name") sleep_for_seconds(5) result_delete = ComputeResource().delete( {'name': result_create['name']}) self.assertEquals( result_delete.return_code, 0, "ComputeResource delete - exit code") sleep_for_seconds(5) stdout = ComputeResource().exists( ('name', result_create['name'])).stdout self.assertFalse( stdout, "ComputeResource list - does not exist name")
def create(self, name, upload_key=False, key_path=None, key_content=None): """ Creates a gpg key from UI. """ self.wait_until_element(locators["gpgkey.new"]).click() if self.wait_until_element(common_locators["name"]): self.find_element(common_locators["name"]).send_keys(name) if upload_key: self.wait_until_element(locators["gpgkey.upload"]).click() self.find_element(locators["gpgkey.file_path"]).send_keys(key_path) elif key_content: self.find_element(locators["gpgkey.content"]).click() self.find_element(locators["gpgkey.content"]).send_keys(key_content) else: raise Exception("Could not create new gpgkey '%s' without contents" % name) self.wait_until_element(common_locators["create"]).click() sleep_for_seconds(2) else: raise Exception("Could not create new gpg key '%s'" % name)
def create(self, name, description=None, sync_plan=None, startdate=None, create_sync_plan=False, gpg_key=None, sync_interval=None): """ Creates new product from UI """ self.wait_until_element(locators["prd.new"]).click() sleep_for_seconds(5) self.text_field_update(common_locators["name"], name) if sync_plan and not create_sync_plan: type_ele = self.find_element(locators["prd.sync_plan"]) Select(type_ele).select_by_visible_text(sync_plan) elif sync_plan and create_sync_plan: self.find_element(locators["prd.new_sync_plan"]).click() self.text_field_update(common_locators["name"], name) if sync_interval: type_ele = self.find_element(locators["prd.sync_interval"]) Select(type_ele).select_by_visible_text(sync_interval) self.text_field_update(locators["prd.sync_startdate"], startdate) self.find_element(common_locators["create"]).click() self.wait_for_ajax() if gpg_key: type_ele = self.find_element(common_locators["gpg_key"]) Select(type_ele).select_by_visible_text(gpg_key) if description: self.text_field_update(common_locators["description"], description) sleep_for_seconds(2) self.wait_until_element(common_locators["create"]).click() sleep_for_seconds(5)
def update(self, name, new_name=None, new_desc=None, new_sync_plan=None, new_gpg_key=None): """ Updates product from UI """ prd_element = self.search_entity(name, locators["prd.select"], katello=True) if prd_element: prd_element.click() sleep_for_seconds(5) self.wait_until_element(tab_locators["prd.tab_details"]).click() sleep_for_seconds(5) if new_name: self.wait_until_element(locators["prd.name_edit"]).click() self.text_field_update(locators["prd.name_update"], new_name) self.find_element(common_locators["save"]).click() sleep_for_seconds(5) if new_desc: self.wait_until_element(locators["prd.desc_edit"]).click() self.text_field_update(locators["prd.desc_update"], new_name) self.find_element(common_locators["create"]).click() if new_gpg_key: self.wait_until_element(locators["prd.gpg_key_edit"]).click() type_ele = self.find_element(locators["prd.gpg_key_update"]) Select(type_ele).select_by_visible_text(new_gpg_key) self.wait_for_ajax() self.find_element(common_locators["create"]).click() if new_sync_plan: self.wait_until_element(locators["prd.sync_plan_edit"]).click() type_ele = self.find_element(locators["prd.sync_plan_update"]) Select(type_ele).select_by_visible_text(new_sync_plan) self.find_element(common_locators["create"]).click()
def command(cmd, hostname=None, expect_csv=False, timeout=None): """ Executes SSH command(s) on remote hostname. Defaults to main.server.hostname. """ # Set a default timeout of 60 seconds if timeout is None: timeout = 60 # Start the timer start = time.time() # Variable to hold results returned from the command stdout = stderr = errorcode = None # Remove escape code for colors displayed in the output regex = re.compile(r'\x1b\[\d\d?m') logger = logging.getLogger('robottelo') logger.debug(">>> %s" % cmd) hostname = hostname or conf.properties['main.server.hostname'] channel = connection.get_transport().open_session() channel.settimeout(timeout) channel.exec_command(cmd) sleep_counter = 0 while True: try: rlist, wlist, elist = select([channel], [], [], float(timeout)) while (not channel.recv_ready() and not channel.recv_stderr_ready() and sleep_counter < SSH_CHANNEL_READY_TIMEOUT * 10): sleep_for_seconds(0.1) sleep_counter += 1 if rlist is not None and len(rlist) > 0: if channel.exit_status_ready(): stdout = channel.recv(1048576) stderr = channel.recv_stderr(1048576) errorcode = channel.recv_exit_status() break elif elist is not None and len(elist) > 0: if channel.recv_stderr_ready(): stdout = channel.recv(1048576) stderr = channel.recv_stderr(1048576) break if time.time() - start > timeout: logger.debug("Command timeout exceeded.") raise CommandTimeOut('Command timeout exceeded') except socket.timeout: logger.debug("SSH channel timeout exceeded.") raise CommandTimeOut('SSH channel timeout exceeded.') # For output we don't really want to see all of Rails traffic # information, so strip it out. if stdout: # Empty fields are returned as "" which gives us u'""' stdout = stdout.replace('""', '') stdout = stdout.decode('utf-8') stdout = u"".join(stdout).split("\n") output = [ regex.sub('', line) for line in stdout if not line.startswith("[") ] else: output = [] # Ignore stderr if errorcode == 0. This is necessary since # we're running Foreman in verbose mode which generates a lot # of output return as stderr. errors = [] if errorcode == 0 else stderr if output: logger.debug("<<<\n%s" % '\n'.join(output[:-1])) if errors: errors = regex.sub('', "".join(errors)) logger.debug("<<< %s" % errors) return SSHCommandResult(output, errors, errorcode, expect_csv)