def test_superadmin_tenant_crud(request):
    """Test suppose to verify CRUD operations for CFME tenants

    Prerequisities:
        * This test is not depending on any other test and can be executed against fresh appliance.

    Steps:
        * Create tenant
        * Update description of tenant
        * Update name of tenat
        * Delete tenant
    """
    tenant = ac.Tenant(
        name='tenant1' + fauxfactory.gen_alphanumeric(),
        description='tenant1 description')

    @request.addfinalizer
    def _delete_tenant():
        if tenant.exists:
            tenant.delete()

    tenant.create()
    with update(tenant):
        tenant.description = tenant.description + "edited"
    with update(tenant):
        tenant.name = tenant.name + "edited"
    tenant.delete()
def test_repository_crud(soft_assert, random_string, request):
    repo_name = 'Test Repo {}'.format(random_string)
    repo = repositories.Repository(repo_name, '//testhost/share/path')
    request.addfinalizer(repo.delete)

    # create
    repo.create()

    # read
    assert repo.exists

    # update
    with update(repo):
        repo.name = 'Updated {}'.format(repo_name)

    with soft_assert.catch_assert():
        assert repo.exists, 'Repository rename failed'

        # Only change the name back if renaming succeeded
        with update(repo):
            repo.name = repo_name

    # delete
    repo.delete()
    try:
        wait_for(lambda: not repo.exists)
    except TimedOutError:
        raise AssertionError('failed to delete repository')
示例#3
0
def test_hawkular_crud(provider):
    """Test provider add with good credentials.

    """
    with sel.ajax_timeout(120):
        provider.create(cancel=False, validate_credentials=True)
    # UI validation, checks whether data provided from Hawkular provider matches data in UI
    provider.validate_stats(ui=True)
    # DB validation, checks whether data provided from Hawkular provider matches data in DB
    provider.validate_stats()
    # validates Properties section of provider's summary page
    provider.validate_properties()
    # validates that provider is refreshed in DB and in UI
    assert provider.is_refreshed(method='ui'), "Provider is not refreshed in UI"
    assert provider.is_refreshed(method='db'), "Provider is not refreshed in DB"

    old_name = provider.name
    with update(provider):
        provider.name = str(uuid.uuid4())  # random uuid

    with update(provider):
        provider.name = old_name  # old name

    provider.delete(cancel=False)
    provider.wait_for_delete()
def test_superadmin_tenant_project_crud(request):
    """Test suppose to verify CRUD operations for CFME projects

    Prerequisities:
        * This test is not depending on any other test and can be executed against fresh appliance.

    Steps:
        * Create tenant
        * Create project as child to tenant
        * Update description of project
        * Update name of project
        * Delete project
        * Delete tenant
    """
    tenant = Tenant(name="tenant1" + fauxfactory.gen_alphanumeric(), description="tenant1 description")
    project = Project(
        name="project1" + fauxfactory.gen_alphanumeric(), description="project1 description", parent_tenant=tenant
    )

    @request.addfinalizer
    def _delete_tenant_and_project():
        for item in [project, tenant]:
            if item.exists:
                item.delete()

    tenant.create()
    project.create()
    with update(project):
        project.description = project.description + "edited"
    with update(project):
        project.name = project.name + "edited"
    project.delete()
    tenant.delete()
def test_vm_analysis_profile_crud():
    """CRUD for VM analysis profiles."""
    p = VMAnalysisProfile(generate_random_string(), generate_random_string(), files=["asdf", "dfg"])
    p.create()
    with update(p):
        p.files = ["qwer"]
    with update(p):
        p.categories = ["check_system"]
    p.delete()
def test_vm_analysis_profile_crud():
    """CRUD for VM analysis profiles."""
    p = VMAnalysisProfile(fauxfactory.gen_alphanumeric(), fauxfactory.gen_alphanumeric(), files=["asdf", "dfg"])
    p.create()
    with update(p):
        p.files = ["qwer"]
    with update(p):
        p.categories = ["check_system"]
    p.delete()
示例#7
0
def test_namespace_crud(namespace):
    namespace.create()
    old_name = namespace.name
    with update(namespace):
        namespace.name = fauxfactory.gen_alphanumeric(8)
    with update(namespace):
        namespace.name = old_name
    namespace.delete()
    assert not namespace.exists()
示例#8
0
def test_display_name_unset_from_ui(request, a_class):
    a_class.create()
    request.addfinalizer(a_class.delete)
    with update(a_class):
        a_class.display_name = generate_random_string()
    assert a_class.exists
    with update(a_class):
        a_class.display_name = ""
    assert a_class.exists
示例#9
0
def test_display_name_unset_from_ui(request, an_instance):
    an_instance.create()
    request.addfinalizer(an_instance.delete)
    with update(an_instance):
        an_instance.display_name = generate_random_string()
    assert an_instance.exists
    with update(an_instance):
        an_instance.display_name = ""
    assert an_instance.exists
示例#10
0
def test_class_crud(a_class):
    a_class.create()
    orig = a_class.description
    with update(a_class):
        a_class.description = 'edited'
    with update(a_class):
        a_class.description = orig
    a_class.delete()
    assert not a_class.exists()
示例#11
0
def test_namespace_crud(namespace):
    namespace.create()
    old_name = namespace.name
    with update(namespace):
        namespace.name = generate_random_string(8)
    with update(namespace):
        namespace.name = old_name
    namespace.delete()
    assert not namespace.exists()
示例#12
0
def test_display_name_unset_from_ui(request, an_instance):
    an_instance.create()
    request.addfinalizer(an_instance.delete)
    with update(an_instance):
        an_instance.display_name = fauxfactory.gen_alphanumeric()
    assert an_instance.exists
    with update(an_instance):
        an_instance.display_name = ""
    assert an_instance.exists
示例#13
0
def test_method_crud(a_method):
    a_method.create()
    origname = a_method.name
    with update(a_method):
        a_method.name = generate_random_string(8)
        a_method.data = "bar"
    with update(a_method):
        a_method.name = origname
    a_method.delete()
    assert not a_method.exists()
示例#14
0
def test_instance_display_name_unset_from_ui(request, klass):
    instance = klass.instances.create(
        name=fauxfactory.gen_alphanumeric(),
        display_name=fauxfactory.gen_alphanumeric())
    with update(instance):
        instance.display_name = fauxfactory.gen_alphanumeric()
    assert instance.exists
    with update(instance):
        instance.display_name = ""
    assert instance.exists
示例#15
0
def test_method_crud(a_method):
    a_method.create()
    origname = a_method.name
    with update(a_method):
        a_method.name = fauxfactory.gen_alphanumeric(8)
        a_method.data = "bar"
    with update(a_method):
        a_method.name = origname
    a_method.delete()
    assert not a_method.exists()
示例#16
0
def test_instance_crud(an_instance):
    an_instance.create()
    origname = an_instance.name
    with update(an_instance):
        an_instance.name = generate_random_string(8)
        an_instance.description = "updated"
    with update(an_instance):
        an_instance.name = origname
    an_instance.delete()
    assert not an_instance.exists()
示例#17
0
def test_instance_crud(an_instance):
    an_instance.create()
    origname = an_instance.name
    with update(an_instance):
        an_instance.name = fauxfactory.gen_alphanumeric(8)
        an_instance.description = "updated"
    with update(an_instance):
        an_instance.name = origname
    an_instance.delete()
    assert not an_instance.exists()
def test_vm_analysis_profile_crud():
    """CRUD for VM analysis profiles."""
    p = AnalysisProfile(name=fauxfactory.gen_alphanumeric(),
                        description=fauxfactory.gen_alphanumeric(),
                        profile_type='VM', files=["asdf", "dfg"])
    p.create()
    with update(p):
        p.files = ["qwer"]
    with update(p):
        p.categories = ["check_system"]
    p.delete()
示例#19
0
def test_provider_edit(provider_crud):
    """ Tests that editing a management system shows the proper detail after an edit."""
    provider_crud.create()
    old_name = provider_crud.name
    with update(provider_crud) as provider_crud:
        provider_crud.name = str(uuid.uuid4())  # random uuid
    flash.assert_message_match('Cloud Provider "%s" was saved' % provider_crud.name)

    with update(provider_crud) as provider_crud:
        provider_crud.name = old_name  # old name
    flash.assert_message_match('Cloud Provider "%s" was saved' % provider_crud.name)
示例#20
0
def test_class_display_name_unset_from_ui(request, namespace):
    a_class = namespace.classes.create(
        name=fauxfactory.gen_alphanumeric(),
        display_name=fauxfactory.gen_alphanumeric(),
        description=fauxfactory.gen_alphanumeric()
    )
    with update(a_class):
        a_class.display_name = fauxfactory.gen_alphanumeric()
    assert a_class.exists
    with update(a_class):
        a_class.display_name = ""
    assert a_class.exists
示例#21
0
def test_domain_lock_unlock(request):
    domains = DomainCollection()
    domain = domains.create(
        name=fauxfactory.gen_alpha(),
        description=fauxfactory.gen_alpha(),
        enabled=True)
    request.addfinalizer(domain.delete)
    ns1 = domain.namespaces.create(name='ns1')
    ns2 = ns1.namespaces.create(name='ns2')
    cls = ns2.classes.create(name='class1')
    cls.schema.add_field(name='myfield', type='Relationship')
    inst = cls.instances.create(name='inst')
    meth = cls.methods.create(name='meth', script='$evm')
    # Lock the domain
    domain.lock()
    # Check that nothing is editable
    # namespaces
    details = navigate_to(ns1, 'Details')
    assert not details.configuration.is_displayed
    details = navigate_to(ns2, 'Details')
    assert not details.configuration.is_displayed
    # class
    details = navigate_to(cls, 'Details')
    assert details.configuration.items == ['Copy selected Instances']
    assert not details.configuration.item_enabled('Copy selected Instances')
    details.schema.select()
    assert not details.configuration.is_displayed
    # instance
    details = navigate_to(inst, 'Details')
    assert details.configuration.items == ['Copy this Instance']
    # method
    details = navigate_to(meth, 'Details')
    assert details.configuration.items == ['Copy this Method']
    # Unlock it
    domain.unlock()
    # Check that it is editable
    with update(ns1):
        ns1.name = 'UpdatedNs1'
    assert ns1.exists
    with update(ns2):
        ns2.name = 'UpdatedNs2'
    assert ns2.exists
    with update(cls):
        cls.name = 'UpdatedClass'
    assert cls.exists
    cls.schema.add_field(name='myfield2', type='Relationship')
    with update(inst):
        inst.name = 'UpdatedInstance'
    assert inst.exists
    with update(meth):
        meth.name = 'UpdatedMethod'
    assert meth.exists
示例#22
0
def test_instance_crud(klass):
    instance = klass.instances.create(
        name=fauxfactory.gen_alphanumeric(),
        display_name=fauxfactory.gen_alphanumeric(),
        description=fauxfactory.gen_alphanumeric()
    )
    orig = instance.description
    with update(instance):
        instance.description = 'edited'
    with update(instance):
        instance.description = orig
    instance.delete()
    assert not instance.exists
示例#23
0
def test_class_crud(namespace):
    a_class = namespace.classes.create(
        name=fauxfactory.gen_alphanumeric(),
        display_name=fauxfactory.gen_alphanumeric(),
        description=fauxfactory.gen_alphanumeric()
    )
    orig = a_class.description
    with update(a_class):
        a_class.description = 'edited'
    with update(a_class):
        a_class.description = orig
    a_class.delete()
    assert not a_class.exists
示例#24
0
def test_provider_crud(provider_crud):
    """ Tests that a provider can be added """
    provider_crud.create()
    provider_crud.validate()

    old_name = provider_crud.name
    with update(provider_crud):
        provider_crud.name = str(uuid.uuid4())  # random uuid

    with update(provider_crud):
        provider_crud.name = old_name  # old name

    provider_crud.delete(cancel=False)
    provider.wait_for_provider_delete(provider_crud)
示例#25
0
def test_tenant_crud(tenant):
    """ Tests tenant create and delete

    Metadata:
        test_flag: tenant
    """

    tenant.create(cancel=True)
    assert not tenant.exists

    tenant.create(wait=True)
    assert tenant.exists

    with update(tenant):
        tenant.name = fauxfactory.gen_alphanumeric(8)
    tenant.wait_for_appear()
    assert tenant.exists

    tenant.delete(from_details=False, cancel=True)
    assert tenant.exists

    # BZ#1411112 Delete/update cloud tenant
    #  not reflected in UI in cloud tenant list
    tenant.delete(from_details=True, cancel=False, wait=True)
    assert not tenant.exists
示例#26
0
def test_check_package_presence(request, fleecing_vm, ssh_client, analysis_profile):
    """This test checks compliance by presence of a certain cfme-appliance package which is expected
    to be present on an appliance."""
    # TODO: If we step out from provisioning a full appliance for fleecing, this might need revisit
    condition = VMCondition(
        "Compliance testing condition {}".format(fauxfactory.gen_alphanumeric(8)),
        expression=("fill_find(field=VM and Instance.Guest Applications : Name, "
            "skey=STARTS WITH, value=cfme-appliance, check=Check Count, ckey= = , cvalue=1)")
    )
    request.addfinalizer(lambda: diaper(condition.delete))
    policy = VMCompliancePolicy("Compliance {}".format(fauxfactory.gen_alphanumeric(8)))
    request.addfinalizer(lambda: diaper(policy.delete))
    policy.create()
    policy.assign_conditions(condition)
    profile = PolicyProfile(
        "Compliance PP {}".format(fauxfactory.gen_alphanumeric(8)),
        policies=[policy]
    )
    request.addfinalizer(lambda: diaper(profile.delete))
    profile.create()
    fleecing_vm.assign_policy_profiles(profile.description)
    request.addfinalizer(lambda: fleecing_vm.unassign_policy_profiles(profile.description))

    with update(analysis_profile):
        analysis_profile.categories = [
            "check_services", "check_accounts", "check_software", "check_vmconfig", "check_system"]

    do_scan(fleecing_vm)
    assert fleecing_vm.check_compliance_and_wait()
示例#27
0
def test_check_files(request, fleecing_vm, ssh_client, analysis_profile):
    """This test checks presence and contents of a certain file. Due to caching, an existing file
    is checked.
    """
    check_file_name = "/etc/sudo.conf"
    check_file_contents = "sudoers_policy"  # The file contains: `Plugin sudoers_policy sudoers.so`
    condition = VMCondition(
        "Compliance testing condition {}".format(fauxfactory.gen_alphanumeric(8)),
        expression=("fill_find(VM and Instance.Files : Name, "
            "=, {}, Check Any, Contents, INCLUDES, {})".format(
                check_file_name, check_file_contents))
    )
    request.addfinalizer(lambda: diaper(condition.delete))
    policy = VMCompliancePolicy("Compliance {}".format(fauxfactory.gen_alphanumeric(8)))
    request.addfinalizer(lambda: diaper(policy.delete))
    policy.create()
    policy.assign_conditions(condition)
    profile = PolicyProfile(
        "Compliance PP {}".format(fauxfactory.gen_alphanumeric(8)),
        policies=[policy]
    )
    request.addfinalizer(lambda: diaper(profile.delete))
    profile.create()
    fleecing_vm.assign_policy_profiles(profile.description)
    request.addfinalizer(lambda: fleecing_vm.unassign_policy_profiles(profile.description))

    with update(analysis_profile):
        analysis_profile.files = [(check_file_name, True)]
        analysis_profile.categories = [
            "check_services", "check_accounts", "check_software", "check_vmconfig", "check_system"]

    do_scan(fleecing_vm, ("Configuration", "Files"))
    assert fleecing_vm.check_compliance_and_wait()
示例#28
0
def test_dashboard_crud():
    d = Dashboard(
        generate_random_string(),
        "EvmGroup-administrator",
        generate_random_string(),
        locked=False,
        widgets=["Top CPU Consumers (weekly)", "Vendor and Guest OS Chart"]
    )
    d.create()
    with update(d):
        d.locked = True
    with update(d):
        d.locked = False
    with update(d):
        d.widgets = "Top Storage Consumers"
    d.delete()
示例#29
0
def test_user_change_password(request):
    user = ac.User(
        name="user {}".format(fauxfactory.gen_alphanumeric()),
        credential=Credential(
            principal="user_principal_{}".format(fauxfactory.gen_alphanumeric()),
            secret="very_secret",
            verify_secret="very_secret"
        ),
        email="*****@*****.**",
        group=usergrp,
    )
    user.create()
    request.addfinalizer(user.delete)
    request.addfinalizer(login.login_admin)
    login.logout()
    assert not login.logged_in()
    login.login(user.credential.principal, user.credential.secret)
    assert login.current_full_name() == user.name
    login.login_admin()
    with update(user):
        user.credential = Credential(
            principal=user.credential.principal,
            secret="another_very_secret",
            verify_secret="another_very_secret",
        )
    login.logout()
    assert not login.logged_in()
    login.login(user.credential.principal, user.credential.secret)
    assert login.current_full_name() == user.name
def test_embedded_ansible_credential_crud(request, wait_for_ansible, credential_type, credentials):
    credentials_collection = CredentialsCollection()
    credential = credentials_collection.create(
        "{}_credential_{}".format(credential_type, fauxfactory.gen_alpha()),
        credential_type,
        **credentials
    )
    updated_value = "edited_{}".format(fauxfactory.gen_alpha())
    with update(credential):
        if credential.credential_type != "Amazon":
            credential.username = updated_value
        else:
            credential.access_key = updated_value
    view = navigate_to(credential, "Details")

    def wait_for_changes(field_name):
        wait_for(
            lambda: view.credential_options.get_text_of(field_name) == updated_value,
            fail_func=view.browser.selenium.refresh,
            delay=10,
            timeout=60
        )

    if credential.credential_type == "Amazon":
        wait_for_changes("Access Key")
    else:
        wait_for_changes("Username")
    credential.delete()
示例#31
0
def test_custom_report_crud(custom_report):
    custom_report.create()
    with update(custom_report):
        custom_report.title += fauxfactory.gen_alphanumeric()
    custom_report.queue(wait_for_finish=True)
    for report in custom_report.get_saved_reports():
        report.data  # touch the results
    custom_report.delete()
def test_edit_storage_chargeback(chargeback_storage_rate):
    chargeback_storage_rate.create()
    with update(chargeback_storage_rate):
        chargeback_storage_rate.description = chargeback_storage_rate.description + "-edited"
        chargeback_storage_rate.fields = {
            'Fixed Storage Cost 1': with_random_per_time(fixed_rate='500'),
            'Allocated Disk Storage': with_random_per_time(fixed_rate='100'),
        }
示例#33
0
def test_pxe_server_crud(pxe_name, pxe_server_crud):
    """
    Basic Add test for PXE server including refresh.
    """
    pxe_server_crud.create(refresh_timeout=300)
    with update(pxe_server_crud):
        pxe_server_crud.name = pxe_server_crud.name + "_update"
    pxe_server_crud.delete(cancel=False)
示例#34
0
def test_user_crud():
    user = new_user()
    user.create()
    with update(user):
        user.name = user.name + "edited"
    copied_user = user.copy()
    copied_user.delete()
    user.delete()
示例#35
0
def test_custom_report_crud(custom_report):
    custom_report.create()
    with update(custom_report):
        custom_report.title += fauxfactory.gen_alphanumeric()
    custom_report.queue(wait_for_finish=True)
    for report in custom_report.get_saved_reports():
        assert hasattr(report, 'data')
    custom_report.delete()
示例#36
0
def test_timeprofile_crud():
    timeprofile = new_timeprofile()
    timeprofile.create()
    with update(timeprofile):
        timeprofile.scope = 'All Users'
    copied_timeprofile = timeprofile.copy()
    copied_timeprofile.delete()
    timeprofile.delete()
def test_category_crud():
    cg = Category(name=generate_lowercase_random_string(size=8),
                  description=generate_random_string(size=32),
                  display_name=generate_random_string(size=32))
    cg.create()
    with update(cg):
        cg.description = generate_random_string(size=32)
    cg.delete(cancel=False)
示例#38
0
def test_role_crud():
    role = new_role()
    role.create()
    with update(role):
        role.name = role.name + "edited"
    copied_role = role.copy()
    copied_role.delete()
    role.delete()
示例#39
0
def test_config_manager_edit(request, config_manager):
    new_name = fauxfactory.gen_alpha(8)
    old_name = config_manager.name
    with update(config_manager):
        config_manager.name = new_name
    request.addfinalizer(lambda: config_manager.update(updates={'name': old_name}))
    assert (config_manager.name == new_name and config_manager.exists,
        "Failed to update configuration manager's name")
示例#40
0
def test_tag_crud(category):
    tag = Tag(name=generate_lowercase_random_string(size=8),
              display_name=generate_random_string(size=32),
              category=category)
    tag.create()
    with update(tag):
        tag.display_name = generate_random_string(size=32)
    tag.delete(cancel=False)
示例#41
0
def test_category_crud():
    cg = Category(name=fauxfactory.gen_alphanumeric(8).lower(),
                  description=fauxfactory.gen_alphanumeric(32),
                  display_name=fauxfactory.gen_alphanumeric(32))
    cg.create()
    with update(cg):
        cg.description = fauxfactory.gen_alphanumeric(32)
    cg.delete(cancel=False)
示例#42
0
def test_condition_crud(condition):
    # CR
    condition.create()
    # U
    with update(condition):
        condition.notes = "Modified!"
    # D
    condition.delete()
def test_edit_compute_chargeback(chargeback_compute_rate):
    chargeback_compute_rate.create()
    with update(chargeback_compute_rate):
        chargeback_compute_rate.description = chargeback_compute_rate.description + "-edited"
        chargeback_compute_rate.fields = {
            'Fixed Compute Cost 1': with_random_per_time(fixed_rate='500'),
            'Allocated CPU Count': with_random_per_time(fixed_rate='100'),
        }
示例#44
0
def test_tag_crud(category):
    tag = Tag(name=fauxfactory.gen_alphanumeric(8).lower(),
              display_name=fauxfactory.gen_alphanumeric(32),
              category=category)
    tag.create()
    with update(tag):
        tag.display_name = fauxfactory.gen_alphanumeric(32)
    tag.delete(cancel=False)
def test_update_service_dialog():
    dialog = ServiceDialog(label=rand.generate_random_string(),
                           description="my dialog",
                           submit=True,
                           cancel=True)
    dialog.create()
    with update(dialog):
        dialog.description = "my edited description"
def test_provision_from_template_with_attached_disks(
        request, setup_provider, provider, vm_name, provisioning,
        disks, soft_assert, domain, modified_request_class, copy_domains):
    """ Tests provisioning from a template and attaching disks

    Metadata:
        test_flag: provision
    """
    image = provisioning['image']['name']
    note = ('Testing provisioning from image {} to vm {} on provider {}'.format(
        image, vm_name, provider.key))

    DEVICE_NAME = "/dev/sd{}"
    device_mapping = []

    with provider.mgmt.with_volumes(1, n=disks) as volumes:
        for i, volume in enumerate(volumes):
            device_mapping.append((volume, DEVICE_NAME.format(chr(ord("b") + i))))
        # Set up automate

        method = modified_request_class.methods.instantiate(name="openstack_PreProvision")

        with update(method):
            disk_mapping = []
            for mapping in device_mapping:
                disk_mapping.append(ONE_FIELD.format(*mapping))
            method.script = VOLUME_METHOD.format(", ".join(disk_mapping))

        def _finish_method():
            with update(method):
                method.script = """prov = $evm.root["miq_provision"]"""
        request.addfinalizer(_finish_method)
        instance = Instance.factory(vm_name, provider, image)
        request.addfinalizer(instance.delete_from_provider)
        inst_args = {
            'email': '*****@*****.**',
            'first_name': 'Image',
            'last_name': 'Provisioner',
            'notes': note,
            'instance_type': provisioning['instance_type'],
            "availability_zone": provisioning["availability_zone"] if provider.type != "azure" else
            provisioning["av_set"],
            'security_groups': [provisioning['security_group']],
            'guest_keypair': provisioning['guest_keypair']
        }

        if isinstance(provider, OpenStackProvider):
            inst_args['cloud_network'] = provisioning['cloud_network']

        instance.create(**inst_args)

        for volume_id in volumes:
            soft_assert(vm_name in provider.mgmt.volume_attachments(volume_id))
        for volume, device in device_mapping:
            soft_assert(provider.mgmt.volume_attachments(volume)[vm_name] == device)
        instance.delete_from_provider()  # To make it possible to delete the volume
        wait_for(lambda: not instance.does_vm_exist_on_provider(), num_sec=180, delay=5)
def test_provision_with_boot_volume(request, setup_provider, provider, vm_name,
        soft_assert, domain, copy_domains, provisioning, modified_request_class):
    """ Tests provisioning from a template and attaching one booting volume.

    Metadata:
        test_flag: provision, volumes
    """
    image = provisioning['image']['name']
    note = ('Testing provisioning from image {} to vm {} on provider {}'.format(
        image, vm_name, provider.key))

    with provider.mgmt.with_volume(1, imageRef=provider.mgmt.get_template_id(image)) as volume:
        # Set up automate
        method = modified_request_class.methods.instantiate(name="openstack_CustomizeRequest")
        with update(method):
            method.script = dedent('''\
                $evm.root["miq_provision"].set_option(
                    :clone_options, {{
                        :image_ref => nil,
                        :block_device_mapping_v2 => [{{
                            :boot_index => 0,
                            :uuid => "{}",
                            :device_name => "vda",
                            :source_type => "volume",
                            :destination_type => "volume",
                            :delete_on_termination => false
                        }}]
                    }}
                )
            '''.format(volume))

        @request.addfinalizer
        def _finish_method():
            with update(method):
                method.script = """prov = $evm.root["miq_provision"]"""
        instance = Instance.factory(vm_name, provider, image)
        request.addfinalizer(instance.delete_from_provider)
        inst_args = {
            'email': '*****@*****.**',
            'first_name': 'Image',
            'last_name': 'Provisioner',
            'notes': note,
            'instance_type': provisioning['instance_type'],
            "availability_zone": provisioning["availability_zone"],
            'security_groups': [provisioning['security_group']],
            'guest_keypair': provisioning['guest_keypair']
        }

        if isinstance(provider, OpenStackProvider):
            inst_args['cloud_network'] = provisioning['cloud_network']

        instance.create(**inst_args)

        soft_assert(vm_name in provider.mgmt.volume_attachments(volume))
        soft_assert(provider.mgmt.volume_attachments(volume)[vm_name] == "vda")
        instance.delete_from_provider()  # To make it possible to delete the volume
        wait_for(lambda: not instance.does_vm_exist_on_provider(), num_sec=180, delay=5)
def test_host_analysis_profile_crud():
    """CRUD for Host analysis profiles."""
    p = HostAnalysisProfile(fauxfactory.gen_alphanumeric(),
                            fauxfactory.gen_alphanumeric(),
                            files=["asdf", "dfg"])
    p.create()
    with update(p):
        p.files = ["qwer"]
    p.delete()
示例#49
0
def test_provider_crud(provider):
    """ Tests provider add with good credentials

    Metadata:
        test_flag: crud
    """
    provider.create()
    provider.validate_stats(ui=True)

    old_name = provider.name
    with update(provider):
        provider.name = str(uuid.uuid4())  # random uuid

    with update(provider):
        provider.name = old_name  # old name

    provider.delete(cancel=False)
    provider.wait_for_delete()
def test_orchestration_template_crud(provisioning):
    template_type = provisioning['stack_provisioning']['template_type']
    template = OrchestrationTemplate(template_type=template_type,
                                     template_name=fauxfactory.gen_alphanumeric(),
                                     description="my template")
    template.create(METHOD_TORSO)
    with update(template):
        template.description = "my edited description"
    template.delete()
示例#51
0
def test_method_crud(request, klass):
    method = klass.methods.create(
        name=fauxfactory.gen_alphanumeric(),
        display_name=fauxfactory.gen_alphanumeric(),
        location='inline',
        script='$evm.log(:info, ":P")',
    )
    assert method.exists
    origname = method.name
    with update(method):
        method.name = fauxfactory.gen_alphanumeric(8)
        method.script = "bar"
    assert method.exists
    with update(method):
        method.name = origname
    assert method.exists
    method.delete()
    assert not method.exists
示例#52
0
def test_policy_crud(policy_class):
    policy = policy_class(fauxfactory.gen_alphanumeric())
    # CR
    policy.create()
    # U
    with update(policy):
        policy.notes = "Modified!"
    # D
    policy.delete()
示例#53
0
def test_edit_storage_chargeback():
    scb = new_storage_rate()
    scb.create()
    with update(scb):
        scb.description = scb.description + "-edited"
        scb.storage_fixed_2 = (2000, cb.MONTHLY)
        scb.storage_alloc = (3000, cb.WEEKLY)
        scb.storage_used = (6000, cb.MONTHLY)
    flash.assert_message_match('Chargeback Rate "%s" was saved' % scb.description)
示例#54
0
def test_policy_profile_crud(random_vm_control_policy,
                             random_host_control_policy):
    profile = policy_profiles.PolicyProfile(
        fauxfactory.gen_alphanumeric(),
        policies=[random_vm_control_policy, random_host_control_policy])
    profile.create()
    with update(profile):
        profile.notes = "Modified!"
    profile.delete()
示例#55
0
def test_edit_storage_chargeback():
    scb = new_storage_rate()
    scb.create()
    with update(scb):
        scb.description = scb.description + "-edited"
        scb.fields = {'Fixed Storage Cost 1':
                      {'per_time': random.choice(per_time), 'fixed_rate': '500'},
                      'Allocated Disk Storage':
                      {'per_time': random.choice(per_time), 'fixed_rate': '100'}}
示例#56
0
def test_edit_compute_chargeback():
    ccb = new_compute_rate()
    ccb.create()
    with update(ccb):
        ccb.description = ccb.description + "-edited"
        ccb.fields = {'Fixed Compute Cost 1':
                      {'per_time': random.choice(per_time), 'fixed_rate': '500'},
                      'Allocated CPU Count':
                      {'per_time': random.choice(per_time), 'fixed_rate': '100'}}
示例#57
0
def test_provision_with_additional_volume(request, testing_instance, provider, soft_assert,
                                          copy_domains, domain, modified_request_class):
    """ Tests provisioning with setting specific image from AE and then also making it create and
    attach an additional 3G volume.

    Metadata:
        test_flag: provision, volumes
    """
    instance, inst_args, image = testing_instance

    # Set up automate
    method = modified_request_class.methods.instantiate(name="openstack_CustomizeRequest")
    try:
        image_id = provider.mgmt.get_template_id(provider.data["small_template"])
    except KeyError:
        pytest.skip("No small_template in provider adta!")
    with update(method):
        method.script = dedent('''\
            $evm.root["miq_provision"].set_option(
              :clone_options, {{
                :image_ref => nil,
                :block_device_mapping_v2 => [{{
                  :boot_index => 0,
                  :uuid => "{}",
                  :device_name => "vda",
                  :source_type => "image",
                  :destination_type => "volume",
                  :volume_size => 3,
                  :delete_on_termination => false
                }}]
              }}
        )
        '''.format(image_id))

    def _finish_method():
        with update(method):
            method.script = """prov = $evm.root["miq_provision"]"""
    request.addfinalizer(_finish_method)

    instance.create(**inst_args)

    prov_instance = provider.mgmt._find_instance_by_name(vm_name)
    try:
        assert hasattr(prov_instance, 'os-extended-volumes:volumes_attached')
        volumes_attached = getattr(prov_instance, 'os-extended-volumes:volumes_attached')
        assert len(volumes_attached) == 1
        volume_id = volumes_attached[0]["id"]
        assert provider.mgmt.volume_exists(volume_id)
        volume = provider.mgmt.get_volume(volume_id)
        assert volume.size == 3
    finally:
        instance.delete_from_provider()
        wait_for(lambda: not instance.does_vm_exist_on_provider(), num_sec=180, delay=5)
        if "volume_id" in locals():  # To handle the case of 1st or 2nd assert
            if provider.mgmt.volume_exists(volume_id):
                provider.mgmt.delete_volume(volume_id)
def modify_instance(create_domain):
    """Modify the instance in new domain to change it to manual approval instead of auto"""

    instance = create_domain.namespaces.instantiate(name='Service')\
        .namespaces.instantiate(name='Provisioning')\
        .namespaces.instantiate(name='StateMachines')\
        .classes.instantiate(name='ServiceProvisionRequestApproval')\
        .instances.instantiate(name='Default')
    with update(instance):
        instance.fields = {"approval_type ": {"value": "manual"}}
示例#59
0
def test_provider_crud(provider):
    """Tests provider add with good credentials

    Metadata:
        test_flag: crud
    """
    provider.create()
    # Fails on upstream, all provider types - BZ1087476
    provider.validate(db=False)

    old_name = provider.name
    with update(provider):
        provider.name = str(uuid.uuid4())  # random uuid

    with update(provider):
        provider.name = old_name  # old name

    provider.delete(cancel=False)
    provider.wait_for_delete()
示例#60
0
def test_button_group_crud(request):
    buttongroup = ButtonGroup(text=fauxfactory.gen_alphanumeric(),
                              hover="btn_hvr",
                              type=ButtonGroup.SERVICE)
    request.addfinalizer(buttongroup.delete_if_exists)
    buttongroup.create()
    with update(buttongroup):
        buttongroup.hover = "edit_desc_{}".format(
            fauxfactory.gen_alphanumeric())
    buttongroup.delete()