← Back to branch summary

~jfb-tempo-consulting/unifield-wm/sync-env-py3

« back to all changes in this revision

Viewing changes to unittest27/test/test_discovery.py

  • Committer: Samus CTO
  • Date: 2012-09-05 10:40:27 UTC
  • Revision ID: cto@openerp.com-20120905104027-geoynct7122bnoig
[IMPORT] imported unittest from Python 2.7

Show diffs side-by-side

added added

removed removed

Lines of Context:
unittest27/test/test_discovery.py
 
1
import os
 
2
import re
 
3
import sys
 
4
 
 
5
import unittest
 
6
 
 
7
 
 
8
class TestDiscovery(unittest.TestCase):
 
9
 
 
10
    # Heavily mocked tests so I can avoid hitting the filesystem
 
11
    def test_get_name_from_path(self):
 
12
        loader = unittest.TestLoader()
 
13
 
 
14
        loader._top_level_dir = '/foo'
 
15
        name = loader._get_name_from_path('/foo/bar/baz.py')
 
16
        self.assertEqual(name, 'bar.baz')
 
17
 
 
18
        if not __debug__:
 
19
            # asserts are off
 
20
            return
 
21
 
 
22
        with self.assertRaises(AssertionError):
 
23
            loader._get_name_from_path('/bar/baz.py')
 
24
 
 
25
    def test_find_tests(self):
 
26
        loader = unittest.TestLoader()
 
27
 
 
28
        original_listdir = os.listdir
 
29
        def restore_listdir():
 
30
            os.listdir = original_listdir
 
31
        original_isfile = os.path.isfile
 
32
        def restore_isfile():
 
33
            os.path.isfile = original_isfile
 
34
        original_isdir = os.path.isdir
 
35
        def restore_isdir():
 
36
            os.path.isdir = original_isdir
 
37
 
 
38
        path_lists = [['test1.py', 'test2.py', 'not_a_test.py', 'test_dir',
 
39
                       'test.foo', 'test-not-a-module.py', 'another_dir'],
 
40
                      ['test3.py', 'test4.py', ]]
 
41
        os.listdir = lambda path: path_lists.pop(0)
 
42
        self.addCleanup(restore_listdir)
 
43
 
 
44
        def isdir(path):
 
45
            return path.endswith('dir')
 
46
        os.path.isdir = isdir
 
47
        self.addCleanup(restore_isdir)
 
48
 
 
49
        def isfile(path):
 
50
            # another_dir is not a package and so shouldn't be recursed into
 
51
            return not path.endswith('dir') and not 'another_dir' in path
 
52
        os.path.isfile = isfile
 
53
        self.addCleanup(restore_isfile)
 
54
 
 
55
        loader._get_module_from_name = lambda path: path + ' module'
 
56
        loader.loadTestsFromModule = lambda module: module + ' tests'
 
57
 
 
58
        top_level = os.path.abspath('/foo')
 
59
        loader._top_level_dir = top_level
 
60
        suite = list(loader._find_tests(top_level, 'test*.py'))
 
61
 
 
62
        expected = [name + ' module tests' for name in
 
63
                    ('test1', 'test2')]
 
64
        expected.extend([('test_dir.%s' % name) + ' module tests' for name in
 
65
                    ('test3', 'test4')])
 
66
        self.assertEqual(suite, expected)
 
67
 
 
68
    def test_find_tests_with_package(self):
 
69
        loader = unittest.TestLoader()
 
70
 
 
71
        original_listdir = os.listdir
 
72
        def restore_listdir():
 
73
            os.listdir = original_listdir
 
74
        original_isfile = os.path.isfile
 
75
        def restore_isfile():
 
76
            os.path.isfile = original_isfile
 
77
        original_isdir = os.path.isdir
 
78
        def restore_isdir():
 
79
            os.path.isdir = original_isdir
 
80
 
 
81
        directories = ['a_directory', 'test_directory', 'test_directory2']
 
82
        path_lists = [directories, [], [], []]
 
83
        os.listdir = lambda path: path_lists.pop(0)
 
84
        self.addCleanup(restore_listdir)
 
85
 
 
86
        os.path.isdir = lambda path: True
 
87
        self.addCleanup(restore_isdir)
 
88
 
 
89
        os.path.isfile = lambda path: os.path.basename(path) not in directories
 
90
        self.addCleanup(restore_isfile)
 
91
 
 
92
        class Module(object):
 
93
            paths = []
 
94
            load_tests_args = []
 
95
 
 
96
            def __init__(self, path):
 
97
                self.path = path
 
98
                self.paths.append(path)
 
99
                if os.path.basename(path) == 'test_directory':
 
100
                    def load_tests(loader, tests, pattern):
 
101
                        self.load_tests_args.append((loader, tests, pattern))
 
102
                        return 'load_tests'
 
103
                    self.load_tests = load_tests
 
104
 
 
105
            def __eq__(self, other):
 
106
                return self.path == other.path
 
107
 
 
108
            # Silence py3k warning
 
109
            __hash__ = None
 
110
 
 
111
        loader._get_module_from_name = lambda name: Module(name)
 
112
        def loadTestsFromModule(module, use_load_tests):
 
113
            if use_load_tests:
 
114
                raise self.failureException('use_load_tests should be False for packages')
 
115
            return module.path + ' module tests'
 
116
        loader.loadTestsFromModule = loadTestsFromModule
 
117
 
 
118
        loader._top_level_dir = '/foo'
 
119
        # this time no '.py' on the pattern so that it can match
 
120
        # a test package
 
121
        suite = list(loader._find_tests('/foo', 'test*'))
 
122
 
 
123
        # We should have loaded tests from the test_directory package by calling load_tests
 
124
        # and directly from the test_directory2 package
 
125
        self.assertEqual(suite,
 
126
                         ['load_tests', 'test_directory2' + ' module tests'])
 
127
        self.assertEqual(Module.paths, ['test_directory', 'test_directory2'])
 
128
 
 
129
        # load_tests should have been called once with loader, tests and pattern
 
130
        self.assertEqual(Module.load_tests_args,
 
131
                         [(loader, 'test_directory' + ' module tests', 'test*')])
 
132
 
 
133
    def test_discover(self):
 
134
        loader = unittest.TestLoader()
 
135
 
 
136
        original_isfile = os.path.isfile
 
137
        original_isdir = os.path.isdir
 
138
        def restore_isfile():
 
139
            os.path.isfile = original_isfile
 
140
 
 
141
        os.path.isfile = lambda path: False
 
142
        self.addCleanup(restore_isfile)
 
143
 
 
144
        orig_sys_path = sys.path[:]
 
145
        def restore_path():
 
146
            sys.path[:] = orig_sys_path
 
147
        self.addCleanup(restore_path)
 
148
 
 
149
        full_path = os.path.abspath(os.path.normpath('/foo'))
 
150
        with self.assertRaises(ImportError):
 
151
            loader.discover('/foo/bar', top_level_dir='/foo')
 
152
 
 
153
        self.assertEqual(loader._top_level_dir, full_path)
 
154
        self.assertIn(full_path, sys.path)
 
155
 
 
156
        os.path.isfile = lambda path: True
 
157
        os.path.isdir = lambda path: True
 
158
 
 
159
        def restore_isdir():
 
160
            os.path.isdir = original_isdir
 
161
        self.addCleanup(restore_isdir)
 
162
 
 
163
        _find_tests_args = []
 
164
        def _find_tests(start_dir, pattern):
 
165
            _find_tests_args.append((start_dir, pattern))
 
166
            return ['tests']
 
167
        loader._find_tests = _find_tests
 
168
        loader.suiteClass = str
 
169
 
 
170
        suite = loader.discover('/foo/bar/baz', 'pattern', '/foo/bar')
 
171
 
 
172
        top_level_dir = os.path.abspath('/foo/bar')
 
173
        start_dir = os.path.abspath('/foo/bar/baz')
 
174
        self.assertEqual(suite, "['tests']")
 
175
        self.assertEqual(loader._top_level_dir, top_level_dir)
 
176
        self.assertEqual(_find_tests_args, [(start_dir, 'pattern')])
 
177
        self.assertIn(top_level_dir, sys.path)
 
178
 
 
179
    def test_discover_with_modules_that_fail_to_import(self):
 
180
        loader = unittest.TestLoader()
 
181
 
 
182
        listdir = os.listdir
 
183
        os.listdir = lambda _: ['test_this_does_not_exist.py']
 
184
        isfile = os.path.isfile
 
185
        os.path.isfile = lambda _: True
 
186
        orig_sys_path = sys.path[:]
 
187
        def restore():
 
188
            os.path.isfile = isfile
 
189
            os.listdir = listdir
 
190
            sys.path[:] = orig_sys_path
 
191
        self.addCleanup(restore)
 
192
 
 
193
        suite = loader.discover('.')
 
194
        self.assertIn(os.getcwd(), sys.path)
 
195
        self.assertEqual(suite.countTestCases(), 1)
 
196
        test = list(list(suite)[0])[0] # extract test from suite
 
197
 
 
198
        with self.assertRaises(ImportError):
 
199
            test.test_this_does_not_exist()
 
200
 
 
201
    def test_command_line_handling_parseArgs(self):
 
202
        # Haha - take that uninstantiable class
 
203
        program = object.__new__(unittest.TestProgram)
 
204
 
 
205
        args = []
 
206
        def do_discovery(argv):
 
207
            args.extend(argv)
 
208
        program._do_discovery = do_discovery
 
209
        program.parseArgs(['something', 'discover'])
 
210
        self.assertEqual(args, [])
 
211
 
 
212
        program.parseArgs(['something', 'discover', 'foo', 'bar'])
 
213
        self.assertEqual(args, ['foo', 'bar'])
 
214
 
 
215
    def test_command_line_handling_do_discovery_too_many_arguments(self):
 
216
        class Stop(Exception):
 
217
            pass
 
218
        def usageExit():
 
219
            raise Stop
 
220
 
 
221
        program = object.__new__(unittest.TestProgram)
 
222
        program.usageExit = usageExit
 
223
 
 
224
        with self.assertRaises(Stop):
 
225
            # too many args
 
226
            program._do_discovery(['one', 'two', 'three', 'four'])
 
227
 
 
228
 
 
229
    def test_command_line_handling_do_discovery_calls_loader(self):
 
230
        program = object.__new__(unittest.TestProgram)
 
231
 
 
232
        class Loader(object):
 
233
            args = []
 
234
            def discover(self, start_dir, pattern, top_level_dir):
 
235
                self.args.append((start_dir, pattern, top_level_dir))
 
236
                return 'tests'
 
237
 
 
238
        program._do_discovery(['-v'], Loader=Loader)
 
239
        self.assertEqual(program.verbosity, 2)
 
240
        self.assertEqual(program.test, 'tests')
 
241
        self.assertEqual(Loader.args, [('.', 'test*.py', None)])
 
242
 
 
243
        Loader.args = []
 
244
        program = object.__new__(unittest.TestProgram)
 
245
        program._do_discovery(['--verbose'], Loader=Loader)
 
246
        self.assertEqual(program.test, 'tests')
 
247
        self.assertEqual(Loader.args, [('.', 'test*.py', None)])
 
248
 
 
249
        Loader.args = []
 
250
        program = object.__new__(unittest.TestProgram)
 
251
        program._do_discovery([], Loader=Loader)
 
252
        self.assertEqual(program.test, 'tests')
 
253
        self.assertEqual(Loader.args, [('.', 'test*.py', None)])
 
254
 
 
255
        Loader.args = []
 
256
        program = object.__new__(unittest.TestProgram)
 
257
        program._do_discovery(['fish'], Loader=Loader)
 
258
        self.assertEqual(program.test, 'tests')
 
259
        self.assertEqual(Loader.args, [('fish', 'test*.py', None)])
 
260
 
 
261
        Loader.args = []
 
262
        program = object.__new__(unittest.TestProgram)
 
263
        program._do_discovery(['fish', 'eggs'], Loader=Loader)
 
264
        self.assertEqual(program.test, 'tests')
 
265
        self.assertEqual(Loader.args, [('fish', 'eggs', None)])
 
266
 
 
267
        Loader.args = []
 
268
        program = object.__new__(unittest.TestProgram)
 
269
        program._do_discovery(['fish', 'eggs', 'ham'], Loader=Loader)
 
270
        self.assertEqual(program.test, 'tests')
 
271
        self.assertEqual(Loader.args, [('fish', 'eggs', 'ham')])
 
272
 
 
273
        Loader.args = []
 
274
        program = object.__new__(unittest.TestProgram)
 
275
        program._do_discovery(['-s', 'fish'], Loader=Loader)
 
276
        self.assertEqual(program.test, 'tests')
 
277
        self.assertEqual(Loader.args, [('fish', 'test*.py', None)])
 
278
 
 
279
        Loader.args = []
 
280
        program = object.__new__(unittest.TestProgram)
 
281
        program._do_discovery(['-t', 'fish'], Loader=Loader)
 
282
        self.assertEqual(program.test, 'tests')
 
283
        self.assertEqual(Loader.args, [('.', 'test*.py', 'fish')])
 
284
 
 
285
        Loader.args = []
 
286
        program = object.__new__(unittest.TestProgram)
 
287
        program._do_discovery(['-p', 'fish'], Loader=Loader)
 
288
        self.assertEqual(program.test, 'tests')
 
289
        self.assertEqual(Loader.args, [('.', 'fish', None)])
 
290
        self.assertFalse(program.failfast)
 
291
        self.assertFalse(program.catchbreak)
 
292
 
 
293
        Loader.args = []
 
294
        program = object.__new__(unittest.TestProgram)
 
295
        program._do_discovery(['-p', 'eggs', '-s', 'fish', '-v', '-f', '-c'],
 
296
                              Loader=Loader)
 
297
        self.assertEqual(program.test, 'tests')
 
298
        self.assertEqual(Loader.args, [('fish', 'eggs', None)])
 
299
        self.assertEqual(program.verbosity, 2)
 
300
        self.assertTrue(program.failfast)
 
301
        self.assertTrue(program.catchbreak)
 
302
 
 
303
    def test_detect_module_clash(self):
 
304
        class Module(object):
 
305
            __file__ = 'bar/foo.py'
 
306
        sys.modules['foo'] = Module
 
307
        full_path = os.path.abspath('foo')
 
308
        original_listdir = os.listdir
 
309
        original_isfile = os.path.isfile
 
310
        original_isdir = os.path.isdir
 
311
 
 
312
        def cleanup():
 
313
            os.listdir = original_listdir
 
314
            os.path.isfile = original_isfile
 
315
            os.path.isdir = original_isdir
 
316
            del sys.modules['foo']
 
317
            if full_path in sys.path:
 
318
                sys.path.remove(full_path)
 
319
        self.addCleanup(cleanup)
 
320
 
 
321
        def listdir(_):
 
322
            return ['foo.py']
 
323
        def isfile(_):
 
324
            return True
 
325
        def isdir(_):
 
326
            return True
 
327
        os.listdir = listdir
 
328
        os.path.isfile = isfile
 
329
        os.path.isdir = isdir
 
330
 
 
331
        loader = unittest.TestLoader()
 
332
 
 
333
        mod_dir = os.path.abspath('bar')
 
334
        expected_dir = os.path.abspath('foo')
 
335
        msg = re.escape(r"'foo' module incorrectly imported from %r. Expected %r. "
 
336
                "Is this module globally installed?" % (mod_dir, expected_dir))
 
337
        self.assertRaisesRegexp(
 
338
            ImportError, '^%s$' % msg, loader.discover,
 
339
            start_dir='foo', pattern='foo.py'
 
340
        )
 
341
        self.assertEqual(sys.path[0], full_path)
 
342
 
 
343
 
 
344
    def test_discovery_from_dotted_path(self):
 
345
        loader = unittest.TestLoader()
 
346
 
 
347
        tests = [self]
 
348
        expectedPath = os.path.abspath(os.path.dirname(unittest.test.__file__))
 
349
 
 
350
        self.wasRun = False
 
351
        def _find_tests(start_dir, pattern):
 
352
            self.wasRun = True
 
353
            self.assertEqual(start_dir, expectedPath)
 
354
            return tests
 
355
        loader._find_tests = _find_tests
 
356
        suite = loader.discover('unittest.test')
 
357
        self.assertTrue(self.wasRun)
 
358
        self.assertEqual(suite._tests, tests)
 
359
 
 
360
 
 
361
if __name__ == '__main__':
 
362
    unittest.main()