Python testscenarios.load_tests_apply_scenarios函数代码示例

def load_tests_input_scenario_utils(*args):
    """
    Wrapper for testscenarios to set the scenarios to avoid running a getattr
    on the CONF object at import.
    """
    if getattr(args[0], "suiteClass", None) is not None:
        loader, standard_tests, pattern = args
    else:
        standard_tests, module, loader = args
    output = None
    scenario_utils = None
    try:
        scenario_utils = InputScenarioUtils()
        scenario_flavor = scenario_utils.scenario_flavors
        scenario_image = scenario_utils.scenario_images
    except (exc_lib.InvalidCredentials, TypeError):
        output = standard_tests
    finally:
        if scenario_utils:
            scenario_utils.clear_creds()
    if output is not None:
        return output
    for test in testtools.iterate_tests(standard_tests):
        setattr(test, "scenarios", testscenarios.multiply_scenarios(scenario_image, scenario_flavor))
    return testscenarios.load_tests_apply_scenarios(*args)

def load_tests(loader, tests, pattern):

    flake8_style = engine.get_style_guide(parse_argv=False,
                                          # Ignore H104 otherwise it's
                                          # raised on doctests.
                                          ignore=('F', 'H104'))
    options = flake8_style.options

    for entry in pkg_resources.iter_entry_points('flake8.extension'):
        if not entry.module_name.startswith('spotless.'):
            continue
        check = entry.load()
        name = entry.attrs[0]
        if check.skip_on_py3 and six.PY3:
            continue
        for (lineno, (raw, (code, source))) in enumerate(
                test_doctest._get_lines(check)):
            lines = [part.replace(r'\t', '\t') + '\n'
                     for part in source.split(r'\n')]
            test_doctest.file_cases.append(("%s-%s-line-%s"
                                            % (entry.name, name, lineno),
                                            dict(
                                                lines=lines,
                                                raw=raw,
                                                options=options,
                                                code=code)))

    return testscenarios.load_tests_apply_scenarios(loader, tests, pattern)

def load_tests(loader, tests, pattern):

    default_checks = [e.name for e
                      in pkg_resources.iter_entry_points('flake8.extension')]
    flake8_style = engine.get_style_guide(
        parse_argv=False,
        # We are testing neutron-specific hacking rules, so there is no need
        # to run the checks registered by hacking or other flake8 extensions.
        ignore=default_checks)
    options = flake8_style.options

    for name, check in checks.__dict__.items():
        if not hasattr(check, 'name'):
            continue
        if check.name != checks.__name__:
            continue
        if not check.__doc__:
            continue
        for (lineno, (raw, line)) in enumerate(_get_lines(check)):
            code, __, filename, source = line
            lines = [part.replace(r'\t', '\t') + '\n'
                     for part in source.split(r'\n')]
            file_cases.append(("%s-line-%s" % (name, lineno),
                              dict(lines=lines, raw=raw, options=options,
                                   code=code, filename=filename)))
    return testscenarios.load_tests_apply_scenarios(loader, tests, pattern)

def load_tests(loader, tests, pattern):

    flake8_style = engine.get_style_guide(
        parse_argv=False,
        # Ignore H104 otherwise it's
        # raised on doctests.
        ignore=("F", "H104"),
    )
    options = flake8_style.options

    for name, check in checks.__dict__.items():
        if not hasattr(check, "name"):
            continue
        if check.name != checks.__name__:
            continue
        if not check.__doc__:
            continue
        for (lineno, (raw, line)) in enumerate(_get_lines(check)):
            code, __, filename, source = line
            lines = [part.replace(r"\t", "\t") + "\n" for part in source.split(r"\n")]
            file_cases.append(
                (
                    "%s-line-%s" % (name, lineno),
                    dict(lines=lines, raw=raw, options=options, code=code, filename=filename),
                )
            )
    return testscenarios.load_tests_apply_scenarios(loader, tests, pattern)

def load_tests(loader, tests, pattern):

    flake8_style = engine.get_style_guide(parse_argv=False, ignore="F")
    options = flake8_style.options

    for name, check in hacking.core.__dict__.items():
        if not name.startswith("hacking_"):
            continue
        for (lineno, (raw, (code, source))) in enumerate(_get_lines(check)):
            lines = [part.replace(r"\t", "\t") + "\n" for part in source.split(r"\n")]
            file_cases.append(("%s-line-%s" % (name, lineno), dict(lines=lines, raw=raw, options=options, code=code)))
    return testscenarios.load_tests_apply_scenarios(loader, tests, pattern)

def module_load_tests(loader, found_tests, pattern):
    """Apply OptimisingTestSuite on a per-module basis.

    FIXME(zzzeek): oslo.db provides this but the contract that
    "pattern" should be None no longer seems to behave as it used
    to at the module level, so this function needs to be added in this
    form.

    """

    result = testresources.OptimisingTestSuite()
    found_tests = testscenarios.load_tests_apply_scenarios(
        loader, found_tests, pattern)
    result.addTest(found_tests)
    return result

 def load_tests(*args):
     """
     Wrapper for testscenarios to set the mandatory scenarios variable
     only in case a real test loader is in place. Will be automatically
     called in case the variable "load_tests" is set.
     """
     if getattr(args[0], "suiteClass", None) is not None:
         loader, standard_tests, pattern = args
     else:
         standard_tests, module, loader = args
     for test in testtools.iterate_tests(standard_tests):
         schema_file = getattr(test, "_schema_file", None)
         if schema_file is not None:
             setattr(test, "scenarios", NegativeAutoTest.generate_scenario(schema_file))
     return testscenarios.load_tests_apply_scenarios(*args)

    def load_tests(loader, found_tests, pattern):
        # pattern is None if the directive is placed within
        # a test module directly, as well as within certain test
        # discovery patterns

        if pattern is not None:
            pkg_tests = loader.discover(start_dir=this_dir, pattern=pattern)

        result = testresources.OptimisingTestSuite()
        found_tests = testscenarios.load_tests_apply_scenarios(
            loader, found_tests, pattern)
        result.addTest(found_tests)

        if pattern is not None:
            result.addTest(pkg_tests)
        return result

def load_tests_input_scenario_utils(*args):
    """
    Wrapper for testscenarios to set the scenarios to avoid running a getattr
    on the CONF object at import.
    """
    if getattr(args[0], 'suiteClass', None) is not None:
        loader, standard_tests, pattern = args
    else:
        standard_tests, module, loader = args
    scenario_utils = InputScenarioUtils()
    scenario_flavor = scenario_utils.scenario_flavors
    scenario_image = scenario_utils.scenario_images
    for test in testtools.iterate_tests(standard_tests):
        setattr(test, 'scenarios', testscenarios.multiply_scenarios(
            scenario_image,
            scenario_flavor))
    return testscenarios.load_tests_apply_scenarios(*args)

def load_tests(loader, tests, pattern):

    flake8_style = engine.get_style_guide(parse_argv=False,
                                          # Ignore H104 otherwise it's
                                          # raised on doctests.
                                          ignore=('F', 'H104'))
    options = flake8_style.options

    for name, check in hacking.core.__dict__.items():
        if not name.startswith("hacking_"):
            continue
        for (lineno, (raw, (code, source))) in enumerate(_get_lines(check)):
            lines = [part.replace(r'\t', '\t') + '\n'
                     for part in source.split(r'\n')]
            file_cases.append(("%s-line-%s" % (name, lineno),
                              dict(lines=lines, raw=raw, options=options,
                                   code=code)))
    return testscenarios.load_tests_apply_scenarios(loader, tests, pattern)

def load_tests(loader, in_tests, pattern):
    return testscenarios.load_tests_apply_scenarios(loader, in_tests, pattern)