← Back to branch summary

~azzar1/unity/add-show-desktop-key

« back to all changes in this revision

Viewing changes to ivle/webapp/urls/test_router.py

  • Committer: William Grant
  • Date: 2009-07-04 05:45:45 UTC
  • mto: (1294.4.2 ui-the-third)
  • mto: This revision was merged to the branch mainline in revision 1353.
  • Revision ID: grantw@unimelb.edu.au-20090704054545-dnyyundb3kpxiyvh
Replace the tests' OfferingProjects with OfferingFiles.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/webapp/urls/test_router.py
 
1
from nose.tools import assert_equal, raises
 
2
 
 
3
from ivle.webapp.urls import (InsufficientPathSegments, NoPath, NotFound,
 
4
                              RouteConflict, Router, ROOT)
 
5
 
 
6
class Root(object):
 
7
    def __init__(self):
 
8
        self.subjects = {}
 
9
 
 
10
    def add_subject(self, subject):
 
11
        self.subjects[subject.name] = subject
 
12
 
 
13
class Subject(object):
 
14
    def __init__(self, name, code):
 
15
        self.name = name
 
16
        self.code = code
 
17
        self.offerings = {}
 
18
 
 
19
    def add_offering(self, offering):
 
20
        assert self.name == offering.subject.name
 
21
        self.offerings[(offering.year, offering.semester)] = offering
 
22
 
 
23
class Offering(object):
 
24
    def __init__(self, subject, year, semester):
 
25
        self.subject = subject
 
26
        self.year = year
 
27
        self.semester = semester
 
28
 
 
29
class OfferingFiles(object):
 
30
    def __init__(self, offering):
 
31
        self.offering = offering
 
32
 
 
33
class View(object):
 
34
    def __init__(self, context):
 
35
        self.context = context
 
36
 
 
37
class RootIndex(View):
 
38
    pass
 
39
 
 
40
class SubjectIndex(View):
 
41
    pass
 
42
 
 
43
class SubjectEdit(View):
 
44
    pass
 
45
 
 
46
class OfferingIndex(View):
 
47
    pass
 
48
 
 
49
class OfferingEdit(View):
 
50
    pass
 
51
 
 
52
class OfferingAPIIndex(View):
 
53
    pass
 
54
 
 
55
class OfferingFilesIndex(View):
 
56
    pass
 
57
 
 
58
 
 
59
def root_to_subject(root, name):
 
60
    return root.subjects.get(name)
 
61
 
 
62
def subject_to_offering(subject, year, semester):
 
63
    return subject.offerings.get((int(year), int(semester)))
 
64
 
 
65
def offering_to_files(offering):
 
66
    return OfferingFiles(offering)
 
67
 
 
68
def subject_url(subject):
 
69
    return (ROOT, subject.name)
 
70
 
 
71
def offering_url(offering):
 
72
    return (offering.subject, (str(offering.year), str(offering.semester)))
 
73
 
 
74
def offering_projects_url(offeringprojects):
 
75
    return (offeringprojects.offering, '+projects')
 
76
 
 
77
 
 
78
class BaseTest(object):
 
79
    def setUp(self):
 
80
        r = Root()
 
81
        self.r = r
 
82
 
 
83
        # Give us some subjects...
 
84
        r.add_subject(Subject('info1', '600151'))
 
85
        r.add_subject(Subject('info2', '600152'))
 
86
        r.add_subject(Subject('info3', '600251'))
 
87
 
 
88
        # ... and some offerings.
 
89
        r.subjects['info1'].add_offering(Offering(self.r.subjects['info1'],
 
90
                                         2008, 1))
 
91
        r.subjects['info1'].add_offering(Offering(self.r.subjects['info1'],
 
92
                                         2008, 2))
 
93
        r.subjects['info1'].add_offering(Offering(self.r.subjects['info1'],
 
94
                                         2009, 1))
 
95
        r.subjects['info2'].add_offering(Offering(self.r.subjects['info2'],
 
96
                                         2008, 2))
 
97
        r.subjects['info2'].add_offering(Offering(self.r.subjects['info2'],
 
98
                                         2009, 1))
 
99
        r.subjects['info3'].add_offering(Offering(self.r.subjects['info3'],
 
100
                                         2009, 1))
 
101
 
 
102
class TestResolution(BaseTest):
 
103
    def setUp(self):
 
104
        super(TestResolution, self).setUp()
 
105
        self.rtr = Router(root=self.r, viewset='browser')
 
106
        self.rtr.add_set_switch('api', 'api')
 
107
        self.rtr.add_forward(Root, None, root_to_subject, 1)
 
108
        self.rtr.add_forward(Subject, None, subject_to_offering, 2)
 
109
        self.rtr.add_forward(Offering, '+files', offering_to_files, 0)
 
110
        self.rtr.add_view(Subject, '+index', SubjectIndex, viewset='browser')
 
111
        self.rtr.add_view(Subject, '+edit', SubjectEdit, viewset='browser')
 
112
        self.rtr.add_view(Offering, '+index', OfferingIndex, viewset='browser')
 
113
        self.rtr.add_view(Offering, '+index', OfferingAPIIndex, viewset='api')
 
114
        self.rtr.add_view(OfferingFiles, '+index', OfferingFilesIndex,
 
115
                          viewset='browser')
 
116
 
 
117
    def testOneRoute(self):
 
118
        assert_equal(self.rtr.resolve('/info1'),
 
119
                     (self.r.subjects['info1'], SubjectIndex, ())
 
120
                     )
 
121
        assert_equal(self.rtr.resolve('/info3'),
 
122
                     (self.r.subjects['info3'], SubjectIndex, ())
 
123
                     )
 
124
 
 
125
    def testTwoRoutes(self):
 
126
        assert_equal(self.rtr.resolve('/info1/2009/1'),
 
127
             (self.r.subjects['info1'].offerings[(2009, 1)], OfferingIndex, ())
 
128
             )
 
129
        assert_equal(self.rtr.resolve('/info2/2008/2'),
 
130
             (self.r.subjects['info2'].offerings[(2008, 2)], OfferingIndex, ())
 
131
             )
 
132
 
 
133
    def testNamedRoute(self):
 
134
        assert_equal(type(self.rtr.resolve('/info1/2009/1/+files')[0]),
 
135
                     OfferingFiles
 
136
                    )
 
137
        assert_equal(self.rtr.resolve('/info1/2009/1/+files')[0].offering,
 
138
                     self.r.subjects['info1'].offerings[(2009, 1)]
 
139
                    )
 
140
 
 
141
    def testNonDefaultView(self):
 
142
        assert_equal(self.rtr.resolve('/info1/+edit'),
 
143
                     (self.r.subjects['info1'], SubjectEdit, ())
 
144
                     )
 
145
 
 
146
    def testDefaultView(self):
 
147
        assert_equal(self.rtr.resolve('/info1'),
 
148
                     (self.r.subjects['info1'], SubjectIndex, ())
 
149
                     )
 
150
 
 
151
    def testViewWithSubpath(self):
 
152
        assert_equal(self.rtr.resolve('/info1/+edit/foo/bar'),
 
153
                     (self.r.subjects['info1'], SubjectEdit, ('foo', 'bar'))
 
154
                     )
 
155
 
 
156
    def testNoDefaultView(self):
 
157
        try:
 
158
            self.rtr.default = 'not+index'
 
159
            self.rtr.resolve('/info1')
 
160
        except NotFound, e:
 
161
            assert_equal(e.args, (self.r.subjects['info1'], '+index', ()))
 
162
        except:
 
163
            raise
 
164
        else:
 
165
            raise AssertionError('did not raise NotFound')
 
166
        finally:
 
167
            self.rtr.default = '+index'
 
168
 
 
169
    def testMissingView(self):
 
170
        try:
 
171
            self.rtr.resolve('/info1/+foo')
 
172
        except NotFound, e:
 
173
            assert_equal(e.args, (self.r.subjects['info1'], '+foo', ()))
 
174
        except:
 
175
            raise
 
176
        else:
 
177
            raise AssertionError('did not raise NotFound')
 
178
 
 
179
    def testViewSetSeparation(self):
 
180
        try:
 
181
            self.rtr.resolve('/api/info1/+edit')
 
182
        except NotFound, e:
 
183
            assert_equal(e.args, (self.r.subjects['info1'], '+edit', ()))
 
184
        except:
 
185
            raise
 
186
        else:
 
187
            raise AssertionError('did not raise NotFound')
 
188
 
 
189
    def testRouteReturningNone(self):
 
190
        try:
 
191
            self.rtr.resolve('/info9/+index')
 
192
        except NotFound, e:
 
193
            assert_equal(e.args, (self.r, 'info9', ('+index',)))
 
194
        except:
 
195
            raise
 
196
        else:
 
197
            raise AssertionError('did not raise NotFound')
 
198
 
 
199
    def testAlternateViewSetWithDefault(self):
 
200
        assert_equal(self.rtr.resolve('/info1/2009/1'),
 
201
             (self.r.subjects['info1'].offerings[(2009, 1)], OfferingIndex, ())
 
202
             )
 
203
 
 
204
        assert_equal(self.rtr.resolve('/api/info1/2009/1'),
 
205
          (self.r.subjects['info1'].offerings[(2009, 1)], OfferingAPIIndex, ())
 
206
          )
 
207
 
 
208
class TestGeneration(BaseTest):
 
209
    def setUp(self):
 
210
        super(TestGeneration, self).setUp()
 
211
        self.rtr = Router(root=self.r, viewset='browser')
 
212
        self.rtr.add_set_switch('api', 'api')
 
213
        self.rtr.add_reverse(Subject, subject_url)
 
214
        self.rtr.add_reverse(Offering, offering_url)
 
215
        self.rtr.add_view(Subject, '+index', SubjectIndex, viewset='browser')
 
216
        self.rtr.add_view(Subject, '+edit', SubjectEdit, viewset='browser')
 
217
        self.rtr.add_view(Offering, '+index', OfferingIndex, viewset='browser')
 
218
        self.rtr.add_view(Offering, '+index', OfferingAPIIndex, viewset='api')
 
219
 
 
220
    def testOneLevel(self):
 
221
        assert_equal(self.rtr.generate(self.r.subjects['info1']), '/info1')
 
222
 
 
223
    def testTwoLevel(self):
 
224
        assert_equal(
 
225
            self.rtr.generate(self.r.subjects['info1'].offerings[(2009, 1)]),
 
226
            '/info1/2009/1'
 
227
            )
 
228
        assert_equal(
 
229
            self.rtr.generate(self.r.subjects['info2'].offerings[(2008, 2)]),
 
230
            '/info2/2008/2'
 
231
            )
 
232
 
 
233
    def testView(self):
 
234
        assert_equal(self.rtr.generate(self.r.subjects['info1'], SubjectEdit),
 
235
                     '/info1/+edit'
 
236
                     )
 
237
 
 
238
    def testDefaultView(self):
 
239
        assert_equal(
 
240
            self.rtr.generate(self.r.subjects['info1'].offerings[(2009, 1)],
 
241
                              OfferingIndex
 
242
                              ),
 
243
            '/info1/2009/1'
 
244
            )
 
245
 
 
246
    def testViewWithSubpath(self):
 
247
        assert_equal(self.rtr.generate(self.r.subjects['info1'], SubjectEdit,
 
248
                                       ('foo', 'bar')),
 
249
                     '/info1/+edit/foo/bar'
 
250
                     )
 
251
 
 
252
    def testViewWithStringSubpath(self):
 
253
        assert_equal(self.rtr.generate(self.r.subjects['info1'], SubjectEdit,
 
254
                                       'foo/bar'),
 
255
                     '/info1/+edit/foo/bar'
 
256
                     )
 
257
 
 
258
    def testAlternateViewSetWithDefault(self):
 
259
        assert_equal(
 
260
            self.rtr.generate(self.r.subjects['info1'].offerings[(2009, 1)],
 
261
                              OfferingAPIIndex
 
262
                              ),
 
263
            '/api/info1/2009/1'
 
264
            )
 
265
 
 
266
 
 
267
class TestErrors(BaseTest):
 
268
    def setUp(self):
 
269
        super(TestErrors, self).setUp()
 
270
        self.rtr = Router(root=self.r)
 
271
        self.rtr.add_forward(Root, None, root_to_subject, 1)
 
272
        self.rtr.add_forward(Subject, '+foo', lambda s: s.name + 'foo', 0)
 
273
        self.rtr.add_forward(Subject, None, subject_to_offering, 2)
 
274
        self.rtr.add_reverse(Subject, subject_url)
 
275
        self.rtr.add_reverse(Offering, offering_url)
 
276
        self.rtr.add_view(Offering, '+index', OfferingIndex)
 
277
        self.rtr.add_view(Offering, '+index', OfferingAPIIndex, viewset='api')
 
278
        self.rtr.add_set_switch('rest', 'rest')
 
279
 
 
280
    @raises(RouteConflict)
 
281
    def testForwardConflict(self):
 
282
        self.rtr.add_forward(Subject, '+foo', object(), 2)
 
283
 
 
284
    @raises(RouteConflict)
 
285
    def testReverseConflict(self):
 
286
        self.rtr.add_reverse(Subject, object())
 
287
 
 
288
    @raises(RouteConflict)
 
289
    def testViewConflict(self):
 
290
        self.rtr.add_view(Offering, '+index', object())
 
291
 
 
292
    @raises(RouteConflict)
 
293
    def testSetSwitchForwardConflict(self):
 
294
        self.rtr.add_set_switch('rest', 'foo')
 
295
 
 
296
    @raises(RouteConflict)
 
297
    def testSetSwitchReverseConflict(self):
 
298
        self.rtr.add_set_switch('bar', 'rest')
 
299
 
 
300
    @raises(NoPath)
 
301
    def testNoPath(self):
 
302
        self.rtr.generate(object())
 
303
 
 
304
    @raises(NoPath)
 
305
    def testNoSetSwitch(self):
 
306
        self.rtr.generate(self.r.subjects['info1'].offerings[(2009, 1)],
 
307
                          OfferingAPIIndex)
 
308
 
 
309
    @raises(NoPath)
 
310
    def testUnregisteredView(self):
 
311
        self.rtr.generate(self.r.subjects['info1'], SubjectIndex)
 
312
 
 
313
    @raises(NotFound)
 
314
    def testNotFound(self):
 
315
        self.rtr.resolve('/bar')
 
316
 
 
317
    @raises(InsufficientPathSegments)
 
318
    def testInsufficientPathSegments(self):
 
319
        self.rtr.resolve('/info1/foo')