def main():

    parser = smoke.json_options.JSONOptionParser(
        usage=USAGE, configfile_args=smoke_config.get_named_configs())

    values, args, json_root = parser.parse_json_args()

    if "tests" in json_root:
        json_root = {"tests": json_root["tests"]}

    # Assume remaining arguments are test roots
    if args:
        json_root = smoke.json_options.json_update_path(
            json_root, "tests.roots", args)

    print "Metadata extraction configuration:"
    print smoke.json_options.json_dump(json_root)

    if not "tests" in json_root or json_root["tests"] is None:
        raise Exception("No tests specified.")

    def re_compile_all(re_patterns):
        if isinstance(re_patterns, basestring):
            re_patterns = [re_patterns]
        return [re.compile(pattern) for pattern in re_patterns]

    def build_test_metadata(roots=["./"],
                            include_files=[],
                            include_files_except=[],
                            exclude_files=[],
                            exclude_files_except=[],
                            **kwargs):

        if len(kwargs) > 0:
            raise optparse.OptionValueError(
                "Unrecognized options for building test metadata: %s" % kwargs)

        file_regex_query = smoke.suites.RegexQuery(
            re_compile_all(include_files),
            re_compile_all(include_files_except),
            re_compile_all(exclude_files),
            re_compile_all(exclude_files_except))

        tests = smoke.tests.build_tests(roots,
                                        file_regex_query,
                                        extract_metadata=True)

        print "Writing test metadata for %s tests..." % len(tests)
        smoke.tests.write_metadata(tests, json_only=True)
        print "Test metadata written."

    build_test_metadata(**json_root["tests"])
Example #2
0
def main():

    parser = smoke.json_options.JSONOptionParser(usage=USAGE,
                                                 configfile_args=smoke_config.get_named_configs())

    values, args, json_root = parser.parse_json_args()

    if "tests" in json_root:
        json_root = {"tests": json_root["tests"]}

    # Assume remaining arguments are test roots
    if args:
        json_root = smoke.json_options.json_update_path(json_root, "tests.roots", args)

    print "Metadata extraction configuration:"
    print smoke.json_options.json_dump(json_root)

    if not "tests" in json_root or json_root["tests"] is None:
        raise Exception("No tests specified.")

    def re_compile_all(re_patterns):
        if isinstance(re_patterns, basestring):
            re_patterns = [re_patterns]
        return [re.compile(pattern) for pattern in re_patterns]

    def build_test_metadata(roots=["./"],
                            include_files=[],
                            include_files_except=[],
                            exclude_files=[],
                            exclude_files_except=[],
                            **kwargs):

        if len(kwargs) > 0:
            raise optparse.OptionValueError(
                "Unrecognized options for building test metadata: %s" % kwargs)

        file_regex_query = smoke.suites.RegexQuery(re_compile_all(include_files),
                                                   re_compile_all(
                                                       include_files_except),
                                                   re_compile_all(
                                                       exclude_files),
                                                   re_compile_all(exclude_files_except))

        tests = smoke.tests.build_tests(roots, file_regex_query, extract_metadata=True)

        print "Writing test metadata for %s tests..." % len(tests)
        smoke.tests.write_metadata(tests, json_only=True)
        print "Test metadata written."

    build_test_metadata(**json_root["tests"])
Example #3
0
def main():

    named_configs = smoke_config.get_named_configs()

    parser = smoke.json_options.JSONOptionParser(usage=USAGE,
                                                 configfile_args=named_configs)

    help = \
        """Just outputs the configured JSON options."""

    parser.add_option('--dump-options', default=False, dest='dump_options', action="store_true",
                      help=help)

    help = \
        """Outputs all the tests found with metadata."""

    parser.add_option('--dump-tests', default=False, dest='dump_tests', action="store_true",
                      help=help)

    help = \
        """Outputs the tests in the suite."""

    parser.add_option('--dump-suite', default=False, dest='dump_suite', action="store_true",
                      help=help)

    values, args, json_root = parser.parse_json_args()

    # Assume remaining arguments are test roots
    if args:
        json_root = smoke.json_options.json_update_path(json_root, "tests.roots", args)

    # Assume all files in suite if not specified
    if "suite" not in json_root or json_root["suite"] is None:
        json_root["suite"] = {}

    # Assume default_logging if no other logging specified
    if "logging" not in json_root or json_root["logging"] is None:
        default_logging = \
            smoke.json_options.json_file_load(named_configs["log_default"])
        json_root["logging"] = default_logging["logging"]

    if "executor" not in json_root or json_root["executor"] is None:
        default_executor = \
            smoke.json_options.json_file_load(named_configs["executor_default"])
        json_root["executor"] = default_executor["executor"]

    if not values.dump_options:
        print "Test Configuration: \n---"

    for key in ["tests", "suite", "executor", "logging"]:
        if key in json_root:
            print smoke.json_options.json_dump({key: json_root[key]}),
    print

    if values.dump_options:
        return

    def validate_config(tests=None, suite=None, executor=None, logging=None, **kwargs):

        if len(kwargs) > 0:
            raise optparse.OptionValueError(
                "Unrecognized test options: %s" % kwargs)

        if not all([tests is not None, executor is not None]):
            raise optparse.OptionValueError(
                "Test options must contain \"tests\" and \"executor\".")

    validate_config(**json_root)
    logging.config.dictConfig(json_root["logging"])

    def re_compile_all(re_patterns):
        if isinstance(re_patterns, basestring):
            re_patterns = [re_patterns]
        return [re.compile(pattern) for pattern in re_patterns]

    def build_tests(roots=["./"],
                    include_files=[],
                    include_files_except=[],
                    exclude_files=[],
                    exclude_files_except=[],
                    extract_metadata=True,
                    **kwargs):

        if len(kwargs) > 0:
            raise optparse.OptionValueError(
                "Unrecognized options for tests: %s" % kwargs)

        file_regex_query = smoke.suites.RegexQuery(re_compile_all(include_files),
                                                   re_compile_all(
                                                       include_files_except),
                                                   re_compile_all(
                                                       exclude_files),
                                                   re_compile_all(exclude_files_except))

        if isinstance(roots, basestring):
            roots = [roots]

        return smoke.tests.build_tests(roots, file_regex_query, extract_metadata)

    tests = build_tests(**json_root["tests"])

    if values.dump_tests:
        print "Tests:\n%s" % tests

    def build_suite(tests,
                    include_tags=[],
                    include_tags_except=[],
                    exclude_tags=[],
                    exclude_tags_except=[],
                    **kwargs):

        if len(kwargs) > 0:
            raise optparse.OptionValueError(
                "Unrecognized options for suite: %s" % kwargs)

        tag_regex_query = smoke.suites.RegexQuery(re_compile_all(include_tags),
                                                  re_compile_all(
                                                      include_tags_except),
                                                  re_compile_all(exclude_tags),
                                                  re_compile_all(exclude_tags_except))

        return smoke.suites.build_suite(tests, tag_regex_query)

    suite = build_suite(tests, **json_root["suite"])
    suite.sort(key=lambda test: test.uri)

    if values.dump_suite:
        print "Suite:\n%s" % suite

    print "Running %s tests in suite (out of %s tests found)..." % (len(tests), len(suite))

    local_logger_filenames = get_local_logger_filenames(json_root["logging"])
    if local_logger_filenames:
        print "\nOutput from tests redirected to:\n\t%s\n" % \
            "\n\t".join(local_logger_filenames)

    try:
        smoke.executor.exec_suite(suite, logging.getLogger("executor"), **json_root["executor"])
    finally:
        if local_logger_filenames:
            print "\nOutput from tests was redirected to:\n\t%s\n" % \
                "\n\t".join(local_logger_filenames)