import sys, os, string, re
import pythoncom
import win32com.client
from win32com.test.util import CheckClean, TestCase,  \
            CapturingFunctionTestCase, ShellTestCase, \
            TestLoader, TestRunner, RegisterPythonServer
import traceback
import getopt

import unittest

verbosity = 1 # default unittest verbosity.

try:
    this_file = __file__
except NameError:
    this_file = sys.argv[0]

def GenerateAndRunOldStyle():
    import GenTestScripts
    GenTestScripts.GenerateAll()
    try:
        pass #
    finally:
        GenTestScripts.CleanAll()

def CleanGenerated():
    import win32com, shutil
    if os.path.isdir(win32com.__gen_path__):
        if verbosity > 1:
            print "Deleting files from %s" % (win32com.__gen_path__)
        shutil.rmtree(win32com.__gen_path__)
    import win32com.client.gencache
    win32com.client.gencache.__init__() # Reset

def RemoveRefCountOutput(data):
    while 1:
        last_line_pos = data.rfind("\n")
        if not re.match("\[\d+ refs\]", data[last_line_pos+1:]):
            break
        if last_line_pos < 0:
            # All the output
            return ''
        data = data[:last_line_pos]
        
    return data

def ExecuteSilentlyIfOK(cmd, testcase):
    f = os.popen(cmd)
    data = f.read().strip()
    rc = f.close()
    if rc:
        print data
        testcase.fail("Executing '%s' failed (%d)" % (cmd, rc))
    # for "_d" builds, strip the '[xxx refs]' line
    return RemoveRefCountOutput(data)

class PyCOMTest(TestCase):
    no_leak_tests = True # done by the test itself
    def testit(self):
        # Check that the item is registered, so we get the correct
        # 'skipped' behaviour (and recorded as such) rather than either
        # error or silence due to non-registration.
        RegisterPythonServer(os.path.join(os.path.dirname(__file__), '..', "servers", "test_pycomtest.py"),
                             "Python.Test.PyCOMTest")

        # Execute testPyComTest in its own process so it can play
        # with the Python thread state
        fname = os.path.join(os.path.dirname(this_file), "testPyComTest.py")
        cmd = '%s "%s" -q 2>&1' % (sys.executable, fname)
        data = ExecuteSilentlyIfOK(cmd, self)

class PippoTest(TestCase):
    def testit(self):
        # Check we are registered before spawning the process.
        from win32com.test import pippo_server
        RegisterPythonServer(pippo_server.__file__, "Python.Test.Pippo")

        python = sys.executable
        fname = os.path.join(os.path.dirname(this_file), "testPippo.py")
        cmd = '%s "%s" 2>&1' % (python, fname)
        ExecuteSilentlyIfOK(cmd, self)

# This is a list of "win32com.test.???" module names, optionally with a
# function in that module if the module isn't unitest based...
unittest_modules = [
        # Level 1 tests.
        """testIterators testvbscript_regexp testStorage 
          testStreams testWMI policySemantics testShell testROT
          testAXScript testxslt testDictionary testCollections
          testServers errorSemantics.test testvb testArrays
          testClipboard testMarshal
        """.split(),
        # Level 2 tests.
        """testMSOffice.TestAll testMSOfficeEvents.test testAccess.test
           testExplorer.TestAll testExchange.test
        """.split(),
        # Level 3 tests.
        """testmakepy.TestAll
        """.split()
]

# A list of other unittest modules we use - these are fully qualified module
# names and the module is assumed to be unittest based.
unittest_other_modules = [
        # Level 1 tests.
        """win32com.directsound.test.ds_test
        """.split(),
        # Level 2 tests.
        [],
        # Level 3 tests.
        []
]


output_checked_programs = [
        # Level 1 tests.
        [
            ("cscript.exe /nologo //E:vbscript testInterp.vbs", "VBScript test worked OK"),
            ("cscript.exe /nologo //E:vbscript testDictionary.vbs",
                         "VBScript has successfully tested Python.Dictionary"),
        ],
        # Level 2 tests.
        [
        ],
        # Level 3 tests
        [
        ],
]

custom_test_cases = [
        # Level 1 tests.
        [
            PyCOMTest,
            PippoTest,
        ],
        # Level 2 tests.
        [
        ],
        # Level 3 tests
        [
        ],
]

def get_test_mod_and_func(test_name, import_failures):
    if test_name.find(".")>0:
        mod_name, func_name = test_name.split(".")
    else:
        mod_name = test_name
        func_name = None
    fq_mod_name = "win32com.test." + mod_name
    try:
        __import__(fq_mod_name)
        mod = sys.modules[fq_mod_name]
    except:
        import_failures.append((mod_name, sys.exc_info()[:2]))
        return None, None
    if func_name is None:
        func = None
    else:
        func = getattr(mod, func_name)
    return mod, func

# Return a test suite all loaded with the tests we want to run
def make_test_suite(test_level = 1):
    suite = unittest.TestSuite()
    import_failures = []
    loader = TestLoader()
    for i in range(testLevel):
        for mod_name in unittest_modules[i]:
            mod, func = get_test_mod_and_func(mod_name, import_failures)
            if mod is None:
                continue
            if func is not None:
                test = CapturingFunctionTestCase(func, description=mod_name)
            else:
                if hasattr(mod, "suite"):
                    test = mod.suite()
                else:
                    test = loader.loadTestsFromModule(mod)
            assert test.countTestCases() > 0, "No tests loaded from %r" % mod
            suite.addTest(test)
        for cmd, output in output_checked_programs[i]:
            suite.addTest(ShellTestCase(cmd, output))

        for test_class in custom_test_cases[i]:
            suite.addTest(unittest.defaultTestLoader.loadTestsFromTestCase(test_class))
    # other "normal" unittest modules.
    for i in range(testLevel):
        for mod_name in unittest_other_modules[i]:
            try:
                __import__(mod_name)
            except:
                import_failures.append((mod_name, sys.exc_info()[:2]))
                continue
            
            mod = sys.modules[mod_name]
            if hasattr(mod, "suite"):
                test = mod.suite()
            else:
                test = loader.loadTestsFromModule(mod)
            assert test.countTestCases() > 0, "No tests loaded from %r" % mod
            suite.addTest(test)

    return suite, import_failures

def usage(why):
    print why
    print
    print "win32com test suite"
    print "usage: testall [-v] test_level"
    print "  where test_level is an integer 1-3.  Level 1 tests are quick,"
    print "  level 2 tests invoke Word, IE etc, level 3 take ages!"
    sys.exit(1)
    
if __name__=='__main__':
    try:
        opts, args = getopt.getopt(sys.argv[1:], "v")
    except getopt.error, why:
        usage(why)
    for opt, val in opts:
        if opt=='-v':
            verbosity += 1
    testLevel = 1 # default to quick test
    test_names = []
    for arg in args:
        try:
            testLevel = int(arg)
            if testLevel < 0 or testLevel > 3:
                raise ValueError("Only levels 1-3 are supported")
        except ValueError:
            test_names.append(arg)
    if test_names:
        usage("Test names are not supported yet")
    CleanGenerated()
    
    suite, import_failures = make_test_suite(testLevel)
    if verbosity:
        if hasattr(sys, "gettotalrefcount"):
            print "This is a debug build - memory leak tests will also be run."
            print "These tests may take *many* minutes to run - be patient!"
            print "(running from python.exe will avoid these leak tests)"
        print "Executing level %d tests - %d test cases will be run" \
                % (testLevel, suite.countTestCases())
        if verbosity==1 and suite.countTestCases() < 70:
            # A little row of markers so the dots show how close to finished
            print '|' * suite.countTestCases()
    testRunner = TestRunner(verbosity=verbosity)
    testResult = testRunner.run(suite)
    if import_failures:
        testResult.stream.writeln("*** The following test modules could not be imported ***")
        for mod_name, (exc_type, exc_val) in import_failures:
            desc = '\n'.join(traceback.format_exception_only(exc_type, exc_val))
            testResult.stream.write("%s: %s" % (mod_name, desc))
        testResult.stream.writeln("*** %d test(s) could not be run ***" % len(import_failures))
    
    # re-print unit-test error here so it is noticed
    if not testResult.wasSuccessful():
        print "*" * 20, "- unittest tests FAILED"
    
    CheckClean()
    pythoncom.CoUninitialize()
    CleanGenerated()
