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

Last change on this file since 9797 was 9797, checked in by uli, 12 years ago

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