Esempio n. 1
0
def create_method(request, copy_domain):
    method = Method(name="InspectMe",
                    data=METHOD_TORSO,
                    cls=Class(name="Request",
                              namespace=Namespace(name="System",
                                                  parent=copy_domain)))
    method.create()
    return method
def create_method(request, copy_domain):
    method = Method(
        name="InspectMe",
        data=METHOD_TORSO,
        cls=Class(
            name="Request",
            namespace=Namespace(
                name="System",
                parent=copy_domain
            )
        )
    )
    method.create()
    return method
def original_method(request, original_method_write_data):
    method = Method(
        name=generate_random_string(),
        data=METHOD_TORSO.format(original_method_write_data),
        cls=Class(
            name="Request",
            namespace=Namespace(
                name="System",
                parent=Domain.default
            )
        )
    )
    method.create()
    request.addfinalizer(lambda: method.delete() if method.exists() else None)
    return method
def create_method(request, copy_domain):
    method = Method(
        name="InspectMe",
        data=METHOD_TORSO,
        cls=Class(
            name="Request",
            namespace=Namespace(
                name="System",
                parent=copy_domain
            )
        )
    )
    method.create()
    request.addfinalizer(lambda: method.delete() if method.exists() else None)
    return method
def test_add_vm_to_service(myservice, request, copy_domain):
    """Tests adding vm to service

    Metadata:
        test_flag: provision
    """
    method_torso = """
    def add_to_service
        vm      = $evm.root['vm']
        service = $evm.vmdb('service').find_by_name('{}')
        user    = $evm.root['user']

    if service && vm
        $evm.log('info', "XXXXXXXX Attaching Service to VM: [#{{service.name}}][#{{vm.name}}]")
        vm.add_to_service(service)
        vm.owner = user if user
        vm.group = user.miq_group if user
    end
    end

    $evm.log("info", "Listing Root Object Attributes:")
    $evm.log("info", "===========================================")

    add_to_service
    """.format(myservice.service_name)

    method = Method(
        name="InspectMe",
        data=method_torso,
        cls=Class(
            name="Request",
            namespace=Namespace(
                name="System",
                parent=copy_domain
            )
        )
    )
    method.create()
    request.addfinalizer(lambda: method.delete() if method.exists() else None)
    simulate(
        instance="Request",
        message="create",
        request=method.name,
        attribute=["VM and Instance", "auto_test_services"],  # Random selection, does not matter
        execute_methods=True
    )
    myservice.check_vm_add("auto_test_services")
    request.addfinalizer(lambda: myservice.delete(myservice.service_name))
Esempio n. 6
0
def test_create_snapshot_via_ae(request, domain, test_vm):
    """This test checks whether the vm.create_snapshot works in AE.

    Prerequisities:
        * A VMware provider
        * A VM that has been discovered by CFME

    Steps:
        * Clone the Request class inside the System namespace into a new domain
        * Add a method named ``snapshot`` and insert the provided code there.
        * Add an instance named ``snapshot`` and set the methd from previous step
            as ``meth5``
        * Run the simulation of the method against the VM, preferably setting
            ``snap_name`` to something that can be checked
        * Wait until snapshot with such name appears.
    """
    # PREPARE
    file = data_path.join("ui").join("automate").join(
        "test_create_snapshot_via_ae.rb")
    with file.open("r") as f:
        method_contents = f.read()
    miq_domain = Domain("ManageIQ (Locked)")
    miq_class = Class("Request",
                      namespace=Namespace("System", domain=miq_domain))
    request_cls = miq_class.copy_to(domain)
    request.addfinalizer(request_cls.delete)
    method = Method("snapshot", data=method_contents, cls=request_cls)
    method.create()
    request.addfinalizer(method.delete)
    instance = Instance("snapshot",
                        values={"meth5": "snapshot"},
                        cls=request_cls)
    instance.create()
    request.addfinalizer(instance.delete)

    # SIMULATE
    snap_name = fauxfactory.gen_alpha()
    snapshot = Vm.Snapshot(name=snap_name, parent_vm=test_vm)
    simulate(instance="Request",
             request="snapshot",
             attribute=["VM and Instance", test_vm.name],
             execute_methods=True,
             avp={"snap_name": snap_name})

    wait_for(snapshot.does_snapshot_exist, timeout="2m", delay=10)

    # Clean up if it appeared
    snapshot.delete()
Esempio n. 7
0
def test_create_snapshot_via_ae(request, domain, test_vm):
    """This test checks whether the vm.create_snapshot works in AE.

    Prerequisities:
        * A VMware provider
        * A VM that has been discovered by CFME

    Steps:
        * Clone the Request class inside the System namespace into a new domain
        * Add a method named ``snapshot`` and insert the provided code there.
        * Add an instance named ``snapshot`` and set the methd from previous step
            as ``meth5``
        * Run the simulation of the method against the VM, preferably setting
            ``snap_name`` to something that can be checked
        * Wait until snapshot with such name appears.
    """
    # PREPARE
    file = data_path.join("ui").join("automate").join("test_create_snapshot_via_ae.rb")
    with file.open("r") as f:
        method_contents = f.read()
    miq_domain = Domain("ManageIQ (Locked)")
    miq_class = Class("Request", namespace=Namespace("System", domain=miq_domain))
    request_cls = miq_class.copy_to(domain)
    request.addfinalizer(request_cls.delete)
    method = Method("snapshot", data=method_contents, cls=request_cls)
    method.create()
    request.addfinalizer(method.delete)
    instance = Instance("snapshot", values={"meth5": "snapshot"}, cls=request_cls)
    instance.create()
    request.addfinalizer(instance.delete)

    # SIMULATE
    snap_name = fauxfactory.gen_alpha()
    snapshot = Vm.Snapshot(name=snap_name, parent_vm=test_vm)
    simulate(
        instance="Request",
        request="snapshot",
        attribute=["VM and Instance", test_vm.name],
        execute_methods=True,
        avp={"snap_name": snap_name},
    )

    wait_for(snapshot.does_snapshot_exist, timeout="2m", delay=10)

    # Clean up if it appeared
    snapshot.delete()
Esempio n. 8
0
def original_method(request, original_method_write_data, original_domain):
    method = Method(
        name=fauxfactory.gen_alphanumeric(),
        data=METHOD_TORSO.format(original_method_write_data),
        cls=Class(
            name="Request",
            namespace=Namespace(
                name="System",
                parent=original_domain
            ),
            setup_schema=[Class.SchemaField(name="meth5",
                                            type_="Method")]
        )
    )
    method.create()
    request.addfinalizer(lambda: method.delete() if method.exists() else None)
    return method
Esempio n. 9
0
def original_method(request, original_method_write_data, original_domain, original_class):
    method = Method(
        name=fauxfactory.gen_alphanumeric(),
        data=METHOD_TORSO.format(original_method_write_data),
        cls=original_class,
    )
    method.create()
    request.addfinalizer(lambda: method.delete() if method.exists() else None)
    return method
def original_method(request, original_method_write_data, original_domain):
    method = Method(name=fauxfactory.gen_alphanumeric(),
                    data=METHOD_TORSO.format(original_method_write_data),
                    cls=Class(name="Request",
                              namespace=Namespace(name="System",
                                                  parent=original_domain),
                              setup_schema=[
                                  Class.SchemaField(name="meth5",
                                                    type_="Method")
                              ]))
    method.create()
    request.addfinalizer(lambda: method.delete() if method.exists() else None)
    return method
Esempio n. 11
0
def test_add_vm_to_service(myservice, request, copy_domain):
    """Tests adding vm to service

    Metadata:
        test_flag: provision
    """
    method_torso = """
    def add_to_service
        vm      = $evm.root['vm']
        service = $evm.vmdb('service').find_by_name('%s')
        user    = $evm.root['user']

    if service && vm
        $evm.log('info', "XXXXXXXX Attaching Service to VM: [#{service.name}][#{vm.name}]")
        vm.add_to_service(service)
        vm.owner = user if user
        vm.group = user.miq_group if user
    end
    end

    $evm.log("info", "Listing Root Object Attributes:")
    $evm.log("info", "===========================================")

    add_to_service
    """ % myservice.service_name

    method = Method(
        name="InspectMe",
        data=method_torso,
        cls=Class(
            name="Request",
            namespace=Namespace(
                name="System",
                parent=copy_domain
            )
        )
    )
    method.create()
    request.addfinalizer(lambda: method.delete() if method.exists() else None)
    simulate(
        instance="Request",
        message="create",
        request=method.name,
        attribute=["VM and Instance", "auto_test_services"],  # Random selection, does not matter
        execute_methods=True
    )
    myservice.check_vm_add("auto_test_services")
    request.addfinalizer(lambda: myservice.delete(myservice.service_name))
def test_vmware_vimapi_hotadd_disk(
        request, testing_group, provider, testing_vm, domain, cls):
    """ Tests hot adding a disk to vmware vm.

    This test exercises the ``VMware_HotAdd_Disk`` method, located in ``/Integration/VMware/VimApi``

    Steps:
        * It creates an instance in ``System/Request`` that can be accessible from eg. a button.
        * Then it creates a service dialog that contains a field with the desired disk size, the
            text field name should be ``size``
        * Then it creates a button, that refers to the ``VMware_HotAdd_Disk`` in ``Request``. The
            button shall belong in the VM and instance button group.
        * After the button is created, it goes to a VM's summary page, clicks the button, enters
            the size of the disk and submits the dialog.
        * The test waits until the number of disks is raised.

    Metadata:
        test_flag: hotdisk, provision
    """
    meth = Method(
        name='parse_dialog_value_{}'.format(fauxfactory.gen_alpha()),
        data=dedent('''\
            # Transfers the dialog value to the root so the VMware method can use it.

            $evm.root['size'] = $evm.object['dialog_size']
            exit MIQ_OK
            '''),
        cls=cls)

    @request.addfinalizer
    def _remove_method():
        if meth.exists():
            meth.delete()

    meth.create()

    # Instance that calls the method and is accessible from the button
    instance = Instance(
        name="VMware_HotAdd_Disk_{}".format(fauxfactory.gen_alpha()),
        values={
            "meth4": {'on_entry': meth.name},  # To preparse the value
            "rel5": "/Integration/VMware/VimApi/VMware_HotAdd_Disk",
        },
        cls=cls
    )

    @request.addfinalizer
    def _remove_instance():
        if instance.exists():
            instance.delete()
    instance.create()
    # Dialog to put the disk capacity
    element_data = {
        'ele_label': "Disk size",
        'ele_name': "size",
        'ele_desc': "Disk size",
        'choose_type': "Text Box",
        'default_text_box': "Default text"
    }
    dialog = ServiceDialog(
        label=fauxfactory.gen_alphanumeric(),
        description=fauxfactory.gen_alphanumeric(),
        submit=True,
        tab_label=fauxfactory.gen_alphanumeric(),
        tab_desc=fauxfactory.gen_alphanumeric(),
        box_label=fauxfactory.gen_alphanumeric(),
        box_desc=fauxfactory.gen_alphanumeric(),
    )
    dialog.create(element_data)
    request.addfinalizer(dialog.delete)
    # Button that will invoke the dialog and action
    button_name = fauxfactory.gen_alphanumeric()
    button = Button(group=testing_group,
                    text=button_name,
                    hover=button_name,
                    dialog=dialog, system="Request", request=instance.name)
    request.addfinalizer(button.delete_if_exists)
    button.create()

    def _get_disk_count():
        return int(testing_vm.get_detail(
            properties=("Datastore Allocation Summary", "Number of Disks")).strip())
    original_disk_count = _get_disk_count()
    logger.info('Initial disk count: %s', original_disk_count)
    toolbar.select(testing_group.text, button.text)
    fill(Input("size"), '1')
    pytest.sel.click(submit)
    flash.assert_no_errors()
    try:
        wait_for(
            lambda: original_disk_count + 1 == _get_disk_count(), num_sec=180, delay=5)
    finally:
        logger.info('End disk count: %s', _get_disk_count())
Esempio n. 13
0
def test_vmware_vimapi_hotadd_disk(
        request, testing_group, provider, testing_vm, domain, cls):
    """ Tests hot adding a disk to vmware vm.

    This test exercises the ``VMware_HotAdd_Disk`` method, located in ``/Integration/VMware/VimApi``

    Steps:
        * It creates an instance in ``System/Request`` that can be accessible from eg. a button.
        * Then it creates a button, that refers to the ``VMware_HotAdd_Disk`` in ``Request``. The
            button shall belong in the VM and instance button group.
        * After the button is created, it goes to a VM's summary page, clicks the button.
        * The test waits until the capacity of disks is raised.

    Metadata:
        test_flag: hotdisk, provision
    """
    meth = Method(
        name='load_value_{}'.format(fauxfactory.gen_alpha()),
        data=dedent('''\
            # Sets the capacity of the new disk.

            $evm.root['size'] = 1  # GB
            exit MIQ_OK
            '''),
        cls=cls)

    @request.addfinalizer
    def _remove_method():
        if meth.exists():
            meth.delete()

    meth.create()

    # Instance that calls the method and is accessible from the button
    instance = Instance(
        name="VMware_HotAdd_Disk_{}".format(fauxfactory.gen_alpha()),
        values={
            "meth4": meth.name,  # To get the value
            "rel5": "/Integration/VMware/VimApi/VMware_HotAdd_Disk",
        },
        cls=cls
    )

    @request.addfinalizer
    def _remove_instance():
        if instance.exists():
            instance.delete()
    instance.create()

    # Button that will invoke the dialog and action
    button_name = fauxfactory.gen_alphanumeric()
    button = Button(group=testing_group,
                    text=button_name,
                    hover=button_name, system="Request", request=instance.name)
    request.addfinalizer(button.delete_if_exists)
    button.create()

    def _get_disk_capacity():
        testing_vm.summary.reload()
        return testing_vm.summary.datastore_allocation_summary.total_allocation.value

    original_disk_capacity = _get_disk_capacity()
    logger.info('Initial disk allocation: %s', original_disk_capacity)
    toolbar.select(testing_group.text, button.text)
    flash.assert_no_errors()
    try:
        wait_for(
            lambda: _get_disk_capacity() > original_disk_capacity, num_sec=180, delay=5)
    finally:
        logger.info('End disk capacity: %s', _get_disk_capacity())
Esempio n. 14
0
def test_vmware_vimapi_hotadd_disk(request, testing_group, provider,
                                   testing_vm, domain, cls):
    """ Tests hot adding a disk to vmware vm.

    This test exercises the ``VMware_HotAdd_Disk`` method, located in ``/Integration/VMware/VimApi``

    Steps:
        * It creates an instance in ``System/Request`` that can be accessible from eg. a button.
        * Then it creates a service dialog that contains a field with the desired disk size, the
            text field name should be ``size``
        * Then it creates a button, that refers to the ``VMware_HotAdd_Disk`` in ``Request``. The
            button shall belong in the VM and instance button group.
        * After the button is created, it goes to a VM's summary page, clicks the button, enters
            the size of the disk and submits the dialog.
        * The test waits until the number of disks is raised.

    Metadata:
        test_flag: hotdisk, provision
    """
    meth = Method(name='parse_dialog_value_{}'.format(fauxfactory.gen_alpha()),
                  data=dedent('''\
            # Transfers the dialog value to the root so the VMware method can use it.

            $evm.root['size'] = $evm.object['dialog_size']
            exit MIQ_OK
            '''),
                  cls=cls)

    @request.addfinalizer
    def _remove_method():
        if meth.exists():
            meth.delete()

    meth.create()

    # Instance that calls the method and is accessible from the button
    instance = Instance(
        name="VMware_HotAdd_Disk_{}".format(fauxfactory.gen_alpha()),
        values={
            "meth4": {
                'on_entry': meth.name
            },  # To preparse the value
            "rel5": "/Integration/VMware/VimApi/VMware_HotAdd_Disk",
        },
        cls=cls)

    @request.addfinalizer
    def _remove_instance():
        if instance.exists():
            instance.delete()

    instance.create()
    # Dialog to put the disk capacity
    element_data = {
        'ele_label': "Disk size",
        'ele_name': "size",
        'ele_desc': "Disk size",
        'choose_type': "Text Box",
        'default_text_box': "Default text"
    }
    dialog = ServiceDialog(
        label=fauxfactory.gen_alphanumeric(),
        description=fauxfactory.gen_alphanumeric(),
        submit=True,
        tab_label=fauxfactory.gen_alphanumeric(),
        tab_desc=fauxfactory.gen_alphanumeric(),
        box_label=fauxfactory.gen_alphanumeric(),
        box_desc=fauxfactory.gen_alphanumeric(),
    )
    dialog.create(element_data)
    request.addfinalizer(dialog.delete)
    # Button that will invoke the dialog and action
    button_name = fauxfactory.gen_alphanumeric()
    button = Button(group=testing_group,
                    text=button_name,
                    hover=button_name,
                    dialog=dialog,
                    system="Request",
                    request=instance.name)
    request.addfinalizer(button.delete_if_exists)
    button.create()

    def _get_disk_count():
        return int(
            testing_vm.get_detail(properties=("Datastore Allocation Summary",
                                              "Number of Disks")).strip())

    original_disk_count = _get_disk_count()
    logger.info('Initial disk count: {}'.format(original_disk_count))
    toolbar.select(testing_group.text, button.text)
    fill(Input("size"), '1')
    pytest.sel.click(submit)
    flash.assert_no_errors()
    try:
        wait_for(lambda: original_disk_count + 1 == _get_disk_count(),
                 num_sec=180,
                 delay=5)
    finally:
        logger.info('End disk count: {}'.format(_get_disk_count()))
Esempio n. 15
0
def a_method(a_class):
    return Method(name=fauxfactory.gen_alphanumeric(8),
                  data="foo.bar()",
                  cls=a_class)
Esempio n. 16
0
def a_method(a_class):
    return Method(name=generate_random_string(8),
                  data="foo.bar()",
                  cls=a_class)