master
/ .localenv / lib / python3.5 / site-packages / IPython / testing / tests / test_tools.py

test_tools.py @master — raw · history · blame 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
# encoding: utf-8
"""
Tests for testing.tools
"""

#-----------------------------------------------------------------------------
#  Copyright (C) 2008-2011  The IPython Development Team
#
#  Distributed under the terms of the BSD License.  The full license is in
#  the file COPYING, distributed as part of this software.
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Imports
#-----------------------------------------------------------------------------

import os
import unittest

import nose.tools as nt

from IPython.testing import decorators as dec
from IPython.testing import tools as tt

#-----------------------------------------------------------------------------
# Tests
#-----------------------------------------------------------------------------

@dec.skip_win32
def test_full_path_posix():
    spath = '/foo/bar.py'
    result = tt.full_path(spath,['a.txt','b.txt'])
    nt.assert_equal(result, ['/foo/a.txt', '/foo/b.txt'])
    spath = '/foo'
    result = tt.full_path(spath,['a.txt','b.txt'])
    nt.assert_equal(result, ['/a.txt', '/b.txt'])
    result = tt.full_path(spath,'a.txt')
    nt.assert_equal(result, ['/a.txt'])


@dec.skip_if_not_win32
def test_full_path_win32():
    spath = 'c:\\foo\\bar.py'
    result = tt.full_path(spath,['a.txt','b.txt'])
    nt.assert_equal(result, ['c:\\foo\\a.txt', 'c:\\foo\\b.txt'])
    spath = 'c:\\foo'
    result = tt.full_path(spath,['a.txt','b.txt'])
    nt.assert_equal(result, ['c:\\a.txt', 'c:\\b.txt'])
    result = tt.full_path(spath,'a.txt')
    nt.assert_equal(result, ['c:\\a.txt'])

    
def test_parser():
    err = ("FAILED (errors=1)", 1, 0)
    fail = ("FAILED (failures=1)", 0, 1)
    both = ("FAILED (errors=1, failures=1)", 1, 1)
    for txt, nerr, nfail in [err, fail, both]:
        nerr1, nfail1 = tt.parse_test_output(txt)
        nt.assert_equal(nerr, nerr1)
        nt.assert_equal(nfail, nfail1)


def test_temp_pyfile():
    src = 'pass\n'
    fname, fh = tt.temp_pyfile(src)
    assert os.path.isfile(fname)
    fh.close()
    with open(fname) as fh2:
        src2 = fh2.read()
    nt.assert_equal(src2, src)

class TestAssertPrints(unittest.TestCase):
    def test_passing(self):
        with tt.AssertPrints("abc"):
            print("abcd")
            print("def")
            print(b"ghi")
    
    def test_failing(self):
        def func():
            with tt.AssertPrints("abc"):
                print("acd")
                print("def")
                print(b"ghi")
        
        self.assertRaises(AssertionError, func)


class Test_ipexec_validate(unittest.TestCase, tt.TempFileMixin):
    def test_main_path(self):
        """Test with only stdout results.
        """
        self.mktmp("print('A')\n"
                   "print('B')\n"
                   )
        out = "A\nB"
        tt.ipexec_validate(self.fname, out)

    def test_main_path2(self):
        """Test with only stdout results, expecting windows line endings.
        """
        self.mktmp("print('A')\n"
                   "print('B')\n"
                   )
        out = "A\r\nB"
        tt.ipexec_validate(self.fname, out)

    def test_exception_path(self):
        """Test exception path in exception_validate.
        """
        self.mktmp("import sys\n"
                   "print('A')\n"
                   "print('B')\n"
                   "print('C', file=sys.stderr)\n"
                   "print('D', file=sys.stderr)\n"
                   )
        out = "A\nB"
        tt.ipexec_validate(self.fname, expected_out=out, expected_err="C\nD")

    def test_exception_path2(self):
        """Test exception path in exception_validate, expecting windows line endings.
        """
        self.mktmp("import sys\n"
                   "print('A')\n"
                   "print('B')\n"
                   "print('C', file=sys.stderr)\n"
                   "print('D', file=sys.stderr)\n"
                   )
        out = "A\r\nB"
        tt.ipexec_validate(self.fname, expected_out=out, expected_err="C\r\nD")


    def tearDown(self):
        # tear down correctly the mixin,
        # unittest.TestCase.tearDown does nothing
        tt.TempFileMixin.tearDown(self)