Python utils.partial_match函数代码示例

def create_catalog_item(provider, provisioning, vm_name, dialog, catalog, console_template=None):
    catalog_item_type = provider.catalog_name
    provision_type, template, host, datastore, iso_file, vlan = map(provisioning.get,
        ('provision_type', 'template', 'host', 'datastore', 'iso_file', 'vlan'))
    if console_template:
        logger.info("Console template name : {}".format(console_template.name))
        template = console_template.name
    item_name = dialog.label
    if provider.one_of(InfraProvider):
        catalog_name = template
        provisioning_data = {
            'catalog': {'vm_name': vm_name,
                        'provision_type': provision_type},
            'environment': {'host_name': {'name': host},
                            'datastore_name': {'name': datastore}},
            'network': {'vlan': partial_match(vlan)},
        }
    elif provider.one_of(CloudProvider):
        catalog_name = provisioning['image']['name']
        provisioning_data = {
            'catalog': {'vm_name': vm_name},
            'properties': {'instance_type': partial_match(provisioning['instance_type']),
                           'guest_keypair': provisioning['guest_keypair'],
                           'boot_disk_size': provisioning.get('boot_disk_size', None)},
            'environment': {'availability_zone': provisioning['availability_zone'],
                            'cloud_network': provisioning['cloud_network']}
        }
    catalog_item = CatalogItem(item_type=catalog_item_type, name=item_name,
        description="my catalog", display_in=True, catalog=catalog,
        dialog=dialog, catalog_name=catalog_name,
        provider=provider, prov_data=provisioning_data)
    return catalog_item

def _form_data_mapping(selector, second_provider, provider, source_list=None, target_list=None):
    source_data = second_provider.data.get(selector, [])
    target_data = provider.data.get(selector, [])
    if selector is 'clusters':
        source = source_data if source_data else None
        target = target_data if target_data else None
        skip_test = not source or not target
    else:
        if selector is 'datastores':
            source = [d.name for d in source_data if d.type == source_list]
            target = [d.name for d in target_data if d.type == target_list]
        else:
            source = [v for v in source_data if v == source_list]
            target = [v for v in target_data if v == target_list]
        skip_test = not (source_data and target_data and source and target)

    if skip_test:
        pytest.skip("No data for source or target {} in providers.".format(selector))
    else:
        _source, _target = partial_match(source[0]), partial_match(target[0])

    return {
        'sources': [_source],
        'target': [_target]
    }

def _form_data_cluster_mapping(second_provider, provider):
    # since we have only one cluster on providers
    source_cluster = second_provider.data.get('clusters', [False])[0]
    target_cluster = provider.data.get('clusters', [False])[0]
    if not source_cluster or not target_cluster:
        pytest.skip("No data for source or target cluster in providers.")

    return {
        'sources': [partial_match(source_cluster)],
        'target': [partial_match(target_cluster)]
    }

def _form_data_datastore_mapping(second_provider, provider, source_type, target_type):
    source_datastores_list = second_provider.data.get('datastores', [])
    target_datastores_list = provider.data.get('datastores', [])
    # assuming, we just have 1 datastore of each type
    source_datastore = [d.name for d in source_datastores_list if d.type == source_type]
    target_datastore = [d.name for d in target_datastores_list if d.type == target_type]
    if (not source_datastores_list or not target_datastores_list or
            not source_datastore or not target_datastore):
        pytest.skip("No data for source or target datastore in providers.")

    return {
        'sources': [partial_match(source_datastore[0])],
        'target': [partial_match(target_datastore[0])]
    }

def test_iso_provision_from_template(appliance, provider, vm_name, datastore_init,
                                     request, smtp_test):
    """Tests ISO provisioning

    Metadata:
        test_flag: iso, provision
        suite: infra_provisioning
    """
    # generate_tests makes sure these have values
    iso_template, host, datastore, iso_file, iso_kickstart,\
        iso_root_password, iso_image_type, vlan = map(provider.data['provisioning'].get,
            ('pxe_template', 'host', 'datastore', 'iso_file', 'iso_kickstart',
             'iso_root_password', 'iso_image_type', 'vlan'))

    request.addfinalizer(lambda:
                         appliance.collections.infra_vms.instantiate(vm_name, provider)
                         .cleanup_on_provider())

    provisioning_data = {
        'catalog': {
            'vm_name': vm_name,
            'provision_type': 'ISO',
            'iso_file': {'name': iso_file}},
        'environment': {
            'host_name': {'name': host},
            'datastore_name': {'name': datastore}},
        'customize': {
            'custom_template': {'name': iso_kickstart},
            'root_password': iso_root_password},
        'network': {
            'vlan': partial_match(vlan)}}
    do_vm_provisioning(appliance, iso_template, provider, vm_name, provisioning_data, request,
                       smtp_test, num_sec=1500)

def test_run_host_analysis(setup_provider_modscope, provider, host_type, host_name, register_event,
                           soft_assert, host_with_credentials):
    """ Run host SmartState analysis

    Metadata:
        test_flag: host_analysis
    """
    register_event(target_type='Host', target_name=host_name, event_type='request_host_scan')
    register_event(target_type='Host', target_name=host_name, event_type='host_scan_complete')

    # Initiate analysis
    host_with_credentials.run_smartstate_analysis(wait_for_task_result=True)

    # Check results of the analysis
    view = navigate_to(host_with_credentials, 'Details')
    drift_history = view.entities.summary('Relationships').get_text_of('Drift History')
    soft_assert(drift_history != '0', 'No drift history change found')

    if provider.type == "rhevm":
        soft_assert(view.entities.summary('Configuration').get_text_of('Services') != '0',
                    'No services found in host detail')

    if host_type in ('rhel', 'rhev'):
        soft_assert(view.entities.summary('Configuration').get_text_of('Packages') != '0',
                    'No packages found in host detail')
        soft_assert(view.entities.summary('Configuration').get_text_of('Files') != '0',
                    'No files found in host detail')

    elif host_type in ('esx', 'esxi'):
        soft_assert(view.entities.summary('Configuration').get_text_of('Advanced Settings') != '0',
                    'No advanced settings found in host detail')
        view.security_accordion.navigation.select(partial_match('Firewall Rules'))
        # Page get updated if rules value is not 0, and title is update
        soft_assert("(Firewall Rules)" in view.title.text, (
            "No firewall rules found in host detail"))

def new_instance(provider, zero_disk_flavor):
    flavor_name = zero_disk_flavor.name
    prov_data = provider.data['provisioning']
    prov_form_data = {
        'request': {'email': fauxfactory.gen_email(),
                    'first_name': fauxfactory.gen_alpha(),
                    'last_name': fauxfactory.gen_alpha()},
        'catalog': {'num_vms': '1',
                    'vm_name': fauxfactory.gen_alpha()},
        'environment': {'cloud_network': prov_data['cloud_network'],
                        'cloud_tenant': prov_data['cloud_tenant']},
        'properties': {'instance_type': partial_match(flavor_name)},
    }

    instance_name = prov_form_data['catalog']['vm_name']

    try:
        instance = provider.appliance.collections.cloud_instances.create(
            instance_name,
            provider,
            prov_form_data, find_in_cfme=True
        )

    except KeyError:
        # some yaml value wasn't found
        pytest.skip('Unable to find an image map in provider "{}" provisioning data: {}'
                    .format(provider, prov_data))

    yield instance

    instance.cleanup_on_provider()

def prov_data(provider, vm_name, template_name):
    if provider.one_of(OpenStackProvider):
        return {
            "catalog": {'vm_name': vm_name, 'catalog_name': {'name': template_name}},
            "environment": {'automatic_placement': True},
            "properties": {'instance_type': partial_match('m1.large')}
        }

def catalog_item(setup_provider, provider, vm_name, dialog, catalog, provisioning):
    iso_template, host, datastore, iso_file, iso_kickstart,\
        iso_root_password, iso_image_type, vlan = map(provisioning.get, ('pxe_template', 'host',
                                'datastore', 'iso_file', 'iso_kickstart',
                                'iso_root_password', 'iso_image_type', 'vlan'))

    provisioning_data = {
        'catalog': {'vm_name': vm_name,
                    'provision_type': 'ISO',
                    'iso_file': {'name': iso_file},
                    },
        'environment': {'host_name': {'name': host},
                        'datastore_name': {'name': datastore},
                        },
        'customize': {'custom_template': {'name': iso_kickstart},
                      'root_password': iso_root_password,
                      },
        'network': {'vlan': partial_match(vlan),
                    },
    }

    item_name = fauxfactory.gen_alphanumeric()
    catalog_item = CatalogItem(item_type="RHEV", name=item_name,
                  description="my catalog", display_in=True, catalog=catalog,
                  dialog=dialog, catalog_name=iso_template,
                  provider=provider, prov_data=provisioning_data)
    yield catalog_item

def catalog_item(appliance, provider, provisioning, tagcontrol_dialog, catalog):
    template, host, datastore, iso_file, vlan = map(provisioning.get,
        ('template', 'host', 'datastore', 'iso_file', 'vlan'))

    provisioning_data = {
        'catalog': {'catalog_name': {'name': template, 'provider': provider.name},
                    'vm_name': random_vm_name('service')},
        'environment': {'host_name': {'name': host},
                        'datastore_name': {'name': datastore}},
        'network': {'vlan': partial_match(vlan)},
    }

    if provider.type == 'rhevm':
        provisioning_data['catalog']['provision_type'] = 'Native Clone'
    elif provider.type == 'virtualcenter':
        provisioning_data['catalog']['provision_type'] = 'VMware'
    item_name = fauxfactory.gen_alphanumeric()
    catalog_item = appliance.collections.catalog_items.create(
        provider.catalog_item_type,
        name=item_name,
        description="my catalog",
        display_in=True,
        catalog=catalog,
        dialog=tagcontrol_dialog,
        prov_data=provisioning_data)
    return catalog_item

def create_catalog_item(provider, provisioning, vm_name, dialog, catalog, console_template=None):

    template, host, datastore, iso_file, catalog_item_type, vlan = map(provisioning.get,
        ('template', 'host', 'datastore', 'iso_file', 'catalog_item_type', 'vlan'))
    if console_template:
        logger.info("Console template name : {}".format(console_template.name))
        template = console_template.name
    item_name = dialog.label

    provisioning_data = {
        'catalog': {'vm_name': vm_name,
                    },
        'environment': {'host_name': {'name': host},
                        'datastore_name': {'name': datastore},
                        },
        'network': {'vlan': partial_match(vlan),
                    },
    }

    if provider.type == 'rhevm':
        provisioning_data['catalog']['provision_type'] = 'Native Clone'
    elif provider.type == 'virtualcenter':
        provisioning_data['catalog']['provision_type'] = 'VMware'
    catalog_item = CatalogItem(item_type=catalog_item_type, name=item_name,
        description="my catalog", display_in=True, catalog=catalog,
        dialog=dialog, catalog_name=template,
        provider=provider, prov_data=provisioning_data)
    return catalog_item

def catalog_item(appliance, provider, dialog, catalog, provisioning,
                 setup_pxe_servers_vm_prov):
    # generate_tests makes sure these have values
    pxe_template, host, datastore, pxe_server, pxe_image, pxe_kickstart, pxe_root_password,\
        pxe_image_type, pxe_vlan = map(
            provisioning.get, (
                'pxe_template', 'host', 'datastore', 'pxe_server', 'pxe_image', 'pxe_kickstart',
                'pxe_root_password', 'pxe_image_type', 'vlan'
            )
        )

    provisioning_data = {
        'catalog': {'catalog_name': {'name': pxe_template, 'provider': provider.name},
                    'provision_type': 'PXE',
                    'pxe_server': pxe_server,
                    'pxe_image': {'name': pxe_image},
                    'vm_name': random_vm_name('pxe_service')},
        'environment': {'datastore_name': {'name': datastore},
                        'host_name': {'name': host}},
        'customize': {'root_password': pxe_root_password,
                      'custom_template': {'name': pxe_kickstart}},
        'network': {'vlan': partial_match(pxe_vlan)},
    }

    item_name = fauxfactory.gen_alphanumeric()
    return appliance.collections.catalog_items.create(
        provider.catalog_item_type,
        name=item_name,
        description="my catalog", display_in=True, catalog=catalog,
        dialog=dialog, prov_data=provisioning_data)

def catalog_item(provider, vm_name, dialog, catalog, provisioning, setup_pxe_servers_vm_prov):
    # generate_tests makes sure these have values
    pxe_template, host, datastore, pxe_server, pxe_image, pxe_kickstart, pxe_root_password,\
        pxe_image_type, pxe_vlan, catalog_item_type = map(
            provisioning.get, (
                'pxe_template', 'host', 'datastore', 'pxe_server', 'pxe_image', 'pxe_kickstart',
                'pxe_root_password', 'pxe_image_type', 'vlan', 'catalog_item_type'
            )
        )

    provisioning_data = {
        'catalog': {'provision_type': 'PXE',
                    'pxe_server': pxe_server,
                    'pxe_image': {'name': pxe_image},
                    'vm_name': vm_name,
                    },
        'environment': {'datastore_name': {'name': datastore},
                        'host_name': {'name': host},
                        },
        'customize': {'root_password': pxe_root_password,
                      'custom_template': {'name': pxe_kickstart},
                      },
        'network': {'vlan': partial_match(pxe_vlan),
                    },
    }

    item_name = fauxfactory.gen_alphanumeric()
    catalog_item = CatalogItem(item_type=catalog_item_type, name=item_name,
                  description="my catalog", display_in=True, catalog=catalog,
                  dialog=dialog, catalog_name=pxe_template,
                  provider=provider, prov_data=provisioning_data)
    yield catalog_item

def generated_request(appliance, provider, provisioning, template_name, vm_name):
    """Creates a provision request, that is not automatically approved, and returns the search data.

    After finishing the test, request should be automatically deleted.

    Slightly modified code from :py:module:`cfme.tests.infrastructure.test_provisioning`
    """
    if provider.one_of(RHEVMProvider) and provisioning.get('vlan') is None:
        pytest.skip('rhevm requires a vlan value in provisioning info')
    first_name = fauxfactory.gen_alphanumeric()
    last_name = fauxfactory.gen_alphanumeric()
    notes = fauxfactory.gen_alphanumeric()
    e_mail = "{}@{}.test".format(first_name, last_name)
    host, datastore = map(provisioning.get, ('host', 'datastore'))
    vm = appliance.collections.infra_vms.instantiate(name=vm_name,
                                                     provider=provider,
                                                     template_name=template_name)
    view = navigate_to(vm.parent, 'Provision')

    provisioning_data = {
        'request': {
            'email': e_mail,
            'first_name': first_name,
            'last_name': last_name,
            'notes': notes},
        'catalog': {
            'vm_name': vm_name,
            'num_vms': '10'},
        'environment':
            {'host_name': {'name': host},
             'datastore_name': {'name': datastore}},
        'network':
            {'vlan': partial_match(provisioning['vlan'] if provisioning.get('vlan') else None)}
    }

    # Same thing, different names. :\
    if provider.one_of(RHEVMProvider):
        provisioning_data['catalog']['provision_type'] = 'Native Clone'
    elif provider.one_of(VMwareProvider):
        provisioning_data['catalog']['provision_type'] = 'VMware'

    # template and provider names for template selection
    provisioning_data['template_name'] = template_name
    provisioning_data['provider_name'] = provider.name

    view.form.fill_with(provisioning_data, on_change=view.form.submit_button)
    request_cells = {
        "Description": "Provision from [{}] to [{}###]".format(template_name, vm_name),
    }
    provision_request = appliance.collections.requests.instantiate(cells=request_cells)
    yield provision_request

    browser().get(appliance.url)
    appliance.server.login_admin()

    provision_request.remove_request()

def _form_data_network_mapping(second_provider, provider, source_network_name, target_network_name):
    source_vlans_list = second_provider.data.get('vlans', [])
    target_vlans_list = provider.data.get('vlans', [])
    # assuming there will be only 1 network matching given name
    source_network = [v for v in source_vlans_list if v == source_network_name]
    target_network = [v for v in target_vlans_list if v == target_network_name]
    if not source_vlans_list or not target_vlans_list or not source_network or not target_network:
        pytest.skip("No data for source or target cluster in providers.")

    return {
        'sources': [partial_match(source_network[0])],
        'target': [partial_match(target_network[0])]
    }