import py

pydir = py.path.local(py.__file__).dirpath()
pytestpath = pydir.join("bin", "py.test")
EXPECTTIMEOUT=10.0

class TestPyTest:
    def test_config_error(self, testdir):
        testdir.makeconftest("""
            class ConftestPlugin:
                def pytest_configure(self, config):
                    raise config.Error("hello")
        """)
        result = testdir.runpytest(testdir.tmpdir)
        assert result.ret != 0
        assert result.stderr.fnmatch_lines([
            'config ERROR: hello'
        ])

    def test_basetemp(self, testdir):
        mytemp = testdir.tmpdir.mkdir("mytemp")
        p = testdir.makepyfile("""
            import py
            def test_1(): 
                py.test.ensuretemp('xyz')
        """)
        result = testdir.runpytest(p, '--basetemp=%s' %mytemp)
        assert result.ret == 0
        assert mytemp.join('xyz').check(dir=1)
                
    def test_assertion_magic(self, testdir):
        p = testdir.makepyfile("""
            def test_this():
                x = 0
                assert x
        """)
        result = testdir.runpytest(p)
        extra = result.stdout.fnmatch_lines([
            ">       assert x", 
            "E       assert 0",
        ])
        assert result.ret == 1

    def test_collectonly_simple(self, testdir):
        p = testdir.makepyfile("""
            def test_func1():
                pass
            class TestClass:
                def test_method(self):
                    pass
        """)
        result = testdir.runpytest("--collectonly", p)
        stderr = result.stderr.str().strip()
        assert stderr.startswith("inserting into sys.path")
        assert result.ret == 0
        extra = result.stdout.fnmatch_lines(py.code.Source("""
            <Module '*.py'>
              <Function 'test_func1'*>
              <Class 'TestClass'>
                <Instance '()'>
                  <Function 'test_method'*>
        """).strip())

    def test_collectonly_error(self, testdir):
        p = testdir.makepyfile("import Errlkjqweqwe")
        result = testdir.runpytest("--collectonly", p)
        stderr = result.stderr.str().strip()
        assert stderr.startswith("inserting into sys.path")
        assert result.ret == 1
        extra = result.stdout.fnmatch_lines(py.code.Source("""
            <Module '*.py'>
              *ImportError*
            !!!*failures*!!!
            *test_collectonly_error.py:1*
        """).strip())


    def test_nested_import_error(self, testdir):
        p = testdir.makepyfile("""
                import import_fails
                def test_this():
                    assert import_fails.a == 1
        """)
        testdir.makepyfile(import_fails="import does_not_work")
        result = testdir.runpytest(p)
        extra = result.stdout.fnmatch_lines([
            ">   import import_fails",
            "E   ImportError: No module named does_not_work",
        ])
        assert result.ret == 1

    def test_skipped_reasons(self, testdir):
        testdir.makepyfile(
            test_one="""
                from conftest import doskip
                def setup_function(func):
                    doskip()
                def test_func():
                    pass
                class TestClass:
                    def test_method(self):
                        doskip()
           """,
           test_two = """
                from conftest import doskip
                doskip()
           """,
           conftest = """
                import py
                def doskip():
                    py.test.skip('test')
            """
        )
        result = testdir.runpytest() 
        extra = result.stdout.fnmatch_lines([
            "*test_one.py ss",
            "*test_two.py S",
            "___* skipped test summary *_", 
            "*conftest.py:3: *3* Skipped: 'test'", 
        ])
        assert result.ret == 0

    def test_deselected(self, testdir):
        testpath = testdir.makepyfile("""
                def test_one():
                    pass
                def test_two():
                    pass
                def test_three():
                    pass
           """
        )
        result = testdir.runpytest("-k", "test_two:", testpath)
        extra = result.stdout.fnmatch_lines([
            "*test_deselected.py ..", 
            "=* 1 test*deselected by 'test_two:'*=", 
        ])
        assert result.ret == 0

    def test_no_skip_summary_if_failure(self, testdir):
        testdir.makepyfile("""
            import py
            def test_ok():
                pass
            def test_fail():
                assert 0
            def test_skip():
                py.test.skip("dontshow")
        """)
        result = testdir.runpytest() 
        assert result.stdout.str().find("skip test summary") == -1
        assert result.ret == 1

    def test_passes(self, testdir):
        p1 = testdir.makepyfile("""
            def test_passes():
                pass
            class TestClass:
                def test_method(self):
                    pass
        """)
        old = p1.dirpath().chdir()
        try:
            result = testdir.runpytest()
        finally:
            old.chdir()
        extra = result.stdout.fnmatch_lines([
            "test_passes.py ..", 
            "* 2 pass*",
        ])
        assert result.ret == 0

    def test_header_trailer_info(self, testdir):
        p1 = testdir.makepyfile("""
            def test_passes():
                pass
        """)
        result = testdir.runpytest()
        verinfo = ".".join(map(str, py.std.sys.version_info[:3]))
        extra = result.stdout.fnmatch_lines([
            "*===== test session starts ====*",
            "HOSTUP*INPROCESS* %s %s - Python %s*" %(
                    py.std.sys.platform, py.std.sys.executable, verinfo),
            "*test_header_trailer_info.py .",
            "=* 1 passed in *.[0-9][0-9] seconds *=", 
        ])

    def test_traceback_failure(self, testdir):
        p1 = testdir.makepyfile("""
            def g():
                return 2
            def f(x):
                assert x == g()
            def test_onefails():
                f(3)
        """)
        result = testdir.runpytest(p1)
        result.stdout.fnmatch_lines([
            "*test_traceback_failure.py F", 
            "====* FAILURES *====",
            "____*____", 
            "",
            "    def test_onefails():",
            ">       f(3)",
            "",
            "*test_*.py:6: ",
            "_ _ _ *",
            #"",
            "    def f(x):",
            ">       assert x == g()",
            "E       assert 3 == 2",
            "E        +  where 2 = g()",
            "",
            "*test_traceback_failure.py:4: AssertionError"
        ])

    def test_capturing_outerr(self, testdir): 
        p1 = testdir.makepyfile("""
            import sys 
            def test_capturing():
                print 42
                print >>sys.stderr, 23 
            def test_capturing_error():
                print 1
                print >>sys.stderr, 2
                raise ValueError
        """)
        result = testdir.runpytest(p1)
        result.stdout.fnmatch_lines([
            "*test_capturing_outerr.py .F", 
            "====* FAILURES *====",
            "____*____", 
            "*test_capturing_outerr.py:8: ValueError",
            "*--- Captured stdout ---*",
            "1",
            "*--- Captured stderr ---*",
            "2",
        ])

    def test_showlocals(self, testdir): 
        p1 = testdir.makepyfile("""
            def test_showlocals():
                x = 3
                y = "x" * 5000 
                assert 0
        """)
        result = testdir.runpytest(p1, '-l')
        result.stdout.fnmatch_lines([
            #"_ _ * Locals *", 
            "x* = 3",
            "y* = 'xxxxxx*"
        ])


    def test_dist_testing(self, testdir):
        p1 = testdir.makepyfile("""
                import py
                def test_fail0():
                    assert 0
                def test_fail1():
                    raise ValueError()
                def test_ok():
                    pass
                def test_skip():
                    py.test.skip("hello")
            """, 
        )
        result = testdir.runpytest(p1, '-d', '--gateways=popen,popen')
        result.stdout.fnmatch_lines([
            "HOSTUP: popen*Python*",
            #"HOSTUP: localhost*Python*",
            #"HOSTUP: localhost*Python*",
            "*2 failed, 1 passed, 1 skipped*",
        ])
        assert result.ret == 1

    def test_dist_testing_conftest_specified(self, testdir):
        p1 = testdir.makepyfile("""
                import py
                def test_fail0():
                    assert 0
                def test_fail1():
                    raise ValueError()
                def test_ok():
                    pass
                def test_skip():
                    py.test.skip("hello")
            """, 
        )
        testdir.makeconftest("""
            pytest_option_gateways='popen,popen,popen'
        """)
        result = testdir.runpytest(p1, '-d')
        result.stdout.fnmatch_lines([
            "HOSTUP: popen*Python*",
            #"HOSTUP: localhost*Python*",
            #"HOSTUP: localhost*Python*",
            "*2 failed, 1 passed, 1 skipped*",
        ])
        assert result.ret == 1

    def test_dist_tests_with_crash(self, testdir):
        if not hasattr(py.std.os, 'kill'):
            py.test.skip("no os.kill")
        
        p1 = testdir.makepyfile("""
                import py
                def test_fail0():
                    assert 0
                def test_fail1():
                    raise ValueError()
                def test_ok():
                    pass
                def test_skip():
                    py.test.skip("hello")
                def test_crash():
                    import time
                    import os
                    time.sleep(0.5)
                    os.kill(os.getpid(), 15)
            """
        )
        result = testdir.runpytest(p1, '-d', '--gateways=popen,popen,popen')
        result.stdout.fnmatch_lines([
            "*popen*Python*",
            "*popen*Python*",
            "*popen*Python*",
            "HostDown*TERMINATED*",
            "*3 failed, 1 passed, 1 skipped*"
        ])
        assert result.ret == 1

    def test_keyboard_interrupt(self, testdir):
        p1 = testdir.makepyfile("""
            import py
            def test_fail():
                raise ValueError()
            def test_inter():
                raise KeyboardInterrupt()
        """)
        result = testdir.runpytest(p1)
        result.stdout.fnmatch_lines([
            #"*test_inter() INTERRUPTED",
            "*KEYBOARD INTERRUPT*",
            "*1 failed*", 
        ])

    def test_verbose_reporting(self, testdir):
        p1 = testdir.makepyfile("""
            import py
            def test_fail():
                raise ValueError()
            def test_pass():
                pass
            class TestClass:
                def test_skip(self):
                    py.test.skip("hello")
            def test_gen():
                def check(x):
                    assert x == 1
                yield check, 0
        """)
        result = testdir.runpytest(p1, '-v')
        result.stdout.fnmatch_lines([
            "*test_verbose_reporting.py:2: test_fail*FAIL", 
            "*test_verbose_reporting.py:4: test_pass*PASS",
            "*test_verbose_reporting.py:7: TestClass.test_skip*SKIP",
            "*test_verbose_reporting.py:10: test_gen*FAIL",
        ])
        assert result.ret == 1

class TestInteractive:
    def getspawn(self, tmpdir):
        pexpect = py.test.importorskip("pexpect")
        basetemp = tmpdir.mkdir("basetemp")
        def spawn(cmd):
            cmd = cmd + " --basetemp=" + str(basetemp)
            return pexpect.spawn(cmd, logfile=tmpdir.join("spawn.out").open("w"))
        return spawn

    def requirespexpect(self, version_needed):
        pexpect = py.test.importorskip("pexpect")
        ver = tuple(map(int, pexpect.__version__.split(".")))
        if ver < version_needed:
            py.test.skip("pexpect version %s needed" %(".".join(map(str, version_needed))))
       
    def test_pdb_interaction(self, testdir):
        self.requirespexpect((2,3))
        spawn = self.getspawn(testdir.tmpdir)
        p1 = testdir.makepyfile("""
            def test_1():
                i = 0
                assert i == 1
        """)
        child = spawn("%s %s --pdb %s" % (py.std.sys.executable, pytestpath, p1))
        child.timeout = EXPECTTIMEOUT
        #child.expect(".*def test_1.*")
        child.expect(".*i = 0.*")
        child.expect("(Pdb)")
        child.sendeof()
        child.expect("1 failed")
        if child.isalive(): 
            child.wait()

    def test_simple_looponfailing_interaction(self, testdir):
        spawn = self.getspawn(testdir.tmpdir)
        p1 = testdir.makepyfile("""
            def test_1():
                assert 1 == 0 
        """)
        p1.setmtime(p1.mtime() - 50.0)  
        child = spawn("%s %s --looponfailing %s" % (py.std.sys.executable, pytestpath, p1))
        child.timeout = EXPECTTIMEOUT
        child.expect("assert 1 == 0")
        child.expect("test_simple_looponfailing_interaction.py:")
        child.expect("1 failed")
        child.expect("waiting for changes")
        p1.write(py.code.Source("""
            def test_1():
                assert 1 == 1
        """))
        child.expect("MODIFIED.*test_simple_looponfailing_interaction.py", timeout=4.0)
        child.expect("1 passed", timeout=5.0)
        child.kill(15)

    @py.test.mark.xfail("need new cmdline option")
    def test_dist_each(self, testdir):
        for name in ("python2.4", "python2.5"):
            if not py.path.local.sysfind(name):
                py.test.skip("%s not found" % name)
        testdir.makepyfile(__init__="", test_one="""
            import sys
            def test_hello():
                print sys.version_info[:2]
                assert 0
        """)
        result = testdir.runpytest("--dist-each", "--gateways=popen-python2.5,popen-python2.4")
        assert result.ret == 1
        result.stdout.fnmatch_lines([
            "*popen-python2.5*FAIL*", 
            "*popen-python2.4*FAIL*",
            "*2 failed*"
        ])