source: main/waeup.kofa/trunk/src/waeup/kofa/students/tests/test_export.py @ 9844

Last change on this file since 9844 was 9844, checked in by Henrik Bettermann, 12 years ago

Use keywords not only to filter students but also to restrict access to coursetickets which belong to the course so that lecturers (who gain access to courses) can download only coursetickets of their own course.

  • Property svn:keywords set to Id
File size: 35.5 KB
Line 
1import grok
2import datetime
3from zope.component import queryUtility
4from zope.event import notify
5from zope.interface.verify import verifyObject, verifyClass
6from waeup.kofa.interfaces import ICSVExporter
7from waeup.kofa.students.catalog import StudentsQuery
8from waeup.kofa.students.export import (
9    StudentsExporter, StudentStudyCourseExporter, StudentStudyLevelExporter,
10    CourseTicketExporter, StudentPaymentsExporter, BedTicketsExporter,
11    StudentPaymentsOverviewExporter, StudentStudyLevelsOverviewExporter,
12    get_students,)
13from waeup.kofa.students.accommodation import BedTicket
14from waeup.kofa.students.interfaces import ICSVStudentExporter
15from waeup.kofa.students.payments import StudentOnlinePayment
16from waeup.kofa.students.student import Student
17from waeup.kofa.students.studycourse import StudentStudyCourse
18from waeup.kofa.students.studylevel import StudentStudyLevel, CourseTicket
19from waeup.kofa.students.tests.test_batching import StudentImportExportSetup
20from waeup.kofa.testing import FunctionalLayer
21
22curr_year = datetime.datetime.now().year
23year_range = range(curr_year - 9, curr_year + 1)
24year_range_str = ','.join([str(i) for i in year_range])
25
26class ExportHelperTests(StudentImportExportSetup):
27    layer = FunctionalLayer
28    def setUp(self):
29        super(ExportHelperTests, self).setUp()
30        student = Student()
31        self.app['students'].addStudent(student)
32        student = self.setup_student(student)
33        notify(grok.ObjectModifiedEvent(student))
34        self.student = self.app['students'][student.student_id]
35        return
36
37    def test_get_students_plain(self):
38        # without a filter we get all students
39        result = get_students(self.app)
40        self.assertEqual(len(list(result)), 1)
41        return
42
43    def test_get_students_by_session(self):
44        # we can filter out students of a certain session
45        my_filter1 = StudentsQuery(current_session=2012)
46        result = get_students(self.app, stud_filter=my_filter1)
47        self.assertEqual(len(list(result)), 1)
48
49        my_filter2 = StudentsQuery(current_session=1964)
50        result = get_students(self.app, stud_filter=my_filter2)
51        self.assertEqual(len(list(result)), 0)
52        return
53
54    def test_get_students_by_level(self):
55        # we can filter out students of a certain level
56        my_filter1 = StudentsQuery(current_level=200)
57        result = get_students(self.app, stud_filter=my_filter1)
58        self.assertEqual(len(list(result)), 1)
59
60        my_filter2 = StudentsQuery(current_level=300)
61        result = get_students(self.app, stud_filter=my_filter2)
62        self.assertEqual(len(list(result)), 0)
63        return
64
65    def test_get_students_by_deptcode(self):
66        # we can filter out students of a certain dept.
67        my_filter1 = StudentsQuery(depcode='NA')
68        result = get_students(self.app, stud_filter=my_filter1)
69        self.assertEqual(len(list(result)), 1)
70
71        my_filter2 = StudentsQuery(depcode='NOTEXISTING')
72        result = get_students(self.app, stud_filter=my_filter2)
73        self.assertEqual(len(list(result)), 0)
74        return
75
76    def test_get_students_by_faccode(self):
77        # we can filter out students of a certain faculty.
78        my_filter1 = StudentsQuery(faccode='NA')
79        result = get_students(self.app, stud_filter=my_filter1)
80        self.assertEqual(len(list(result)), 1)
81
82        my_filter2 = StudentsQuery(faccode='NOTEXISTING')
83        result = get_students(self.app, stud_filter=my_filter2)
84        self.assertEqual(len(list(result)), 0)
85        return
86
87    def test_get_students_by_current_mode(self):
88        # we can filter out students in a certain mode.
89        my_filter1 = StudentsQuery(current_mode='ug_ft')
90        result = get_students(self.app, stud_filter=my_filter1)
91        self.assertEqual(len(list(result)), 1)
92
93        my_filter2 = StudentsQuery(current_mode='NOTEXISTING')
94        result = get_students(self.app, stud_filter=my_filter2)
95        self.assertEqual(len(list(result)), 0)
96        return
97
98
99class StudentsExporterTest(StudentImportExportSetup):
100
101    layer = FunctionalLayer
102
103    std_csv_entry = (
104        'my adm code,0,my clr code,1981-02-04#,anna@sample.com,,'
105        'Anna,Tester,234,M.,NG,,"Studentroad 21\nLagos 123456\n",,'
106        '+234-123-12345#,123,f,A111111,0,,,created'
107        )
108
109    def setUp(self):
110        super(StudentsExporterTest, self).setUp()
111        self.setup_for_export()
112        return
113
114    def test_ifaces(self):
115        # make sure we fullfill interface contracts
116        obj = StudentsExporter()
117        verifyObject(ICSVStudentExporter, obj)
118        verifyClass(ICSVStudentExporter, StudentsExporter)
119        return
120
121    def test_get_as_utility(self):
122        # we can get an student exporter as utility
123        result = queryUtility(ICSVExporter, name="students")
124        self.assertTrue(result is not None)
125        return
126
127    def test_export(self):
128        # we can really export students
129        # set values we can expect in export file
130        self.setup_student(self.student)
131        exporter = StudentsExporter()
132        exporter.export([self.student], self.outfile)
133        result = open(self.outfile, 'rb').read()
134        self.assertTrue(
135            'adm_code,clearance_locked,clr_code,date_of_birth,email,employer,'
136            'firstname,lastname,matric_number,middlename,nationality,officer_comment,'
137            'perm_address,personal_updated,'
138            'phone,reg_number,sex,student_id,suspended,suspended_comment,password,'
139            'state,history,certcode,is_postgrad,current_level,current_session\r\n'
140
141            'my adm code,0,my clr code,1981-02-04#,anna@sample.com,,'
142            'Anna,Tester,234,M.,NG,,"Studentroad 21\nLagos 123456\n",,'
143            '+234-123-12345#,123,f,A111111,0,,,created'
144            in result
145            )
146        return
147
148    def test_export_all(self):
149        # we can really export students
150        # set values we can expect in export file
151        self.setup_student(self.student)
152        exporter = StudentsExporter()
153        exporter.export_all(self.app, self.outfile)
154        result = open(self.outfile, 'rb').read()
155        self.assertTrue(
156            'adm_code,clearance_locked,clr_code,date_of_birth,email,employer,'
157            'firstname,lastname,matric_number,middlename,nationality,officer_comment,'
158            'perm_address,personal_updated'
159            ',phone,reg_number,sex,student_id,suspended,suspended_comment,password,'
160            'state,history,certcode,is_postgrad,current_level,current_session\r\n'
161
162            'my adm code,0,my clr code,1981-02-04#,anna@sample.com,,'
163            'Anna,Tester,234,M.,NG,,"Studentroad 21\nLagos 123456\n",,'
164            '+234-123-12345#,123,f,A111111,0,,,created'
165            in result
166            )
167        return
168
169    def test_export_student(self):
170        # we can export a single student
171        self.setup_student(self.student)
172        exporter = StudentsExporter()
173        exporter.export_student(self.student, self.outfile)
174        result = open(self.outfile, 'rb').read()
175        self.assertTrue(
176            'adm_code,clearance_locked,clr_code,date_of_birth,email,employer,'
177            'firstname,lastname,matric_number,middlename,nationality,officer_comment,'
178            'perm_address,personal_updated'
179            ',phone,reg_number,sex,student_id,suspended,suspended_comment,password,'
180            'state,history,certcode,is_postgrad,current_level,current_session\r\n'
181
182            'my adm code,0,my clr code,1981-02-04#,anna@sample.com,,'
183            'Anna,Tester,234,M.,NG,,"Studentroad 21\nLagos 123456\n",,'
184            '+234-123-12345#,123,f,A111111,0,,,created'
185            in result
186            )
187        return
188
189    def test_export_filtered(self):
190        # we can export a filtered set of students (filtered by session/level)
191        self.setup_student(self.student)
192        self.app['students'].addStudent(self.student)
193        notify(grok.ObjectModifiedEvent(self.student))
194        exporter = StudentsExporter()
195
196        exporter.export_filtered(
197            self.app, self.outfile,
198            current_session=None, current_level=None)
199        result1 = open(self.outfile, 'rb').read()
200        exporter.export_filtered(
201            self.app, self.outfile,
202            current_session=2012, current_level=None)
203        result2 = open(self.outfile, 'rb').read()
204        exporter.export_filtered(
205            self.app, self.outfile,
206            current_session=None, current_level=200)
207        result3 = open(self.outfile, 'rb').read()
208        exporter.export_filtered(
209            self.app, self.outfile,
210            current_session=2011, current_level=None)
211        result4 = open(self.outfile, 'rb').read()
212        exporter.export_filtered(
213            self.app, self.outfile,
214            current_session=None, current_level=100)
215        result5 = open(self.outfile, 'rb').read()
216        self.assertTrue(self.std_csv_entry in result1)
217        self.assertTrue(self.std_csv_entry in result2)
218        self.assertTrue(self.std_csv_entry in result3)
219        self.assertTrue(self.std_csv_entry not in result4)
220        self.assertTrue(self.std_csv_entry not in result5)
221        return
222
223    def test_export_filtered_by_dept(self):
224        # we can export a set of students filtered by department
225        self.setup_student(self.student)
226        self.app['students'].addStudent(self.student)
227        notify(grok.ObjectModifiedEvent(self.student))
228        exporter = StudentsExporter()
229
230        exporter.export_filtered(
231            self.app, self.outfile,
232            current_session=2012, current_level=200, depcode='NA')
233        result1 = open(self.outfile, 'rb').read()
234        exporter.export_filtered(
235            self.app, self.outfile,
236            current_session=2012, current_level=200, depcode='NODEPT')
237        result2 = open(self.outfile, 'rb').read()
238        self.assertTrue(self.std_csv_entry in result1)
239        self.assertTrue(self.std_csv_entry not in result2)
240        return
241
242    def test_export_filtered_by_faculty(self):
243        # we can export a set of students filtered by faculty
244        self.setup_student(self.student)
245        self.app['students'].addStudent(self.student)
246        notify(grok.ObjectModifiedEvent(self.student))
247        exporter = StudentsExporter()
248
249        exporter.export_filtered(
250            self.app, self.outfile,
251            current_session=2012, current_level=200, faccode='NA')
252        result1 = open(self.outfile, 'rb').read()
253        exporter.export_filtered(
254            self.app, self.outfile,
255            current_session=2012, current_level=200, faccode='NOFAC')
256        result2 = open(self.outfile, 'rb').read()
257        self.assertTrue(self.std_csv_entry in result1)
258        self.assertTrue(self.std_csv_entry not in result2)
259        return
260
261class StudentStudyCourseExporterTest(StudentImportExportSetup):
262
263    layer = FunctionalLayer
264
265    def setUp(self):
266        super(StudentStudyCourseExporterTest, self).setUp()
267        self.setup_for_export()
268        return
269
270    def test_ifaces(self):
271        # make sure we fullfill interface contracts
272        obj = StudentStudyCourseExporter()
273        verifyObject(ICSVStudentExporter, obj)
274        verifyClass(ICSVStudentExporter, StudentStudyCourseExporter)
275        return
276
277    def test_get_as_utility(self):
278        # we can get an student exporter as utility
279        result = queryUtility(ICSVExporter, name="studentstudycourses")
280        self.assertTrue(result is not None)
281        return
282
283    def test_export_empty(self):
284        # we can export a nearly empty study course
285        study_course = StudentStudyCourse()
286        exporter = StudentStudyCourseExporter()
287        exporter.export([study_course], self.outfile)
288        result = open(self.outfile, 'rb').read()
289        self.assertEqual(
290            result,
291            'certificate,current_level,current_session,current_verdict,'
292            'entry_mode,entry_session,previous_verdict,student_id\r\n'
293
294            ',,,0,,,0,\r\n'
295            )
296        return
297
298    def test_export(self):
299        # we can really export study courses.
300        # set values we can expect in export file
301        self.setup_student(self.student)
302        study_course = self.student.get('studycourse')
303        exporter = StudentStudyCourseExporter()
304        exporter.export([study_course], self.outfile)
305        result = open(self.outfile, 'rb').read()
306        self.assertEqual(
307            result,
308            'certificate,current_level,current_session,current_verdict,'
309            'entry_mode,entry_session,previous_verdict,student_id\r\n'
310
311            'CERT1,200,2012,0,ug_ft,2010,0,A111111\r\n'
312            )
313        return
314
315    def test_export_all(self):
316        # we can really export students
317        # set values we can expect in export file
318        self.setup_student(self.student)
319        exporter = StudentStudyCourseExporter()
320        exporter.export_all(self.app, self.outfile)
321        result = open(self.outfile, 'rb').read()
322        self.assertEqual(
323            result,
324            'certificate,current_level,current_session,current_verdict,'
325            'entry_mode,entry_session,previous_verdict,student_id\r\n'
326
327            'CERT1,200,2012,0,ug_ft,2010,0,A111111\r\n'
328            )
329        return
330
331    def test_export_student(self):
332        # we can export studycourse of a certain student
333        self.setup_student(self.student)
334        exporter = StudentStudyCourseExporter()
335        exporter.export_student(self.student, self.outfile)
336        result = open(self.outfile, 'rb').read()
337        self.assertEqual(
338            result,
339            'certificate,current_level,current_session,current_verdict,'
340            'entry_mode,entry_session,previous_verdict,student_id\r\n'
341
342            'CERT1,200,2012,0,ug_ft,2010,0,A111111\r\n'
343            )
344        return
345
346    def test_export_filtered(self):
347        # we can export studycourses of a filtered set of students
348        self.setup_student(self.student)
349        self.app['students'].addStudent(self.student)
350        notify(grok.ObjectModifiedEvent(self.student))
351
352        exporter = StudentStudyCourseExporter()
353        exporter.export_filtered(
354            self.student, self.outfile, current_session=2012)
355        result = open(self.outfile, 'rb').read()
356        self.assertEqual(
357            result,
358            'certificate,current_level,current_session,current_verdict,'
359            'entry_mode,entry_session,previous_verdict,student_id\r\n'
360
361            'CERT1,200,2012,0,ug_ft,2010,0,A111111\r\n'
362            )
363        return
364
365
366
367class StudentStudyLevelExporterTest(StudentImportExportSetup):
368
369    layer = FunctionalLayer
370
371    def setUp(self):
372        super(StudentStudyLevelExporterTest, self).setUp()
373        self.setup_for_export()
374        return
375
376    def test_ifaces(self):
377        # make sure we fullfill interface contracts
378        obj = StudentStudyLevelExporter()
379        verifyObject(ICSVStudentExporter, obj)
380        verifyClass(ICSVStudentExporter, StudentStudyLevelExporter)
381        return
382
383    def test_get_as_utility(self):
384        # we can get an student exporter as utility
385        result = queryUtility(ICSVExporter, name="studentstudylevels")
386        self.assertTrue(result is not None)
387        return
388
389    def test_export_empty(self):
390        # we can export a nearly empty study level
391        study_level = StudentStudyLevel()
392        exporter = StudentStudyLevelExporter()
393        exporter.export([study_level], self.outfile)
394        result = open(self.outfile, 'rb').read()
395        self.assertEqual(
396            result,
397            'gpa,level,level_session,level_verdict,total_credits,'
398            'validated_by,validation_date,'
399            'student_id,number_of_tickets,certcode\r\n'
400            '0.0,,,0,0,,,,0,\r\n'
401            )
402        return
403
404    def test_export(self):
405        # we can really export study levels.
406        # set values we can expect in export file
407        self.setup_student(self.student)
408        study_course = self.student.get('studycourse')
409        study_level = study_course[study_course.keys()[0]]
410        exporter = StudentStudyLevelExporter()
411        exporter.export([study_level], self.outfile)
412        result = open(self.outfile, 'rb').read()
413        self.assertEqual(
414            result,
415            'gpa,level,level_session,level_verdict,total_credits,'
416            'validated_by,validation_date,'
417            'student_id,number_of_tickets,certcode\r\n'
418            '0.0,100,2012,A,100,,,A111111,1,CERT1\r\n'
419            )
420        return
421
422    def test_export_all(self):
423        # we can really export study levels
424        # set values we can expect in export file
425        self.setup_student(self.student)
426        exporter = StudentStudyLevelExporter()
427        exporter.export_all(self.app, self.outfile)
428        result = open(self.outfile, 'rb').read()
429        self.assertEqual(
430            result,
431            'gpa,level,level_session,level_verdict,total_credits,'
432            'validated_by,validation_date,'
433            'student_id,number_of_tickets,certcode\r\n'
434            '0.0,100,2012,A,100,,,A111111,1,CERT1\r\n'
435            )
436        return
437
438    def test_export_student(self):
439        # we can really export study levels of a certain student
440        self.setup_student(self.student)
441        exporter = StudentStudyLevelExporter()
442        exporter.export_student(self.student, self.outfile)
443        result = open(self.outfile, 'rb').read()
444        self.assertEqual(
445            result,
446            'gpa,level,level_session,level_verdict,total_credits,'
447            'validated_by,validation_date,'
448            'student_id,number_of_tickets,certcode\r\n'
449            '0.0,100,2012,A,100,,,A111111,1,CERT1\r\n'
450            )
451        return
452
453    def test_export_filtered(self):
454        # we can export studylevels of a filtered set of students
455        self.setup_student(self.student)
456        self.app['students'].addStudent(self.student)
457        notify(grok.ObjectModifiedEvent(self.student))
458
459        exporter = StudentStudyLevelExporter()
460        exporter.export_filtered(
461            self.student, self.outfile, current_level=200)
462        result = open(self.outfile, 'rb').read()
463        self.assertEqual(
464            result,
465            'gpa,level,level_session,level_verdict,total_credits,'
466            'validated_by,validation_date,'
467            'student_id,number_of_tickets,certcode\r\n'
468            '0.0,100,2012,A,100,,,A111111,1,CERT1\r\n'
469            )
470        return
471
472class CourseTicketExporterTest(StudentImportExportSetup):
473
474    layer = FunctionalLayer
475
476    def setUp(self):
477        super(CourseTicketExporterTest, self).setUp()
478        self.setup_for_export()
479        return
480
481    def test_ifaces(self):
482        # make sure we fullfill interface contracts
483        obj = CourseTicketExporter()
484        verifyObject(ICSVStudentExporter, obj)
485        verifyClass(ICSVStudentExporter, CourseTicketExporter)
486        return
487
488    def test_get_as_utility(self):
489        # we can get an student exporter as utility
490        result = queryUtility(ICSVExporter, name="coursetickets")
491        self.assertTrue(result is not None)
492        return
493
494    def test_export_empty(self):
495        # we can export a nearly empty course ticket
496        ticket = CourseTicket()
497        exporter = CourseTicketExporter()
498        exporter.export([ticket], self.outfile)
499        result = open(self.outfile, 'rb').read()
500        self.assertEqual(
501            result,
502            'automatic,carry_over,code,credits,dcode,fcode,level,mandatory,'
503            'passmark,score,semester,title,student_id,certcode\r\n'
504            '0,0,,,,,,0,,,,,,\r\n'
505            )
506        return
507
508    def test_export(self):
509        # we can really export course tickets.
510        # set values we can expect in export file
511        self.setup_student(self.student)
512        study_course = self.student.get('studycourse')
513        study_level = study_course[study_course.keys()[0]]
514        ticket = study_level['CRS1']
515        exporter = CourseTicketExporter()
516        exporter.export([ticket], self.outfile)
517        result = open(self.outfile, 'rb').read()
518        self.assertEqual(
519            result,
520            'automatic,carry_over,code,credits,dcode,fcode,level,mandatory,'
521            'passmark,score,semester,title,student_id,certcode\r\n'
522            '1,1,CRS1,100,DEP1,FAC1,100,0,100,,2,Course 1,A111111,CERT1\r\n'
523            )
524        return
525
526    def test_export_all(self):
527        # we can really export all course tickets
528        # set values we can expect in export file
529        self.setup_student(self.student)
530        exporter = CourseTicketExporter()
531        exporter.export_all(self.app, self.outfile)
532        result = open(self.outfile, 'rb').read()
533        self.assertEqual(
534            result,
535            'automatic,carry_over,code,credits,dcode,fcode,level,mandatory,'
536            'passmark,score,semester,title,student_id,certcode\r\n'
537            '1,1,CRS1,100,DEP1,FAC1,100,0,100,,2,Course 1,A111111,CERT1\r\n'
538            )
539        return
540
541    def test_export_student(self):
542        # we can really export all course tickets of a certain student
543        self.setup_student(self.student)
544        exporter = CourseTicketExporter()
545        exporter.export_student(self.student, self.outfile)
546        result = open(self.outfile, 'rb').read()
547        self.assertEqual(
548            result,
549            'automatic,carry_over,code,credits,dcode,fcode,level,mandatory,'
550            'passmark,score,semester,title,student_id,certcode\r\n'
551            '1,1,CRS1,100,DEP1,FAC1,100,0,100,,2,Course 1,A111111,CERT1\r\n'
552            )
553        return
554
555    def test_export_filtered(self):
556        # we can export course tickets of a filtered set of students
557        self.setup_student(self.student)
558        self.app['students'].addStudent(self.student)
559        notify(grok.ObjectModifiedEvent(self.student))
560
561        exporter = CourseTicketExporter()
562        exporter.export_filtered(
563            self.student, self.outfile, current_level=200)
564        result = open(self.outfile, 'rb').read()
565        self.assertEqual(
566            result,
567            'automatic,carry_over,code,credits,dcode,fcode,level,mandatory,'
568            'passmark,score,semester,title,student_id,certcode\r\n'
569            '1,1,CRS1,100,DEP1,FAC1,100,0,100,,2,Course 1,A111111,CERT1\r\n'
570            )
571        # if the coursetickets catalog is used to filter students
572        # and (course) code is not None
573        # only course tickets which belong to this course are exported
574        exporter.export_filtered(
575            self.student, self.outfile, cat='coursetickets', code='CRS1')
576        result = open(self.outfile, 'rb').read()
577        self.assertEqual(
578            result,
579            'automatic,carry_over,code,credits,dcode,fcode,level,mandatory,'
580            'passmark,score,semester,title,student_id,certcode\r\n'
581            '1,1,CRS1,100,DEP1,FAC1,100,0,100,,2,Course 1,A111111,CERT1\r\n'
582            )
583        exporter.export_filtered(
584            self.student, self.outfile, cat='coursetickets', code='any code')
585        result = open(self.outfile, 'rb').read()
586        self.assertEqual(
587            result,
588            'automatic,carry_over,code,credits,dcode,fcode,level,mandatory,'
589            'passmark,score,semester,title,student_id,certcode\r\n'
590            )
591        return
592
593class StudentPaymentsExporterTest(StudentImportExportSetup):
594
595    layer = FunctionalLayer
596
597    def setUp(self):
598        super(StudentPaymentsExporterTest, self).setUp()
599        self.setup_for_export()
600        return
601
602    def test_ifaces(self):
603        # make sure we fullfill interface contracts
604        obj = StudentPaymentsExporter()
605        verifyObject(ICSVStudentExporter, obj)
606        verifyClass(ICSVStudentExporter, StudentPaymentsExporter)
607        return
608
609    def test_get_as_utility(self):
610        # we can get a payments exporter as utility
611        result = queryUtility(ICSVExporter, name="studentpayments")
612        self.assertTrue(result is not None)
613        return
614
615    def test_export_empty(self):
616        # we can export a nearly empty payment
617        payment = StudentOnlinePayment()
618        payment.creation_date = datetime.datetime(2012, 4, 1, 13, 12, 1)
619        exporter = StudentPaymentsExporter()
620        exporter.export([payment], self.outfile)
621        result = open(self.outfile, 'rb').read()
622        self.assertEqual(
623            result,
624            'ac,amount_auth,creation_date,p_category,p_current,p_id,'
625            'p_item,p_level,p_session,p_state,payment_date,r_amount_approved,'
626            'r_code,r_desc,student_id,student_state,current_session\r\n'
627
628            ',0.0,2012-04-01 13:12:01,schoolfee,1,,,,,unpaid,,0.0,,,,,\r\n'
629            )
630        return
631
632    def test_export(self):
633        # we can really export student payments.
634        # set values we can expect in export file
635        self.setup_student(self.student)
636        payment = self.student['payments']['my-payment']
637        exporter = StudentPaymentsExporter()
638        exporter.export([payment], self.outfile)
639        result = open(self.outfile, 'rb').read()
640        self.assertEqual(
641            result,
642            'ac,amount_auth,creation_date,p_category,p_current,p_id,'
643            'p_item,p_level,p_session,p_state,payment_date,r_amount_approved,'
644            'r_code,r_desc,student_id,student_state,current_session\r\n'
645
646            '666,0.0,2012-04-01 13:12:01,schoolfee,1,my-id,'
647            'p-item,100,2012,unpaid,2012-04-01 14:12:01,12.12,'
648            'r-code,,A111111,created,2012\r\n'
649            )
650        return
651
652    def test_export_all(self):
653        # we can really export all payments
654        # set values we can expect in export file
655        self.setup_student(self.student)
656        exporter = StudentPaymentsExporter()
657        exporter.export_all(self.app, self.outfile)
658        result = open(self.outfile, 'rb').read()
659        self.assertEqual(
660            result,
661            'ac,amount_auth,creation_date,p_category,p_current,p_id,'
662            'p_item,p_level,p_session,p_state,payment_date,r_amount_approved,'
663            'r_code,r_desc,student_id,student_state,current_session\r\n'
664
665            '666,0.0,2012-04-01 13:12:01,schoolfee,1,my-id,'
666            'p-item,100,2012,unpaid,2012-04-01 14:12:01,12.12,'
667            'r-code,,A111111,created,2012\r\n'
668            )
669        return
670
671    def test_export_student(self):
672        # we can really export all payments of a certain student
673        # set values we can expect in export file
674        self.setup_student(self.student)
675        exporter = StudentPaymentsExporter()
676        exporter.export_student(self.student, self.outfile)
677        result = open(self.outfile, 'rb').read()
678        self.assertEqual(
679            result,
680            'ac,amount_auth,creation_date,p_category,p_current,p_id,'
681            'p_item,p_level,p_session,p_state,payment_date,r_amount_approved,'
682            'r_code,r_desc,student_id,student_state,current_session\r\n'
683
684            '666,0.0,2012-04-01 13:12:01,schoolfee,1,my-id,'
685            'p-item,100,2012,unpaid,2012-04-01 14:12:01,12.12,'
686            'r-code,,A111111,created,2012\r\n'
687            )
688        return
689
690    def test_export_filtered(self):
691        # we can export payments of a filtered set of students
692        self.setup_student(self.student)
693        self.app['students'].addStudent(self.student)
694        notify(grok.ObjectModifiedEvent(self.student))
695
696        exporter = StudentPaymentsExporter()
697        exporter.export_filtered(
698            self.student, self.outfile, current_level=200)
699        result = open(self.outfile, 'rb').read()
700        self.assertEqual(
701            result,
702            'ac,amount_auth,creation_date,p_category,p_current,p_id,'
703            'p_item,p_level,p_session,p_state,payment_date,r_amount_approved,'
704            'r_code,r_desc,student_id,student_state,current_session\r\n'
705
706            '666,0.0,2012-04-01 13:12:01,schoolfee,1,my-id,'
707            'p-item,100,2012,unpaid,2012-04-01 14:12:01,12.12,'
708            'r-code,,A111111,created,2012\r\n'
709            )
710        return
711
712class BedTicketsExporterTest(StudentImportExportSetup):
713
714    layer = FunctionalLayer
715
716    def setUp(self):
717        super(BedTicketsExporterTest, self).setUp()
718        self.setup_for_export()
719        return
720
721    def test_ifaces(self):
722        # make sure we fullfill interface contracts
723        obj = BedTicketsExporter()
724        verifyObject(ICSVStudentExporter, obj)
725        verifyClass(ICSVStudentExporter, BedTicketsExporter)
726        return
727
728    def test_get_as_utility(self):
729        # we can get a bedtickets exporter as utility
730        result = queryUtility(ICSVExporter, name="bedtickets")
731        self.assertTrue(result is not None)
732        return
733
734    def test_export_empty(self):
735        # we can export a nearly empty bedticket
736        bedticket = BedTicket()
737        bed = self.app['hostels']['hall-1']['hall-1_A_101_A']
738        bedticket.bed = bed
739        exporter = BedTicketsExporter()
740        exporter.export([bedticket], self.outfile)
741        result = open(self.outfile, 'rb').read()
742        self.assertMatches(
743            result,
744            'bed,bed_coordinates,bed_type,booking_code,booking_date,'
745            'booking_session,student_id,actual_bed_type\r\n'
746            'hall-1_A_101_A,,,,<YYYY-MM-DD hh:mm:ss>.<6-DIGITS>,,,regular_male_fr\r\n'
747            )
748        return
749
750    def test_export(self):
751        # we can really export student bedtickets.
752        # set values we can expect in export file
753        self.setup_student(self.student)
754        bedticket = self.student['accommodation']['2004']
755        exporter = BedTicketsExporter()
756        exporter.export([bedticket], self.outfile)
757        result = open(self.outfile, 'rb').read()
758        self.assertMatches(
759            result,
760            'bed,bed_coordinates,bed_type,booking_code,booking_date,'
761            'booking_session,student_id,actual_bed_type\r\n'
762            'hall-1_A_101_A,,any bed type,,<YYYY-MM-DD hh:mm:ss>.<6-DIGITS>,2004,'
763            'A111111,regular_male_fr\r\n'
764            )
765        return
766
767    def test_export_all(self):
768        # we can really export all bedtickets
769        # set values we can expect in export file
770        self.setup_student(self.student)
771        exporter = BedTicketsExporter()
772        exporter.export_all(self.app, self.outfile)
773        result = open(self.outfile, 'rb').read()
774        self.assertMatches(
775            result,
776            'bed,bed_coordinates,bed_type,booking_code,booking_date,'
777            'booking_session,student_id,actual_bed_type\r\n'
778            'hall-1_A_101_A,,any bed type,,<YYYY-MM-DD hh:mm:ss>.<6-DIGITS>,2004,'
779            'A111111,regular_male_fr\r\n'
780            )
781        return
782
783    def test_export_student(self):
784        # we can really export all bedtickets of a certain student
785        # set values we can expect in export file
786        self.setup_student(self.student)
787        exporter = BedTicketsExporter()
788        exporter.export_student(self.student, self.outfile)
789        result = open(self.outfile, 'rb').read()
790        self.assertMatches(
791            result,
792            'bed,bed_coordinates,bed_type,booking_code,booking_date,'
793            'booking_session,student_id,actual_bed_type\r\n'
794            'hall-1_A_101_A,,any bed type,,<YYYY-MM-DD hh:mm:ss>.<6-DIGITS>,2004,'
795            'A111111,regular_male_fr\r\n'
796            )
797        return
798
799    def test_export_filtered(self):
800        # we can export payments of a filtered set of students
801        self.setup_student(self.student)
802        self.app['students'].addStudent(self.student)
803        notify(grok.ObjectModifiedEvent(self.student))
804
805        exporter = BedTicketsExporter()
806        exporter.export_filtered(
807            self.student, self.outfile, current_level=200)
808        result = open(self.outfile, 'rb').read()
809        self.assertMatches(
810            result,
811            'bed,bed_coordinates,bed_type,booking_code,booking_date,'
812            'booking_session,student_id,actual_bed_type\r\n'
813            'hall-1_A_101_A,,any bed type,,<YYYY-MM-DD hh:mm:ss>.<6-DIGITS>,'
814            '2004,A111111,regular_male_fr\r\n')
815        return
816
817
818class StudentPaymentsOverviewExporterTest(StudentImportExportSetup):
819
820    layer = FunctionalLayer
821
822    def setUp(self):
823        super(StudentPaymentsOverviewExporterTest, self).setUp()
824        self.setup_for_export()
825        return
826
827    def test_ifaces(self):
828        # make sure we fullfill interface contracts
829        obj = StudentPaymentsOverviewExporter()
830        verifyObject(ICSVStudentExporter, obj)
831        verifyClass(ICSVStudentExporter, StudentPaymentsOverviewExporter)
832        return
833
834    def test_get_as_utility(self):
835        # we can get a payments exporter as utility
836        result = queryUtility(ICSVExporter, name="paymentsoverview")
837        self.assertTrue(result is not None)
838        return
839
840    def test_export(self):
841        self.setup_student(self.student)
842        exporter = StudentPaymentsOverviewExporter()
843        exporter.export([self.student], self.outfile)
844        result = open(self.outfile, 'rb').read()
845        self.assertEqual(
846            'student_id,state,certcode,faccode,depcode,is_postgrad,'
847            'current_level,current_session,current_mode,'
848            '%s\r\n'
849            'A111111,created,CERT1,NA,NA,0,200,2012,ug_ft,'
850            ',,,,,,,,,\r\n' % year_range_str,
851            result
852            )
853        return
854
855    def test_export_all(self):
856        # we can really export students
857        # set values we can expect in export file
858        self.setup_student(self.student)
859        # We add successful payments
860        payment = StudentOnlinePayment()
861        payment.p_id = 'my-id'
862        payment.p_session = 2009
863        payment.amount_auth = 12.12
864        payment.p_state = u'paid'
865        self.student['payments']['my-2ndpayment'] = payment
866        exporter = StudentPaymentsOverviewExporter()
867        exporter.export_all(self.app, self.outfile)
868        result = open(self.outfile, 'rb').read()
869        self.assertEqual(
870            'student_id,state,certcode,faccode,depcode,is_postgrad,'
871            'current_level,current_session,current_mode,'
872            '%s\r\nA111111,created,CERT1,NA,NA,0,'
873            '200,2012,ug_ft,,,,,,12.12,,,,\r\n' % year_range_str,
874            result
875            )
876        return
877
878class StudentStudyLevelsOverviewExporterTest(StudentImportExportSetup):
879
880    layer = FunctionalLayer
881
882    def setUp(self):
883        super(StudentStudyLevelsOverviewExporterTest, self).setUp()
884        self.setup_for_export()
885        return
886
887    def test_ifaces(self):
888        obj = StudentStudyLevelsOverviewExporter()
889        verifyObject(ICSVStudentExporter, obj)
890        verifyClass(ICSVStudentExporter, StudentStudyLevelsOverviewExporter)
891        return
892
893    def test_get_as_utility(self):
894        result = queryUtility(ICSVExporter, name="studylevelsoverview")
895        self.assertTrue(result is not None)
896        return
897
898    def test_export(self):
899        self.setup_student(self.student)
900        exporter = StudentStudyLevelsOverviewExporter()
901        exporter.export([self.student], self.outfile)
902        result = open(self.outfile, 'rb').read()
903        self.assertEqual(
904             'student_id,state,certcode,faccode,depcode,is_postgrad,'
905             'entry_session,current_level,current_session,'
906             '10,100,110,120,200,210,220,300,310,320,400,410,420,500,'
907             '510,520,600,610,620,700,710,720,800,810,820,900,910,920,999\r\n'
908             'A111111,created,CERT1,NA,NA,0,2010,200,2012,,2012'
909             ',,,,,,,,,,,,,,,,,,,,,,,,,,,\r\n',
910            result
911            )
912        return
913
914    def test_export_all(self):
915        self.setup_student(self.student)
916        exporter = StudentStudyLevelsOverviewExporter()
917        exporter.export_all(self.app, self.outfile)
918        result = open(self.outfile, 'rb').read()
919        self.assertEqual(
920            'student_id,state,certcode,faccode,depcode,is_postgrad,'
921            'entry_session,current_level,current_session,'
922            '10,100,110,120,200,210,220,300,310,320,400,410,420,500,'
923            '510,520,600,610,620,700,710,720,800,810,820,900,910,920,999\r\n'
924            'A111111,created,CERT1,NA,NA,0,2010,200,2012,,2012'
925            ',,,,,,,,,,,,,,,,,,,,,,,,,,,\r\n',
926            result
927            )
928        return
Note: See TracBrowser for help on using the repository browser.