def test_filter_save_and_load_cancel(request, providers, ssh_client):
    pytest.sel.force_navigate("infrastructure_providers")
    filter_name = fauxfactory.gen_alphanumeric()
    # Set up finalizer
    request.addfinalizer(
        lambda: ssh_client.run_rails_command(
            "\"MiqSearch.where(:description => {}).first.delete\"".format(repr(filter_name))))
    # Try save filter
    search.save_filter("fill_count(Infrastructure Provider.VMs, >)", filter_name)

    @request.addfinalizer
    def cleanup():
        pytest.sel.force_navigate("infrastructure_providers")
        search.load_filter(filter_name)
        search.delete_filter()

    assert_no_cfme_exception()
    search.reset_filter()

    search.load_and_apply_filter(
        filter_name,
        fill_callback={"COUNT": 0},
        cancel_on_user_filling=True
    )
    assert_no_cfme_exception()
def test_filter_save_cancel(vms, subset_of_vms, expression_for_vms_subset):
    pytest.sel.force_navigate("infra_vms")
    filter_name = fauxfactory.gen_alphanumeric()
    # Set up the filter
    search.save_filter("fill_field(Virtual Machine : Name, =)", filter_name, cancel=True)
    assert_no_cfme_exception()
    with pytest.raises(pytest.sel.NoSuchElementException):
        search.load_filter(filter_name)  # does not exist
def test_filter_save_cancel(hosts, hosts_with_vm_count, host_with_median_vm):
    sel.force_navigate("infrastructure_hosts")
    median_host, median_vm_count = host_with_median_vm
    filter_name = generate_random_string()
    # Try save filter
    search.save_filter("fill_count(Host.VMs, >)", filter_name, cancel=True)
    assert_no_cfme_exception()
    with pytest.raises(sel.NoSuchElementException):
        search.load_filter(filter_name)  # does not exist
Ejemplo n.º 4
0
def test_filter_save_cancel(hosts, hosts_with_vm_count, host_with_median_vm):
    pytest.sel.force_navigate("infrastructure_hosts")
    median_host, median_vm_count = host_with_median_vm
    filter_name = fauxfactory.gen_alphanumeric()
    # Try save filter
    search.save_filter(get_expression(True), filter_name, cancel=True)
    assert_no_cfme_exception()
    with pytest.raises(pytest.sel.NoSuchElementException):
        search.load_filter(filter_name)  # does not exist
def test_delete_button_should_appear_after_save(single_provider, rails_delete_filter):
    """Delete button appears only after load, not after save"""
    # bind filter_name to the function for fixture cleanup
    test_delete_button_should_appear_after_save.filter_name = fauxfactory.gen_alphanumeric()
    search.save_filter("fill_count(Infrastructure Provider.VMs, >, 0)",
                       test_delete_button_should_appear_after_save.filter_name)

    if not search.delete_filter():  # Returns False if the button is not present
        pytest.fail("Could not delete filter right after saving!")
def test_filter_save_cancel(request, providers, ssh_client):
    pytest.sel.force_navigate("infrastructure_providers")
    filter_name = fauxfactory.gen_alphanumeric()
    # Set up finalizer
    request.addfinalizer(
        lambda: ssh_client.run_rails_command(
            "\"MiqSearch.where(:description => {}).first.delete\"".format(repr(filter_name))))
    # Try save filter
    search.save_filter("fill_count(Infrastructure Provider.VMs, >)", filter_name, cancel=True)
    assert_no_cfme_exception()
    with pytest.raises(pytest.sel.NoSuchElementException):
        search.load_filter(filter_name)  # does not exist
Ejemplo n.º 7
0
def test_can_delete_filter():
    pytest.sel.force_navigate("infrastructure_hosts")
    filter_name = fauxfactory.gen_alphanumeric()
    search.save_filter(get_expression(False).format(0), filter_name)
    assert_no_cfme_exception()
    search.reset_filter()
    assert_no_cfme_exception()
    search.load_filter(filter_name)
    assert_no_cfme_exception()
    if not search.delete_filter():
        raise pytest.fail("Cannot delete filter! Probably the delete button is not present!")
    assert_no_cfme_exception()
def test_can_delete_filter():
    sel.force_navigate("infrastructure_hosts")
    filter_name = generate_random_string()
    search.save_filter("fill_count(Host.VMs, >, 0)", filter_name)
    assert_no_cfme_exception()
    search.reset_filter()
    assert_no_cfme_exception()
    search.load_filter(filter_name)
    assert_no_cfme_exception()
    if not search.delete_filter():
        raise pytest.fail("Cannot delete filter! Probably the delete button is not present!")
    assert_no_cfme_exception()
def test_filter_save_cancel(vms, subset_of_vms, expression_for_vms_subset):
    navigate_to(Vm, 'VMsOnly')
    filter_name = fauxfactory.gen_alphanumeric()
    # Set up the filter
    search.save_filter(
        "fill_field(Virtual Machine : Name, =)",
        filter_name,
        cancel=True
    )
    assert_no_cfme_exception()
    with pytest.raises(search.DisabledButtonException):
        search.load_filter(filter_name)  # does not exist
def test_can_delete_filter():
    sel.force_navigate("infra_vms")
    filter_name = fauxfactory.gen_alphanumeric()
    search.save_filter("fill_count(Virtual Machine.Files, >, 0)", filter_name)
    assert_no_cfme_exception()
    search.reset_filter()
    assert_no_cfme_exception()
    search.load_filter(filter_name)
    assert_no_cfme_exception()
    if not search.delete_filter():
        raise pytest.fail("Cannot delete filter! Probably the delete button is not present!")
    assert_no_cfme_exception()
def test_can_delete_filter():
    pytest.sel.force_navigate("infrastructure_providers")
    filter_name = fauxfactory.gen_alphanumeric()
    search.save_filter("fill_count(Infrastructure Provider.VMs, >, 0)", filter_name)
    assert_no_cfme_exception()
    search.reset_filter()
    assert_no_cfme_exception()
    search.load_filter(filter_name)
    assert_no_cfme_exception()
    if not search.delete_filter():
        raise pytest.fail("Cannot delete filter! Probably the delete button is not present!")
    assert_no_cfme_exception()
def test_filter_save_and_load(request, vms, subset_of_vms, expression_for_vms_subset):
    sel.force_navigate("infra_vms")
    filter_name = fauxfactory.gen_alphanumeric()
    vm = sample(subset_of_vms, 1)[0]
    # Set up the filter
    search.save_filter("fill_field(Virtual Machine : Name, =)", filter_name)
    assert_no_cfme_exception()
    search.reset_filter()

    search.load_and_apply_filter(filter_name, fill_callback={"Virtual Machine": vm})
    assert_no_cfme_exception()
    request.addfinalizer(search.delete_filter)
    assert vm in virtual_machines.get_all_vms(do_not_navigate=True)
def test_delete_button_should_appear_after_save(request):
    """Delete button appears only after load, not after save"""
    sel.force_navigate("infrastructure_hosts")
    filter_name = generate_random_string()
    search.save_filter("fill_count(Host.VMs, >, 0)", filter_name)

    def cleanup():
        search.load_filter(filter_name)
        search.delete_filter()

    request.addfinalizer(cleanup)
    if not search.delete_filter():  # Returns False if the button is not present
        pytest.fail("Could not delete filter right after saving!")
def test_delete_button_should_appear_after_save(request):
    """Delete button appears only after load, not after save"""
    pytest.sel.force_navigate("infrastructure_providers")
    filter_name = fauxfactory.gen_alphanumeric()
    search.save_filter("fill_count(Infrastructure Provider.VMs, >, 0)", filter_name)

    @request.addfinalizer
    def cleanup():
        pytest.sel.force_navigate("infrastructure_providers")
        search.load_filter(filter_name)
        search.delete_filter()

    if not search.delete_filter():  # Returns False if the button is not present
        pytest.fail("Could not delete filter right after saving!")
Ejemplo n.º 15
0
def test_delete_button_should_appear_after_save(request):
    """Delete button appears only after load, not after save"""
    pytest.sel.force_navigate("infrastructure_hosts")
    filter_name = fauxfactory.gen_alphanumeric()
    search.save_filter(get_expression(False).format(0), filter_name)

    @request.addfinalizer
    def cleanup():
        pytest.sel.force_navigate("infrastructure_hosts")
        search.load_filter(filter_name)
        search.delete_filter()

    if not search.delete_filter():  # Returns False if the button is not present
        pytest.fail("Could not delete filter right after saving!")
def test_delete_button_should_appear_after_save(request):
    """Delete button appears only after load, not after save"""
    sel.force_navigate("infra_vms")
    filter_name = fauxfactory.gen_alphanumeric()
    search.save_filter("fill_count(Virtual Machine.Files, >, 0)", filter_name)

    def cleanup():
        sel.force_navigate("infra_vms")
        search.load_filter(filter_name)
        search.delete_filter()

    request.addfinalizer(cleanup)
    if not search.delete_filter():  # Returns False if the button is not present
        pytest.fail("Could not delete filter right after saving!")
def test_filter_save_and_load(request, providers, ssh_client):
    sel.force_navigate("infrastructure_providers")
    filter_name = generate_random_string()
    # Set up finalizer
    request.addfinalizer(
        lambda: ssh_client.run_rails_command(
            "\"MiqSearch.where(:description => {}).first.delete\"".format(repr(filter_name))))
    # Try save filter
    search.save_filter("fill_count(Infrastructure Provider.VMs, >)", filter_name)
    assert_no_cfme_exception()
    search.reset_filter()

    search.load_and_apply_filter(filter_name, fill_callback={"COUNT": 0})
    assert_no_cfme_exception()
    request.addfinalizer(search.delete_filter)
def test_delete_button_should_appear_after_save(request):
    """Delete button appears only after load, not after save"""
    pytest.sel.force_navigate("infrastructure_providers")
    filter_name = fauxfactory.gen_alphanumeric()
    search.save_filter("fill_count(Infrastructure Provider.VMs, >, 0)",
                       filter_name)

    @request.addfinalizer
    def cleanup():
        pytest.sel.force_navigate("infrastructure_providers")
        search.load_filter(filter_name)
        search.delete_filter()

    if not search.delete_filter(
    ):  # Returns False if the button is not present
        pytest.fail("Could not delete filter right after saving!")
Ejemplo n.º 19
0
def test_filter_save_and_cancel_load(request):
    sel.force_navigate("infra_vms")
    filter_name = generate_random_string()
    # Set up the filter
    search.save_filter("fill_field(Virtual Machine : Name, =)", filter_name)

    def cleanup():
        search.load_filter(filter_name)
        search.delete_filter()

    request.addfinalizer(cleanup)
    assert_no_cfme_exception()
    search.reset_filter()

    search.load_filter(filter_name, cancel=True)
    assert_no_cfme_exception()
Ejemplo n.º 20
0
def test_filter_save_and_load(request, hosts, hosts_with_vm_count, host_with_median_vm):
    pytest.sel.force_navigate("infrastructure_hosts")
    median_host, median_vm_count = host_with_median_vm
    # We will filter out hosts with less than median VMs
    more_than_median_hosts = list(dropwhile(lambda h: h[1] <= median_vm_count, hosts_with_vm_count))

    filter_name = fauxfactory.gen_alphanumeric()
    # Try save filter
    search.save_filter(get_expression(True), filter_name)
    assert_no_cfme_exception()
    search.reset_filter()

    search.load_and_apply_filter(filter_name, fill_callback={"COUNT": median_vm_count})
    assert_no_cfme_exception()
    request.addfinalizer(search.delete_filter)
    assert len(more_than_median_hosts) == len(host.get_all_hosts(do_not_navigate=True))
def test_filter_save_and_load(request, providers, ssh_client):
    pytest.sel.force_navigate("infrastructure_providers")
    filter_name = fauxfactory.gen_alphanumeric()
    # Set up finalizer
    request.addfinalizer(lambda: ssh_client.run_rails_command(
        "\"MiqSearch.where(:description => {}).first.delete\"".format(
            repr(filter_name))))
    # Try save filter
    search.save_filter("fill_count(Infrastructure Provider.VMs, >)",
                       filter_name)
    assert_no_cfme_exception()
    search.reset_filter()

    search.load_and_apply_filter(filter_name, fill_callback={"COUNT": 0})
    assert_no_cfme_exception()
    request.addfinalizer(search.delete_filter)
def test_filter_save_and_load(request, hosts, hosts_with_vm_count, host_with_median_vm):
    navigate_to(Host, 'All')
    median_host, median_vm_count = host_with_median_vm
    # We will filter out hosts with less than median VMs
    more_than_median_hosts = list(dropwhile(lambda h: h[1] <= median_vm_count, hosts_with_vm_count))

    filter_name = fauxfactory.gen_alphanumeric()
    # Try save filter
    search.save_filter(get_expression(True), filter_name)
    assert_no_cfme_exception()
    search.reset_filter()

    search.load_and_apply_filter(filter_name, fill_callback={"COUNT": median_vm_count})
    assert_no_cfme_exception()
    request.addfinalizer(search.delete_filter)
    assert len(more_than_median_hosts) == len(host.get_all_hosts())
Ejemplo n.º 23
0
def test_filter_save_and_cancel_load(request):
    pytest.sel.force_navigate("infra_vms")
    filter_name = fauxfactory.gen_alphanumeric()
    # Set up the filter
    search.save_filter("fill_field(Virtual Machine : Name, =)", filter_name)

    @request.addfinalizer
    def cleanup():
        pytest.sel.force_navigate("infra_vms")
        search.load_filter(filter_name)
        search.delete_filter()

    assert_no_cfme_exception()
    search.reset_filter()

    search.load_filter(filter_name, cancel=True)
    assert_no_cfme_exception()
Ejemplo n.º 24
0
def test_filter_save_and_cancel_load(request):
    sel.force_navigate("infra_vms")
    filter_name = fauxfactory.gen_alphanumeric()
    # Set up the filter
    search.save_filter("fill_field(Virtual Machine : Name, =)", filter_name)

    def cleanup():
        sel.force_navigate("infra_vms")
        search.load_filter(filter_name)
        search.delete_filter()

    request.addfinalizer(cleanup)
    assert_no_cfme_exception()
    search.reset_filter()

    search.load_filter(filter_name, cancel=True)
    assert_no_cfme_exception()
def test_filter_save_and_cancel_load(request):
    navigate_to(Vm, 'VMsOnly')
    filter_name = fauxfactory.gen_alphanumeric()
    # Set up the filter
    search.save_filter("fill_field(Virtual Machine : Name, =)", filter_name)

    @request.addfinalizer
    def cleanup():
        navigate_to(Vm, 'VMsOnly')
        search.load_filter(filter_name)
        search.delete_filter()

    assert_no_cfme_exception()
    search.reset_filter()

    search.load_filter(filter_name, cancel=True)
    assert_no_cfme_exception()
def test_filter_save_and_cancel_load(request, hosts, hosts_with_vm_count, host_with_median_vm):
    sel.force_navigate("infrastructure_hosts")
    median_host, median_vm_count = host_with_median_vm

    filter_name = generate_random_string()
    # Try save filter
    search.save_filter("fill_count(Host.VMs, >)", filter_name)

    def cleanup():
        search.load_filter(filter_name)
        search.delete_filter()

    request.addfinalizer(cleanup)
    assert_no_cfme_exception()
    search.reset_filter()

    search.load_filter(filter_name, cancel=True)
    assert_no_cfme_exception()
Ejemplo n.º 27
0
def test_cannot_delete_more_than_once(request, nuke_browser_after_test):
    """When Delete button appars, it does not want to go away"""
    navigate_to(Host, 'All')
    filter_name = fauxfactory.gen_alphanumeric()
    search.save_filter(get_expression(False).format(0), filter_name)

    search.load_filter(filter_name)  # circumvent the thing happening in previous test
    # Delete once
    if not search.delete_filter():
        pytest.fail("Could not delete the filter even first time!")
    assert_no_cfme_exception()
    # Try it second time
    if search.delete_filter():  # If the button is there, it says True
        # This should not happen
        msg = "Delete twice accepted!"
        if is_cfme_exception():
            msg += " CFME Exception text: `{}`".format(cfme_exception_text())
        pytest.fail(msg)
Ejemplo n.º 28
0
def test_cannot_delete_more_than_once(request, nuke_browser_after_test):
    """When Delete button appars, it does not want to go away"""
    pytest.sel.force_navigate("infrastructure_hosts")
    filter_name = fauxfactory.gen_alphanumeric()
    search.save_filter(get_expression(False).format(0), filter_name)

    search.load_filter(filter_name)  # circumvent the thing happening in previous test
    # Delete once
    if not search.delete_filter():
        pytest.fail("Could not delete the filter even first time!")
    assert_no_cfme_exception()
    # Try it second time
    if search.delete_filter():  # If the button is there, it says True
        # This should not happen
        msg = "Delete twice accepted!"
        if is_cfme_exception():
            msg += " CFME Exception text: `{}`".format(cfme_exception_text())
        pytest.fail(msg)
def test_cannot_delete_more_than_once(request):
    """When Delete button appars, it does not want to go away"""
    sel.force_navigate("infra_vms")
    filter_name = fauxfactory.gen_alphanumeric()
    search.save_filter("fill_count(Virtual Machine.Files, >, 0)", filter_name)

    search.load_filter(filter_name)  # circumvent the thing happening in previous test
    # Delete once
    if not search.delete_filter():
        pytest.fail("Could not delete the filter even first time!")
    assert_no_cfme_exception()
    # Try it second time
    if search.delete_filter():  # If the button is there, it says True
        # This should not happen
        msg = "Delete twice accepted!"
        if is_cfme_exception():
            msg += " CFME Exception text: `{}`".format(cfme_exception_text())
        pytest.fail(msg)
def test_cannot_delete_more_than_once(request):
    """When Delete button appars, it does not want to go away"""
    sel.force_navigate("infrastructure_providers")
    filter_name = generate_random_string()
    search.save_filter("fill_count(Infrastructure Provider.VMs, >, 0)", filter_name)

    search.load_filter(filter_name)  # circumvent the thing happening in previous test
    # Delete once
    if not search.delete_filter():
        pytest.fail("Could not delete the filter even first time!")
    assert_no_cfme_exception()
    # Try it second time
    if search.delete_filter():  # If the button is there, it says True
        # This should not happen
        msg = "Delete twice accepted!"
        if is_cfme_exception():
            msg += " CFME Exception text: `{}`".format(cfme_exception_text())
        pytest.fail(msg)
def test_filter_save_and_load_cancel(request, vms, subset_of_vms):
    pytest.sel.force_navigate("infra_vms")
    filter_name = fauxfactory.gen_alphanumeric()
    vm = sample(subset_of_vms, 1)[0]
    # Set up the filter
    search.save_filter("fill_field(Virtual Machine : Name, =)", filter_name)

    @request.addfinalizer
    def cleanup():
        pytest.sel.force_navigate("infra_vms")
        search.load_filter(filter_name)
        search.delete_filter()

    assert_no_cfme_exception()
    search.reset_filter()

    search.load_and_apply_filter(filter_name, fill_callback={"Virtual Machine": vm}, cancel_on_user_filling=True)
    assert_no_cfme_exception()
Ejemplo n.º 32
0
def test_filter_save_and_cancel_load(request, hosts, hosts_with_vm_count, host_with_median_vm):
    pytest.sel.force_navigate("infrastructure_hosts")
    median_host, median_vm_count = host_with_median_vm

    filter_name = fauxfactory.gen_alphanumeric()
    # Try save filter
    search.save_filter(get_expression(True), filter_name)

    @request.addfinalizer
    def cleanup():
        pytest.sel.force_navigate("infrastructure_hosts")
        search.load_filter(filter_name)
        search.delete_filter()

    assert_no_cfme_exception()
    search.reset_filter()

    search.load_filter(filter_name, cancel=True)
    assert_no_cfme_exception()
Ejemplo n.º 33
0
def test_filter_save_and_cancel_load(request, hosts, hosts_with_vm_count, host_with_median_vm):
    navigate_to(Host, 'All')
    median_host, median_vm_count = host_with_median_vm

    filter_name = fauxfactory.gen_alphanumeric()
    # Try save filter
    search.save_filter(get_expression(True), filter_name)

    @request.addfinalizer
    def cleanup():
        navigate_to(Host, 'All')
        search.load_filter(filter_name)
        search.delete_filter()

    assert_no_cfme_exception()
    search.reset_filter()

    search.load_filter(filter_name, cancel=True)
    assert_no_cfme_exception()
Ejemplo n.º 34
0
def test_filter_save_and_cancel_load(request, hosts, hosts_with_vm_count,
                                     host_with_median_vm):
    sel.force_navigate("infrastructure_hosts")
    median_host, median_vm_count = host_with_median_vm

    filter_name = generate_random_string()
    # Try save filter
    search.save_filter("fill_count(Host.VMs, >)", filter_name)

    def cleanup():
        search.load_filter(filter_name)
        search.delete_filter()

    request.addfinalizer(cleanup)
    assert_no_cfme_exception()
    search.reset_filter()

    search.load_filter(filter_name, cancel=True)
    assert_no_cfme_exception()
Ejemplo n.º 35
0
def test_cannot_delete_more_than_once(request):
    """When Delete button appars, it does not want to go away"""
    sel.force_navigate("infrastructure_hosts")
    filter_name = generate_random_string()
    search.save_filter("fill_count(Host.VMs, >, 0)", filter_name)

    search.load_filter(
        filter_name)  # circumvent the thing happening in previous test
    # Delete once
    if not search.delete_filter():
        pytest.fail("Could not delete the filter even first time!")
    assert_no_cfme_exception()
    # Try it second time
    if search.delete_filter():  # If the button is there, it says True
        # This should not happen
        msg = "Delete twice accepted!"
        if is_cfme_exception():
            msg += " CFME Exception text: `{}`".format(cfme_exception_text())
        pytest.fail(msg)
def test_filter_save_and_load_cancel(request, hosts, hosts_with_vm_count, host_with_median_vm):
    sel.force_navigate("infrastructure_hosts")
    median_host, median_vm_count = host_with_median_vm

    filter_name = fauxfactory.gen_alphanumeric()
    # Try save filter
    search.save_filter(get_expression(True), filter_name)

    def cleanup():
        sel.force_navigate("infrastructure_hosts")
        search.load_filter(filter_name)
        search.delete_filter()

    request.addfinalizer(cleanup)
    assert_no_cfme_exception()
    search.reset_filter()

    search.load_and_apply_filter(filter_name, fill_callback={"COUNT": median_vm_count}, cancel_on_user_filling=True)
    assert_no_cfme_exception()
Ejemplo n.º 37
0
def test_filter_save_and_load_cancel(request, vms, subset_of_vms):
    sel.force_navigate("infra_vms")
    filter_name = generate_random_string()
    vm = pick(subset_of_vms, 1)[0]
    # Set up the filter
    search.save_filter("fill_field(Virtual Machine : Name, =)", filter_name)

    def cleanup():
        search.load_filter(filter_name)
        search.delete_filter()

    request.addfinalizer(cleanup)
    assert_no_cfme_exception()
    search.reset_filter()

    search.load_and_apply_filter(filter_name,
                                 fill_callback={"Virtual Machine": vm},
                                 cancel_on_user_filling=True)
    assert_no_cfme_exception()
def test_filter_save_and_load_cancel(request, vms, subset_of_vms):
    navigate_to(Vm, 'VMsOnly')
    filter_name = fauxfactory.gen_alphanumeric()
    vm = sample(subset_of_vms, 1)[0]
    # Set up the filter
    search.save_filter("fill_field(Virtual Machine : Name, =)", filter_name)

    @request.addfinalizer
    def cleanup():
        navigate_to(Vm, 'VMsOnly')
        search.load_filter(filter_name)
        search.delete_filter()

    assert_no_cfme_exception()
    search.reset_filter()

    search.load_and_apply_filter(filter_name,
                                 fill_callback={"Virtual Machine": vm},
                                 cancel_on_user_filling=True)
    assert_no_cfme_exception()
Ejemplo n.º 39
0
def test_filter_save_and_load(request, hosts, hosts_with_vm_count,
                              host_with_median_vm):
    sel.force_navigate("infrastructure_hosts")
    median_host, median_vm_count = host_with_median_vm
    # We will filter out hosts with less than median VMs
    more_than_median_hosts = list(
        dropwhile(lambda h: h[1] <= median_vm_count, hosts_with_vm_count))

    filter_name = generate_random_string()
    # Try save filter
    search.save_filter("fill_count(Host.VMs, >)", filter_name)
    assert_no_cfme_exception()
    search.reset_filter()

    search.load_and_apply_filter(filter_name,
                                 fill_callback={"COUNT": median_vm_count})
    assert_no_cfme_exception()
    request.addfinalizer(search.delete_filter)
    assert len(more_than_median_hosts) == len(
        host.get_all_hosts(do_not_navigate=True))
Ejemplo n.º 40
0
def test_filter_save_and_cancel_load(request, hosts, hosts_with_vm_count,
                                     host_with_median_vm):
    sel.force_navigate("infrastructure_hosts")
    median_host, median_vm_count = host_with_median_vm

    filter_name = fauxfactory.gen_alphanumeric()
    # Try save filter
    search.save_filter(get_expression(True), filter_name)

    def cleanup():
        sel.force_navigate("infrastructure_hosts")
        search.load_filter(filter_name)
        search.delete_filter()

    request.addfinalizer(cleanup)
    assert_no_cfme_exception()
    search.reset_filter()

    search.load_filter(filter_name, cancel=True)
    assert_no_cfme_exception()
def test_can_delete_filter(single_provider):
    filter_name = fauxfactory.gen_alphanumeric()
    logger.debug('Set filter_name to: {}'.format(filter_name))
    assert search.save_filter("fill_count(Infrastructure Provider.VMs, >, 0)", filter_name)
    assert_no_cfme_exception()
    search.reset_filter()
    assert_no_cfme_exception()
    search.load_filter(filter_name)
    assert_no_cfme_exception()
    if not search.delete_filter():
        raise pytest.fail("Cannot delete filter! Probably the delete button is not present!")
    assert_no_cfme_exception()
def test_can_delete_filter():
    filter_name = fauxfactory.gen_alphanumeric()
    logger.debug('Set filter_name to: {}'.format(filter_name))
    assert search.save_filter("fill_count(Infrastructure Provider.VMs, >, 0)", filter_name)
    assert_no_cfme_exception()
    search.reset_filter()
    assert_no_cfme_exception()
    search.load_filter(filter_name)
    assert_no_cfme_exception()
    if not search.delete_filter():
        raise pytest.fail("Cannot delete filter! Probably the delete button is not present!")
    assert_no_cfme_exception()
Ejemplo n.º 43
0
def test_filter_save_and_load_cancel(request, vms, subset_of_vms):
    sel.force_navigate("infra_vms")
    filter_name = generate_random_string()
    vm = pick(subset_of_vms, 1)[0]
    # Set up the filter
    search.save_filter("fill_field(Virtual Machine : Name, =)", filter_name)

    def cleanup():
        search.load_filter(filter_name)
        search.delete_filter()

    request.addfinalizer(cleanup)
    assert_no_cfme_exception()
    search.reset_filter()

    search.load_and_apply_filter(
        filter_name,
        fill_callback={"Virtual Machine": vm},
        cancel_on_user_filling=True
    )
    assert_no_cfme_exception()
Ejemplo n.º 44
0
def test_filter_save_and_load_cancel(request, hosts, hosts_with_vm_count,
                                     host_with_median_vm):
    pytest.sel.force_navigate("infrastructure_hosts")
    median_host, median_vm_count = host_with_median_vm

    filter_name = fauxfactory.gen_alphanumeric()
    # Try save filter
    search.save_filter(get_expression(True), filter_name)

    @request.addfinalizer
    def cleanup():
        pytest.sel.force_navigate("infrastructure_hosts")
        search.load_filter(filter_name)
        search.delete_filter()

    assert_no_cfme_exception()
    search.reset_filter()

    search.load_and_apply_filter(filter_name,
                                 fill_callback={"COUNT": median_vm_count},
                                 cancel_on_user_filling=True)
    assert_no_cfme_exception()
def test_filter_save_cancel(single_provider, rails_delete_filter):
    # bind filter_name to the function for fixture cleanup
    test_filter_save_cancel.filter_name = fauxfactory.gen_alphanumeric()
    logger.debug('Set filter_name to: {}'.format(test_filter_save_cancel.filter_name))

    # Try save filter
    assert search.save_filter("fill_count(Infrastructure Provider.VMs, >)",
                              test_filter_save_cancel.filter_name, cancel=True)
    assert_no_cfme_exception()

    assert search.reset_filter()
    # Exception depends on system state - Load button will be disabled if there are no saved filters
    with pytest.raises((DisabledButtonException, NoSuchElementException)):
        search.load_filter(saved_filter=test_filter_save_cancel.filter_name)
def test_filter_save_cancel(rails_delete_filter):
    # bind filter_name to the function for fixture cleanup
    test_filter_save_cancel.filter_name = fauxfactory.gen_alphanumeric()
    logger.debug('Set filter_name to: {}'.format(test_filter_save_cancel.filter_name))

    # Try save filter
    assert search.save_filter("fill_count(Infrastructure Provider.VMs, >)",
                              test_filter_save_cancel.filter_name, cancel=True)
    assert_no_cfme_exception()

    assert search.reset_filter()
    # Exception depends on system state - Load button will be disabled if there are no saved filters
    with pytest.raises((DisabledButtonException, NoSuchElementException)):
        search.load_filter(saved_filter=test_filter_save_cancel.filter_name)
def test_filter_save_and_cancel_load(rails_delete_filter):
    # bind filter_name to the function for fixture cleanup
    test_filter_save_and_cancel_load.filter_name = fauxfactory.gen_alphanumeric()
    logger.debug('Set filter_name to: {}'.format(test_filter_save_and_cancel_load.filter_name))

    # Save filter
    assert search.save_filter("fill_count(Infrastructure Provider.VMs, >, 0)",
                              test_filter_save_and_cancel_load.filter_name)
    assert_no_cfme_exception()

    # Reset Filter
    assert search.reset_filter()

    # Load and cancel
    assert search.load_filter(test_filter_save_and_cancel_load.filter_name, cancel=True)
    assert_no_cfme_exception()
def test_cannot_delete_more_than_once():
    """When Delete button appars, it does not want to go away"""
    filter_name = fauxfactory.gen_alphanumeric()
    assert search.save_filter("fill_count(Infrastructure Provider.VMs, >, 0)", filter_name)

    assert search.load_filter(filter_name)  # circumvent the thing happening in previous test
    # Delete once
    if not search.delete_filter():
        pytest.fail("Could not delete the filter even first time!")
    assert_no_cfme_exception()
    # Try it second time
    if search.delete_filter():  # If the button is there, it says True
        # This should not happen
        msg = "Delete twice accepted!"
        if is_cfme_exception():
            msg += " CFME Exception text: `{}`".format(cfme_exception_text())
        pytest.fail(msg)
def test_filter_save_and_cancel_load_with_user_input(rails_delete_filter):
    # bind filter_name to the function for fixture cleanup
    test_filter_save_and_cancel_load_with_user_input.filter_name = fauxfactory.gen_alphanumeric()
    logger.debug('Set filter_name to: {}'.format(
        test_filter_save_and_cancel_load_with_user_input.filter_name))

    # Save filter
    assert search.save_filter("fill_count(Infrastructure Provider.VMs, >)",
                              test_filter_save_and_cancel_load_with_user_input.filter_name)
    assert_no_cfme_exception()

    # Reset Filter
    assert search.reset_filter()

    search.load_and_apply_filter(
        test_filter_save_and_cancel_load_with_user_input.filter_name,
        fill_callback={"COUNT": 0},
        cancel_on_user_filling=True
    )
    assert_no_cfme_exception()