import inspect import textwrap import pytest from _pytest.compat import MODULE_NOT_FOUND_ERROR from _pytest.doctest import _get_checker from _pytest.doctest import _is_mocked from _pytest.doctest import _is_setup_py from _pytest.doctest import _patch_unwrap_mock_aware from _pytest.doctest import DoctestItem from _pytest.doctest import DoctestModule from _pytest.doctest import DoctestTextfile class TestDoctests: def test_collect_testtextfile(self, testdir): w = testdir.maketxtfile(whatever="") checkfile = testdir.maketxtfile( test_something=""" alskdjalsdk >>> i = 5 >>> i-1 4 """ ) for x in (testdir.tmpdir, checkfile): # print "checking that %s returns custom items" % (x,) items, reprec = testdir.inline_genitems(x) assert len(items) == 1 assert isinstance(items[0], DoctestItem) assert isinstance(items[0].parent, DoctestTextfile) # Empty file has no items. items, reprec = testdir.inline_genitems(w) assert len(items) == 0 def test_collect_module_empty(self, testdir): path = testdir.makepyfile(whatever="#") for p in (path, testdir.tmpdir): items, reprec = testdir.inline_genitems(p, "--doctest-modules") assert len(items) == 0 def test_collect_module_single_modulelevel_doctest(self, testdir): path = testdir.makepyfile(whatever='""">>> pass"""') for p in (path, testdir.tmpdir): items, reprec = testdir.inline_genitems(p, "--doctest-modules") assert len(items) == 1 assert isinstance(items[0], DoctestItem) assert isinstance(items[0].parent, DoctestModule) def test_collect_module_two_doctest_one_modulelevel(self, testdir): path = testdir.makepyfile( whatever=""" '>>> x = None' def my_func(): ">>> magic = 42 " """ ) for p in (path, testdir.tmpdir): items, reprec = testdir.inline_genitems(p, "--doctest-modules") assert len(items) == 2 assert isinstance(items[0], DoctestItem) assert isinstance(items[1], DoctestItem) assert isinstance(items[0].parent, DoctestModule) assert items[0].parent is items[1].parent def test_collect_module_two_doctest_no_modulelevel(self, testdir): path = testdir.makepyfile( whatever=""" '# Empty' def my_func(): ">>> magic = 42 " def unuseful(): ''' # This is a function # >>> # it doesn't have any doctest ''' def another(): ''' # This is another function >>> import os # this one does have a doctest ''' """ ) for p in (path, testdir.tmpdir): items, reprec = testdir.inline_genitems(p, "--doctest-modules") assert len(items) == 2 assert isinstance(items[0], DoctestItem) assert isinstance(items[1], DoctestItem) assert isinstance(items[0].parent, DoctestModule) assert items[0].parent is items[1].parent def test_simple_doctestfile(self, testdir): p = testdir.maketxtfile( test_doc=""" >>> x = 1 >>> x == 1 False """ ) reprec = testdir.inline_run(p) reprec.assertoutcome(failed=1) def test_new_pattern(self, testdir): p = testdir.maketxtfile( xdoc=""" >>> x = 1 >>> x == 1 False """ ) reprec = testdir.inline_run(p, "--doctest-glob=x*.txt") reprec.assertoutcome(failed=1) def test_multiple_patterns(self, testdir): """Test support for multiple --doctest-glob arguments (#1255). """ testdir.maketxtfile( xdoc=""" >>> 1 1 """ ) testdir.makefile( ".foo", test=""" >>> 1 1 """, ) testdir.maketxtfile( test_normal=""" >>> 1 1 """ ) expected = {"xdoc.txt", "test.foo", "test_normal.txt"} assert {x.basename for x in testdir.tmpdir.listdir()} == expected args = ["--doctest-glob=xdoc*.txt", "--doctest-glob=*.foo"] result = testdir.runpytest(*args) result.stdout.fnmatch_lines(["*test.foo *", "*xdoc.txt *", "*2 passed*"]) result = testdir.runpytest() result.stdout.fnmatch_lines(["*test_normal.txt *", "*1 passed*"]) @pytest.mark.parametrize( " test_string, encoding", [("foo", "ascii"), ("öäü", "latin1"), ("öäü", "utf-8")], ) def test_encoding(self, testdir, test_string, encoding): """Test support for doctest_encoding ini option. """ testdir.makeini( """ [pytest] doctest_encoding={} """.format( encoding ) ) doctest = """ >>> "{}" {} """.format( test_string, repr(test_string) ) testdir._makefile(".txt", [doctest], {}, encoding=encoding) result = testdir.runpytest() result.stdout.fnmatch_lines(["*1 passed*"]) def test_doctest_unexpected_exception(self, testdir): testdir.maketxtfile( """ >>> i = 0 >>> 0 / i 2 """ ) result = testdir.runpytest("--doctest-modules") result.stdout.fnmatch_lines( [ "test_doctest_unexpected_exception.txt F *", "", "*= FAILURES =*", "*_ [[]doctest[]] test_doctest_unexpected_exception.txt _*", "001 >>> i = 0", "002 >>> 0 / i", "UNEXPECTED EXCEPTION: ZeroDivisionError*", "Traceback (most recent call last):", ' File "*/doctest.py", line *, in __run', " *", ' File "", line 1, in ', "ZeroDivisionError: division by zero", "*/test_doctest_unexpected_exception.txt:2: UnexpectedException", ], consecutive=True, ) def test_doctest_outcomes(self, testdir): testdir.maketxtfile( test_skip=""" >>> 1 1 >>> import pytest >>> pytest.skip("") >>> 2 3 """, test_xfail=""" >>> import pytest >>> pytest.xfail("xfail_reason") >>> foo bar """, test_importorskip=""" >>> import pytest >>> pytest.importorskip("doesnotexist") >>> foo bar """, ) result = testdir.runpytest("--doctest-modules") result.stdout.fnmatch_lines( [ "collected 3 items", "", "test_importorskip.txt s *", "test_skip.txt s *", "test_xfail.txt x *", "", "*= 2 skipped, 1 xfailed in *", ] ) def test_docstring_partial_context_around_error(self, testdir): """Test that we show some context before the actual line of a failing doctest. """ testdir.makepyfile( ''' def foo(): """ text-line-1 text-line-2 text-line-3 text-line-4 text-line-5 text-line-6 text-line-7 text-line-8 text-line-9 text-line-10 text-line-11 >>> 1 + 1 3 text-line-after """ ''' ) result = testdir.runpytest("--doctest-modules") result.stdout.fnmatch_lines( [ "*docstring_partial_context_around_error*", "005*text-line-3", "006*text-line-4", "013*text-line-11", "014*>>> 1 + 1", "Expected:", " 3", "Got:", " 2", ] ) # lines below should be trimmed out result.stdout.no_fnmatch_line("*text-line-2*") result.stdout.no_fnmatch_line("*text-line-after*") def test_docstring_full_context_around_error(self, testdir): """Test that we show the whole context before the actual line of a failing doctest, provided that the context is up to 10 lines long. """ testdir.makepyfile( ''' def foo(): """ text-line-1 text-line-2 >>> 1 + 1 3 """ ''' ) result = testdir.runpytest("--doctest-modules") result.stdout.fnmatch_lines( [ "*docstring_full_context_around_error*", "003*text-line-1", "004*text-line-2", "006*>>> 1 + 1", "Expected:", " 3", "Got:", " 2", ] ) def test_doctest_linedata_missing(self, testdir): testdir.tmpdir.join("hello.py").write( textwrap.dedent( """\ class Fun(object): @property def test(self): ''' >>> a = 1 >>> 1/0 ''' """ ) ) result = testdir.runpytest("--doctest-modules") result.stdout.fnmatch_lines( ["*hello*", "006*>>> 1/0*", "*UNEXPECTED*ZeroDivision*", "*1 failed*"] ) def test_doctest_linedata_on_property(self, testdir): testdir.makepyfile( """ class Sample(object): @property def some_property(self): ''' >>> Sample().some_property 'another thing' ''' return 'something' """ ) result = testdir.runpytest("--doctest-modules") result.stdout.fnmatch_lines( [ "*= FAILURES =*", "*_ [[]doctest[]] test_doctest_linedata_on_property.Sample.some_property _*", "004 ", "005 >>> Sample().some_property", "Expected:", " 'another thing'", "Got:", " 'something'", "", "*/test_doctest_linedata_on_property.py:5: DocTestFailure", "*= 1 failed in *", ] ) def test_doctest_no_linedata_on_overriden_property(self, testdir): testdir.makepyfile( """ class Sample(object): @property def some_property(self): ''' >>> Sample().some_property 'another thing' ''' return 'something' some_property = property(some_property.__get__, None, None, some_property.__doc__) """ ) result = testdir.runpytest("--doctest-modules") result.stdout.fnmatch_lines( [ "*= FAILURES =*", "*_ [[]doctest[]] test_doctest_no_linedata_on_overriden_property.Sample.some_property _*", "EXAMPLE LOCATION UNKNOWN, not showing all tests of that example", "[?][?][?] >>> Sample().some_property", "Expected:", " 'another thing'", "Got:", " 'something'", "", "*/test_doctest_no_linedata_on_overriden_property.py:None: DocTestFailure", "*= 1 failed in *", ] ) def test_doctest_unex_importerror_only_txt(self, testdir): testdir.maketxtfile( """ >>> import asdalsdkjaslkdjasd >>> """ ) result = testdir.runpytest() # doctest is never executed because of error during hello.py collection result.stdout.fnmatch_lines( [ "*>>> import asdals*", "*UNEXPECTED*{e}*".format(e=MODULE_NOT_FOUND_ERROR), "{e}: No module named *asdal*".format(e=MODULE_NOT_FOUND_ERROR), ] ) def test_doctest_unex_importerror_with_module(self, testdir): testdir.tmpdir.join("hello.py").write( textwrap.dedent( """\ import asdalsdkjaslkdjasd """ ) ) testdir.maketxtfile( """ >>> import hello >>> """ ) result = testdir.runpytest("--doctest-modules") # doctest is never executed because of error during hello.py collection result.stdout.fnmatch_lines( [ "*ERROR collecting hello.py*", "*{e}: No module named *asdals*".format(e=MODULE_NOT_FOUND_ERROR), "*Interrupted: 1 error during collection*", ] ) def test_doctestmodule(self, testdir): p = testdir.makepyfile( """ ''' >>> x = 1 >>> x == 1 False ''' """ ) reprec = testdir.inline_run(p, "--doctest-modules") reprec.assertoutcome(failed=1) def test_doctestmodule_external_and_issue116(self, testdir): p = testdir.mkpydir("hello") p.join("__init__.py").write( textwrap.dedent( """\ def somefunc(): ''' >>> i = 0 >>> i + 1 2 ''' """ ) ) result = testdir.runpytest(p, "--doctest-modules") result.stdout.fnmatch_lines( [ "003 *>>> i = 0", "004 *>>> i + 1", "*Expected:", "* 2", "*Got:", "* 1", "*:4: DocTestFailure", ] ) def test_txtfile_failing(self, testdir): p = testdir.maketxtfile( """ >>> i = 0 >>> i + 1 2 """ ) result = testdir.runpytest(p, "-s") result.stdout.fnmatch_lines( [ "001 >>> i = 0", "002 >>> i + 1", "Expected:", " 2", "Got:", " 1", "*test_txtfile_failing.txt:2: DocTestFailure", ] ) def test_txtfile_with_fixtures(self, testdir): p = testdir.maketxtfile( """ >>> dir = getfixture('tmpdir') >>> type(dir).__name__ 'LocalPath' """ ) reprec = testdir.inline_run(p) reprec.assertoutcome(passed=1) def test_txtfile_with_usefixtures_in_ini(self, testdir): testdir.makeini( """ [pytest] usefixtures = myfixture """ ) testdir.makeconftest( """ import pytest @pytest.fixture def myfixture(monkeypatch): monkeypatch.setenv("HELLO", "WORLD") """ ) p = testdir.maketxtfile( """ >>> import os >>> os.environ["HELLO"] 'WORLD' """ ) reprec = testdir.inline_run(p) reprec.assertoutcome(passed=1) def test_doctestmodule_with_fixtures(self, testdir): p = testdir.makepyfile( """ ''' >>> dir = getfixture('tmpdir') >>> type(dir).__name__ 'LocalPath' ''' """ ) reprec = testdir.inline_run(p, "--doctest-modules") reprec.assertoutcome(passed=1) def test_doctestmodule_three_tests(self, testdir): p = testdir.makepyfile( """ ''' >>> dir = getfixture('tmpdir') >>> type(dir).__name__ 'LocalPath' ''' def my_func(): ''' >>> magic = 42 >>> magic - 42 0 ''' def unuseful(): pass def another(): ''' >>> import os >>> os is os True ''' """ ) reprec = testdir.inline_run(p, "--doctest-modules") reprec.assertoutcome(passed=3) def test_doctestmodule_two_tests_one_fail(self, testdir): p = testdir.makepyfile( """ class MyClass(object): def bad_meth(self): ''' >>> magic = 42 >>> magic 0 ''' def nice_meth(self): ''' >>> magic = 42 >>> magic - 42 0 ''' """ ) reprec = testdir.inline_run(p, "--doctest-modules") reprec.assertoutcome(failed=1, passed=1) def test_ignored_whitespace(self, testdir): testdir.makeini( """ [pytest] doctest_optionflags = ELLIPSIS NORMALIZE_WHITESPACE """ ) p = testdir.makepyfile( """ class MyClass(object): ''' >>> a = "foo " >>> print(a) foo ''' pass """ ) reprec = testdir.inline_run(p, "--doctest-modules") reprec.assertoutcome(passed=1) def test_non_ignored_whitespace(self, testdir): testdir.makeini( """ [pytest] doctest_optionflags = ELLIPSIS """ ) p = testdir.makepyfile( """ class MyClass(object): ''' >>> a = "foo " >>> print(a) foo ''' pass """ ) reprec = testdir.inline_run(p, "--doctest-modules") reprec.assertoutcome(failed=1, passed=0) def test_ignored_whitespace_glob(self, testdir): testdir.makeini( """ [pytest] doctest_optionflags = ELLIPSIS NORMALIZE_WHITESPACE """ ) p = testdir.maketxtfile( xdoc=""" >>> a = "foo " >>> print(a) foo """ ) reprec = testdir.inline_run(p, "--doctest-glob=x*.txt") reprec.assertoutcome(passed=1) def test_non_ignored_whitespace_glob(self, testdir): testdir.makeini( """ [pytest] doctest_optionflags = ELLIPSIS """ ) p = testdir.maketxtfile( xdoc=""" >>> a = "foo " >>> print(a) foo """ ) reprec = testdir.inline_run(p, "--doctest-glob=x*.txt") reprec.assertoutcome(failed=1, passed=0) def test_contains_unicode(self, testdir): """Fix internal error with docstrings containing non-ascii characters. """ testdir.makepyfile( '''\ def foo(): """ >>> name = 'с' # not letter 'c' but instead Cyrillic 's'. 'anything' """ ''' ) result = testdir.runpytest("--doctest-modules") result.stdout.fnmatch_lines(["Got nothing", "* 1 failed in*"]) def test_ignore_import_errors_on_doctest(self, testdir): p = testdir.makepyfile( """ import asdf def add_one(x): ''' >>> add_one(1) 2 ''' return x + 1 """ ) reprec = testdir.inline_run( p, "--doctest-modules", "--doctest-ignore-import-errors" ) reprec.assertoutcome(skipped=1, failed=1, passed=0) def test_junit_report_for_doctest(self, testdir): """ #713: Fix --junit-xml option when used with --doctest-modules. """ p = testdir.makepyfile( """ def foo(): ''' >>> 1 + 1 3 ''' pass """ ) reprec = testdir.inline_run(p, "--doctest-modules", "--junit-xml=junit.xml") reprec.assertoutcome(failed=1) def test_unicode_doctest(self, testdir): """ Test case for issue 2434: DecodeError on Python 2 when doctest contains non-ascii characters. """ p = testdir.maketxtfile( test_unicode_doctest=""" .. doctest:: >>> print( ... "Hi\\n\\nByé") Hi ... Byé >>> 1/0 # Byé 1 """ ) result = testdir.runpytest(p) result.stdout.fnmatch_lines( ["*UNEXPECTED EXCEPTION: ZeroDivisionError*", "*1 failed*"] ) def test_unicode_doctest_module(self, testdir): """ Test case for issue 2434: DecodeError on Python 2 when doctest docstring contains non-ascii characters. """ p = testdir.makepyfile( test_unicode_doctest_module=""" def fix_bad_unicode(text): ''' >>> print(fix_bad_unicode('único')) único ''' return "único" """ ) result = testdir.runpytest(p, "--doctest-modules") result.stdout.fnmatch_lines(["* 1 passed *"]) def test_print_unicode_value(self, testdir): """ Test case for issue 3583: Printing Unicode in doctest under Python 2.7 doesn't work """ p = testdir.maketxtfile( test_print_unicode_value=r""" Here is a doctest:: >>> print('\xE5\xE9\xEE\xF8\xFC') åéîøü """ ) result = testdir.runpytest(p) result.stdout.fnmatch_lines(["* 1 passed *"]) def test_reportinfo(self, testdir): """ Test case to make sure that DoctestItem.reportinfo() returns lineno. """ p = testdir.makepyfile( test_reportinfo=""" def foo(x): ''' >>> foo('a') 'b' ''' return 'c' """ ) items, reprec = testdir.inline_genitems(p, "--doctest-modules") reportinfo = items[0].reportinfo() assert reportinfo[1] == 1 def test_valid_setup_py(self, testdir): """ Test to make sure that pytest ignores valid setup.py files when ran with --doctest-modules """ p = testdir.makepyfile( setup=""" from setuptools import setup, find_packages setup(name='sample', version='0.0', description='description', packages=find_packages() ) """ ) result = testdir.runpytest(p, "--doctest-modules") result.stdout.fnmatch_lines(["*collected 0 items*"]) def test_invalid_setup_py(self, testdir): """ Test to make sure that pytest reads setup.py files that are not used for python packages when ran with --doctest-modules """ p = testdir.makepyfile( setup=""" def test_foo(): return 'bar' """ ) result = testdir.runpytest(p, "--doctest-modules") result.stdout.fnmatch_lines(["*collected 1 item*"]) class TestLiterals: @pytest.mark.parametrize("config_mode", ["ini", "comment"]) def test_allow_unicode(self, testdir, config_mode): """Test that doctests which output unicode work in all python versions tested by pytest when the ALLOW_UNICODE option is used (either in the ini file or by an inline comment). """ if config_mode == "ini": testdir.makeini( """ [pytest] doctest_optionflags = ALLOW_UNICODE """ ) comment = "" else: comment = "#doctest: +ALLOW_UNICODE" testdir.maketxtfile( test_doc=""" >>> b'12'.decode('ascii') {comment} '12' """.format( comment=comment ) ) testdir.makepyfile( foo=""" def foo(): ''' >>> b'12'.decode('ascii') {comment} '12' ''' """.format( comment=comment ) ) reprec = testdir.inline_run("--doctest-modules") reprec.assertoutcome(passed=2) @pytest.mark.parametrize("config_mode", ["ini", "comment"]) def test_allow_bytes(self, testdir, config_mode): """Test that doctests which output bytes work in all python versions tested by pytest when the ALLOW_BYTES option is used (either in the ini file or by an inline comment)(#1287). """ if config_mode == "ini": testdir.makeini( """ [pytest] doctest_optionflags = ALLOW_BYTES """ ) comment = "" else: comment = "#doctest: +ALLOW_BYTES" testdir.maketxtfile( test_doc=""" >>> b'foo' {comment} 'foo' """.format( comment=comment ) ) testdir.makepyfile( foo=""" def foo(): ''' >>> b'foo' {comment} 'foo' ''' """.format( comment=comment ) ) reprec = testdir.inline_run("--doctest-modules") reprec.assertoutcome(passed=2) def test_unicode_string(self, testdir): """Test that doctests which output unicode fail in Python 2 when the ALLOW_UNICODE option is not used. The same test should pass in Python 3. """ testdir.maketxtfile( test_doc=""" >>> b'12'.decode('ascii') '12' """ ) reprec = testdir.inline_run() reprec.assertoutcome(passed=1) def test_bytes_literal(self, testdir): """Test that doctests which output bytes fail in Python 3 when the ALLOW_BYTES option is not used. (#1287). """ testdir.maketxtfile( test_doc=""" >>> b'foo' 'foo' """ ) reprec = testdir.inline_run() reprec.assertoutcome(failed=1) def test_number_re(self) -> None: _number_re = _get_checker()._number_re # type: ignore for s in [ "1.", "+1.", "-1.", ".1", "+.1", "-.1", "0.1", "+0.1", "-0.1", "1e5", "+1e5", "1e+5", "+1e+5", "1e-5", "+1e-5", "-1e-5", "1.2e3", "-1.2e-3", ]: print(s) m = _number_re.match(s) assert m is not None assert float(m.group()) == pytest.approx(float(s)) for s in ["1", "abc"]: print(s) assert _number_re.match(s) is None @pytest.mark.parametrize("config_mode", ["ini", "comment"]) def test_number_precision(self, testdir, config_mode): """Test the NUMBER option.""" if config_mode == "ini": testdir.makeini( """ [pytest] doctest_optionflags = NUMBER """ ) comment = "" else: comment = "#doctest: +NUMBER" testdir.maketxtfile( test_doc=""" Scalars: >>> import math >>> math.pi {comment} 3.141592653589793 >>> math.pi {comment} 3.1416 >>> math.pi {comment} 3.14 >>> -math.pi {comment} -3.14 >>> math.pi {comment} 3. >>> 3. {comment} 3.0 >>> 3. {comment} 3. >>> 3. {comment} 3.01 >>> 3. {comment} 2.99 >>> .299 {comment} .3 >>> .301 {comment} .3 >>> 951. {comment} 1e3 >>> 1049. {comment} 1e3 >>> -1049. {comment} -1e3 >>> 1e3 {comment} 1e3 >>> 1e3 {comment} 1000. Lists: >>> [3.1415, 0.097, 13.1, 7, 8.22222e5, 0.598e-2] {comment} [3.14, 0.1, 13., 7, 8.22e5, 6.0e-3] >>> [[0.333, 0.667], [0.999, 1.333]] {comment} [[0.33, 0.667], [0.999, 1.333]] >>> [[[0.101]]] {comment} [[[0.1]]] Doesn't barf on non-numbers: >>> 'abc' {comment} 'abc' >>> None {comment} """.format( comment=comment ) ) reprec = testdir.inline_run() reprec.assertoutcome(passed=1) @pytest.mark.parametrize( "expression,output", [ # ints shouldn't match floats: ("3.0", "3"), ("3e0", "3"), ("1e3", "1000"), ("3", "3.0"), # Rounding: ("3.1", "3.0"), ("3.1", "3.2"), ("3.1", "4.0"), ("8.22e5", "810000.0"), # Only the actual output is rounded up, not the expected output: ("3.0", "2.98"), ("1e3", "999"), # The current implementation doesn't understand that numbers inside # strings shouldn't be treated as numbers: pytest.param("'3.1416'", "'3.14'", marks=pytest.mark.xfail), ], ) def test_number_non_matches(self, testdir, expression, output): testdir.maketxtfile( test_doc=""" >>> {expression} #doctest: +NUMBER {output} """.format( expression=expression, output=output ) ) reprec = testdir.inline_run() reprec.assertoutcome(passed=0, failed=1) def test_number_and_allow_unicode(self, testdir): testdir.maketxtfile( test_doc=""" >>> from collections import namedtuple >>> T = namedtuple('T', 'a b c') >>> T(a=0.2330000001, b=u'str', c=b'bytes') # doctest: +ALLOW_UNICODE, +ALLOW_BYTES, +NUMBER T(a=0.233, b=u'str', c='bytes') """ ) reprec = testdir.inline_run() reprec.assertoutcome(passed=1) class TestDoctestSkips: """ If all examples in a doctest are skipped due to the SKIP option, then the tests should be SKIPPED rather than PASSED. (#957) """ @pytest.fixture(params=["text", "module"]) def makedoctest(self, testdir, request): def makeit(doctest): mode = request.param if mode == "text": testdir.maketxtfile(doctest) else: assert mode == "module" testdir.makepyfile('"""\n%s"""' % doctest) return makeit def test_one_skipped(self, testdir, makedoctest): makedoctest( """ >>> 1 + 1 # doctest: +SKIP 2 >>> 2 + 2 4 """ ) reprec = testdir.inline_run("--doctest-modules") reprec.assertoutcome(passed=1) def test_one_skipped_failed(self, testdir, makedoctest): makedoctest( """ >>> 1 + 1 # doctest: +SKIP 2 >>> 2 + 2 200 """ ) reprec = testdir.inline_run("--doctest-modules") reprec.assertoutcome(failed=1) def test_all_skipped(self, testdir, makedoctest): makedoctest( """ >>> 1 + 1 # doctest: +SKIP 2 >>> 2 + 2 # doctest: +SKIP 200 """ ) reprec = testdir.inline_run("--doctest-modules") reprec.assertoutcome(skipped=1) def test_vacuous_all_skipped(self, testdir, makedoctest): makedoctest("") reprec = testdir.inline_run("--doctest-modules") reprec.assertoutcome(passed=0, skipped=0) def test_continue_on_failure(self, testdir): testdir.maketxtfile( test_something=""" >>> i = 5 >>> def foo(): ... raise ValueError('error1') >>> foo() >>> i >>> i + 2 7 >>> i + 1 """ ) result = testdir.runpytest("--doctest-modules", "--doctest-continue-on-failure") result.assert_outcomes(passed=0, failed=1) # The lines that contains the failure are 4, 5, and 8. The first one # is a stack trace and the other two are mismatches. result.stdout.fnmatch_lines( ["*4: UnexpectedException*", "*5: DocTestFailure*", "*8: DocTestFailure*"] ) class TestDoctestAutoUseFixtures: SCOPES = ["module", "session", "class", "function"] def test_doctest_module_session_fixture(self, testdir): """Test that session fixtures are initialized for doctest modules (#768) """ # session fixture which changes some global data, which will # be accessed by doctests in a module testdir.makeconftest( """ import pytest import sys @pytest.yield_fixture(autouse=True, scope='session') def myfixture(): assert not hasattr(sys, 'pytest_session_data') sys.pytest_session_data = 1 yield del sys.pytest_session_data """ ) testdir.makepyfile( foo=""" import sys def foo(): ''' >>> assert sys.pytest_session_data == 1 ''' def bar(): ''' >>> assert sys.pytest_session_data == 1 ''' """ ) result = testdir.runpytest("--doctest-modules") result.stdout.fnmatch_lines(["*2 passed*"]) @pytest.mark.parametrize("scope", SCOPES) @pytest.mark.parametrize("enable_doctest", [True, False]) def test_fixture_scopes(self, testdir, scope, enable_doctest): """Test that auto-use fixtures work properly with doctest modules. See #1057 and #1100. """ testdir.makeconftest( """ import pytest @pytest.fixture(autouse=True, scope="{scope}") def auto(request): return 99 """.format( scope=scope ) ) testdir.makepyfile( test_1=''' def test_foo(): """ >>> getfixture('auto') + 1 100 """ def test_bar(): assert 1 ''' ) params = ("--doctest-modules",) if enable_doctest else () passes = 3 if enable_doctest else 2 result = testdir.runpytest(*params) result.stdout.fnmatch_lines(["*=== %d passed in *" % passes]) @pytest.mark.parametrize("scope", SCOPES) @pytest.mark.parametrize("autouse", [True, False]) @pytest.mark.parametrize("use_fixture_in_doctest", [True, False]) def test_fixture_module_doctest_scopes( self, testdir, scope, autouse, use_fixture_in_doctest ): """Test that auto-use fixtures work properly with doctest files. See #1057 and #1100. """ testdir.makeconftest( """ import pytest @pytest.fixture(autouse={autouse}, scope="{scope}") def auto(request): return 99 """.format( scope=scope, autouse=autouse ) ) if use_fixture_in_doctest: testdir.maketxtfile( test_doc=""" >>> getfixture('auto') 99 """ ) else: testdir.maketxtfile( test_doc=""" >>> 1 + 1 2 """ ) result = testdir.runpytest("--doctest-modules") result.stdout.no_fnmatch_line("*FAILURES*") result.stdout.fnmatch_lines(["*=== 1 passed in *"]) @pytest.mark.parametrize("scope", SCOPES) def test_auto_use_request_attributes(self, testdir, scope): """Check that all attributes of a request in an autouse fixture behave as expected when requested for a doctest item. """ testdir.makeconftest( """ import pytest @pytest.fixture(autouse=True, scope="{scope}") def auto(request): if "{scope}" == 'module': assert request.module is None if "{scope}" == 'class': assert request.cls is None if "{scope}" == 'function': assert request.function is None return 99 """.format( scope=scope ) ) testdir.maketxtfile( test_doc=""" >>> 1 + 1 2 """ ) result = testdir.runpytest("--doctest-modules") str(result.stdout.no_fnmatch_line("*FAILURES*")) result.stdout.fnmatch_lines(["*=== 1 passed in *"]) class TestDoctestNamespaceFixture: SCOPES = ["module", "session", "class", "function"] @pytest.mark.parametrize("scope", SCOPES) def test_namespace_doctestfile(self, testdir, scope): """ Check that inserting something into the namespace works in a simple text file doctest """ testdir.makeconftest( """ import pytest import contextlib @pytest.fixture(autouse=True, scope="{scope}") def add_contextlib(doctest_namespace): doctest_namespace['cl'] = contextlib """.format( scope=scope ) ) p = testdir.maketxtfile( """ >>> print(cl.__name__) contextlib """ ) reprec = testdir.inline_run(p) reprec.assertoutcome(passed=1) @pytest.mark.parametrize("scope", SCOPES) def test_namespace_pyfile(self, testdir, scope): """ Check that inserting something into the namespace works in a simple Python file docstring doctest """ testdir.makeconftest( """ import pytest import contextlib @pytest.fixture(autouse=True, scope="{scope}") def add_contextlib(doctest_namespace): doctest_namespace['cl'] = contextlib """.format( scope=scope ) ) p = testdir.makepyfile( """ def foo(): ''' >>> print(cl.__name__) contextlib ''' """ ) reprec = testdir.inline_run(p, "--doctest-modules") reprec.assertoutcome(passed=1) class TestDoctestReportingOption: def _run_doctest_report(self, testdir, format): testdir.makepyfile( """ def foo(): ''' >>> foo() a b 0 1 4 1 2 4 2 3 6 ''' print(' a b\\n' '0 1 4\\n' '1 2 5\\n' '2 3 6') """ ) return testdir.runpytest("--doctest-modules", "--doctest-report", format) @pytest.mark.parametrize("format", ["udiff", "UDIFF", "uDiFf"]) def test_doctest_report_udiff(self, testdir, format): result = self._run_doctest_report(testdir, format) result.stdout.fnmatch_lines( [" 0 1 4", " -1 2 4", " +1 2 5", " 2 3 6"] ) def test_doctest_report_cdiff(self, testdir): result = self._run_doctest_report(testdir, "cdiff") result.stdout.fnmatch_lines( [ " a b", " 0 1 4", " ! 1 2 4", " 2 3 6", " --- 1,4 ----", " a b", " 0 1 4", " ! 1 2 5", " 2 3 6", ] ) def test_doctest_report_ndiff(self, testdir): result = self._run_doctest_report(testdir, "ndiff") result.stdout.fnmatch_lines( [ " a b", " 0 1 4", " - 1 2 4", " ? ^", " + 1 2 5", " ? ^", " 2 3 6", ] ) @pytest.mark.parametrize("format", ["none", "only_first_failure"]) def test_doctest_report_none_or_only_first_failure(self, testdir, format): result = self._run_doctest_report(testdir, format) result.stdout.fnmatch_lines( [ "Expected:", " a b", " 0 1 4", " 1 2 4", " 2 3 6", "Got:", " a b", " 0 1 4", " 1 2 5", " 2 3 6", ] ) def test_doctest_report_invalid(self, testdir): result = self._run_doctest_report(testdir, "obviously_invalid_format") result.stderr.fnmatch_lines( [ "*error: argument --doctest-report: invalid choice: 'obviously_invalid_format' (choose from*" ] ) @pytest.mark.parametrize("mock_module", ["mock", "unittest.mock"]) def test_doctest_mock_objects_dont_recurse_missbehaved(mock_module, testdir): pytest.importorskip(mock_module) testdir.makepyfile( """ from {mock_module} import call class Example(object): ''' >>> 1 + 1 2 ''' """.format( mock_module=mock_module ) ) result = testdir.runpytest("--doctest-modules") result.stdout.fnmatch_lines(["* 1 passed *"]) class Broken: def __getattr__(self, _): raise KeyError("This should be an AttributeError") @pytest.mark.parametrize( # pragma: no branch (lambdas are not called) "stop", [None, _is_mocked, lambda f: None, lambda f: False, lambda f: True] ) def test_warning_on_unwrap_of_broken_object(stop): bad_instance = Broken() assert inspect.unwrap.__module__ == "inspect" with _patch_unwrap_mock_aware(): assert inspect.unwrap.__module__ != "inspect" with pytest.warns( pytest.PytestWarning, match="^Got KeyError.* when unwrapping" ): with pytest.raises(KeyError): inspect.unwrap(bad_instance, stop=stop) assert inspect.unwrap.__module__ == "inspect" def test_is_setup_py_not_named_setup_py(tmpdir): not_setup_py = tmpdir.join("not_setup.py") not_setup_py.write('from setuptools import setup; setup(name="foo")') assert not _is_setup_py(not_setup_py) @pytest.mark.parametrize("mod", ("setuptools", "distutils.core")) def test_is_setup_py_is_a_setup_py(tmpdir, mod): setup_py = tmpdir.join("setup.py") setup_py.write('from {} import setup; setup(name="foo")'.format(mod)) assert _is_setup_py(setup_py) @pytest.mark.parametrize("mod", ("setuptools", "distutils.core")) def test_is_setup_py_different_encoding(tmpdir, mod): setup_py = tmpdir.join("setup.py") contents = ( "# -*- coding: cp1252 -*-\n" 'from {} import setup; setup(name="foo", description="€")\n'.format(mod) ) setup_py.write_binary(contents.encode("cp1252")) assert _is_setup_py(setup_py)