from __future__ import generators
import py
from setupdata import setupdatadir

def setup_module(mod):
    mod.datadir = setupdatadir()
    mod.tmpdir = py.test.ensuretemp('test_collect') 

def test_failing_import_execfile():
    dest = datadir / 'failingimport.py'
    col = py.test.collect.Module(dest) 
    py.test.raises(ImportError, col.run)
    py.test.raises(ImportError, col.run)

def test_collect_listnames_and_back():
    col1 = py.test.collect.Directory(datadir.dirpath())
    col2 = col1.join(datadir.basename) 
    col3 = col2.join('filetest.py')
    l = col3.listnames()
    assert len(l) == 3
    x = col1.getitembynames(l[1:])
    assert x.name == "filetest.py"
    x = col1.getitembynames("/".join(l[1:]))
    assert x.name == "filetest.py"
    l2 = x.listnames()
    assert len(l2) == 3

def test_finds_tests(): 
    fn = datadir / 'filetest.py'
    col = py.test.collect.Module(fn) 
    l = col.run() 
    assert len(l) == 2 
    assert l[0] == 'test_one' 
    assert l[1] == 'TestClass' 

def test_found_certain_testfiles(): 
    tmp = py.test.ensuretemp("found_certain_testfiles")
    tmp.ensure('test_found.py')
    tmp.ensure('found_test.py')

    colitem = py.test.collect.Directory(tmp) 
    items = list(colitem.tryiter(py.test.collect.Module))
    assert len(items) == 2
    items = [item.name for item in items]
    assert 'test_found.py' in items
    assert 'found_test.py' in items

def test_ignored_certain_directories(): 
    tmp = py.test.ensuretemp("ignore_certain_directories")
    tmp.ensure("_darcs", 'test_notfound.py')
    tmp.ensure("CVS", 'test_notfound.py')
    tmp.ensure("{arch}", 'test_notfound.py')
    tmp.ensure(".whatever", 'test_notfound.py')
    tmp.ensure(".bzr", 'test_notfound.py')
    tmp.ensure("normal", 'test_found.py')
    tmp.ensure('test_found.py')

    colitem = py.test.collect.Directory(tmp) 
    items = list(colitem.tryiter(py.test.collect.Module))
    assert len(items) == 2
    for item in items: 
        assert item.name == 'test_found.py' 

def test_failing_import_directory():
    class MyDirectory(py.test.collect.Directory):
        def filefilter(self, p):
            return p.check(fnmatch='testspecial*.py')
    mydir = MyDirectory(datadir)
    l = mydir.run() 
    assert len(l) == 1
    item = mydir.join(l[0])
    assert isinstance(item, py.test.collect.Module)
    py.test.raises(ImportError, item.run)

def test_module_file_not_found():
    fn = datadir.join('nada','no')
    col = py.test.collect.Module(fn) 
    py.test.raises(py.error.ENOENT, col.run) 

def test_syntax_error_in_module():
    (datadir / 'syntax_error.py').write("\nthis is really not python\n")
    modpath = datadir.join('syntax_error.py') 
    col = py.test.collect.Module(modpath) 
    py.test.raises(SyntaxError, col.run)
    (datadir / 'syntax_error.py').remove()

def test_disabled_class():
    col = py.test.collect.Module(datadir.join('disabled.py'))
    l = col.run() 
    assert len(l) == 1
    colitem = col.join(l[0])
    assert isinstance(colitem, py.test.collect.Class)
    assert not colitem.run() 

def test_disabled_module():
    col = py.test.collect.Module(datadir.join('disabled_module.py'))
    l = col.run() 
    assert len(l) == 0

class Testsomeclass:
    disabled = True
    def test_something():
        raise ValueError


#class TestWithCustomItem:
#    class Item(py.test.Item):
#        flag = []
#        def execute(self, target, *args):
#            self.flag.append(42)
#            target(*args)
#
#    def test_hello(self):
#        assert self.Item.flag == [42]
#

def test_generative_simple(): 
    o = tmpdir.ensure('generativetest', dir=1)
    tfile = o.join('test_generative.py')
    tfile.write(py.code.Source("""
        from __future__ import generators # python2.2!
        def func1(arg, arg2): 
            assert arg == arg2 

        def test_gen(): 
            yield func1, 17, 3*5
            yield func1, 42, 6*7

        class TestGenMethods: 
            def test_gen(self): 
                yield func1, 17, 3*5
                yield func1, 42, 6*7
    """))
    col = py.test.collect.Module(tfile) 
    l = col.run() 
    assert len(l) == 2 
    l = col.multijoin(l) 

    generator = l[0]
    assert isinstance(generator, py.test.collect.Generator)
    l2 = generator.run() 
    assert len(l2) == 2 
    l2 = generator.multijoin(l2) 
    assert isinstance(l2[0], py.test.Function)
    assert isinstance(l2[1], py.test.Function)
    assert l2[0].name == '[0]'
    assert l2[1].name == '[1]'

    assert l2[0].obj.func_name == 'func1' 
 
    classlist = l[1].run() 
    assert len(classlist) == 1
    classlist = l[1].multijoin(classlist) 
    cls = classlist[0]
    generator = cls.join(cls.run()[0])
    assert isinstance(generator, py.test.collect.Generator)
    l2 = generator.run() 
    assert len(l2) == 2 
    l2 = generator.multijoin(l2) 
    assert isinstance(l2[0], py.test.Function)
    assert isinstance(l2[1], py.test.Function)
    assert l2[0].name == '[0]'
    assert l2[1].name == '[1]'
   
def test_custom_python_collection_from_conftest():
    o = tmpdir.ensure('customconfigtest', dir=1)
    o.ensure('conftest.py').write("""if 1:
        import py
        class MyFunction(py.test.Function):
            pass
        class Directory(py.test.collect.Directory):
            def filefilter(self, fspath):
                return fspath.check(basestarts='check_', ext='.py')
        class myfuncmixin: 
            Function = MyFunction
            def funcnamefilter(self, name): 
                return name.startswith('check_') 

        class Module(myfuncmixin, py.test.collect.Module):
            def classnamefilter(self, name): 
                return name.startswith('CustomTestClass') 
        class Instance(myfuncmixin, py.test.collect.Instance):
            pass 
        """)
    checkfile = o.ensure('somedir', 'check_something.py')
    checkfile.write("""if 1:
        def check_func():
            assert 42 == 42
        class CustomTestClass:
            def check_method(self):
                assert 23 == 23
        """)

    for x in (o, checkfile, checkfile.dirpath()): 
        config = py.test.config._reparse([x])
        #print "checking that %s returns custom items" % (x,) 
        col = config._getcollector(x)
        assert len(list(col.tryiter(py.test.Item))) == 2 
        #assert items[1].__class__.__name__ == 'MyFunction'

    # test that running a session works from the directories
    old = o.chdir() 
    try: 
        config = py.test.config._reparse([]) 
        out = py.std.cStringIO.StringIO()
        session = config._getsessionclass()(config, out) 
        session.main() 
        l = session.getitemoutcomepairs(py.test.Item.Passed) 
        assert len(l) == 2
    finally: 
        old.chdir() 

    # test that running the file directly works 
    config = py.test.config._reparse([str(checkfile)]) 
    out = py.std.cStringIO.StringIO()
    session = config._getsessionclass()(config, out) 
    session.main() 
    l = session.getitemoutcomepairs(py.test.Item.Passed) 
    assert len(l) == 2

def test_custom_NONpython_collection_from_conftest():
    o = tmpdir.ensure('customconfigtest_nonpython', dir=1)
    o.ensure('conftest.py').write("""if 1:
        import py
        class CustomItem(py.test.Item): 
            def run(self):
                pass

        class Directory(py.test.collect.Directory):
            def filefilter(self, fspath):
                return fspath.check(basestarts='check_', ext='.txt')
            def join(self, name):
                if not name.endswith('.txt'): 
                    return super(Directory, self).join(name) 
                p = self.fspath.join(name) 
                if p.check(file=1): 
                    return CustomItem(p, parent=self)
        """)
    checkfile = o.ensure('somedir', 'moredir', 'check_something.txt')

    for x in (o, checkfile, checkfile.dirpath()): 
        print "checking that %s returns custom items" % (x,) 
        config = py.test.config._reparse([x])
        col = config._getcollector(x)
        assert len(list(col.tryiter(py.test.Item))) == 1
        #assert items[1].__class__.__name__ == 'MyFunction'

    # test that running a session works from the directories
    old = o.chdir() 
    try: 
        config = py.test.config._reparse([]) 
        out = py.std.cStringIO.StringIO()
        session = config._getsessionclass()(config, out) 
        session.main() 
        l = session.getitemoutcomepairs(py.test.Item.Passed) 
        assert len(l) == 1
    finally: 
        old.chdir() 

    # test that running the file directly works 
    config = py.test.config._reparse([str(checkfile)]) 
    out = py.std.cStringIO.StringIO()
    session = config._getsessionclass()(config, out) 
    session.main() 
    l = session.getitemoutcomepairs(py.test.Item.Passed) 
    assert len(l) == 1

def test_order_of_execution_generator_same_codeline():
    if py.test.config.is_boxed():
        py.test.skip("Does not work with boxing")
    test_list = []
    expected_list = range(6)

    def list_append(item):
        test_list.append(item)
        
    def assert_order_of_execution():
        print 'expected order', expected_list
        print 'but got       ', test_list
        assert test_list == expected_list
    
    for i in expected_list:
        yield list_append, i
    yield assert_order_of_execution


def test_order_of_execution_generator_different_codeline():
    if py.test.config.is_boxed():
        py.test.skip("Does not work with boxing")
    test_list = []
    expected_list = range(3)

    def list_append_2():
        test_list.append(2)

    def list_append_1():
        test_list.append(1)

    def list_append_0():
        test_list.append(0)

    def assert_order_of_execution():
        print 'expected order', expected_list
        print 'but got       ', test_list
        assert test_list == expected_list
        
    yield list_append_0
    yield list_append_1
    yield list_append_2
    yield assert_order_of_execution   


def test_documentation_virtual_collector_interaction():
    rootdir = py.path.local(py.__file__).dirpath("doc")
    # HACK 
    from py.__.doc import conftest as conf
    old = conf.option.forcegen
    try:
        conf.option.forcegen = 1
        col = py.test.collect.Directory(rootdir)
        x = list(col.tryiter(yieldtype=py.test.Function))
    finally:
        conf.option.forcegen = old
    

def test_tryiter_ignores_skips():
    tmp = py.test.ensuretemp("tryiterskip")
    tmp.ensure("subdir", "conftest.py").write(py.code.Source("""
        import py
        class Directory(py.test.collect.Directory):
            def run(self):
                py.test.skip("intentional")
    """))
    col = py.test.collect.Directory(tmp)
    try:
        list(col.tryiter())
    except KeyboardInterrupt: 
        raise
    except:
        exc = py.code.ExceptionInfo() 
        py.test.fail("should not have raised: %s"  %(exc,))
    
    
def test_tryiter_ignores_failing_collectors(): 
    tmp = py.test.ensuretemp("tryiterfailing")
    tmp.ensure("subdir", "conftest.py").write(py.code.Source("""
        bla bla bla
    """))
    col = py.test.collect.Directory(tmp)
    try:
        list(col.tryiter())
    except KeyboardInterrupt: 
        raise
    except:
        exc = py.code.ExceptionInfo() 
        py.test.fail("should not have raised: %s"  %(exc,))

    l = []
    list(col.tryiter(reporterror=l.append))
    assert len(l) == 2
    excinfo, item = l[-1]
    assert isinstance(excinfo, py.code.ExceptionInfo)

def test_tryiter_handles_keyboardinterrupt(): 
    tmp = py.test.ensuretemp("tryiterkeyboard")
    tmp.ensure("subdir", "conftest.py").write(py.code.Source("""
        raise KeyboardInterrupt() 
    """))
    col = py.test.collect.Directory(tmp)
    py.test.raises(KeyboardInterrupt, list, col.tryiter())

def test_check_random_inequality():
    tmp = py.test.ensuretemp("ineq")
    tmp.ensure("test_x.py").write(py.code.Source("""def test_one():
        pass
    """))
    col = py.test.collect.Directory(tmp)
    fn = col.tryiter().next()
    assert fn != 3
    assert fn != col
    assert fn != [1,2,3]
    assert [1,2,3] != fn
    assert col != fn

def test_check_generator_collect_problems():
    tmp = py.test.ensuretemp("gener_coll")
    tmp.ensure("test_one.py").write(py.code.Source("""
        def setup_module(mod):
            mod.x = [1,2,3]
        
        def check(zzz):
            assert zzz
        
        def test_one():
            for i in x:
                yield check, i
    """))
    tmp.ensure("__init__.py")
    col = py.test.collect.Module(tmp.join("test_one.py"))
    errors = []
    l = list(col.tryiter(reporterror=errors.append))
    assert len(errors) == 2

def test_check_collect_hashes():
    tmp = py.test.ensuretemp("check_collect_hashes")
    tmp.ensure("test_one.py").write(py.code.Source("""
        def test_1():
            pass
        
        def test_2():
            pass
    """))
    tmp.ensure("test_two.py").write(py.code.Source("""
        def test_1():
            pass
        
        def test_2():
            pass
    """))
    tmp.ensure("__init__.py")
    col = py.test.collect.Directory(tmp)
    l = list(col.tryiter())
    assert len(l) == 4
    for numi, i in enumerate(l):
        for numj, j in enumerate(l):
            if numj != numi:
                assert hash(i) != hash(j)
                assert i != j


def test_check_directory_ordered():
    tmpdir = py.test.ensuretemp("test_check_directory_ordered")
    fnames = []
    for i in range(9, -1, -1):
        x = tmpdir.ensure("xdir%d" %(i, ), dir=1)
        fnames.append(x.basename)
    for i in range(9, -1, -1):
        x = tmpdir.ensure("test_file%d.py" % (i,))
        fnames.append(x.basename)
    fnames.sort()
    tmpdir.ensure('adir', dir=1)
    fnames.insert(10, 'adir')
    col = py.test.collect.Directory(tmpdir)
    names = col.run()
    assert names == fnames