1 from test.test_importlib import util as test_util
2
3 init = test_util.import_importlib('importlib')
4 machinery = test_util.import_importlib('importlib.machinery')
5 util = test_util.import_importlib('importlib.util')
6
7 import os.path
8 import pathlib
9 from test.support.import_helper import CleanImport
10 import unittest
11 import sys
12 import warnings
13
14
15
16 class ESC[4;38;5;81mTestLoader:
17
18 def __init__(self, path=None, is_package=None):
19 self.path = path
20 self.package = is_package
21
22 def __repr__(self):
23 return '<TestLoader object>'
24
25 def __getattr__(self, name):
26 if name == 'get_filename' and self.path is not None:
27 return self._get_filename
28 if name == 'is_package':
29 return self._is_package
30 raise AttributeError(name)
31
32 def _get_filename(self, name):
33 return self.path
34
35 def _is_package(self, name):
36 return self.package
37
38 def create_module(self, spec):
39 return None
40
41
42 class ESC[4;38;5;81mNewLoader(ESC[4;38;5;149mTestLoader):
43
44 EGGS = 1
45
46 def exec_module(self, module):
47 module.eggs = self.EGGS
48
49
50 class ESC[4;38;5;81mLegacyLoader(ESC[4;38;5;149mTestLoader):
51
52 HAM = -1
53
54 with warnings.catch_warnings():
55 warnings.simplefilter("ignore", DeprecationWarning)
56
57 frozen_util = util['Frozen']
58
59 @frozen_util.module_for_loader
60 def load_module(self, module):
61 module.ham = self.HAM
62 return module
63
64
65 class ESC[4;38;5;81mModuleSpecTests:
66
67 def setUp(self):
68 self.name = 'spam'
69 self.path = 'spam.py'
70 self.cached = self.util.cache_from_source(self.path)
71 self.loader = TestLoader()
72 self.spec = self.machinery.ModuleSpec(self.name, self.loader)
73 self.loc_spec = self.machinery.ModuleSpec(self.name, self.loader,
74 origin=self.path)
75 self.loc_spec._set_fileattr = True
76
77 def test_default(self):
78 spec = self.machinery.ModuleSpec(self.name, self.loader)
79
80 self.assertEqual(spec.name, self.name)
81 self.assertEqual(spec.loader, self.loader)
82 self.assertIs(spec.origin, None)
83 self.assertIs(spec.loader_state, None)
84 self.assertIs(spec.submodule_search_locations, None)
85 self.assertIs(spec.cached, None)
86 self.assertFalse(spec.has_location)
87
88 def test_default_no_loader(self):
89 spec = self.machinery.ModuleSpec(self.name, None)
90
91 self.assertEqual(spec.name, self.name)
92 self.assertIs(spec.loader, None)
93 self.assertIs(spec.origin, None)
94 self.assertIs(spec.loader_state, None)
95 self.assertIs(spec.submodule_search_locations, None)
96 self.assertIs(spec.cached, None)
97 self.assertFalse(spec.has_location)
98
99 def test_default_is_package_false(self):
100 spec = self.machinery.ModuleSpec(self.name, self.loader,
101 is_package=False)
102
103 self.assertEqual(spec.name, self.name)
104 self.assertEqual(spec.loader, self.loader)
105 self.assertIs(spec.origin, None)
106 self.assertIs(spec.loader_state, None)
107 self.assertIs(spec.submodule_search_locations, None)
108 self.assertIs(spec.cached, None)
109 self.assertFalse(spec.has_location)
110
111 def test_default_is_package_true(self):
112 spec = self.machinery.ModuleSpec(self.name, self.loader,
113 is_package=True)
114
115 self.assertEqual(spec.name, self.name)
116 self.assertEqual(spec.loader, self.loader)
117 self.assertIs(spec.origin, None)
118 self.assertIs(spec.loader_state, None)
119 self.assertEqual(spec.submodule_search_locations, [])
120 self.assertIs(spec.cached, None)
121 self.assertFalse(spec.has_location)
122
123 def test_has_location_setter(self):
124 spec = self.machinery.ModuleSpec(self.name, self.loader,
125 origin='somewhere')
126 self.assertFalse(spec.has_location)
127 spec.has_location = True
128 self.assertTrue(spec.has_location)
129
130 def test_equality(self):
131 other = type(sys.implementation)(name=self.name,
132 loader=self.loader,
133 origin=None,
134 submodule_search_locations=None,
135 has_location=False,
136 cached=None,
137 )
138
139 self.assertTrue(self.spec == other)
140
141 def test_equality_location(self):
142 other = type(sys.implementation)(name=self.name,
143 loader=self.loader,
144 origin=self.path,
145 submodule_search_locations=None,
146 has_location=True,
147 cached=self.cached,
148 )
149
150 self.assertEqual(self.loc_spec, other)
151
152 def test_inequality(self):
153 other = type(sys.implementation)(name='ham',
154 loader=self.loader,
155 origin=None,
156 submodule_search_locations=None,
157 has_location=False,
158 cached=None,
159 )
160
161 self.assertNotEqual(self.spec, other)
162
163 def test_inequality_incomplete(self):
164 other = type(sys.implementation)(name=self.name,
165 loader=self.loader,
166 )
167
168 self.assertNotEqual(self.spec, other)
169
170 def test_package(self):
171 spec = self.machinery.ModuleSpec('spam.eggs', self.loader)
172
173 self.assertEqual(spec.parent, 'spam')
174
175 def test_package_is_package(self):
176 spec = self.machinery.ModuleSpec('spam.eggs', self.loader,
177 is_package=True)
178
179 self.assertEqual(spec.parent, 'spam.eggs')
180
181 # cached
182
183 def test_cached_set(self):
184 before = self.spec.cached
185 self.spec.cached = 'there'
186 after = self.spec.cached
187
188 self.assertIs(before, None)
189 self.assertEqual(after, 'there')
190
191 def test_cached_no_origin(self):
192 spec = self.machinery.ModuleSpec(self.name, self.loader)
193
194 self.assertIs(spec.cached, None)
195
196 def test_cached_with_origin_not_location(self):
197 spec = self.machinery.ModuleSpec(self.name, self.loader,
198 origin=self.path)
199
200 self.assertIs(spec.cached, None)
201
202 def test_cached_source(self):
203 expected = self.util.cache_from_source(self.path)
204
205 self.assertEqual(self.loc_spec.cached, expected)
206
207 def test_cached_source_unknown_suffix(self):
208 self.loc_spec.origin = 'spam.spamspamspam'
209
210 self.assertIs(self.loc_spec.cached, None)
211
212 def test_cached_source_missing_cache_tag(self):
213 original = sys.implementation.cache_tag
214 sys.implementation.cache_tag = None
215 try:
216 cached = self.loc_spec.cached
217 finally:
218 sys.implementation.cache_tag = original
219
220 self.assertIs(cached, None)
221
222 def test_cached_sourceless(self):
223 self.loc_spec.origin = 'spam.pyc'
224
225 self.assertEqual(self.loc_spec.cached, 'spam.pyc')
226
227
228 (Frozen_ModuleSpecTests,
229 Source_ModuleSpecTests
230 ) = test_util.test_both(ModuleSpecTests, util=util, machinery=machinery)
231
232
233 class ESC[4;38;5;81mModuleSpecMethodsTests:
234
235 @property
236 def bootstrap(self):
237 return self.init._bootstrap
238
239 def setUp(self):
240 self.name = 'spam'
241 self.path = 'spam.py'
242 self.cached = self.util.cache_from_source(self.path)
243 self.loader = TestLoader()
244 self.spec = self.machinery.ModuleSpec(self.name, self.loader)
245 self.loc_spec = self.machinery.ModuleSpec(self.name, self.loader,
246 origin=self.path)
247 self.loc_spec._set_fileattr = True
248
249 # exec()
250
251 def test_exec(self):
252 self.spec.loader = NewLoader()
253 module = self.util.module_from_spec(self.spec)
254 sys.modules[self.name] = module
255 self.assertFalse(hasattr(module, 'eggs'))
256 self.bootstrap._exec(self.spec, module)
257
258 self.assertEqual(module.eggs, 1)
259
260 # load()
261
262 def test_load(self):
263 self.spec.loader = NewLoader()
264 with CleanImport(self.spec.name):
265 loaded = self.bootstrap._load(self.spec)
266 installed = sys.modules[self.spec.name]
267
268 self.assertEqual(loaded.eggs, 1)
269 self.assertIs(loaded, installed)
270
271 def test_load_replaced(self):
272 replacement = object()
273 class ESC[4;38;5;81mReplacingLoader(ESC[4;38;5;149mTestLoader):
274 def exec_module(self, module):
275 sys.modules[module.__name__] = replacement
276 self.spec.loader = ReplacingLoader()
277 with CleanImport(self.spec.name):
278 loaded = self.bootstrap._load(self.spec)
279 installed = sys.modules[self.spec.name]
280
281 self.assertIs(loaded, replacement)
282 self.assertIs(installed, replacement)
283
284 def test_load_failed(self):
285 class ESC[4;38;5;81mFailedLoader(ESC[4;38;5;149mTestLoader):
286 def exec_module(self, module):
287 raise RuntimeError
288 self.spec.loader = FailedLoader()
289 with CleanImport(self.spec.name):
290 with self.assertRaises(RuntimeError):
291 loaded = self.bootstrap._load(self.spec)
292 self.assertNotIn(self.spec.name, sys.modules)
293
294 def test_load_failed_removed(self):
295 class ESC[4;38;5;81mFailedLoader(ESC[4;38;5;149mTestLoader):
296 def exec_module(self, module):
297 del sys.modules[module.__name__]
298 raise RuntimeError
299 self.spec.loader = FailedLoader()
300 with CleanImport(self.spec.name):
301 with self.assertRaises(RuntimeError):
302 loaded = self.bootstrap._load(self.spec)
303 self.assertNotIn(self.spec.name, sys.modules)
304
305 def test_load_legacy(self):
306 with warnings.catch_warnings():
307 warnings.simplefilter("ignore", ImportWarning)
308 self.spec.loader = LegacyLoader()
309 with CleanImport(self.spec.name):
310 loaded = self.bootstrap._load(self.spec)
311
312 self.assertEqual(loaded.ham, -1)
313
314 def test_load_legacy_attributes(self):
315 with warnings.catch_warnings():
316 warnings.simplefilter("ignore", ImportWarning)
317 self.spec.loader = LegacyLoader()
318 with CleanImport(self.spec.name):
319 loaded = self.bootstrap._load(self.spec)
320
321 self.assertIs(loaded.__loader__, self.spec.loader)
322 self.assertEqual(loaded.__package__, self.spec.parent)
323 self.assertIs(loaded.__spec__, self.spec)
324
325 def test_load_legacy_attributes_immutable(self):
326 module = object()
327 with warnings.catch_warnings():
328 warnings.simplefilter("ignore", ImportWarning)
329 class ESC[4;38;5;81mImmutableLoader(ESC[4;38;5;149mTestLoader):
330 def load_module(self, name):
331 sys.modules[name] = module
332 return module
333 self.spec.loader = ImmutableLoader()
334 with CleanImport(self.spec.name):
335 loaded = self.bootstrap._load(self.spec)
336
337 self.assertIs(sys.modules[self.spec.name], module)
338
339 # reload()
340
341 def test_reload(self):
342 self.spec.loader = NewLoader()
343 with CleanImport(self.spec.name):
344 loaded = self.bootstrap._load(self.spec)
345 reloaded = self.bootstrap._exec(self.spec, loaded)
346 installed = sys.modules[self.spec.name]
347
348 self.assertEqual(loaded.eggs, 1)
349 self.assertIs(reloaded, loaded)
350 self.assertIs(installed, loaded)
351
352 def test_reload_modified(self):
353 self.spec.loader = NewLoader()
354 with CleanImport(self.spec.name):
355 loaded = self.bootstrap._load(self.spec)
356 loaded.eggs = 2
357 reloaded = self.bootstrap._exec(self.spec, loaded)
358
359 self.assertEqual(loaded.eggs, 1)
360 self.assertIs(reloaded, loaded)
361
362 def test_reload_extra_attributes(self):
363 self.spec.loader = NewLoader()
364 with CleanImport(self.spec.name):
365 loaded = self.bootstrap._load(self.spec)
366 loaded.available = False
367 reloaded = self.bootstrap._exec(self.spec, loaded)
368
369 self.assertFalse(loaded.available)
370 self.assertIs(reloaded, loaded)
371
372 def test_reload_init_module_attrs(self):
373 self.spec.loader = NewLoader()
374 with CleanImport(self.spec.name):
375 loaded = self.bootstrap._load(self.spec)
376 loaded.__name__ = 'ham'
377 del loaded.__loader__
378 del loaded.__package__
379 del loaded.__spec__
380 self.bootstrap._exec(self.spec, loaded)
381
382 self.assertEqual(loaded.__name__, self.spec.name)
383 self.assertIs(loaded.__loader__, self.spec.loader)
384 self.assertEqual(loaded.__package__, self.spec.parent)
385 self.assertIs(loaded.__spec__, self.spec)
386 self.assertFalse(hasattr(loaded, '__path__'))
387 self.assertFalse(hasattr(loaded, '__file__'))
388 self.assertFalse(hasattr(loaded, '__cached__'))
389
390 def test_reload_legacy(self):
391 with warnings.catch_warnings():
392 warnings.simplefilter("ignore", ImportWarning)
393 self.spec.loader = LegacyLoader()
394 with CleanImport(self.spec.name):
395 loaded = self.bootstrap._load(self.spec)
396 reloaded = self.bootstrap._exec(self.spec, loaded)
397 installed = sys.modules[self.spec.name]
398
399 self.assertEqual(loaded.ham, -1)
400 self.assertIs(reloaded, loaded)
401 self.assertIs(installed, loaded)
402
403
404 (Frozen_ModuleSpecMethodsTests,
405 Source_ModuleSpecMethodsTests
406 ) = test_util.test_both(ModuleSpecMethodsTests, init=init, util=util,
407 machinery=machinery)
408
409
410 class ESC[4;38;5;81mModuleReprTests:
411
412 @property
413 def bootstrap(self):
414 return self.init._bootstrap
415
416 def setUp(self):
417 self.module = type(os)('spam')
418 self.spec = self.machinery.ModuleSpec('spam', TestLoader())
419
420 def test_module___loader___module_repr(self):
421 class ESC[4;38;5;81mLoader:
422 def module_repr(self, module):
423 return '<delicious {}>'.format(module.__name__)
424 self.module.__loader__ = Loader()
425 modrepr = self.bootstrap._module_repr(self.module)
426
427 self.assertEqual(modrepr, '<delicious spam>')
428
429 def test_module___loader___module_repr_bad(self):
430 class ESC[4;38;5;81mLoader(ESC[4;38;5;149mTestLoader):
431 def module_repr(self, module):
432 raise Exception
433 self.module.__loader__ = Loader()
434 modrepr = self.bootstrap._module_repr(self.module)
435
436 self.assertEqual(modrepr,
437 '<module {!r} (<TestLoader object>)>'.format('spam'))
438
439 def test_module___spec__(self):
440 origin = 'in a hole, in the ground'
441 self.spec.origin = origin
442 self.module.__spec__ = self.spec
443 modrepr = self.bootstrap._module_repr(self.module)
444
445 self.assertEqual(modrepr, '<module {!r} ({})>'.format('spam', origin))
446
447 def test_module___spec___location(self):
448 location = 'in_a_galaxy_far_far_away.py'
449 self.spec.origin = location
450 self.spec._set_fileattr = True
451 self.module.__spec__ = self.spec
452 modrepr = self.bootstrap._module_repr(self.module)
453
454 self.assertEqual(modrepr,
455 '<module {!r} from {!r}>'.format('spam', location))
456
457 def test_module___spec___no_origin(self):
458 self.spec.loader = TestLoader()
459 self.module.__spec__ = self.spec
460 modrepr = self.bootstrap._module_repr(self.module)
461
462 self.assertEqual(modrepr,
463 '<module {!r} (<TestLoader object>)>'.format('spam'))
464
465 def test_module___spec___no_origin_no_loader(self):
466 self.spec.loader = None
467 self.module.__spec__ = self.spec
468 modrepr = self.bootstrap._module_repr(self.module)
469
470 self.assertEqual(modrepr, '<module {!r}>'.format('spam'))
471
472 def test_module_no_name(self):
473 del self.module.__name__
474 modrepr = self.bootstrap._module_repr(self.module)
475
476 self.assertEqual(modrepr, '<module {!r}>'.format('?'))
477
478 def test_module_with_file(self):
479 filename = 'e/i/e/i/o/spam.py'
480 self.module.__file__ = filename
481 modrepr = self.bootstrap._module_repr(self.module)
482
483 self.assertEqual(modrepr,
484 '<module {!r} from {!r}>'.format('spam', filename))
485
486 def test_module_no_file(self):
487 self.module.__loader__ = TestLoader()
488 modrepr = self.bootstrap._module_repr(self.module)
489
490 self.assertEqual(modrepr,
491 '<module {!r} (<TestLoader object>)>'.format('spam'))
492
493 def test_module_no_file_no_loader(self):
494 modrepr = self.bootstrap._module_repr(self.module)
495
496 self.assertEqual(modrepr, '<module {!r}>'.format('spam'))
497
498
499 (Frozen_ModuleReprTests,
500 Source_ModuleReprTests
501 ) = test_util.test_both(ModuleReprTests, init=init, util=util,
502 machinery=machinery)
503
504
505 class ESC[4;38;5;81mFactoryTests:
506
507 def setUp(self):
508 self.name = 'spam'
509 self.path = os.path.abspath('spam.py')
510 self.cached = self.util.cache_from_source(self.path)
511 self.loader = TestLoader()
512 self.fileloader = TestLoader(self.path)
513 self.pkgloader = TestLoader(self.path, True)
514
515 # spec_from_loader()
516
517 def test_spec_from_loader_default(self):
518 spec = self.util.spec_from_loader(self.name, self.loader)
519
520 self.assertEqual(spec.name, self.name)
521 self.assertEqual(spec.loader, self.loader)
522 self.assertIs(spec.origin, None)
523 self.assertIs(spec.loader_state, None)
524 self.assertIs(spec.submodule_search_locations, None)
525 self.assertIs(spec.cached, None)
526 self.assertFalse(spec.has_location)
527
528 def test_spec_from_loader_default_with_bad_is_package(self):
529 class ESC[4;38;5;81mLoader:
530 def is_package(self, name):
531 raise ImportError
532 loader = Loader()
533 spec = self.util.spec_from_loader(self.name, loader)
534
535 self.assertEqual(spec.name, self.name)
536 self.assertEqual(spec.loader, loader)
537 self.assertIs(spec.origin, None)
538 self.assertIs(spec.loader_state, None)
539 self.assertIs(spec.submodule_search_locations, None)
540 self.assertIs(spec.cached, None)
541 self.assertFalse(spec.has_location)
542
543 def test_spec_from_loader_origin(self):
544 origin = 'somewhere over the rainbow'
545 spec = self.util.spec_from_loader(self.name, self.loader,
546 origin=origin)
547
548 self.assertEqual(spec.name, self.name)
549 self.assertEqual(spec.loader, self.loader)
550 self.assertIs(spec.origin, origin)
551 self.assertIs(spec.loader_state, None)
552 self.assertIs(spec.submodule_search_locations, None)
553 self.assertIs(spec.cached, None)
554 self.assertFalse(spec.has_location)
555
556 def test_spec_from_loader_is_package_false(self):
557 spec = self.util.spec_from_loader(self.name, self.loader,
558 is_package=False)
559
560 self.assertEqual(spec.name, self.name)
561 self.assertEqual(spec.loader, self.loader)
562 self.assertIs(spec.origin, None)
563 self.assertIs(spec.loader_state, None)
564 self.assertIs(spec.submodule_search_locations, None)
565 self.assertIs(spec.cached, None)
566 self.assertFalse(spec.has_location)
567
568 def test_spec_from_loader_is_package_true(self):
569 spec = self.util.spec_from_loader(self.name, self.loader,
570 is_package=True)
571
572 self.assertEqual(spec.name, self.name)
573 self.assertEqual(spec.loader, self.loader)
574 self.assertIs(spec.origin, None)
575 self.assertIs(spec.loader_state, None)
576 self.assertEqual(spec.submodule_search_locations, [])
577 self.assertIs(spec.cached, None)
578 self.assertFalse(spec.has_location)
579
580 def test_spec_from_loader_origin_and_is_package(self):
581 origin = 'where the streets have no name'
582 spec = self.util.spec_from_loader(self.name, self.loader,
583 origin=origin, is_package=True)
584
585 self.assertEqual(spec.name, self.name)
586 self.assertEqual(spec.loader, self.loader)
587 self.assertIs(spec.origin, origin)
588 self.assertIs(spec.loader_state, None)
589 self.assertEqual(spec.submodule_search_locations, [])
590 self.assertIs(spec.cached, None)
591 self.assertFalse(spec.has_location)
592
593 def test_spec_from_loader_is_package_with_loader_false(self):
594 loader = TestLoader(is_package=False)
595 spec = self.util.spec_from_loader(self.name, loader)
596
597 self.assertEqual(spec.name, self.name)
598 self.assertEqual(spec.loader, loader)
599 self.assertIs(spec.origin, None)
600 self.assertIs(spec.loader_state, None)
601 self.assertIs(spec.submodule_search_locations, None)
602 self.assertIs(spec.cached, None)
603 self.assertFalse(spec.has_location)
604
605 def test_spec_from_loader_is_package_with_loader_true(self):
606 loader = TestLoader(is_package=True)
607 spec = self.util.spec_from_loader(self.name, loader)
608
609 self.assertEqual(spec.name, self.name)
610 self.assertEqual(spec.loader, loader)
611 self.assertIs(spec.origin, None)
612 self.assertIs(spec.loader_state, None)
613 self.assertEqual(spec.submodule_search_locations, [])
614 self.assertIs(spec.cached, None)
615 self.assertFalse(spec.has_location)
616
617 def test_spec_from_loader_default_with_file_loader(self):
618 spec = self.util.spec_from_loader(self.name, self.fileloader)
619
620 self.assertEqual(spec.name, self.name)
621 self.assertEqual(spec.loader, self.fileloader)
622 self.assertEqual(spec.origin, self.path)
623 self.assertIs(spec.loader_state, None)
624 self.assertIs(spec.submodule_search_locations, None)
625 self.assertEqual(spec.cached, self.cached)
626 self.assertTrue(spec.has_location)
627
628 def test_spec_from_loader_is_package_false_with_fileloader(self):
629 spec = self.util.spec_from_loader(self.name, self.fileloader,
630 is_package=False)
631
632 self.assertEqual(spec.name, self.name)
633 self.assertEqual(spec.loader, self.fileloader)
634 self.assertEqual(spec.origin, self.path)
635 self.assertIs(spec.loader_state, None)
636 self.assertIs(spec.submodule_search_locations, None)
637 self.assertEqual(spec.cached, self.cached)
638 self.assertTrue(spec.has_location)
639
640 def test_spec_from_loader_is_package_true_with_fileloader(self):
641 spec = self.util.spec_from_loader(self.name, self.fileloader,
642 is_package=True)
643
644 self.assertEqual(spec.name, self.name)
645 self.assertEqual(spec.loader, self.fileloader)
646 self.assertEqual(spec.origin, self.path)
647 self.assertIs(spec.loader_state, None)
648 self.assertEqual(spec.submodule_search_locations, [os.getcwd()])
649 self.assertEqual(spec.cached, self.cached)
650 self.assertTrue(spec.has_location)
651
652 # spec_from_file_location()
653
654 def test_spec_from_file_location_default(self):
655 spec = self.util.spec_from_file_location(self.name, self.path)
656
657 self.assertEqual(spec.name, self.name)
658 # Need to use a circuitous route to get at importlib.machinery to make
659 # sure the same class object is used in the isinstance() check as
660 # would have been used to create the loader.
661 SourceFileLoader = self.util.spec_from_file_location.__globals__['SourceFileLoader']
662 self.assertIsInstance(spec.loader, SourceFileLoader)
663 self.assertEqual(spec.loader.name, self.name)
664 self.assertEqual(spec.loader.path, self.path)
665 self.assertEqual(spec.origin, self.path)
666 self.assertIs(spec.loader_state, None)
667 self.assertIs(spec.submodule_search_locations, None)
668 self.assertEqual(spec.cached, self.cached)
669 self.assertTrue(spec.has_location)
670
671 def test_spec_from_file_location_path_like_arg(self):
672 spec = self.util.spec_from_file_location(self.name,
673 pathlib.PurePath(self.path))
674 self.assertEqual(spec.origin, self.path)
675
676 def test_spec_from_file_location_default_without_location(self):
677 spec = self.util.spec_from_file_location(self.name)
678
679 self.assertIs(spec, None)
680
681 def test_spec_from_file_location_default_bad_suffix(self):
682 spec = self.util.spec_from_file_location(self.name, 'spam.eggs')
683
684 self.assertIs(spec, None)
685
686 def test_spec_from_file_location_loader_no_location(self):
687 spec = self.util.spec_from_file_location(self.name,
688 loader=self.fileloader)
689
690 self.assertEqual(spec.name, self.name)
691 self.assertEqual(spec.loader, self.fileloader)
692 self.assertEqual(spec.origin, self.path)
693 self.assertIs(spec.loader_state, None)
694 self.assertIs(spec.submodule_search_locations, None)
695 self.assertEqual(spec.cached, self.cached)
696 self.assertTrue(spec.has_location)
697
698 def test_spec_from_file_location_loader_no_location_no_get_filename(self):
699 spec = self.util.spec_from_file_location(self.name,
700 loader=self.loader)
701
702 self.assertEqual(spec.name, self.name)
703 self.assertEqual(spec.loader, self.loader)
704 self.assertEqual(spec.origin, '<unknown>')
705 self.assertIs(spec.loader_state, None)
706 self.assertIs(spec.submodule_search_locations, None)
707 self.assertIs(spec.cached, None)
708 self.assertTrue(spec.has_location)
709
710 def test_spec_from_file_location_loader_no_location_bad_get_filename(self):
711 class ESC[4;38;5;81mLoader:
712 def get_filename(self, name):
713 raise ImportError
714 loader = Loader()
715 spec = self.util.spec_from_file_location(self.name, loader=loader)
716
717 self.assertEqual(spec.name, self.name)
718 self.assertEqual(spec.loader, loader)
719 self.assertEqual(spec.origin, '<unknown>')
720 self.assertIs(spec.loader_state, None)
721 self.assertIs(spec.submodule_search_locations, None)
722 self.assertIs(spec.cached, None)
723 self.assertTrue(spec.has_location)
724
725 def test_spec_from_file_location_smsl_none(self):
726 spec = self.util.spec_from_file_location(self.name, self.path,
727 loader=self.fileloader,
728 submodule_search_locations=None)
729
730 self.assertEqual(spec.name, self.name)
731 self.assertEqual(spec.loader, self.fileloader)
732 self.assertEqual(spec.origin, self.path)
733 self.assertIs(spec.loader_state, None)
734 self.assertIs(spec.submodule_search_locations, None)
735 self.assertEqual(spec.cached, self.cached)
736 self.assertTrue(spec.has_location)
737
738 def test_spec_from_file_location_smsl_empty(self):
739 spec = self.util.spec_from_file_location(self.name, self.path,
740 loader=self.fileloader,
741 submodule_search_locations=[])
742
743 self.assertEqual(spec.name, self.name)
744 self.assertEqual(spec.loader, self.fileloader)
745 self.assertEqual(spec.origin, self.path)
746 self.assertIs(spec.loader_state, None)
747 self.assertEqual(spec.submodule_search_locations, [os.getcwd()])
748 self.assertEqual(spec.cached, self.cached)
749 self.assertTrue(spec.has_location)
750
751 def test_spec_from_file_location_smsl_not_empty(self):
752 spec = self.util.spec_from_file_location(self.name, self.path,
753 loader=self.fileloader,
754 submodule_search_locations=['eggs'])
755
756 self.assertEqual(spec.name, self.name)
757 self.assertEqual(spec.loader, self.fileloader)
758 self.assertEqual(spec.origin, self.path)
759 self.assertIs(spec.loader_state, None)
760 self.assertEqual(spec.submodule_search_locations, ['eggs'])
761 self.assertEqual(spec.cached, self.cached)
762 self.assertTrue(spec.has_location)
763
764 def test_spec_from_file_location_smsl_default(self):
765 spec = self.util.spec_from_file_location(self.name, self.path,
766 loader=self.pkgloader)
767
768 self.assertEqual(spec.name, self.name)
769 self.assertEqual(spec.loader, self.pkgloader)
770 self.assertEqual(spec.origin, self.path)
771 self.assertIs(spec.loader_state, None)
772 self.assertEqual(spec.submodule_search_locations, [os.getcwd()])
773 self.assertEqual(spec.cached, self.cached)
774 self.assertTrue(spec.has_location)
775
776 def test_spec_from_file_location_smsl_default_not_package(self):
777 class ESC[4;38;5;81mLoader:
778 def is_package(self, name):
779 return False
780 loader = Loader()
781 spec = self.util.spec_from_file_location(self.name, self.path,
782 loader=loader)
783
784 self.assertEqual(spec.name, self.name)
785 self.assertEqual(spec.loader, loader)
786 self.assertEqual(spec.origin, self.path)
787 self.assertIs(spec.loader_state, None)
788 self.assertIs(spec.submodule_search_locations, None)
789 self.assertEqual(spec.cached, self.cached)
790 self.assertTrue(spec.has_location)
791
792 def test_spec_from_file_location_smsl_default_no_is_package(self):
793 spec = self.util.spec_from_file_location(self.name, self.path,
794 loader=self.fileloader)
795
796 self.assertEqual(spec.name, self.name)
797 self.assertEqual(spec.loader, self.fileloader)
798 self.assertEqual(spec.origin, self.path)
799 self.assertIs(spec.loader_state, None)
800 self.assertIs(spec.submodule_search_locations, None)
801 self.assertEqual(spec.cached, self.cached)
802 self.assertTrue(spec.has_location)
803
804 def test_spec_from_file_location_smsl_default_bad_is_package(self):
805 class ESC[4;38;5;81mLoader:
806 def is_package(self, name):
807 raise ImportError
808 loader = Loader()
809 spec = self.util.spec_from_file_location(self.name, self.path,
810 loader=loader)
811
812 self.assertEqual(spec.name, self.name)
813 self.assertEqual(spec.loader, loader)
814 self.assertEqual(spec.origin, self.path)
815 self.assertIs(spec.loader_state, None)
816 self.assertIs(spec.submodule_search_locations, None)
817 self.assertEqual(spec.cached, self.cached)
818 self.assertTrue(spec.has_location)
819
820 def test_spec_from_file_location_relative_path(self):
821 spec = self.util.spec_from_file_location(self.name,
822 os.path.basename(self.path), loader=self.fileloader)
823
824 self.assertEqual(spec.name, self.name)
825 self.assertEqual(spec.loader, self.fileloader)
826 self.assertEqual(spec.origin, self.path)
827 self.assertIs(spec.loader_state, None)
828 self.assertIs(spec.submodule_search_locations, None)
829 self.assertEqual(spec.cached, self.cached)
830 self.assertTrue(spec.has_location)
831
832 (Frozen_FactoryTests,
833 Source_FactoryTests
834 ) = test_util.test_both(FactoryTests, util=util, machinery=machinery)
835
836
837 if __name__ == '__main__':
838 unittest.main()