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