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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
import unittest
class TestCallerPath(unittest.TestCase):
def tearDown(self):
from repoze.bfg.tests import test_path
if hasattr(test_path, '__bfg_abspath__'):
del test_path.__bfg_abspath__
def _callFUT(self, path, level=2):
from repoze.bfg.path import caller_path
return caller_path(path, level)
def test_isabs(self):
result = self._callFUT('/a/b/c')
self.assertEqual(result, '/a/b/c')
def test_pkgrelative(self):
import os
here = os.path.abspath(os.path.dirname(__file__))
result = self._callFUT('a/b/c')
self.assertEqual(result, os.path.join(here, 'a/b/c'))
def test_memoization_has_bfg_abspath(self):
import os
from repoze.bfg.tests import test_path
test_path.__bfg_abspath__ = '/foo/bar'
here = os.path.abspath(os.path.dirname(__file__))
result = self._callFUT('a/b/c')
self.assertEqual(result, os.path.join('/foo/bar', 'a/b/c'))
def test_memoization_success(self):
import os
here = os.path.abspath(os.path.dirname(__file__))
from repoze.bfg.tests import test_path
result = self._callFUT('a/b/c')
self.assertEqual(result, os.path.join(here, 'a/b/c'))
self.assertEqual(test_path.__bfg_abspath__, here)
class TestCallerModule(unittest.TestCase):
def _callFUT(self, level=2):
from repoze.bfg.path import caller_module
return caller_module(level)
def test_it_level_1(self):
from repoze.bfg.tests import test_path
result = self._callFUT(1)
self.assertEqual(result, test_path)
def test_it_level_2(self):
from repoze.bfg.tests import test_path
result = self._callFUT(2)
self.assertEqual(result, test_path)
def test_it_level_3(self):
import unittest
result = self._callFUT(3)
self.assertEqual(result, unittest)
class TestCallerPackage(unittest.TestCase):
def _callFUT(self, *arg, **kw):
from repoze.bfg.path import caller_package
return caller_package(*arg, **kw)
def test_it_level_1(self):
from repoze.bfg import tests
result = self._callFUT(1)
self.assertEqual(result, tests)
def test_it_level_2(self):
from repoze.bfg import tests
result = self._callFUT(2)
self.assertEqual(result, tests)
def test_it_level_3(self):
import unittest
result = self._callFUT(3)
self.assertEqual(result, unittest)
def test_it_package(self):
import repoze.bfg.tests
def dummy_caller_module(*arg):
return repoze.bfg.tests
result = self._callFUT(1, caller_module=dummy_caller_module)
self.assertEqual(result, repoze.bfg.tests)
class TestPackagePath(unittest.TestCase):
def _callFUT(self, package):
from repoze.bfg.path import package_path
return package_path(package)
def test_it_package(self):
from repoze.bfg import tests
package = DummyPackageOrModule(tests)
result = self._callFUT(package)
self.assertEqual(result, package.package_path)
def test_it_module(self):
from repoze.bfg.tests import test_path
module = DummyPackageOrModule(test_path)
result = self._callFUT(module)
self.assertEqual(result, module.package_path)
def test_memoization_success(self):
from repoze.bfg.tests import test_path
module = DummyPackageOrModule(test_path)
result = self._callFUT(module)
self.assertEqual(module.__bfg_abspath__, module.package_path)
def test_memoization_fail(self):
from repoze.bfg.tests import test_path
module = DummyPackageOrModule(test_path, raise_exc=TypeError)
result = self._callFUT(module)
self.failIf(hasattr(module, '__bfg_abspath__'))
self.assertEqual(result, module.package_path)
class TestPackageName(unittest.TestCase):
def _callFUT(self, package):
from repoze.bfg.path import package_name
return package_name(package)
def test_it_package(self):
from repoze.bfg import tests
package = DummyPackageOrModule(tests)
result = self._callFUT(package)
self.assertEqual(result, 'repoze.bfg.tests')
def test_it_module(self):
from repoze.bfg.tests import test_path
module = DummyPackageOrModule(test_path)
result = self._callFUT(module)
self.assertEqual(result, 'repoze.bfg.tests')
class DummyPackageOrModule:
def __init__(self, real_package_or_module, raise_exc=None):
self.__dict__['raise_exc'] = raise_exc
self.__dict__['__name__'] = real_package_or_module.__name__
import os
self.__dict__['package_path'] = os.path.dirname(
os.path.abspath(real_package_or_module.__file__))
self.__dict__['__file__'] = real_package_or_module.__file__
def __setattr__(self, key, val):
if self.raise_exc is not None:
raise self.raise_exc
self.__dict__[key] = val
|
