#! /usr/bin/env python
#
# Gramps - a GTK+/GNOME based genealogy program
#
# Copyright (C) 2000-2005  Donald N. Allingham
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# test/regrtest.py
# Original: RunAllTests.py Written by Richard Taylor
# (jgs: revised for embedded "test" subdirs as regrtest.py )

"""
Testing framework for performing a variety of unttests for Gramps.
"""

# TODO: review whether logging is really useful for unittest
#  it does seem to work .. try -v5
import logging

import os
import sys
import unittest
from optparse import OptionParser

from ..test import test_util as tu

gramps_root = tu.path_append_parent()


def make_parser():
    usage = "usage: %prog [options]"
    parser = OptionParser(usage)
    parser.add_option(
        "-v",
        "--verbosity",
        type="int",
        dest="verbose_level",
        default=0,
        help="Level of verboseness",
    )
    parser.add_option(
        "-p",
        "--performance",
        action="store_true",
        dest="performance",
        default=False,
        help="Run the performance tests.",
    )
    return parser


def getTestSuites(loc=gramps_root):
    # in a developer's checkout, it is worth filtering-out .git
    #  and we only need to look inside test subdirs
    #   (this might change)
    # this is not so performance critical that we can't afford
    # a couple of function calls to make it readable
    # TODO: handle parts of a module (see unittest.py)

    ldr = unittest.defaultTestLoader

    test_dirname = "test"
    test_suffix = "_test.py"

    def test_mod(p, ds):
        """test for path p=test dir; removes a dir '.git' in ds"""
        if ".git" in ds:
            ds.remove(".git")
        return os.path.basename(p) == test_dirname

    def match_mod(fs):
        """test for any test modules; deletes all non-tests"""
        # NB: do not delete fs elements within a "for f in fs"
        dels = [f for f in fs if not f.endswith(test_suffix)]
        for f in dels:
            fs.remove(f)
        return len(fs) > 0

    test_suites = []
    perf_suites = []
    # note that test_mod and match_mod modify passed-in lists
    paths = [
        (path, files)
        for path, dirs, files in os.walk(loc)
        if test_mod(path, dirs) and match_mod(files)
    ]

    ## NO -- see explanation below
    ##  oldpath = list(sys.path)
    for dir, test_modules in paths:
        sys.path.append(dir)

        for module in test_modules:
            if not module.endswith(test_suffix):
                raise ValueError
            mod = __import__(module[: -len(".py")])
            if getattr(mod, "suite", None):
                test_suites.append(mod.suite())
            else:
                test_suites.append(ldr.loadTestsFromModule(mod))
            try:
                perf_suites.append(mod.perfSuite())
            except:
                pass
        # NO: was: remove temporary paths added
        # this seems like it should be reasonable,
        # but it causes failure in _GrampsDbWRFactories_test.py
        #  (I suspect it is an actual bug in the runner
        #   but the easiest fix is to keep the imports,
        #   which is what other loaders seem to do)
        # ==>  this aspect of test frameworks is *hard*
        ## NO -- do NOT:
        ## remove temporary paths added
        ## sys.path = list(oldpath)
    return (test_suites, perf_suites)


if __name__ == "__main__":

    def logging_init():
        global logger
        global console
        console = logging.StreamHandler()
        console.setLevel(logging.INFO)
        console.setFormatter(
            logging.Formatter("%(name)-12s: %(levelname)-8s %(message)s")
        )
        logger = logging.getLogger("Gramps")
        logger.addHandler(console)
        return console, logger

    def logging_adjust(verbose_level):
        if verbose_level == 1:
            logger.setLevel(logging.INFO)
            console.setLevel(logging.INFO)
        elif verbose_level == 2:
            logger.setLevel(logging.DEBUG)
            console.setLevel(logging.DEBUG)
        elif verbose_level == 3:
            logger.setLevel(logging.NOTSET)
            console.setLevel(logging.NOTSET)
        elif verbose_level >= 4:
            logger.setLevel(logging.NOTSET)
            console.setLevel(logging.NOTSET)
            os.environ["GRAMPS_SIGNAL"] = "1"
        else:
            logger.setLevel(logging.ERROR)
            console.setLevel(logging.ERROR)

    console, logger = logging_init()
    options, args = make_parser().parse_args()
    logging_adjust(options.verbose_level)

    # TODO allow multiple subdirs, modules, or testnames
    #  (see unittest.py)
    # hmmm this is starting to look like a unittest.Testprog
    # (maybe with a custom TestLoader)
    if args and os.path.isdir(args[0]):
        loc = args[0].rstrip(os.path.sep)
    else:
        loc = gramps_root

    utests, ptests = getTestSuites(loc)
    if options.performance:
        suite = unittest.TestSuite(ptests)
    else:
        suite = unittest.TestSuite(utests)

    unittest.TextTestRunner(verbosity=options.verbose_level).run(suite)

# ===eof===
