File: test_objectdispatcher.py

package info (click to toggle)
python-crank 0.7.2-6
  • links: PTS, VCS
  • area: main
  • in suites: bookworm
  • size: 204 kB
  • sloc: python: 1,353; makefile: 18
file content (297 lines) | stat: -rw-r--r-- 11,086 bytes parent folder | download | duplicates (5)
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
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
# encoding: utf-8
import sys
from nose.tools import raises
from crank.objectdispatcher import *
from crank.dispatchstate import DispatchState
from webob.exc import HTTPNotFound

_PY3 = bool(sys.version_info[0] == 3)
if _PY3:
    def u(s): return s
else:
    def u(s): return s.decode('utf-8')

class MockRequest(object):

    def __init__(self, path_info, params=None):
        self.path_info = path_info
        self.params = params
        if params is None:
            self.params = {}

class MockSubDispatcher(ObjectDispatcher):
    def index(self):
        pass

class MockLookupHelperWithArgs:

    def get_here(self, *args):
        pass

    def post_with_mixed_args(self, arg1, arg2, **kw):
        pass

class MockLoookupDispatcherWithArgs(ObjectDispatcher):

    def _lookup(self, *args):
        return MockLookupHelperWithArgs(), args

mock_lookup_dispatcher_with_args = MockLoookupDispatcherWithArgs()

class MockDispatchDispatcher(ObjectDispatcher):

    def wacky(self, *args, **kw):
        pass

    def _check_security(self):
        pass

    def _dispatch(self, state, remainder=None):
        state.add_method(self.wacky, remainder)
        return state

class MockDispatcher(ObjectDispatcher):


    def index(self):
        pass

    def _default(self, *args, **kw):
        pass

    def no_args(self):
        pass

    def with_args(self, a, b):
        pass

    sub = MockSubDispatcher()
    override_dispatch = MockDispatchDispatcher()

class MockError(Exception):pass
class MockDispatcherWithSecurity(ObjectDispatcher):
    def _check_security(self):
        raise MockError

    def _default(self, *args, **kw):
        pass

mock_dispatcher_with_check_security = MockDispatcherWithSecurity()

class MockDispatcherWithNoDefaultOrIndex(ObjectDispatcher):

    def no_args(self):
        pass

    def with_args(self, a, b):
        pass

mock_dispatcher_with_no_default_or_index = MockDispatcherWithNoDefaultOrIndex()

class MockDispatcherWithNoDefault(ObjectDispatcher):
    def index(self):
        pass

    sub_child = MockDispatcher()

mock_dispatcher_with_no_default = MockDispatcherWithNoDefault()

class MockDispatcherWithIndexWithArgVars(ObjectDispatcher):
    def index(self, *args):
        pass

mock_dispatcher_with_index_with_argvars = MockDispatcherWithIndexWithArgVars()

class MockDispatcherWithNoIndex(ObjectDispatcher):
    def _default(self):
        pass

mock_dispatcher_with_no_index = MockDispatcherWithNoIndex()

class TestDispatcher:

    def setup(self):
        self.dispatcher = MockDispatcher()

    def test_create(self):
        pass
    
    def test_call(self):
        req = MockRequest('/')
        state = DispatchState(req)
        state = self.dispatcher(state, [])
        assert state.method.__name__ == 'index', state.method

    def test_dispatch_index(self):
        req = MockRequest('/')
        state = DispatchState(req)
        state = self.dispatcher._dispatch(state, [])
        assert state.method.__name__ == 'index', state.method

    def test_dispatch_default(self):
        req = MockRequest('/', params={'a':1})
        state = DispatchState(req, self.dispatcher)
        state = self.dispatcher._dispatch(state)
        assert state.method.__name__ == '_default', state.method

    def test_dispatch_default_with_unicode(self):
        req = MockRequest('/', params={u('å'):u('ß')})
        state = DispatchState(req)
        state = self.dispatcher._dispatch(state)
        assert state.method.__name__ == '_default', state.method

    def test_controller_method_dispatch_no_args(self):
        req = MockRequest('/no_args')
        state = DispatchState(req)
        state = self.dispatcher._dispatch(state)
        assert state.method.__name__ == 'no_args', state.method

    def test_controller_method_with_unicode_args(self):
        req = MockRequest(u('/with_args/å/ß'))
        state = DispatchState(req)
        state = self.dispatcher._dispatch(state)
        assert state.method.__name__ == 'with_args', state.method

    def test_controller_method_with_empty_args(self):
        req = MockRequest('/with_args//a/b')
        state = DispatchState(req)
        state = self.dispatcher._dispatch(state)
        assert state.method.__name__ == '_default', state.method

    def test_controller_method_with_args(self):
        req = MockRequest('/with_args/a/b')
        state = DispatchState(req)
        state = self.dispatcher._dispatch(state)
        assert state.method.__name__ == 'with_args', state.method

    def test_controller_method_with_args_missing_args_default(self):
        req = MockRequest('/with_args/a')
        state = DispatchState(req)
        state = self.dispatcher._dispatch(state)
        assert state.method.__name__ == '_default', state.method

    @raises(HTTPNotFound)
    def test_controller_method_with_args_missing_args_404_default_or_index(self):
        req = MockRequest('/with_args/a')
        state = DispatchState(req, mock_dispatcher_with_no_default_or_index)
        state = mock_dispatcher_with_no_default_or_index._dispatch(state)
        assert state.method.__name__ == '_default', state.method

    @raises(HTTPNotFound)
    def test_controller_method_with_args_missing_args_404_no_default(self):
        req = MockRequest('/with_args/a')
        state = DispatchState(req, mock_dispatcher_with_no_default)
        state = mock_dispatcher_with_no_default_or_index._dispatch(state)
        assert state.method.__name__ == '_default', state.method

    def test_controller_method_with_args_missing_args_index(self):
        req = MockRequest('/with_args/a')
        state = DispatchState(req, mock_dispatcher_with_index_with_argvars)
        state = mock_dispatcher_with_index_with_argvars._dispatch(state)
        assert state.method.__name__ == 'index', state.method

    @raises(HTTPNotFound)
    def test_controller_method_with_args_missing_args_index_disabled(self):
        req = MockRequest('/with_args/a')
        state = DispatchState(req, mock_dispatcher_with_index_with_argvars)
        
        try:
            mock_dispatcher_with_index_with_argvars._use_index_fallback = False
            state = mock_dispatcher_with_index_with_argvars._dispatch(state)
        finally:
            mock_dispatcher_with_index_with_argvars._use_index_fallback = True

    @raises(MockError)
    def test_check_security(self):
        req = MockRequest('/with_args/a')
        state = DispatchState(req, mock_dispatcher_with_check_security)
        state = mock_dispatcher_with_check_security._dispatch(state)

    def test_sub_dispatcher(self):
        req = MockRequest('/sub')
        state = DispatchState(req)
        state = self.dispatcher._dispatch(state)
        assert state.method.__name__ == 'index', state.method
        assert state.controller.__class__.__name__ == 'MockSubDispatcher', state.controller

    def test_sub_dispatcher_bad_remainder_call_parent_default(self):
        req = MockRequest('/sub/a')
        state = DispatchState(req)
        state = self.dispatcher._dispatch(state)
        assert state.method.__name__ == '_default', state.method

    def test_sub_dispatcher_bad_params_call_parent_default(self):
        req = MockRequest('/sub', params={'a':1})
        state = DispatchState(req)
        state = self.dispatcher._dispatch(state)
        assert state.method.__name__ == '_default', state.method

    def test_sub_dispatcher_override_dispatch(self):
        req = MockRequest('/override_dispatch', params={'a':1})
        state = DispatchState(req)
        state = self.dispatcher._dispatch(state)
        assert state.method.__name__ == 'wacky', state.method

    def test_lookup_dispatch(self):
        req = MockRequest('/get_here')
        state = DispatchState(req, mock_lookup_dispatcher_with_args)
        state = mock_lookup_dispatcher_with_args._dispatch(state)
        assert state.method.__name__ == 'get_here', state.method
        assert state.controller.__class__.__name__ == 'MockLookupHelperWithArgs', state.controller

    @raises(HTTPNotFound)
    def test_lookup_dispatch_bad_params(self):
        req = MockRequest('/get_here', params={'a':1})
        state = DispatchState(req, mock_lookup_dispatcher_with_args)
        state = mock_lookup_dispatcher_with_args._dispatch(state)

    def test_path_translation(self):
        req = MockRequest('/no.args.json')
        state = DispatchState(req, mock_dispatcher_with_no_default_or_index, path_translator=True)
        state = mock_dispatcher_with_no_default_or_index._dispatch(state)
        assert state.method.__name__ == 'no_args', state.method

    def test_path_translation_no_extension(self):
        req = MockRequest('/no.args')
        state = DispatchState(req, mock_dispatcher_with_no_default_or_index,
                              strip_extension=False, path_translator=True)
        state = mock_dispatcher_with_no_default_or_index._dispatch(state)
        assert state.method.__name__ == 'no_args', state.method

    @raises(HTTPNotFound)
    def test_disabled_path_translation_no_extension(self):
        req = MockRequest('/no.args')
        state = DispatchState(req, mock_dispatcher_with_no_default_or_index,
                              strip_extension=False, path_translator=None)
        state = mock_dispatcher_with_no_default_or_index._dispatch(state)

    def test_path_translation_args_skipped(self):
        req = MockRequest('/with.args/para.meter1/para.meter2.json')
        state = DispatchState(req, mock_dispatcher_with_no_default_or_index, path_translator=True)
        state = mock_dispatcher_with_no_default_or_index._dispatch(state)
        assert state.method.__name__ == 'with_args', state.method
        assert 'para.meter1' in state.remainder, state.remainder
        assert 'para.meter2' in state.remainder, state.remainder

    def test_path_translation_sub_controller(self):
        req = MockRequest('/sub.child/with.args/para.meter1/para.meter2.json')
        state = DispatchState(req, mock_dispatcher_with_no_default, path_translator=True)
        state = mock_dispatcher_with_no_default._dispatch(state)

        path_pieces = [piece[0] for piece in state.controller_path]
        assert 'sub_child' in path_pieces
        assert state.method.__name__ == 'with_args', state.method
        assert 'para.meter1' in state.remainder, state.remainder
        assert 'para.meter2' in state.remainder, state.remainder

    def test_path_translation_sub_controller_no_strip_extension(self):
        req = MockRequest('/sub.child/with.args/para.meter1/para.meter2.json')
        state = DispatchState(req, mock_dispatcher_with_no_default,
                              strip_extension=False, path_translator=True)
        state = mock_dispatcher_with_no_default._dispatch(state)

        path_pieces = [piece[0] for piece in state.controller_path]
        assert 'sub_child' in path_pieces
        assert state.method.__name__ == 'with_args', state.method
        assert 'para.meter1' in state.remainder, state.remainder
        assert 'para.meter2.json' in state.remainder, state.remainder