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

Last change on this file since 8422 was 8411, checked in by uli, 13 years ago

Dirty fix for problem with export of student subobjects.
  • Property svn:keywords set to Id
File size: 15.7 KB
Line 
1import datetime
2from zope.component import queryUtility
3from zope.interface.verify import verifyObject, verifyClass
4from waeup.kofa.interfaces import ICSVExporter
5from waeup.kofa.students.export import (
6    StudentsExporter, StudentStudyCourseExporter, StudentStudyLevelExporter,
7    CourseTicketExporter, PaymentsExporter)
8from waeup.kofa.students.payments import StudentOnlinePayment
9from waeup.kofa.students.studycourse import StudentStudyCourse
10from waeup.kofa.students.studylevel import StudentStudyLevel, CourseTicket
11from waeup.kofa.students.tests.test_batching import StudentImportExportSetup
12from waeup.kofa.testing import FunctionalLayer
13
14class StudentsExporterTest(StudentImportExportSetup):
15
16    layer = FunctionalLayer
17
18    def setUp(self):
19        super(StudentsExporterTest, self).setUp()
20        self.setup_for_export()
21        return
22
23    def test_ifaces(self):
24        # make sure we fullfill interface contracts
25        obj = StudentsExporter()
26        verifyObject(ICSVExporter, obj)
27        verifyClass(ICSVExporter, StudentsExporter)
28        return
29
30    def test_get_as_utility(self):
31        # we can get an student exporter as utility
32        result = queryUtility(ICSVExporter, name="students")
33        self.assertTrue(result is not None)
34        return
35
36    def test_export(self):
37        # we can really export students
38        # set values we can expect in export file
39        self.setup_student(self.student)
40        exporter = StudentsExporter()
41        exporter.export([self.student], self.outfile)
42        result = open(self.outfile, 'rb').read()
43        self.assertEqual(
44            result,
45            'adm_code,clearance_locked,clr_code,date_of_birth,email,employer,'
46            'firstname,lastname,matric_number,middlename,nationality,'
47            'perm_address,phone,reg_number,sex,student_id\r\n'
48
49            'my adm code,0,my clr code,1981-02-04#,anna@sample.com,,Anna,'
50            'Tester,M123456,M.,NG,"Studentroad 21\nLagos 123456\n",'
51            '+234-123-12345,123456,f,A111111\r\n'
52            )
53        return
54
55    def test_export_all(self):
56        # we can really export students
57        # set values we can expect in export file
58        self.setup_student(self.student)
59        exporter = StudentsExporter()
60        exporter.export_all(self.app, self.outfile)
61        result = open(self.outfile, 'rb').read()
62        self.assertEqual(
63            result,
64            'adm_code,clearance_locked,clr_code,date_of_birth,email,employer,'
65            'firstname,lastname,matric_number,middlename,nationality,'
66            'perm_address,phone,reg_number,sex,student_id\r\n'
67
68            'my adm code,0,my clr code,1981-02-04#,anna@sample.com,,Anna,'
69            'Tester,M123456,M.,NG,"Studentroad 21\nLagos 123456\n",'
70            '+234-123-12345,123456,f,A111111\r\n'
71            )
72        return
73
74    def test_export_student(self):
75        # we can export a single student
76        self.setup_student(self.student)
77        exporter = StudentsExporter()
78        exporter.export_student(self.student, self.outfile)
79        result = open(self.outfile, 'rb').read()
80        self.assertEqual(
81            result,
82            'adm_code,clearance_locked,clr_code,date_of_birth,email,employer,'
83            'firstname,lastname,matric_number,middlename,nationality,'
84            'perm_address,phone,reg_number,sex,student_id\r\n'
85
86            'my adm code,0,my clr code,1981-02-04#,anna@sample.com,,Anna,'
87            'Tester,M123456,M.,NG,"Studentroad 21\nLagos 123456\n",'
88            '+234-123-12345,123456,f,A111111\r\n'
89            )
90        return
91
92
93class StudentStudyCourseExporterTest(StudentImportExportSetup):
94
95    layer = FunctionalLayer
96
97    def setUp(self):
98        super(StudentStudyCourseExporterTest, self).setUp()
99        self.setup_for_export()
100        return
101
102    def test_ifaces(self):
103        # make sure we fullfill interface contracts
104        obj = StudentStudyCourseExporter()
105        verifyObject(ICSVExporter, obj)
106        verifyClass(ICSVExporter, StudentStudyCourseExporter)
107        return
108
109    def test_get_as_utility(self):
110        # we can get an student exporter as utility
111        result = queryUtility(ICSVExporter, name="studentstudycourses")
112        self.assertTrue(result is not None)
113        return
114
115    def test_export_empty(self):
116        # we can export a nearly empty study course
117        study_course = StudentStudyCourse()
118        exporter = StudentStudyCourseExporter()
119        exporter.export([study_course], self.outfile)
120        result = open(self.outfile, 'rb').read()
121        self.assertEqual(
122            result,
123            'certificate,current_level,current_session,current_verdict,'
124            'entry_mode,entry_session,previous_verdict\r\n'
125
126            ',,,0,,,0\r\n'
127            )
128        return
129
130    def test_export(self):
131        # we can really export study courses.
132        # set values we can expect in export file
133        self.setup_student(self.student)
134        study_course = self.student.get('studycourse')
135        exporter = StudentStudyCourseExporter()
136        exporter.export([study_course], self.outfile)
137        result = open(self.outfile, 'rb').read()
138        self.assertEqual(
139            result,
140            'certificate,current_level,current_session,current_verdict,'
141            'entry_mode,entry_session,previous_verdict\r\n'
142
143            'CERT1,200,2012,0,ug_ft,2010,0\r\n'
144            )
145        return
146
147    def test_export_all(self):
148        # we can really export students
149        # set values we can expect in export file
150        self.setup_student(self.student)
151        exporter = StudentStudyCourseExporter()
152        exporter.export_all(self.app, self.outfile)
153        result = open(self.outfile, 'rb').read()
154        self.assertEqual(
155            result,
156            'certificate,current_level,current_session,current_verdict,'
157            'entry_mode,entry_session,previous_verdict\r\n'
158
159            'CERT1,200,2012,0,ug_ft,2010,0\r\n'
160            )
161        return
162
163    def test_export_student(self):
164        # we can export studycourse of a certain student
165        self.setup_student(self.student)
166        exporter = StudentStudyCourseExporter()
167        exporter.export_student(self.student, self.outfile)
168        result = open(self.outfile, 'rb').read()
169        self.assertEqual(
170            result,
171            'certificate,current_level,current_session,current_verdict,'
172            'entry_mode,entry_session,previous_verdict\r\n'
173
174            'CERT1,200,2012,0,ug_ft,2010,0\r\n'
175            )
176        return
177
178class StudentStudyLevelExporterTest(StudentImportExportSetup):
179
180    layer = FunctionalLayer
181
182    def setUp(self):
183        super(StudentStudyLevelExporterTest, self).setUp()
184        self.setup_for_export()
185        return
186
187    def test_ifaces(self):
188        # make sure we fullfill interface contracts
189        obj = StudentStudyLevelExporter()
190        verifyObject(ICSVExporter, obj)
191        verifyClass(ICSVExporter, StudentStudyLevelExporter)
192        return
193
194    def test_get_as_utility(self):
195        # we can get an student exporter as utility
196        result = queryUtility(ICSVExporter, name="studentstudylevels")
197        self.assertTrue(result is not None)
198        return
199
200    def test_export_empty(self):
201        # we can export a nearly empty study level
202        study_level = StudentStudyLevel()
203        exporter = StudentStudyLevelExporter()
204        exporter.export([study_level], self.outfile)
205        result = open(self.outfile, 'rb').read()
206        self.assertEqual(
207            result,
208            'level,level_session,level_verdict,matric_number,reg_number\r\n'
209            ',,0,,\r\n'
210            )
211        return
212
213    def test_export(self):
214        # we can really export study levels.
215        # set values we can expect in export file
216        self.setup_student(self.student)
217        study_course = self.student.get('studycourse')
218        study_level = study_course[study_course.keys()[0]]
219        exporter = StudentStudyLevelExporter()
220        exporter.export([study_level], self.outfile)
221        result = open(self.outfile, 'rb').read()
222        self.assertEqual(
223            result,
224            'level,level_session,level_verdict,matric_number,reg_number\r\n'
225            '100,2012,A,M123456,123456\r\n'
226            )
227        return
228
229    def test_export_all(self):
230        # we can really export study levels
231        # set values we can expect in export file
232        self.setup_student(self.student)
233        exporter = StudentStudyLevelExporter()
234        exporter.export_all(self.app, self.outfile)
235        result = open(self.outfile, 'rb').read()
236        self.assertEqual(
237            result,
238            'level,level_session,level_verdict,matric_number,reg_number\r\n'
239            '100,2012,A,M123456,123456\r\n'
240            )
241        return
242
243    def test_export_student(self):
244        # we can really export study levels of a certain student
245        self.setup_student(self.student)
246        exporter = StudentStudyLevelExporter()
247        exporter.export_student(self.student, self.outfile)
248        result = open(self.outfile, 'rb').read()
249        self.assertEqual(
250            result,
251            'level,level_session,level_verdict,matric_number,reg_number\r\n'
252            '100,2012,A,M123456,123456\r\n'
253            )
254        return
255
256class CourseTicketExporterTest(StudentImportExportSetup):
257
258    layer = FunctionalLayer
259
260    def setUp(self):
261        super(CourseTicketExporterTest, self).setUp()
262        self.setup_for_export()
263        return
264
265    def test_ifaces(self):
266        # make sure we fullfill interface contracts
267        obj = CourseTicketExporter()
268        verifyObject(ICSVExporter, obj)
269        verifyClass(ICSVExporter, CourseTicketExporter)
270        return
271
272    def test_get_as_utility(self):
273        # we can get an student exporter as utility
274        result = queryUtility(ICSVExporter, name="coursetickets")
275        self.assertTrue(result is not None)
276        return
277
278    def test_export_empty(self):
279        # we can export a nearly empty course ticket
280        ticket = CourseTicket()
281        exporter = CourseTicketExporter()
282        exporter.export([ticket], self.outfile)
283        result = open(self.outfile, 'rb').read()
284        self.assertEqual(
285            result,
286            'automatic,carry_over,code,credits,dcode,fcode,level,mandatory,'
287            'matric_number,passmark,reg_number,score,semester,title\r\n'
288            '0,0,,,,,,0,,,,0,,\r\n'
289            )
290        return
291
292    def test_export(self):
293        # we can really export course tickets.
294        # set values we can expect in export file
295        self.setup_student(self.student)
296        study_course = self.student.get('studycourse')
297        study_level = study_course[study_course.keys()[0]]
298        ticket = study_level['CRS1']
299        exporter = CourseTicketExporter()
300        exporter.export([ticket], self.outfile)
301        result = open(self.outfile, 'rb').read()
302        self.assertEqual(
303            result,
304            'automatic,carry_over,code,credits,dcode,fcode,level,mandatory,'
305            'matric_number,passmark,reg_number,score,semester,title\r\n'
306            '1,1,CRS1,100,DEP1,FAC1,100,0,M123456,100,123456,0,2,Course 1\r\n'
307            )
308        return
309
310    def test_export_all(self):
311        # we can really export all course tickets
312        # set values we can expect in export file
313        self.setup_student(self.student)
314        exporter = CourseTicketExporter()
315        exporter.export_all(self.app, self.outfile)
316        result = open(self.outfile, 'rb').read()
317        self.assertEqual(
318            result,
319            'automatic,carry_over,code,credits,dcode,fcode,level,mandatory,'
320            'matric_number,passmark,reg_number,score,semester,title\r\n'
321            '1,1,CRS1,100,DEP1,FAC1,100,0,M123456,100,123456,0,2,Course 1\r\n'
322            )
323        return
324
325    def test_export_student(self):
326        # we can really export all course tickets of a certain student
327        self.setup_student(self.student)
328        exporter = CourseTicketExporter()
329        exporter.export_student(self.student, self.outfile)
330        result = open(self.outfile, 'rb').read()
331        self.assertEqual(
332            result,
333            'automatic,carry_over,code,credits,dcode,fcode,level,mandatory,'
334            'matric_number,passmark,reg_number,score,semester,title\r\n'
335            '1,1,CRS1,100,DEP1,FAC1,100,0,M123456,100,123456,0,2,Course 1\r\n'
336            )
337        return
338
339class PaymentsExporterTest(StudentImportExportSetup):
340
341    layer = FunctionalLayer
342
343    def setUp(self):
344        super(PaymentsExporterTest, self).setUp()
345        self.setup_for_export()
346        return
347
348    def test_ifaces(self):
349        # make sure we fullfill interface contracts
350        obj = PaymentsExporter()
351        verifyObject(ICSVExporter, obj)
352        verifyClass(ICSVExporter, PaymentsExporter)
353        return
354
355    def test_get_as_utility(self):
356        # we can get a payments exporter as utility
357        result = queryUtility(ICSVExporter, name="studentpayments")
358        self.assertTrue(result is not None)
359        return
360
361    def test_export_empty(self):
362        # we can export a nearly empty payment
363        payment = StudentOnlinePayment()
364        payment.creation_date = datetime.datetime(2012, 4, 1, 13, 12, 1)
365        exporter = PaymentsExporter()
366        exporter.export([payment], self.outfile)
367        result = open(self.outfile, 'rb').read()
368        self.assertEqual(
369            result,
370            'ac,amount_auth,creation_date,matric_number,p_category,p_id,'
371            'p_item,p_level,p_session,p_state,payment_date,r_amount_approved,'
372            'r_code,reg_number\r\n'
373
374            ',0.0,2012-04-01 13:12:01,,schoolfee,,,,,unpaid,,0.0,,\r\n'
375            )
376        return
377
378    def test_export(self):
379        # we can really export student payments.
380        # set values we can expect in export file
381        self.setup_student(self.student)
382        payment = self.student['payments']['my-payment']
383        exporter = PaymentsExporter()
384        exporter.export([payment], self.outfile)
385        result = open(self.outfile, 'rb').read()
386        self.assertEqual(
387            result,
388            'ac,amount_auth,creation_date,matric_number,p_category,p_id,'
389            'p_item,p_level,p_session,p_state,payment_date,r_amount_approved,'
390            'r_code,reg_number\r\n'
391
392            '666,0.0,2012-04-01 13:12:01,M123456,schoolfee,my-id,'
393            'p-item,100,2012,unpaid,2012-04-01 14:12:01,12.12,'
394            'r-code,123456\r\n'
395            )
396        return
397
398    def test_export_all(self):
399        # we can really export all payments
400        # set values we can expect in export file
401        self.setup_student(self.student)
402        exporter = PaymentsExporter()
403        exporter.export_all(self.app, self.outfile)
404        result = open(self.outfile, 'rb').read()
405        self.assertEqual(
406            result,
407            'ac,amount_auth,creation_date,matric_number,p_category,p_id,'
408            'p_item,p_level,p_session,p_state,payment_date,r_amount_approved,'
409            'r_code,reg_number\r\n'
410
411            '666,0.0,2012-04-01 13:12:01,M123456,schoolfee,my-id,'
412            'p-item,100,2012,unpaid,2012-04-01 14:12:01,12.12,'
413            'r-code,123456\r\n'
414            )
415        return
416
417    def test_export_student(self):
418        # we can really export all payments of a certain student
419        # set values we can expect in export file
420        self.setup_student(self.student)
421        exporter = PaymentsExporter()
422        exporter.export_student(self.student, self.outfile)
423        result = open(self.outfile, 'rb').read()
424        self.assertEqual(
425            result,
426            'ac,amount_auth,creation_date,matric_number,p_category,p_id,'
427            'p_item,p_level,p_session,p_state,payment_date,r_amount_approved,'
428            'r_code,reg_number\r\n'
429
430            '666,0.0,2012-04-01 13:12:01,M123456,schoolfee,my-id,'
431            'p-item,100,2012,unpaid,2012-04-01 14:12:01,12.12,'
432            'r-code,123456\r\n'
433            )
434        return
Note: See TracBrowser for help on using the repository browser.