def docs_info():
    if version.current_version() < "5.4.0.1":
        return [
            'Control',
            'Lifecycle and Automation',
            'Quick Start',
            'Settings And Operations',
            'Insight',
            'Integration Services'
        ]
    elif version.current_version() < "5.5.0.12":
        return [
            'Insight',
            'Control',
            'Lifecycle and Automation',
            'REST API',
            'SOAP API',
            'User',
            'Settings and Operations'
        ]
    elif version.appliance_is_downstream():
        return [
            'Monitoring Alerts Reporting',
            'General Configuration',
            'Virtual Machines Hosts',
            'Methods For Automation',
            'Infrastructure Inventory',
            'Providers',
            'Scripting Actions',
            'Defining Policies Profiles'
        ]
    else:
        # Upstream version has no docs
        return []

    def get_current_menu_state(self):
        """Returns the current menu state

        This function returns what each level of the menu is pointing to, or None, if that level
        of menu is unused. Future work could possibly see this method using recursion to allow
        unlimited levels of menu to be used, however it is unlikely that more than 3 will ever be
        used.
        """
        lev = [None, None, None]
        lev[0] = (sel.text(self.CURRENT_TOP_MENU).encode("utf-8").strip())
        if version.current_version() < "5.6.0.1" or version.current_version() == version.LATEST:
            try:
                lev[1] = sel.text("//nav[contains(@class, 'navbar')]//ul/li[@class='active']/a") \
                    .encode("utf-8").strip()
            except NoSuchElementException:
                pass
        else:
            lev[1] = sel.text("{}{}".format(
                self.CURRENT_TOP_MENU, self.ACTIVE_LEV)).encode("utf-8").strip()
            try:
                lev[2] = sel.text("{}{}{}".format(
                    self.CURRENT_TOP_MENU, self.ACTIVE_LEV, self.ACTIVE_LEV)).encode(
                        "utf-8").strip()
            except NoSuchElementException:
                pass

        return lev

    def test_retire_service_future(self, rest_api, services):
        """Test retiring a service
        Prerequisities:
            * An appliance with ``/api`` available.
        Steps:
            * Retrieve list of entities using GET /api/services , pick the first one
            * POST /api/service/<id> (method ``retire``) with the ``retire_date``
        Metadata:
            test_flag: rest
        """
        assert "retire" in rest_api.collections.services.action.all

        retire_service = services[0]
        date = (datetime.datetime.now() + datetime.timedelta(days=5)).strftime('%m/%d/%y')
        future = {
            "date": date,
            "warn": "4",
        }
        date_before = retire_service.updated_at
        retire_service.action.retire(future)

        def _finished():
            retire_service.reload()
            if retire_service.updated_at > date_before:
                    return True
            return False

        wait_for(_finished, num_sec=600, delay=5, message="REST automation_request finishes")

        @pytest.mark.uncollectif(lambda: version.current_version() < '5.5')
        def test_set_service_owner(self, rest_api, services):
            if "set_ownership" not in rest_api.collections.services.action.all:
                pytest.skip("Set owner action for service is not implemented in this version")
            service = services[0]
            user = rest_api.collections.users.get(userid='admin')
            data = {
                "owner": {"href": user.href}
            }
            service.action.set_ownership(data)
            service.reload()
            assert hasattr(service, "evm_owner")
            assert service.evm_owner.userid == user.userid

        @pytest.mark.uncollectif(lambda: version.current_version() < '5.5')
        def test_set_services_owner(self, rest_api, services):
            if "set_ownership" not in rest_api.collections.services.action.all:
                pytest.skip("Set owner action for service is not implemented in this version")
            data = []
            user = rest_api.collections.users.get(userid='admin')
            for service in services:
                tmp_data = {
                    "href": service.href,
                    "owner": {"href": user.href}
                }
                data.append(tmp_data)
            rest_api.collections.services.action.set_ownership(*data)
            for service in services:
                service.reload()
                assert hasattr(service, "evm_owner")
                assert service.evm_owner.userid == user.userid

def test_evmserverd_start_twice(ssh_client):
    """If evmserverd start is ran twice, it will then tell that it is already running.

    Steps:
        * Stop the evmserverd using ``service evmserverd stop``.
        * Start the evmserverd using ``service evmserverd start`` command.
        * Assert that the output of the previous command states "Running EVM in background".
        * Start the evmserverd using ``service evmserverd start`` command.
        * Assert that the output of the previous command states "EVM is already running".
        * Extract the PID of the evmserverd from the output from the last command.
        * Verify the process with such PID exists ``kill -0 $PID``.
    """
    assert ssh_client.run_command("service evmserverd stop").rc == 0
    # Start first time
    res = ssh_client.run_command("service evmserverd start")
    if current_version() < "5.5":
        assert "running evm in background" in res.output.lower()
    else:
        assert "started evm server daemon" in res.output.lower()
    assert res.rc == 0
    # Start second time
    res = ssh_client.run_command("service evmserverd start")
    if current_version() < "5.5":
        assert "evm is already running" in res.output.lower()
    assert res.rc == 0
    # Verify the process is running
    if current_version() < "5.5":
        pid_match = re.search(r"\(PID=(\d+)\)", res.output)
    else:
        pid_match = re.search(r"Main PID: (\d+)", res.output)
    assert pid_match is not None
    pid = int(pid_match.groups()[0])
    assert ssh_client.run_command("kill -0 {}".format(pid)).rc == 0

def all_possible_roles():
    roles = server_roles_conf['all']
    if version.current_version() < 5.6:
        roles.remove('git_owner')
        roles.remove('websocket')
    if version.current_version() >= 5.7:
        roles.remove('database_synchronization')
    return roles

    def create(self):
        # Create has sequential forms, the first is only the provider type
        navigate_to(self, 'Add')
        # For element not found exception (To be removed)
        sel.sleep(5)
        sel.select("//select[@id='st_prov_type']",
                   self.provider_type or self.item_type or 'Generic')

        sel.wait_for_element(basic_info_form.name_text)
        catalog = fakeobject_or_object(self.catalog, "name", "Unassigned")
        dialog = fakeobject_or_object(self.dialog, "name", "No Dialog")

        # Need to provide the (optional) provider name to the form, not the object
        provider_name = None
        provider_required_types = ['AnsibleTower', 'Orchestration']
        if self.item_type in provider_required_types \
                or self.provider_type in provider_required_types:
            provider_name = self.provider.name
        # For tests where orchestration template is None
        orch_template = None
        if self.orch_template:
            orch_template = self.orch_template.template_name

        fill(basic_info_form, {'name_text': self.name,
                               'description_text': self.description,
                               'display_checkbox': self.display_in,
                               'select_catalog': catalog.name,
                               'select_dialog': dialog.name,
                               'select_orch_template': orch_template,
                               'select_provider': provider_name,
                               'select_config_template': self.config_template})
        if not (self.item_type in provider_required_types):
            sel.click(basic_info_form.field_entry_point)
            if version.current_version() < "5.7":
                dynamic_tree.click_path("Datastore", self.domain, "Service", "Provisioning",
                                     "StateMachines", "ServiceProvision_Template", "default")
            else:
                entry_tree.click_path("Datastore", self.domain, "Service", "Provisioning",
                    "StateMachines", "ServiceProvision_Template", "default")
            sel.click(basic_info_form.apply_btn)
        if version.current_version() >= "5.7" and self.item_type == "AnsibleTower":
            sel.click(basic_info_form.retirement_entry_point)
            entry_tree.click_path("Datastore", self.domain, "Service", "Retirement",
                    "StateMachines", "ServiceRetirement", "Generic")
            sel.click(basic_info_form.apply_btn)
        if self.catalog_name is not None \
                and self.provisioning_data is not None \
                and not isinstance(self.provider, NoneType):
            tabstrip.select_tab("Request Info")
            tabstrip.select_tab("Catalog")
            template = template_select_form.template_table.find_row_by_cells({
                'Name': self.catalog_name,
                'Provider': self.provider.name
            })
            sel.click(template)
            request_form.fill(self.provisioning_data)
        sel.click(template_select_form.add_button)

 def resolve_blocker(self, blocker, version=None, ignore_bugs=None, force_block_streams=None):
     # ignore_bugs is mutable but is not mutated here! Same force_block_streams
     force_block_streams = force_block_streams or []
     ignore_bugs = set([]) if not ignore_bugs else ignore_bugs
     if isinstance(id, BugWrapper):
         bug = blocker
     else:
         bug = self.get_bug(blocker)
     if version is None:
         version = current_version()
     if version == LATEST:
         version = bug.product.latest_version
     variants = self.get_bug_variants(bug)
     filtered = set([])
     version_series = ".".join(str(version).split(".")[:2])
     for variant in variants:
         if variant.id in ignore_bugs:
             continue
         if variant.version is not None and variant.version > version:
             continue
         if ((variant.version is not None and variant.target_release is not None) and
                 (
                     variant.version.is_in_series(version_series) or
                     variant.target_release.is_in_series(version_series))):
                 filtered.add(variant)
         elif variant.release_flag is not None:
             if version.is_in_series(variant.release_flag):
                 # Simple case
                 filtered.add(variant)
             else:
                 logger.info(
                     "Ignoring bug #%s, appliance version not in bug release flag", variant.id)
         else:
             logger.info("No release flags, wrong versions, ignoring %s", variant.id)
     if not filtered:
         # No appropriate bug was found
         for forced_stream in force_block_streams:
             # Find out if we force this bug.
             if current_version().is_in_series(forced_stream):
                 return bug
         else:
             # No bug, yipee :)
             return None
     # First, use versions
     for bug in filtered:
         if ((bug.version is not None and bug.target_release is not None) and
                 check_fixed_in(bug.fixed_in, version_series) and
                 (
                     bug.version.is_in_series(version_series) or
                     bug.target_release.is_in_series(version_series))):
             return bug
     # Otherwise prefer release_flag
     for bug in filtered:
         if bug.release_flag and version.is_in_series(bug.release_flag):
             return bug
     return None

def group_data():
    roles = cfme_data.get("group_roles", {})

    # These roles are not present on 5.2 appliance in these groups
    if version.current_version() < "5.3":
        _remove_page(roles, "evmgroup-super_administrator", ["clouds_tenants"])
        _remove_page(roles, "evmgroup-user", ["services_requests", "infrastructure_requests"])
    if version.current_version() < "5.4":
        _remove_from_all(roles, "clouds_stacks")
        _remove_from_all(roles, "infrastructure_config_management")
    return roles

    def visible_pages(self):
        """Return a list of all the menu pages currently visible top- and second-level pages

        Mainly useful for RBAC testing

        """
        if version.current_version() < "5.6.0.1" or version.current_version() == version.LATEST:
            displayed_menus = self._old_visible_pages()
        else:
            displayed_menus = self._new_visible_pages()
        return sorted(
            [self.reverse_lookup(*displayed) for displayed in displayed_menus if displayed])

 def initialize(self):
     """Initializes the menu object by collapsing the grafted tree items onto the tree"""
     if not self._branches:
         self._branches = self._branch_convert(self.sections)
         self.add_branch('toplevel', self._branches)
         while self._branch_stack:
             name, branches = self._branch_stack.pop(0)
             self.add_branch(name, branches)
         if version.current_version() < "5.6.0.1" or version.current_version() == version.LATEST:
             self.CURRENT_TOP_MENU = "//ul[@id='maintab']/li[not(contains(@class, 'drop'))]/a[2]"
         else:
             self.CURRENT_TOP_MENU = "{}{}".format(self.ROOT, self.ACTIVE_LEV)

        def form(self):
            fields = [
                ('token_secret_55', Input('bearer_token')),
                ('google_service_account', Input('service_account')),
            ]
            tab_fields = {
                ("Default", ('default_when_no_tabs', )): [
                    ('default_principal', Input("default_userid")),
                    ('default_secret', Input("default_password")),
                    ('default_verify_secret', Input("default_verify")),
                    ('token_secret', {
                        version.LOWEST: Input('bearer_password'),
                        '5.6': Input('default_password')
                    }),
                    ('token_verify_secret', {
                        version.LOWEST: Input('bearer_verify'),
                        '5.6': Input('default_verify')
                    }),
                ],

                "RSA key pair": [
                    ('ssh_user', Input("ssh_keypair_userid")),
                    ('ssh_key', FileInput("ssh_keypair_password")),
                ],

                "C & U Database": [
                    ('candu_principal', Input("metrics_userid")),
                    ('candu_secret', Input("metrics_password")),
                    ('candu_verify_secret', Input("metrics_verify")),
                ],
            }
            fields_end = [
                ('validate_btn', form_buttons.validate),
            ]

            if version.current_version() >= '5.6':
                amevent = "Events"
            else:
                amevent = "AMQP"
            tab_fields[amevent] = []
            if version.current_version() >= "5.6":
                tab_fields[amevent].append(('event_selection', Radio('event_stream_selection')))
            tab_fields[amevent].extend([
                ('amqp_principal', Input("amqp_userid")),
                ('amqp_secret', Input("amqp_password")),
                ('amqp_verify_secret', Input("amqp_verify")),
            ])

            return TabStripForm(fields=fields, tab_fields=tab_fields, fields_end=fields_end)

def test_timeprofile_description_required_error_validation():
    tp = st.Timeprofile(
        description=None,
        scope='Current User',
        timezone="(GMT-10:00) Hawaii")
    if version.current_version() > "5.7":
        tp.create(cancel=True)
        assert tp.timeprofile_form.description.angular_help_block == "Required"
        if version.current_version() > "5.8":
            assert form_buttons.save.is_dimmed
        else:
            assert form_buttons.add.is_dimmed
    else:
        with error.expected("Description is required"):
            tp.create()

def domain(request):
    if version.current_version() < "5.3":
        return None
    domain = Domain(name=fauxfactory.gen_alphanumeric(), enabled=True)
    domain.create()
    request.addfinalizer(lambda: domain.delete() if domain.exists() else None)
    return domain

 def _filter_restricted_version(self, provider):
     """ Filters by yaml version restriction; not applied if SSH is not available """
     if self.restrict_version:
         # TODO
         # get rid of this since_version hotfix by translating since_version
         # to restricted_version; in addition, restricted_version should turn into
         # "version_restrictions" and it should be a sequence of restrictions with operators
         # so that we can create ranges like ">= 5.6" and "<= 5.8"
         version_restrictions = []
         since_version = provider.data.get('since_version')
         if since_version:
             version_restrictions.append('>= {}'.format(since_version))
         restricted_version = provider.data.get('restricted_version')
         if restricted_version:
             version_restrictions.append(restricted_version)
         for restriction in version_restrictions:
             for op, comparator in ProviderFilter._version_operator_map.items():
                 # split string by op; if the split works, version won't be empty
                 head, op, ver = restriction.partition(op)
                 if not ver:  # This means that the operator was not found
                     continue
                 try:
                     curr_ver = version.current_version()
                 except:
                     return True
                 if not comparator(curr_ver, ver):
                     return False
                 break
             else:
                 raise Exception('Operator not found in {}'.format(restriction))
     return None

    def edit_schema(self, add_fields=None, remove_fields=None):
        sel.force_navigate("automate_explorer_schema_edit", context={'tree_item': self})
        for remove_field in remove_fields or []:
            f = remove_field.get_form()
            fill(f, {}, action=f.remove_entry_button, action_always=True)
            if version.current_version() < "5.5.0.7":
                sel.handle_alert()

        for add_field in add_fields or []:
            sel.click(self.schema_edit_page.add_field_btn)
            f = add_field.get_form(blank=True)
            fill(f, {'name_text': add_field.name,
                     'type_select': add_field.type_,
                     'data_type_select': add_field.data_type,
                     'default_value_text': add_field.default_value,
                     'description_text': add_field.description,
                     'sub_cb': add_field.sub,
                     'collect_text': add_field.collect,
                     'message_text': add_field.message,
                     'on_entry_text': add_field.on_entry,
                     'on_exit_text': add_field.on_exit,
                     'max_retries_text': add_field.max_retries,
                     'max_time_text': add_field.max_time},
                 action=f.add_entry_button)

        sel.click(form_buttons.save)
        flash.assert_success_message('Schema for Automate Class "%s" was saved' % self.name)

def test_provider_crud(request, rest_api, from_detail):
    """Test the CRUD on provider using REST API.
    Steps:
        * POST /api/providers (method ``create``) <- {"hostname":..., "name":..., "type":
            "EmsVmware"}
        * Remember the provider ID.
        * Delete it either way:
            * DELETE /api/providers/<id>
            * POST /api/providers (method ``delete``) <- list of dicts containing hrefs to the
                providers, in this case just list with one dict.
    Metadata:
        test_flag: rest
    """
    if "create" not in rest_api.collections.providers.action.all:
        pytest.skip("Create action is not implemented in this version")

    if current_version() < "5.5":
        provider_type = "EmsVmware"
    else:
        provider_type = "ManageIQ::Providers::Vmware::InfraManager"
    provider = rest_api.collections.providers.action.create(
        hostname=fauxfactory.gen_alphanumeric(),
        name=fauxfactory.gen_alphanumeric(),
        type=provider_type,
    )[0]
    if from_detail:
        provider.action.delete()
        provider.wait_not_exists(num_sec=30, delay=0.5)
    else:
        rest_api.collections.providers.action.delete(provider)
        provider.wait_not_exists(num_sec=30, delay=0.5)

def pytest_runtest_protocol(item):
    global session_ver
    global session_build
    global session_stream

    if not session_ver:
        session_ver = str(version.current_version())
        session_build = store.current_appliance.build
        session_stream = store.current_appliance.version.stream()
        art_client.fire_hook('session_info', version=session_ver, build=session_build,
            stream=session_stream)

    name, location = get_test_idents(item)
    tier = item.get_marker('tier')
    if tier:
        tier = tier.args[0]

    try:
        params = item.callspec.params
        param_dict = {p: get_name(v) for p, v in params.iteritems()}
    except:
        param_dict = {}

    # This pre_start_test hook is needed so that filedump is able to make get the test
    # object set up before the logger starts logging. As the logger fires a nested hook
    # to the filedumper, and we can't specify order inriggerlib.
    art_client.fire_hook('pre_start_test', test_location=location, test_name=name,
                         slaveid=SLAVEID, ip=appliance_ip_address)
    art_client.fire_hook('start_test', test_location=location, test_name=name,
                         slaveid=SLAVEID, ip=appliance_ip_address,
                         tier=tier, param_dict=param_dict)
    yield

def _rpms_present_packages():
    # autogenerate the rpms to test based on the current appliance version
    # and the list of possible packages that can be installed
    current_version = version.current_version()
    possible_packages = [
        'cfme',
        'cfme-appliance',
        'cfme-lib',
        'nfs-utils',
        'nfs-utils-lib',
        'libnfsidmap',
        'mingw32-cfme-host',
        'ipmitool',
        'prince',
        'netapp-manageability-sdk',
        'rhn-client-tools',
        'rhn-check',
        'rhnlib'
    ]

    def package_filter(package):
        package_tests = [
            # stopped shipping this with 5.4
            package == 'mingw32-cfme-host' and current_version >= '5.4',
            # stopped shipping these with 5.5
            package in ('cfme-lib', 'netapp-manageability-sdk') and current_version >= 5.5,
            # nfs-utils-lib was superseded by libnfsidmap in el7/cfme 5.5
            # so filter out nfs-utils-lib on 5.5 and up, and libnfsidmap below 5.5
            package == 'nfs-utils-lib' and current_version >= '5.5',
            package == 'libnfsidmap' and current_version < '5.5',
        ]
        # If any of the package tests eval'd to true, filter this package out
        return not any(package_tests)

    return filter(package_filter, possible_packages)

def test_relationships_tables(provider, data_set):
    """This test verifies the integrity of the Relationships table.
    clicking on each field in the Relationships table takes the user
    to either Summary page where we verify that the field that appears
    in the Relationships table also appears in the Properties table,
    or to the page where the number of rows is equal to the number
    that is displayed in the Relationships table.
    """

    if current_version() < "5.7" and data_set.obj == Template:
        pytest.skip('Templates are not exist in CFME version smaller than 5.7. skipping...')

    rows = navigate_and_get_rows(provider, data_set.obj, data_set.paged_tbl, 1)
    if not rows:
        pytest.skip('No objects to test for relationships for {}'.format(data_set.obj.__name__))
    row = rows[-1]

    if data_set.obj is Container:
        instance = data_set.obj(row.name.text, row.pod_name.text)
    elif data_set.obj is ImageRegistry:
        instance = data_set.obj(row.host.text, provider)
    elif data_set.obj is Image:
        instance = data_set.obj(row.name.text, row.tag.text, provider)
    else:
        instance = data_set.obj(row.name.text, provider)

    check_relationships(instance)

def get_vm_object(vm_name):
    """Looks up the CFME database for the VM.

    Args:
        vm_name: VM name
    Returns:
        If found, :py:class:`utils.miq_soap.MiqVM` for 5.4 and :py:class:`utils.api.Entity` for 5.5
        If not, `None`
    """
    if current_version() < "5.5":
        vm_table = store.current_appliance.db['vms']
        for vm in store.current_appliance.db.session.query(vm_table.name, vm_table.guid)\
                .filter(vm_table.template == False):  # NOQA
            # Previous line is ok, if you change it to `is`, it won't work!
            if vm.name == vm_name:
                return MiqVM(vm.guid)
        else:
            return None
    else:
        rest_api = pytest.store.current_appliance.rest_api
        results = rest_api.collections.vms.find_by(name=vm_name)
        if len(results) > 0:
            return results[0]
        else:
            return None