[svn r37264] create the new development trunk

--HG-- branch : trunk
2007-01-24 15:24:01 +01:00
commit 5992a8ef21
435 changed files with 58640 additions and 0 deletions
@@ -0,0 +1,455 @@
+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 XXXtest_finds_root(): 
+    fn = datadir / 'filetest.py'
+    col = py.test.collect.Module(fn) 
+    root, namelist = col.fromroot() 
+    assert isinstance(root, py.test.collect.Directory) 
+    cur = root
+    for x in namelist: 
+        cur = cur.join(x) 
+    assert cur.name == col.name 
+    assert cur.parent == col.parent  
+    assert cur.fspath == cur.fspath 
+
+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
+        """)
+
+    from py.__.test.collect import getfscollector
+    for x in (o, checkfile, checkfile.dirpath()): 
+        #print "checking that %s returns custom items" % (x,) 
+        col = getfscollector(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')
+
+    from py.__.test.collect import getfscollector
+    for x in (o, checkfile, checkfile.dirpath()): 
+        print "checking that %s returns custom items" % (x,) 
+        col = getfscollector(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():
+    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():
+    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 
+        
+