← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ivle/webapp/publisher/test_publisher.py

Quick port of fileservice to the new framework. It's still very much old-style,
though.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/webapp/publisher/test_publisher.py
1
 
from nose.tools import assert_equal, raises
2
 
 
3
 
from ivle.webapp.publisher import (INF, InsufficientPathSegments, NoPath,
4
 
                                   NotFound, RouteConflict, Publisher, ROOT)
5
 
 
6
 
class Root(object):
7
 
    def __init__(self):
8
 
        self.subjects = {}
9
 
        self.users = {}
10
 
 
11
 
    def add_subject(self, subject):
12
 
        self.subjects[subject.name] = subject
13
 
 
14
 
    def add_user(self, user):
15
 
        self.users[user.login] = user
16
 
 
17
 
class User(object):
18
 
    def __init__(self, login):
19
 
        self.login = login
20
 
 
21
 
class Subject(object):
22
 
    def __init__(self, name, code):
23
 
        self.name = name
24
 
        self.code = code
25
 
        self.offerings = {}
26
 
 
27
 
    def add_offering(self, offering):
28
 
        assert self.name == offering.subject.name
29
 
        self.offerings[(offering.year, offering.semester)] = offering
30
 
 
31
 
class Offering(object):
32
 
    def __init__(self, subject, year, semester):
33
 
        self.subject = subject
34
 
        self.year = year
35
 
        self.semester = semester
36
 
        self.projects = {}
37
 
 
38
 
    def add_project(self, project):
39
 
        assert project.offering is self
40
 
        self.projects[project.name] = project
41
 
 
42
 
class OfferingFiles(object):
43
 
    def __init__(self, offering):
44
 
        self.offering = offering
45
 
 
46
 
class OfferingFile(object):
47
 
    def __init__(self, offeringfiles, path):
48
 
        self.offering = offeringfiles.offering
49
 
        self.path = path
50
 
 
51
 
class Project(object):
52
 
    def __init__(self, offering, name):
53
 
        self.offering = offering
54
 
        self.name = name
55
 
 
56
 
 
57
 
class View(object):
58
 
    def __init__(self, context):
59
 
        self.context = context
60
 
 
61
 
class RootIndex(View):
62
 
    pass
63
 
 
64
 
class UserServeView(View):
65
 
    pass
66
 
 
67
 
class SubjectIndex(View):
68
 
    pass
69
 
 
70
 
class SubjectEdit(View):
71
 
    pass
72
 
 
73
 
class OfferingIndex(View):
74
 
    pass
75
 
 
76
 
class OfferingEdit(View):
77
 
    pass
78
 
 
79
 
class OfferingAPIIndex(View):
80
 
    pass
81
 
 
82
 
class OfferingFilesIndex(View):
83
 
    pass
84
 
 
85
 
class OfferingFileIndex(View):
86
 
    pass
87
 
 
88
 
class ProjectIndex(View):
89
 
    pass
90
 
 
91
 
class OfferingProjects(View):
92
 
    pass
93
 
 
94
 
class OfferingAddProject(View):
95
 
    pass
96
 
 
97
 
class OfferingWorksheets(View):
98
 
    pass
99
 
 
100
 
class OfferingWorksheetMarks(View):
101
 
    pass
102
 
 
103
 
class OfferingWorksheetCSVMarks(View):
104
 
    pass
105
 
 
106
 
def root_to_subject_or_user(root, name):
107
 
    if name.startswith('~'):
108
 
        return root.users.get(name[1:])
109
 
    return root.subjects.get(name)
110
 
 
111
 
def subject_to_offering(subject, year, semester):
112
 
    return subject.offerings.get((int(year), int(semester)))
113
 
 
114
 
def offering_to_files(offering):
115
 
    return OfferingFiles(offering)
116
 
 
117
 
def offering_files_to_file(offeringfiles, *path):
118
 
    return OfferingFile(offeringfiles, path)
119
 
 
120
 
def offering_to_project(offering, name):
121
 
    return offering.projects.get(name)
122
 
 
123
 
def subject_url(subject):
124
 
    return (ROOT, subject.name)
125
 
 
126
 
def offering_url(offering):
127
 
    return (offering.subject, (str(offering.year), str(offering.semester)))
128
 
 
129
 
def offering_files_url(offeringfiles):
130
 
    return (offeringfiles.offering, '+files')
131
 
 
132
 
def project_url(project):
133
 
    return (project.offering, ('+projects', project.name))
134
 
 
135
 
class BaseTest(object):
136
 
    def setUp(self):
137
 
        r = Root()
138
 
        self.r = r
139
 
 
140
 
        # A user would be nice.
141
 
        r.add_user(User('jsmith'))
142
 
 
143
 
        # Give us some subjects...
144
 
        r.add_subject(Subject('info1', '600151'))
145
 
        r.add_subject(Subject('info2', '600152'))
146
 
        r.add_subject(Subject('info3', '600251'))
147
 
 
148
 
        # ... and some offerings.
149
 
        r.subjects['info1'].add_offering(Offering(self.r.subjects['info1'],
150
 
                                         2008, 1))
151
 
        r.subjects['info1'].add_offering(Offering(self.r.subjects['info1'],
152
 
                                         2008, 2))
153
 
        r.subjects['info1'].add_offering(Offering(self.r.subjects['info1'],
154
 
                                         2009, 1))
155
 
        r.subjects['info2'].add_offering(Offering(self.r.subjects['info2'],
156
 
                                         2008, 2))
157
 
        r.subjects['info2'].add_offering(Offering(self.r.subjects['info2'],
158
 
                                         2009, 1))
159
 
        r.subjects['info3'].add_offering(Offering(self.r.subjects['info3'],
160
 
                                         2009, 1))
161
 
 
162
 
        # A normal project...
163
 
        r.subjects['info1'].offerings[(2009, 1)].add_project(
164
 
            Project(r.subjects['info1'].offerings[(2009, 1)], 'p1')
165
 
            )
166
 
 
167
 
        # And one conflicting with a deep view, just to be nasty.
168
 
        r.subjects['info1'].offerings[(2009, 1)].add_project(
169
 
            Project(r.subjects['info1'].offerings[(2009, 1)], '+new')
170
 
            )
171
 
 
172
 
class TestResolution(BaseTest):
173
 
    def setUp(self):
174
 
        super(TestResolution, self).setUp()
175
 
        self.rtr = Publisher(root=self.r, viewset='browser')
176
 
        self.rtr.add_set_switch('api', 'api')
177
 
        self.rtr.add_forward(Root, None, root_to_subject_or_user, 1)
178
 
        self.rtr.add_forward(Subject, None, subject_to_offering, 2)
179
 
        self.rtr.add_forward(Offering, '+files', offering_to_files, 0)
180
 
        self.rtr.add_forward(OfferingFiles, None, offering_files_to_file, INF)
181
 
        self.rtr.add_forward(Offering, '+projects', offering_to_project, 1)
182
 
        self.rtr.add_view(User, None, UserServeView, viewset='browser')
183
 
        self.rtr.add_view(Subject, '+index', SubjectIndex, viewset='browser')
184
 
        self.rtr.add_view(Subject, '+edit', SubjectEdit, viewset='browser')
185
 
        self.rtr.add_view(Offering, '+index', OfferingIndex, viewset='browser')
186
 
        self.rtr.add_view(Offering, '+index', OfferingAPIIndex, viewset='api')
187
 
        self.rtr.add_view(OfferingFiles, '+index', OfferingFilesIndex,
188
 
                          viewset='browser')
189
 
        self.rtr.add_view(OfferingFile, '+index', OfferingFileIndex,
190
 
                          viewset='browser')
191
 
        self.rtr.add_view(Project, '+index', ProjectIndex, viewset='browser')
192
 
        self.rtr.add_view(Offering, ('+projects', '+new'), OfferingAddProject,
193
 
                          viewset='browser')
194
 
        self.rtr.add_view(Offering, ('+projects', '+index'), OfferingProjects,
195
 
                          viewset='browser')
196
 
        self.rtr.add_view(Offering, ('+worksheets', '+index'),
197
 
                          OfferingWorksheets, viewset='browser')
198
 
        self.rtr.add_view(Offering, ('+worksheets', '+marks', '+index'),
199
 
                          OfferingWorksheetMarks, viewset='browser')
200
 
        self.rtr.add_view(Offering, ('+worksheets', '+marks', 'marks.csv'),
201
 
                          OfferingWorksheetCSVMarks, viewset='browser')
202
 
 
203
 
    def testOneRoute(self):
204
 
        assert_equal(self.rtr.resolve('/info1'),
205
 
                     (self.r.subjects['info1'], SubjectIndex, ())
206
 
                     )
207
 
        assert_equal(self.rtr.resolve('/info3'),
208
 
                     (self.r.subjects['info3'], SubjectIndex, ())
209
 
                     )
210
 
 
211
 
    def testTwoRoutes(self):
212
 
        assert_equal(self.rtr.resolve('/info1/2009/1'),
213
 
             (self.r.subjects['info1'].offerings[(2009, 1)], OfferingIndex, ())
214
 
             )
215
 
        assert_equal(self.rtr.resolve('/info2/2008/2'),
216
 
             (self.r.subjects['info2'].offerings[(2008, 2)], OfferingIndex, ())
217
 
             )
218
 
 
219
 
    def testNamedRoute(self):
220
 
        assert_equal(type(self.rtr.resolve('/info1/2009/1/+files')[0]),
221
 
                     OfferingFiles
222
 
                    )
223
 
        assert_equal(self.rtr.resolve('/info1/2009/1/+files')[0].offering,
224
 
                     self.r.subjects['info1'].offerings[(2009, 1)]
225
 
                    )
226
 
 
227
 
    def testNonDefaultView(self):
228
 
        assert_equal(self.rtr.resolve('/info1/+edit'),
229
 
                     (self.r.subjects['info1'], SubjectEdit, ())
230
 
                     )
231
 
 
232
 
    def testDefaultView(self):
233
 
        assert_equal(self.rtr.resolve('/info1'),
234
 
                     (self.r.subjects['info1'], SubjectIndex, ())
235
 
                     )
236
 
 
237
 
    def testViewWithSubpath(self):
238
 
        assert_equal(self.rtr.resolve('/info1/+edit/foo/bar'),
239
 
                     (self.r.subjects['info1'], SubjectEdit, ('foo', 'bar'))
240
 
                     )
241
 
 
242
 
    def testNoDefaultView(self):
243
 
        try:
244
 
            self.rtr.default = 'not+index'
245
 
            self.rtr.resolve('/info1')
246
 
        except NotFound, e:
247
 
            assert_equal(e.args, (self.r.subjects['info1'], '+index', ()))
248
 
        except:
249
 
            raise
250
 
        else:
251
 
            raise AssertionError('did not raise NotFound')
252
 
        finally:
253
 
            self.rtr.default = '+index'
254
 
 
255
 
    def testMissingView(self):
256
 
        try:
257
 
            self.rtr.resolve('/info1/+foo')
258
 
        except NotFound, e:
259
 
            assert_equal(e.args, (self.r.subjects['info1'], '+foo', ()))
260
 
        except:
261
 
            raise
262
 
        else:
263
 
            raise AssertionError('did not raise NotFound')
264
 
 
265
 
    def testViewSetSeparation(self):
266
 
        try:
267
 
            self.rtr.resolve('/api/info1/+edit')
268
 
        except NotFound, e:
269
 
            assert_equal(e.args, (self.r.subjects['info1'], '+edit', ()))
270
 
        except:
271
 
            raise
272
 
        else:
273
 
            raise AssertionError('did not raise NotFound')
274
 
 
275
 
    def testRouteReturningNone(self):
276
 
        try:
277
 
            self.rtr.resolve('/info9/+index')
278
 
        except NotFound, e:
279
 
            assert_equal(e.args, (self.r, 'info9', ('+index',)))
280
 
        except:
281
 
            raise
282
 
        else:
283
 
            raise AssertionError('did not raise NotFound')
284
 
 
285
 
    def testRouteWithInfinitelyManyArguments(self):
286
 
        o, v, sp = self.rtr.resolve('/info1/2009/1/+files/foo/bar/baz')
287
 
 
288
 
        assert_equal(type(o), OfferingFile)
289
 
        assert_equal(o.path, ('foo', 'bar', 'baz'))
290
 
        assert_equal(o.offering, self.r.subjects['info1'].offerings[(2009, 1)])
291
 
        assert_equal(v, OfferingFileIndex)
292
 
        assert_equal(sp, ())
293
 
 
294
 
    def testMissingRoute(self):
295
 
        try:
296
 
            self.rtr.resolve('/info1/2009/1/+foo')
297
 
        except NotFound, e:
298
 
            assert_equal(e.args, (
299
 
                self.r.subjects['info1'].offerings[(2009, 1)],
300
 
                '+foo',
301
 
                ()
302
 
                ))
303
 
        except:
304
 
            raise
305
 
        else:
306
 
            raise AssertionError('did not raise NotFound')
307
 
 
308
 
    def testAlternateViewSetWithDefault(self):
309
 
        assert_equal(self.rtr.resolve('/info1/2009/1'),
310
 
             (self.r.subjects['info1'].offerings[(2009, 1)], OfferingIndex, ())
311
 
             )
312
 
 
313
 
        assert_equal(self.rtr.resolve('/api/info1/2009/1'),
314
 
          (self.r.subjects['info1'].offerings[(2009, 1)], OfferingAPIIndex, ())
315
 
          )
316
 
 
317
 
    def testDeepView(self):
318
 
        assert_equal(self.rtr.resolve('/info1/2009/1/+projects/+new'),
319
 
             (self.r.subjects['info1'].offerings[(2009, 1)],
320
 
              OfferingAddProject, ())
321
 
             )
322
 
 
323
 
    def testDefaultDeepView(self):
324
 
        assert_equal(self.rtr.resolve('/info1/2009/1/+projects'),
325
 
             (self.r.subjects['info1'].offerings[(2009, 1)],
326
 
              OfferingProjects, ())
327
 
             )
328
 
 
329
 
    def testAnotherDefaultDeepView(self):
330
 
        assert_equal(self.rtr.resolve('/info1/2009/1/+worksheets'),
331
 
             (self.r.subjects['info1'].offerings[(2009, 1)],
332
 
              OfferingWorksheets, ())
333
 
             )
334
 
 
335
 
    def testReallyDeepView(self):
336
 
        assert_equal(
337
 
             self.rtr.resolve('/info1/2009/1/+worksheets/+marks/marks.csv'),
338
 
             (self.r.subjects['info1'].offerings[(2009, 1)],
339
 
              OfferingWorksheetCSVMarks, ())
340
 
             )
341
 
 
342
 
    def testDefaultReallyDeepView(self):
343
 
        assert_equal(self.rtr.resolve('/info1/2009/1/+worksheets/+marks'),
344
 
             (self.r.subjects['info1'].offerings[(2009, 1)],
345
 
              OfferingWorksheetMarks, ())
346
 
             )
347
 
 
348
 
    def testNamedRouteWithDeepView(self):
349
 
        assert_equal(self.rtr.resolve('/info1/2009/1/+projects/p1'),
350
 
             (self.r.subjects['info1'].offerings[(2009, 1)].projects['p1'],
351
 
              ProjectIndex, ())
352
 
             )
353
 
 
354
 
    def testNullPathView(self):
355
 
        """Verify that views can be placed immediately under an object.
356
 
 
357
 
        There are some cases in which it is useful for a view with a
358
 
        subpath to exist immediately under an object, with no name.
359
 
        """
360
 
        assert_equal(self.rtr.resolve('/~jsmith/foo/bar'),
361
 
             (self.r.users['jsmith'], UserServeView, ('foo', 'bar')))
362
 
 
363
 
    def testTrailingSlashResolvesToDefaultView(self):
364
 
        assert_equal(
365
 
             self.rtr.resolve('/info1/2009/1/'),
366
 
             (self.r.subjects['info1'].offerings[(2009, 1)],
367
 
              OfferingIndex, ())
368
 
             )
369
 
 
370
 
    def testTrailingSlashResolvesToDeepDefaultView(self):
371
 
        assert_equal(
372
 
             self.rtr.resolve('/info1/2009/1/+worksheets/+marks/'),
373
 
             (self.r.subjects['info1'].offerings[(2009, 1)],
374
 
              OfferingWorksheetMarks, ())
375
 
             )
376
 
 
377
 
    def testSubpathIndicatesTrailingSlash(self):
378
 
        assert_equal(
379
 
             self.rtr.resolve('/info1/2009/1/+index/'),
380
 
             (self.r.subjects['info1'].offerings[(2009, 1)],
381
 
              OfferingIndex, ('',))
382
 
             )
383
 
 
384
 
class TestGeneration(BaseTest):
385
 
    def setUp(self):
386
 
        super(TestGeneration, self).setUp()
387
 
        self.rtr = Publisher(root=self.r, viewset='browser')
388
 
        self.rtr.add_set_switch('api', 'api')
389
 
        self.rtr.add_reverse(Subject, subject_url)
390
 
        self.rtr.add_reverse(Offering, offering_url)
391
 
        self.rtr.add_reverse(OfferingFiles, offering_files_url)
392
 
        self.rtr.add_reverse(Project, project_url)
393
 
        self.rtr.add_view(Subject, '+index', SubjectIndex, viewset='browser')
394
 
        self.rtr.add_view(Subject, '+edit', SubjectEdit, viewset='browser')
395
 
        self.rtr.add_view(Offering, '+index', OfferingIndex, viewset='browser')
396
 
        self.rtr.add_view(Offering, '+index', OfferingAPIIndex, viewset='api')
397
 
        self.rtr.add_view(Project, '+index', ProjectIndex, viewset='browser')
398
 
        self.rtr.add_view(Offering, ('+projects', '+new'), OfferingAddProject,
399
 
                          viewset='browser')
400
 
        self.rtr.add_view(Offering, ('+projects', '+index'), OfferingProjects,
401
 
                          viewset='browser')
402
 
 
403
 
    def testOneLevel(self):
404
 
        assert_equal(self.rtr.generate(self.r.subjects['info1']), '/info1')
405
 
 
406
 
    def testTwoLevel(self):
407
 
        assert_equal(
408
 
            self.rtr.generate(self.r.subjects['info1'].offerings[(2009, 1)]),
409
 
            '/info1/2009/1'
410
 
            )
411
 
        assert_equal(
412
 
            self.rtr.generate(self.r.subjects['info2'].offerings[(2008, 2)]),
413
 
            '/info2/2008/2'
414
 
            )
415
 
 
416
 
    def testNamedRoute(self):
417
 
        assert_equal(self.rtr.generate(
418
 
                OfferingFiles(self.r.subjects['info1'].offerings[(2009, 1)])),
419
 
                '/info1/2009/1/+files'
420
 
            )
421
 
 
422
 
    def testView(self):
423
 
        assert_equal(self.rtr.generate(self.r.subjects['info1'], SubjectEdit),
424
 
                     '/info1/+edit'
425
 
                     )
426
 
 
427
 
    def testDefaultView(self):
428
 
        assert_equal(
429
 
            self.rtr.generate(self.r.subjects['info1'].offerings[(2009, 1)],
430
 
                              OfferingIndex
431
 
                              ),
432
 
            '/info1/2009/1'
433
 
            )
434
 
 
435
 
    def testViewWithSubpath(self):
436
 
        assert_equal(self.rtr.generate(self.r.subjects['info1'], SubjectEdit,
437
 
                                       ('foo', 'bar')),
438
 
                     '/info1/+edit/foo/bar'
439
 
                     )
440
 
 
441
 
    def testViewWithStringSubpath(self):
442
 
        assert_equal(self.rtr.generate(self.r.subjects['info1'], SubjectEdit,
443
 
                                       'foo/bar'),
444
 
                     '/info1/+edit/foo/bar'
445
 
                     )
446
 
 
447
 
    def testAlternateViewSetWithDefault(self):
448
 
        assert_equal(
449
 
            self.rtr.generate(self.r.subjects['info1'].offerings[(2009, 1)],
450
 
                              OfferingAPIIndex
451
 
                              ),
452
 
            '/api/info1/2009/1'
453
 
            )
454
 
 
455
 
    def testDeepView(self):
456
 
        assert_equal(
457
 
            self.rtr.generate(
458
 
                self.r.subjects['info1'].offerings[(2009, 1)],
459
 
                OfferingAddProject
460
 
                ),
461
 
        '/info1/2009/1/+projects/+new'
462
 
        )
463
 
 
464
 
    def testDefaultDeepView(self):
465
 
        assert_equal(
466
 
            self.rtr.generate(
467
 
                self.r.subjects['info1'].offerings[(2009, 1)],
468
 
                OfferingProjects
469
 
                ),
470
 
        '/info1/2009/1/+projects'
471
 
        )
472
 
 
473
 
    def testDefaultDeepViewWithSubpath(self):
474
 
        assert_equal(
475
 
            self.rtr.generate(
476
 
                self.r.subjects['info1'].offerings[(2009, 1)],
477
 
                OfferingProjects, ('foo', 'bar')
478
 
                ),
479
 
        '/info1/2009/1/+projects/+index/foo/bar'
480
 
        )
481
 
 
482
 
    def testNamedRouteWithDeepView(self):
483
 
        assert_equal(
484
 
            self.rtr.generate(
485
 
                self.r.subjects['info1'].offerings[(2009, 1)].projects['p1'],
486
 
                ProjectIndex
487
 
                ),
488
 
        '/info1/2009/1/+projects/p1'
489
 
        )
490
 
 
491
 
    def testRoot(self):
492
 
        assert_equal(self.rtr.generate(self.r), '/')
493
 
 
494
 
 
495
 
class TestErrors(BaseTest):
496
 
    def setUp(self):
497
 
        super(TestErrors, self).setUp()
498
 
        self.rtr = Publisher(root=self.r)
499
 
        self.rtr.add_forward(Root, None, root_to_subject_or_user, 1)
500
 
        self.rtr.add_forward(Subject, '+foo', lambda s: s.name + 'foo', 0)
501
 
        self.rtr.add_forward(Subject, None, subject_to_offering, 2)
502
 
        self.rtr.add_reverse(Subject, subject_url)
503
 
        self.rtr.add_reverse(Offering, offering_url)
504
 
        self.rtr.add_view(Offering, '+index', OfferingIndex)
505
 
        self.rtr.add_view(Offering, '+index', OfferingAPIIndex, viewset='api')
506
 
        self.rtr.add_set_switch('rest', 'rest')
507
 
 
508
 
    @raises(RouteConflict)
509
 
    def testForwardConflict(self):
510
 
        self.rtr.add_forward(Subject, '+foo', object(), 2)
511
 
 
512
 
    @raises(RouteConflict)
513
 
    def testReverseConflict(self):
514
 
        self.rtr.add_reverse(Subject, object())
515
 
 
516
 
    @raises(RouteConflict)
517
 
    def testViewConflict(self):
518
 
        self.rtr.add_view(Offering, '+index', object())
519
 
 
520
 
    @raises(RouteConflict)
521
 
    def testSetSwitchForwardConflict(self):
522
 
        self.rtr.add_set_switch('rest', 'foo')
523
 
 
524
 
    @raises(RouteConflict)
525
 
    def testSetSwitchReverseConflict(self):
526
 
        self.rtr.add_set_switch('bar', 'rest')
527
 
 
528
 
    @raises(NoPath)
529
 
    def testNoPath(self):
530
 
        self.rtr.generate(object())
531
 
 
532
 
    @raises(NoPath)
533
 
    def testNoSetSwitch(self):
534
 
        self.rtr.generate(self.r.subjects['info1'].offerings[(2009, 1)],
535
 
                          OfferingAPIIndex)
536
 
 
537
 
    @raises(NoPath)
538
 
    def testUnregisteredView(self):
539
 
        self.rtr.generate(self.r.subjects['info1'], SubjectIndex)
540
 
 
541
 
    @raises(NotFound)
542
 
    def testNotFound(self):
543
 
        self.rtr.resolve('/bar')
544
 
 
545
 
    @raises(InsufficientPathSegments)
546
 
    def testInsufficientPathSegments(self):
547
 
        self.rtr.resolve('/info1/foo')