def __init__(self, generate=False):
"""Generates valid model for crud operations"""
if generate:
self.name = unicode(generate_name(8))
self.info = unicode(generate_name(8))
self.vendor_class = unicode(generate_name(8))
self.hardware_model = unicode(generate_name(8))
def make_user(options=None):
"""
Usage:
hammer user create [OPTIONS]
Options:
--login LOGIN
--firstname FIRSTNAME
--lastname LASTNAME
--mail MAIL
--admin ADMIN Is an admin account?
--password PASSWORD
--auth-source-id AUTH_SOURCE_ID
"""
login = generate_name(6)
# Assigning default values for attributes
args = {
'login': login,
'firstname': generate_name(),
'lastname': generate_name(),
'mail': "*****@*****.**" % login,
'admin': None,
'password': generate_name(),
'auth-source-id': 1,
}
args = update_dictionary(args, options)
args.update(create_object(User, args))
return args
def make_user(options=None):
"""
Usage:
hammer user create [OPTIONS]
Options:
--login LOGIN
--firstname FIRSTNAME
--lastname LASTNAME
--mail MAIL
--admin ADMIN Is an admin account?
--password PASSWORD
--auth-source-id AUTH_SOURCE_ID
"""
login = generate_name(6)
# Assigning default values for attributes
args = {
'login': login,
'firstname': generate_name(),
'lastname': generate_name(),
'mail': "*****@*****.**" % login,
'admin': None,
'password': generate_name(),
'auth-source-id': 1,
}
args = update_dictionary(args, options)
args.update(create_object(User, args))
return args
def test_medium_update(self):
"""
@Test: Check if medium can be updated
@Feature: Medium - Update medium
@Assert: Medium updated
"""
name = generate_name(6)
new_name = generate_name(6)
try:
medium = make_medium({'name': name})
except CLIFactoryError as e:
self.fail(e)
args = {'name': medium['name'],
'new-name': new_name}
result = Medium().update(args)
self.assertEqual(result.return_code, 0,
"Could not update media")
self.assertEqual(len(result.stderr), 0,
"There should not be an exception here")
result = Medium().info({'id': medium['id']})
self.assertEqual(result.stdout['name'], new_name,
"Medium name was not updated")
def test_update_template_os(self):
"""
@Feature: Template - Positive Update
@Test: Creates new template, along with two OS's
and associate list of OS's with created template
@Assert: The template should be updated with newly created OS's
successfully
"""
name = generate_name(6)
new_name = generate_name(6)
temp_type = 'provision'
os_name1 = generate_name(6)
os_name2 = generate_name(6)
os_list = [os_name1, os_name2]
major_version = generate_string('numeric', 1)
template_path = get_data_file(OS_TEMPLATE_DATA_FILE)
self.login.login(self.katello_user, self.katello_passwd)
for os_name in os_list:
self.navigator.go_to_operating_systems()
self.operatingsys.create(os_name, major_version)
self.assertIsNotNone(self.operatingsys.search(os_name))
self.create_template(name, template_path, True,
temp_type, None)
self.template.update(name, False, new_name, new_os_list=os_list)
self.assertIsNotNone(self.template.search(new_name))
def create_medium(self, name=None, path=None, os_family=None):
"Create Installation media with navigation steps"
name = name or generate_name(6)
path = path or URL % generate_name(6)
self.navigator.go_to_installation_media() # go to media page
self.medium.create(name, path, os_family)
self.assertIsNotNone(self.medium.search(name))
def test_delete_template_1(self):
"""
@Test: Check if Template can be deleted
@Feature: Template - Delete
@Assert: Template is deleted
"""
content = generate_name()
name = generate_name(6)
new_obj = make_template(
{
'name': name,
'content': content,
}
)
result = Template.info({'id': new_obj['id']})
self.assertEqual(result.return_code, 0)
self.assertEqual(len(result.stderr), 0)
self.assertEqual(new_obj['name'], result.stdout['name'])
Template.delete({'id': new_obj['id']})
result = Template.info({'id': new_obj['id']})
self.assertNotEqual(result.return_code, 0)
self.assertGreater(len(result.stderr), 0)
def test_create_medium(self):
"Create new Media"
name = generate_name(6)
path = URL % generate_name(6)
os_family = "Redhat"
self.login.login(self.katello_user, self.katello_passwd) # login
self.create_medium(name, path, os_family)
self.assertTrue(self, self.medium.search(name))
def create_arch(self, arch_name, os_name=None):
"""
Function navigates and creates new architecture from UI
"""
arch_name = arch_name or generate_name(4)
os_name = os_name or generate_name(6)
self.navigator.go_to_architectures() # go to architecture page
self.architecture.create(arch_name, os_name)
def test_set_parameter(self):
"""Set domain parameter"""
name = DOMAIN % generate_name(4)
description = name
param_name = generate_name(4)
param_value = generate_name(3)
self.create_domain(name, description)
self.domain.set_domain_parameter(description, param_name, param_value)
def test_update_domain(self):
"""Create new domain and update its name, description"""
name = generate_name(4) + '.com'
description = DOMAIN % name
new_name = generate_name(4) + '.org'
new_description = DOMAIN % new_name
self.create_domain(name, description)
self.domain.update(name, new_name, new_description)
def test_set_parameter(self):
"Set OS parameter"
name = generate_name(6)
major_version = generate_string('numeric', 1)
param_name = generate_name(4)
param_value = generate_name(3)
self.login.login(self.katello_user, self.katello_passwd) # login
self.create_os(name, major_version)
self.operatingsys.set_os_parameter(name, param_name, param_value)
def __init__(self, generate=False):
if generate:
self.login = unicode(generate_name(6))
self.password = unicode(generate_name(8))
self.mail = unicode(generate_email_address())
self.firstname = unicode(generate_name(6))
self.lastname = unicode(generate_name(6))
self.admin = False
self.auth_source_id = 1
def create_arch(self, arch_name, os_names=None):
"""
Function navigates and creates new architecture from UI
"""
arch_name = arch_name or generate_name(4)
os_names = os_names or [generate_name(6)]
self.navigator.go_to_architectures() # go to architecture page
self.architecture.create(arch_name, os_names)
self.assertIsNotNone(self.architecture.search(arch_name))
def test_remove_parameter(self):
"""Remove selected domain parameter"""
name = DOMAIN % generate_name(4)
description = name
param_name = generate_name(4)
param_value = generate_name(3)
self.create_domain(name, description)
self.domain.set_domain_parameter(description, param_name, param_value)
self.domain.remove_domain_parameter(description, param_name)
def test_remove_medium(self):
"Delete Media"
name = generate_name(6)
path = URL % generate_name(6)
os_family = "Redhat"
self.login.login(self.katello_user, self.katello_passwd) # login
self.create_medium(name, path, os_family)
self.medium.remove(name, True)
self.assertTrue(self.user.wait_until_element(locators["notif.success"]))
def test_create_user(self):
"Create a new User"
name = generate_name(6)
password = generate_name(8)
email = generate_email_address()
self.login.login(self.katello_user, self.katello_passwd) # login
self.navigator.go_to_users()
self.user.create(name, email, password, password)
self.assertIsNotNone(self.user.search(name)) #confirm the User appears in the UI
def test_update_hostgroup(self):
name = generate_name(7)
updated_name = generate_name(7)
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_host_groups()
self.hostgroup.create(name)
#confirm the Hostgroup appears in the UI
self.assertIsNotNone(self.hostgroup.search(name))
self.hostgroup.update(name, new_name=updated_name)
self.assertIsNotNone(self.hostgroup.search(updated_name))
def test_update_domain(self):
"""Create new domain and update its name, description"""
name = DOMAIN % generate_name(4)
description = name
new_name = DOMAIN % generate_name(4)
new_description = new_name
self.create_domain(name, description)
self.domain.update(name, new_name, new_description)
self.assertIsNotNone(self,
self.domain.search(new_description))
def test_update_org(self):
"""Update org name - given a valid new org name"""
org_name = generate_name(8, 8)
self.login.login(self.katello_user, self.katello_passwd)
self.create_org(org_name)
self.org.search(org_name)
new_name = generate_name(8, 8)
self.org.update(org_name, new_name)
self.assertIsNotNone(
self.org.search(new_name))
def test_set(self):
""" `global_parameter set` 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)
def test_set_parameter(self):
"Set OS parameter"
name = generate_name(6)
major_version = generate_string('numeric', 1)
param_name = generate_name(4)
param_value = generate_name(3)
self.login.login(self.katello_user, self.katello_passwd) # login
self.navigator.go_to_operating_systems() # go to operating system page
self.operatingsys.create(name, major_version)
self.operatingsys.set_os_parameter(name, param_name, param_value)
def test_create_arch(self):
"Create new Arch"
name = generate_name(4)
os_name = generate_name(6)
major_version = generate_string('numeric', 1)
self.login.login(self.katello_user, self.katello_passwd) # login
self.create_os(os_name, major_version) # create os
self.navigator.go_to_architectures() # go to architecture page
self.architecture.create(name, os_name)
self.assertTrue(self, self.architecture.search(name))
def test_remove_arch(self):
"Delete Arch"
name = generate_name(4)
os_name = generate_name(6)
major_version = generate_string('numeric', 1)
self.login.login(self.katello_user, self.katello_passwd) # login
self.create_os(os_name, major_version)
self.navigator.go_to_architectures() # go to architecture page
self.architecture.create(name, os_name)
self.architecture.remove(name, True)
def test_delete_user(self):
"Create and Delete a User"
name = generate_name(6)
password = generate_name(8)
email = generate_email_address()
self.login.login(self.katello_user, self.katello_passwd) # login
self.navigator.go_to_users()
self.user.create(name, email, password, password)
self.assertIsNotNone(self.user.search(name)) #confirm the User appears in the UI
self.user.delete(name, really=True)
self.assertTrue(self.user.wait_until_element(locators["notif.success"]))
def test_create_medium(self):
"""
@Feature: Media - Create
@Test: Create a new media
@Assert: Media is created
"""
name = generate_name(6)
path = URL % generate_name(6)
os_family = "Red Hat"
self.login.login(self.katello_user, self.katello_passwd) # login
self.create_medium(name, path, os_family)
def test_create_user(self):
"""
Create a new User
"""
name = generate_name(6)
password = generate_name(8)
email = generate_email_address()
search_key = "login"
self.login.login(self.katello_user, self.katello_passwd)
self.create_user(name, password, email, search_key)
def test_update_role(self):
"""Create new role and update its name or permission"""
name = generate_name(6)
new_name = generate_name(4)
perm_type = "Media"
permissions = ['create_media', 'edit_media'] # List of permissions
self.login.login(self.katello_user, self.katello_passwd) # login
self.navigator.go_to_roles()
self.role.create(name)
self.role.update(name, new_name, perm_type, permissions)
self.assertIsNotNone(self.role.search(new_name))
def test_update_subnet_1(self):
"Update subnet name"
subnet_name = generate_name(8, 8)
subnet_network = generate_ipaddr(ip3=True)
subnet_mask = "255.255.255.0"
self.login.login(self.katello_user, self.katello_passwd)
self.create_subnet(subnet_name, subnet_network, subnet_mask)
new_subnet_name = generate_name(8, 8)
self.subnet.update(subnet_name, new_subnet_name, None, None)
result_object = self.search_subnet(new_subnet_name)
self.assertEqual(new_subnet_name, result_object['name'])
def test_create_env(self):
"""
Creates a new environment from UI
"""
name = generate_name(6)
org_name = generate_name(8, 8)
self.login.login(self.katello_user, self.katello_passwd)
self.create_org(org_name)
self.navigator.go_to_environments()
self.environment.create(name, [org_name])
search = self.environment.search(name)
self.assertIsNotNone(search)
def test_update_medium(self):
"Create new Media and update its name, path and OS family"
name = generate_name(6)
newname = generate_name(4)
path = URL % generate_name(6)
newpath = URL % generate_name(6)
os_family = "Redhat"
new_os_family = "Debian"
self.login.login(self.katello_user, self.katello_passwd) # login
self.create_medium(name, path, os_family)
self.medium.update(name, newname, newpath, new_os_family)
self.assertTrue(self, self.medium.search(newname))
def test_update_role_name(self):
"""
@Feature: Role - Positive Update
@Test: Update role name
@Assert: Role is updated
"""
name = generate_name(6)
new_name = generate_name(4)
self.login.login(self.katello_user, self.katello_passwd) # login
self.navigator.go_to_roles()
self.role.create(name)
self.role.update(name, new_name)
self.assertIsNotNone(self.role.search(new_name))
def test_update_role_org(self):
"""
@Feature: Role - Positive Update
@Test: Update organization under selected role
@Assert: Role is updated
"""
name = generate_name(6)
org_name = generate_name(6)
self.login.login(self.katello_user, self.katello_passwd) # login
self.navigator.go_to_org()
self.org.create(org_name)
self.navigator.go_to_roles()
self.role.create(name)
self.role.update(name, add_permission=True, organization=[org_name])
def make_lifecycle_environment(options=None):
"""
Usage:
hammer lifecycle-environment create [OPTIONS]
Options:
--organization-id ORGANIZATION_ID name of organization
--name NAME name of the environment
--description DESCRIPTION description of the environment
--prior PRIOR Name of an environment that is prior to
the new environment in the chain. It has to be either ‘Library’ or an
environment at the end of a chain.
"""
# Organization ID is required
if not options or not options.get('organization-id', None):
raise Exception("Please provide a valid ORG ID.")
if not options.get('prior', None):
options['prior'] = 'Library'
# Assigning default values for attributes
args = {
'organization-id': None,
'name': generate_name(6),
'description': None,
'prior': None,
}
args = update_dictionary(args, options)
args.update(create_object(LifecycleEnvironment, args))
return args
def create_org(cls):
"""Creates and returns an organization"""
label = generate_name(6)
org = make_org({'label': label})
result = Org.exists(tuple_search=('id', org['id']))
org.update(result.stdout)
return org
def make_template(options=None):
"""
Usage:
hammer template create [OPTIONS]
Options:
--file TEMPLATE Path to a file that contains the template
--type TYPE Template type. Eg. snippet, script, provision
--name NAME template name
--audit-comment AUDIT_COMMENT
--operatingsystem-ids OPERATINGSYSTEM_IDS
Array of operating systems ID
to associate the template with
Comma separated list of values.
"""
# Assigning default values for attribute
args = {
'file': "/tmp/%s" % generate_name(),
'type': random.choice(TEMPLATE_TYPES),
'name': generate_name(6),
'audit-comment': None,
'operatingsystem-ids': None,
}
# Write content to file or random text
if options is not None and 'content' in options.keys():
content = options.pop('content')
else:
content = generate_name()
# Special handling for template factory
(file_handle, layout) = mkstemp(text=True)
chmod(layout, 0700)
with open(layout, "w") as ptable:
ptable.write(content)
# Upload file to server
ssh.upload_file(local_file=layout, remote_file=args['file'])
# End - Special handling for template factory
args = update_dictionary(args, options)
args.update(create_object(Template, args))
return args
def make_gpg_key(options=None):
"""
Usage:
hammer gpg create [OPTIONS]
Options:
--organization-id ORGANIZATION_ID organization identifier
--name NAME identifier of the GPG Key
--key GPG_KEY_FILE GPG Key file
-h, --help print help
"""
# Organization ID is a required field.
if not options or not options.get('organization-id', None):
raise Exception("Please provide a valid ORG ID.")
# Create a fake gpg key file if none was provided
if not options.get('key', None):
(file_handle, key_filename) = mkstemp(text=True)
os.chmod(key_filename, 0700)
with open(key_filename, "w") as gpg_key_file:
gpg_key_file.write(generate_name(minimum=20, maximum=50))
else:
# If the key is provided get its local path and remove it from options
# to not override the remote path
key_filename = options.pop('key')
args = {
'name': generate_name(),
'key': "/tmp/%s" % generate_name(),
'organization-id': None,
}
# Upload file to server
ssh.upload_file(local_file=key_filename, remote_file=args['key'])
args = update_dictionary(args, options)
# gpg create returns a dict inside a list
new_obj = create_object(GPGKey, args)
args.update(new_obj)
return args
def make_partition_table(options=None):
"""
Usage:
hammer partition_table update [OPTIONS]
Options:
--file LAYOUT Path to a file that contains
the partition layout
--os-family OS_FAMILY
--id ID resource id
--name NAME resource name
--new-name NEW_NAME new name for the resource
-h, --help print help
[root@qe-blade-04 ~]# hammer partition_table create --help
Usage:
hammer partition_table create [OPTIONS]
Options:
--file LAYOUT Path to a file that contains
the partition layout
--name NAME
--os-family OS_FAMILY
"""
if options is None:
options = {}
(file_handle, layout) = mkstemp(text=True)
os.chmod(layout, 0700)
with open(layout, "w") as ptable:
ptable.write(options.get('content', 'default ptable content'))
args = {
'name': generate_name(),
'file': "/tmp/%s" % generate_name(),
'os-family': random.choice(OPERATING_SYSTEMS)
}
# Upload file to server
ssh.upload_file(local_file=layout, remote_file=args['file'])
args = update_dictionary(args, options)
args.update(create_object(PartitionTable, args))
return args
def test_create_role(self):
"""
@Feature: Role - Positive Create
@Test: Create new role
@Assert: Role is created
"""
name = generate_name(6)
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_roles()
self.role.create(name)
self.assertIsNotNone(self.role.search(name))
def create_gpg_key_file(self, content=None):
"""
Creates a fake GPG Key file and returns its path or None if an error
happens.
"""
(file_handle, key_filename) = mkstemp(text=True)
if not content:
content = generate_name(minimum=20, maximum=50)
with open(key_filename, "w") as gpg_key_file:
gpg_key_file.write(content)
return key_filename
return None
def test_remove_role(self):
"""
@Feature: Role - Positive Delete
@Test: Delete an existing role
@Assert: Role is deleted
"""
name = generate_name(6)
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_roles()
self.role.create(name)
self.role.remove(name, True)
self.assertTrue(self.role.wait_until_element
(common_locators["notif.success"]))
self.assertIsNone(self.role.search(name))
def make_os(options=None):
"""
Creates the operating system
"""
# Assigning default values for attributes
args = {
'name': generate_name(6),
'major': random.randint(0, 10),
'minor': random.randint(0, 10),
}
args = update_dictionary(args, options)
args.update(create_object(OperatingSys, args))
return args
def test_update_role_permission(self):
"""
@Feature: Role - Positive Update
@Test: Update role permissions
@Assert: Role is updated
"""
name = generate_name(6)
resource_type = 'Architecture'
permission_list = ['access_dashboard', 'access_settings']
self.login.login(self.katello_user, self.katello_passwd) # login
self.navigator.go_to_roles()
self.role.create(name)
self.role.update(name, add_permission=True,
resource_type=resource_type,
permission_list=permission_list)
def make_environment(options=None):
"""
Usage:
hammer environment create [OPTIONS]
Options:
--name NAME
"""
# Assigning default values for attributes
args = {
'name': generate_name(6),
}
args = update_dictionary(args, options)
args.update(create_object(Environment, args))
return args
def login(self, username, password, organization=None):
"""
Logins user from UI
"""
if self.wait_until_element(locators["login.username"]):
self.field_update("login.username", username)
self.field_update("login.password", password)
self.find_element(common_locators["submit"]).click()
if self.find_element(common_locators["notif.error"]):
return
if self.find_element(locators["location.new"]):
loc = Location(self.browser)
loc.create(generate_name())
if organization:
nav = Navigator(self.browser)
nav.go_to_select_org(organization)
def make_activation_key(options=None):
"""
Usage:
hammer activation-key create [OPTIONS]
Options:
--content-view CONTENT_VIEW_NAME
--content-view-id CONTENT_VIEW_ID content view id
--description DESCRIPTION description
--environment ENVIRONMENT_NAME
--environment-id ENVIRONMENT_ID environment id
--name NAME name
--organization ORGANIZATION_NAME
--organization-id ORGANIZATION_ID organization identifier
--organization-label ORGANIZATION_LABEL
--usage-limit USAGE_LIMIT maximum number of registered
content hosts, or 'unlimited'
"""
# Organization Name, Label or ID is a required field.
if (not options or not options.get('organization', None)
and not options.get('organization-label', None)
and not options.get('organization-id', None)):
raise Exception("Please provide a valid Organization.")
args = {
'name': generate_name(),
'description': None,
'organization': None,
'organization-id': None,
'organization-label': None,
'content-view': None,
'content-view-id': None,
'environment': None,
'environment-id': None,
'usage-limit': 'unlimited',
}
# Override default dictionary with updated one
args = update_dictionary(args, options)
args.update(create_object(ActivationKey, args))
return args
def make_subnet(options=None):
"""
Usage:
hammer subnet create [OPTIONS]
Options:
--name NAME Subnet name
--network NETWORK Subnet network
--mask MASK Netmask for this subnet
--gateway GATEWAY Primary DNS for this subnet
--dns-primary DNS_PRIMARY Primary DNS for this subnet
--dns-secondary DNS_SECONDARY Secondary DNS for this subnet
--from FROM Starting IP Address for IP auto
suggestion
--to TO Ending IP Address for IP auto suggestion
--vlanid VLANID VLAN ID for this subnet
--domain-ids DOMAIN_IDS Domains in which this subnet is part
Comma separated list of values.
--dhcp-id DHCP_ID DHCP Proxy to use within this subnet
--tftp-id TFTP_ID TFTP Proxy to use within this subnet
--dns-id DNS_ID DNS Proxy to use within this subnet
"""
args = {
'name': generate_name(8, 8),
'network': generate_ipaddr(ip3=True),
'mask': u'255.255.255.0',
'gateway': None,
'dns-primary': None,
'dns-secondary': None,
'from': None,
'to': None,
'vlanid': None,
'domain-ids': None,
'dhcp-id': None,
'tftp-id': None,
'dns-id': None,
}
args = update_dictionary(args, options)
args.update(create_object(Subnet, args))
return args
def make_medium(options=None):
"""
Usage:
hammer medium create [OPTIONS]
Options:
--name NAME Name of media
--path PATH The path to the medium, can be a URL or a valid
NFS server (exclusive of the architecture)
for example http://mirror.centos.org/centos/
$version/os/$arch where $arch will be
substituted for the host’s actual OS
architecture and $version, $major and $minor
will be substituted for the version of the
operating system.
Solaris and Debian media may also use $release.
--os-family OS_FAMILY The family that the operating system belongs to.
Available families:
Archlinux
Debian
Gentoo
Redhat
Solaris
Suse
Windows
--operatingsystem-ids OPERATINGSYSTEM_IDS Comma separated list of values.
--operatingsystem-ids OSIDS os ids
Comma separated list of values.
"""
# Assigning default values for attributes
args = {
'name': generate_name(6),
'path': 'http://%s' % (generate_string('alpha', 6)),
'os-family': None,
'operatingsystem-ids': None,
}
args = update_dictionary(args, options)
args.update(create_object(Medium, args))
return args
def make_compute_resource(options=None):
"""
Usage:
hammer compute_resource create [OPTIONS]
Options:
--name NAME
--provider PROVIDER Providers include Libvirt, Ovirt, EC2,
Vmware, Openstack, Rackspace, GCE
--url URL URL for Libvirt, Ovirt, and Openstack
--description DESCRIPTION
--user USER Username for Ovirt, EC2, Vmware,
Openstack. Access Key for EC2.
--password PASSWORD Password for Ovirt, EC2, Vmware,
Openstack. Secret key for EC2
--uuid UUID for Ovirt, Vmware Datacenter
--region REGION for EC2 only
--tenant TENANT for Openstack only
--server SERVER for Vmware
-h, --help print help
"""
args = {
'name': generate_name(8, 8),
'provider': None,
'url': None,
'description': None,
'user': None,
'password': None,
'uuid': None,
'region': None,
'tenant': None,
'server': None
}
args = update_dictionary(args, options)
if args['provider'] is None:
options['provider'] = FOREMAN_PROVIDERS['libvirt']
if args['url'] is None:
options['url'] = "qemu+tcp://localhost:16509/system"
args.update(create_object(ComputeResource, args))
return args
def test_delete_ptable_1(self):
"""
@Feature: Partition Table - Delete
@Test: Check if Partition Table can be deleted
@Assert: Partition Table is deleted
"""
content = "Fake ptable"
name = generate_name(6)
make_partition_table({'name': name, 'content': content})
ptable = PartitionTable().exists(tuple_search=('name', name)).stdout
args = {
'id': ptable['id'],
}
PartitionTable().delete(args)
self.assertFalse(PartitionTable().exists(tuple_search=('name',
name)).stdout)
def test_dump_ptable_1(self):
"""
@Feature: Partition Table - Create
@Test: Check if Partition Table can be created with specific content
@Assert: Partition Table is created
"""
content = "Fake ptable"
name = generate_name(6)
make_partition_table({'name': name, 'content': content})
ptable = PartitionTable().exists(tuple_search=('name', name)).stdout
args = {
'id': ptable['id'],
}
ptable_content = PartitionTable().dump(args)
self.assertTrue(content in ptable_content.stdout[0])
def make_architecture(options=None):
"""
Usage:
hammer architecture create [OPTIONS]
Options:
--name NAME
--operatingsystem-ids OPERATINGSYSTEM_IDS Operatingsystem ID’s
Comma separated list of values.
"""
args = {
'name': generate_name(),
'operatingsystem-ids': None,
}
# Override default dictionary with updated one
args = update_dictionary(args, options)
args.update(create_object(Architecture, args))
return args
def test_redmine_4272(self):
"""
@Test: gpg info should display key content
@Feature: GPG Keys
@Assert: gpg info should display key content
@BZ: Redmine#4272
"""
# GPG Key data
data = {'name': generate_string("alpha", 10)}
data['organization-id'] = self.org['id']
# Setup a new key file
content = generate_name()
gpg_key = self.create_gpg_key_file(content=content)
self.assertIsNotNone(gpg_key, 'GPG Key file must be created')
data['key'] = gpg_key
try:
new_obj = make_gpg_key(data)
except Exception, e:
self.fail(e)
def make_domain(options=None):
"""
Usage:
hammer domain create [OPTIONS]
Options:
--name NAME The full DNS Domain name
--dns-id DNS_ID DNS Proxy to use within this domain
--description DESC Full name describing the domain
"""
# Assigning default values for attributes
args = {
'name': generate_name(6),
'dns-id': None,
'description': None,
}
args = update_dictionary(args, options)
args.update(create_object(Domain, args))
return args
def make_proxy(options=None):
"""
Usage:
hammer proxy create [OPTIONS]
Options:
--name NAME
--url URL
"""
args = {
'name':
generate_name(),
'url':
'http://%s:%s' %
(generate_string('alpha', 6), generate_string('numeric', 4)),
}
args = update_dictionary(args, options)
args.update(create_object(Proxy, args))
return args
def make_org(options=None):
"""
Usage:
hammer organization create [OPTIONS]
Options:
--name NAME name
--label LABEL unique label
--description DESCRIPTION description
"""
# Assigning default values for attributes
args = {
'name': generate_name(6),
'label': None,
'description': None,
}
args = update_dictionary(args, options)
args.update(create_object(Org, args))
return args
def test_negative_create_3(self, data):
"""
@test: Create gpg key with invalid name and valid gpg key via
file import
@feature: GPG Keys
@assert: gpg key is not created
"""
# Setup data to pass to create
data = data.copy()
data['key'] = '/tmp/%s' % generate_name()
data['organization-id'] = self.org['id']
ssh.upload_file(local_file=VALID_GPG_KEY_FILE_PATH,
remote_file=data['key'])
# Try to create a new object passing @data to factory method
new_obj = GPGKey().create(data)
self.assertNotEqual(new_obj.return_code, 0,
"Object should not be created")
self.assertGreater(len(new_obj.stderr), 0,
"Should have raised an exception")
def make_hostgroup(options=None):
"""
Usage:
hammer hostgroup create [OPTIONS]
Options:
--name NAME
--parent-id PARENT_ID
--environment-id ENVIRONMENT_ID
--operatingsystem-id OPERATINGSYSTEM_ID
--architecture-id ARCHITECTURE_ID
--medium-id MEDIUM_ID
--ptable-id PTABLE_ID
--puppet-ca-proxy-id PUPPET_CA_PROXY_ID
--subnet-id SUBNET_ID
--domain-id DOMAIN_ID
--puppet-proxy-id PUPPET_PROXY_ID
"""
# Assigning default values for attributes
args = {
'name': generate_name(6),
'parent-id': None,
'environment-id': None,
'operatingsystem-id': None,
'architecture-id': None,
'medium-id': None,
'ptable-id': None,
'puppet-ca-proxy-id': None,
'subnet-id': None,
'domain-id': None,
'puppet-proxy-id': None,
}
args = update_dictionary(args, options)
args.update(create_object(HostGroup, args))
return args
def make_model(options=None):
"""
Usage:
hammer model create [OPTIONS]
Options:
--name NAME
--info INFO
--vendor-class VENDOR_CLASS
--hardware-model HARDWARE_MODEL
"""
args = {
'name': generate_name(),
'info': None,
'vendor-class': None,
'hardware-model': None,
}
# Override default dictionary with updated one
args = update_dictionary(args, options)
args.update(create_object(Model, args))
return args
new_obj = make_gpg_key(data)
except Exception, e:
self.fail(e)
# Can we find the new object?
result = GPGKey().exists({'organization-id': self.org['id']},
(self.search_key, new_obj[self.search_key]))
self.assertEqual(result.return_code, 0, "Failed to create object")
self.assertEqual(len(result.stderr), 0,
"There should not be an exception here")
self.assertEqual(new_obj[self.search_key],
result.stdout[self.search_key])
# Setup a new key file
data['key'] = '/tmp/%s' % generate_name()
gpg_key = self.create_gpg_key_file()
self.assertIsNotNone(gpg_key, 'GPG Key file must be created')
ssh.upload_file(local_file=gpg_key, remote_file=data['key'])
# Try to create a gpg key with the same name
new_obj = GPGKey().create(data)
self.assertNotEqual(new_obj.return_code, 0,
"Object should not be created")
self.assertGreater(len(new_obj.stderr), 0,
"Should have raised an exception")
@data(*positive_create_data())
def test_negative_create_2(self, data):
"""
@test: Create gpg key with valid name and no gpg key
