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

Last change on this file since 11107 was 10874, checked in by Henrik Bettermann, 11 years ago

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