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