Context navigation

test_export.py @ 17952

Last change on this file since 17952 was 17769, checked in by Henrik Bettermann, 6 months ago
After import with entry_mode 'transfer' we must ensure that after export and reimport the student is not transferred again.
Property svn:keywords set to `Id`
File size: 76.8 KB

Line
1	## $Id: test_export.py 17769 2024-05-13 06:26:57Z henrik $
2	##
3	## Copyright (C) 2011 Uli Fouquet & Henrik Bettermann
4	## This program is free software; you can redistribute it and/or modify
5	## it under the terms of the GNU General Public License as published by
6	## the Free Software Foundation; either version 2 of the License, or
7	## (at your option) any later version.
8	##
9	## This program is distributed in the hope that it will be useful,
10	## but WITHOUT ANY WARRANTY; without even the implied warranty of
11	## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12	## GNU General Public License for more details.
13	##
14	## You should have received a copy of the GNU General Public License
15	## along with this program; if not, write to the Free Software
16	## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17	##
18
19	import os
20	import grok
21	import datetime
22	from cStringIO import StringIO
23	from zope.component import queryUtility, getUtility, createObject
24	from zope.event import notify
25	from zope.interface.verify import verifyObject, verifyClass
26	from waeup.kofa.interfaces import (
27	ICSVExporter, IExtFileStore, IFileStoreNameChooser)
28	from waeup.kofa.students.catalog import StudentsQuery
29	from waeup.kofa.university.course import Course
30	from waeup.kofa.university.certificate import CertificateCourse
31	from waeup.kofa.students.export import (
32	StudentExporter,
33	StudentStudyCourseExporter,
34	FirstStudentStudyCourseExporter,
35	SecondStudentStudyCourseExporter,
36	StudentStudyLevelExporter,
37	FirstStudentStudyLevelExporter,
38	SecondStudentStudyLevelExporter,
39	CourseTicketExporter,
40	FirstCourseTicketExporter,
41	SecondCourseTicketExporter,
42	StudentPaymentExporter, BedTicketExporter,
43	SchoolFeePaymentsOverviewExporter, StudyLevelsOverviewExporter,
44	ComboCardDataExporter, DataForBursaryExporter,
45	UnpaidPaymentsExporter, SessionPaymentsOverviewExporter,
46	OutstandingCoursesExporter,
47	AccommodationPaymentsExporter,
48	TranscriptDataExporter,
49	TrimmedDataExporter,
50	StudentTrimmedPaymentExporter,
51	get_students,)
52	from waeup.kofa.students.accommodation import BedTicket
53	from waeup.kofa.students.interfaces import ICSVStudentExporter
54	from waeup.kofa.students.payments import StudentOnlinePayment
55	from waeup.kofa.students.student import Student
56	from waeup.kofa.students.studycourse import StudentStudyCourse
57	from waeup.kofa.students.studylevel import StudentStudyLevel, CourseTicket
58	from waeup.kofa.students.tests.test_batching import StudentImportExportSetup
59	from waeup.kofa.testing import FunctionalLayer
60
61	curr_year = datetime.datetime.now().year
62	year_range = range(curr_year - 11, curr_year + 1)
63	year_range_str = ','.join([str(i) for i in year_range])
64
65	class ExportHelperTests(StudentImportExportSetup):
66	layer = FunctionalLayer
67	def setUp(self):
68	super(ExportHelperTests, self).setUp()
69	student = Student()
70	self.app['students'].addStudent(student)
71	student = self.setup_student(student)
72	notify(grok.ObjectModifiedEvent(student))
73	self.student = self.app['students'][student.student_id]
74	return
75
76	def test_get_students_plain(self):
77	# without a filter we get all students
78	result = get_students(self.app)
79	self.assertEqual(len(list(result)), 1)
80	return
81
82	def test_get_students_by_session(self):
83	# we can filter out students of a certain session
84	my_filter1 = StudentsQuery(current_session=2012)
85	result = get_students(self.app, stud_filter=my_filter1)
86	self.assertEqual(len(list(result)), 1)
87
88	my_filter2 = StudentsQuery(current_session=1964)
89	result = get_students(self.app, stud_filter=my_filter2)
90	self.assertEqual(len(list(result)), 0)
91	return
92
93	def test_get_students_by_level(self):
94	# we can filter out students of a certain level
95	my_filter1 = StudentsQuery(current_level=200)
96	result = get_students(self.app, stud_filter=my_filter1)
97	self.assertEqual(len(list(result)), 1)
98
99	my_filter2 = StudentsQuery(current_level=300)
100	result = get_students(self.app, stud_filter=my_filter2)
101	self.assertEqual(len(list(result)), 0)
102	return
103
104	def test_get_students_by_deptcode(self):
105	# we can filter out students of a certain dept.
106	my_filter1 = StudentsQuery(depcode='NA')
107	result = get_students(self.app, stud_filter=my_filter1)
108	self.assertEqual(len(list(result)), 1)
109
110	my_filter2 = StudentsQuery(depcode='NOTEXISTING')
111	result = get_students(self.app, stud_filter=my_filter2)
112	self.assertEqual(len(list(result)), 0)
113	return
114
115	def test_get_students_by_faccode(self):
116	# we can filter out students of a certain faculty.
117	my_filter1 = StudentsQuery(faccode='NA')
118	result = get_students(self.app, stud_filter=my_filter1)
119	self.assertEqual(len(list(result)), 1)
120
121	my_filter2 = StudentsQuery(faccode='NOTEXISTING')
122	result = get_students(self.app, stud_filter=my_filter2)
123	self.assertEqual(len(list(result)), 0)
124	return
125
126	def test_get_students_by_current_mode(self):
127	# we can filter out students in a certain mode.
128	my_filter1 = StudentsQuery(current_mode='ug_ft')
129	result = get_students(self.app, stud_filter=my_filter1)
130	self.assertEqual(len(list(result)), 1)
131
132	my_filter2 = StudentsQuery(current_mode='NOTEXISTING')
133	result = get_students(self.app, stud_filter=my_filter2)
134	self.assertEqual(len(list(result)), 0)
135	return
136
137
138	class StudentExporterTest(StudentImportExportSetup):
139
140	layer = FunctionalLayer
141
142	std_csv_entry = (
143	'my adm code,my clr code,1981-02-04#,anna@sample.com,,'
144	'Anna,,Tester,234,M.,NG,,,"Studentroad 21\nLagos 123456\n",,'
145	'+234-123-12345#,123,f,A111111,0,,,created'
146	)
147
148	def setUp(self):
149	super(StudentExporterTest, self).setUp()
150	self.setup_for_export()
151	return
152
153	def test_ifaces(self):
154	# make sure we fullfill interface contracts
155	obj = StudentExporter()
156	verifyObject(ICSVStudentExporter, obj)
157	verifyClass(ICSVStudentExporter, StudentExporter)
158	return
159
160	def test_get_as_utility(self):
161	# we can get an student exporter as utility
162	result = queryUtility(ICSVExporter, name="students")
163	self.assertTrue(result is not None)
164	return
165
166	def test_export(self):
167	# we can really export students
168	# set values we can expect in export file
169	self.setup_student(self.student)
170	exporter = StudentExporter()
171	exporter.export([self.student], self.outfile)
172	result = open(self.outfile, 'rb').read()
173	self.assertTrue(
174	'adm_code,clr_code,date_of_birth,email,'
175	'employer,firstname,flash_notice,lastname,matric_number,middlename,'
176	'nationality,officer_comment,parents_email,'
177	'perm_address,personal_updated,'
178	'phone,reg_number,sex,student_id,suspended,suspended_comment,'
179	'password,state,history,certcode,is_postgrad,'
180	'current_level,current_session,entry_session\r\n'
181	'my adm code,my clr code,'
182	'1981-02-04#,anna@sample.com,,Anna,,Tester,234,M.,NG,,,'
183	'"Studentroad 21\nLagos 123456\n",,+234-123-12345#,123,f,'
184	'A111111,0,,,created'
185	in result
186	)
187	return
188
189	def test_export_all(self):
190	# we can really export students
191	# set values we can expect in export file
192	self.setup_student(self.student)
193	exporter = StudentExporter()
194	exporter.export_all(self.app, self.outfile)
195	result = open(self.outfile, 'rb').read()
196	self.assertTrue(
197	'adm_code,clr_code,date_of_birth,email,'
198	'employer,firstname,flash_notice,lastname,matric_number,middlename,'
199	'nationality,officer_comment,parents_email,'
200	'perm_address,personal_updated,'
201	'phone,reg_number,sex,student_id,suspended,suspended_comment,'
202	'password,state,history,certcode,is_postgrad,'
203	'current_level,current_session,entry_session\r\n'
204	'my adm code,my clr code,1981-02-04#,anna@sample.com,,'
205	'Anna,,Tester,234,M.,NG,,,"Studentroad 21\nLagos 123456\n"'
206	',,+234-123-12345#,123,f,A111111,0,,,created'
207	in result
208	)
209	return
210
211	def test_export_student(self):
212	# we can export a single student
213	self.setup_student(self.student)
214	exporter = StudentExporter()
215	exporter.export_student(self.student, self.outfile)
216	result = open(self.outfile, 'rb').read()
217	self.assertTrue(
218	'adm_code,clr_code,date_of_birth,email,'
219	'employer,firstname,flash_notice,lastname,matric_number,middlename,'
220	'nationality,officer_comment,parents_email,'
221	'perm_address,personal_updated,'
222	'phone,reg_number,sex,student_id,suspended,suspended_comment,'
223	'password,state,history,certcode,is_postgrad,'
224	'current_level,current_session,entry_session\r\n'
225	'my adm code,my clr code,1981-02-04#,anna@sample.com,,'
226	'Anna,,Tester,234,M.,NG,,,"Studentroad 21\nLagos 123456\n"'
227	',,+234-123-12345#,123,f,A111111,0,,,created'
228	in result
229	)
230	return
231
232	def test_export_filtered(self):
233	# we can export a filtered set of students (filtered by session/level)
234	self.setup_student(self.student)
235	self.app['students'].addStudent(self.student)
236	notify(grok.ObjectModifiedEvent(self.student))
237	exporter = StudentExporter()
238
239	exporter.export_filtered(
240	self.app, self.outfile,
241	current_session=None, current_level=None)
242	result1 = open(self.outfile, 'rb').read()
243	exporter.export_filtered(
244	self.app, self.outfile,
245	current_session=2012, current_level=None)
246	result2 = open(self.outfile, 'rb').read()
247	# current_level and current_session can be both a string ...
248	exporter.export_filtered(
249	self.app, self.outfile,
250	current_session='2012', current_level=u'200')
251	result3 = open(self.outfile, 'rb').read()
252	exporter.export_filtered(
253	self.app, self.outfile,
254	current_session=2011, current_level=None)
255	result4 = open(self.outfile, 'rb').read()
256	# ... and an integer
257	exporter.export_filtered(
258	self.app, self.outfile,
259	current_session=None, current_level=100)
260	result5 = open(self.outfile, 'rb').read()
261	# Also students at probating levels are being exported ...
262	self.student['studycourse'].current_level = 210
263	notify(grok.ObjectModifiedEvent(self.student))
264	exporter.export_filtered(
265	self.app, self.outfile,
266	current_session=None, current_level=200)
267	result6 = open(self.outfile, 'rb').read()
268	# ... but not in the wrong level range.
269	self.student['studycourse'].current_level = 310
270	notify(grok.ObjectModifiedEvent(self.student))
271	exporter.export_filtered(
272	self.app, self.outfile,
273	current_session=None, current_level=200)
274	result7 = open(self.outfile, 'rb').read()
275	self.assertTrue(self.std_csv_entry in result1)
276	self.assertTrue(self.std_csv_entry in result2)
277	self.assertTrue(self.std_csv_entry in result3)
278	self.assertFalse(self.std_csv_entry in result4)
279	self.assertFalse(self.std_csv_entry in result5)
280	self.assertTrue(self.std_csv_entry in result6)
281	self.assertFalse(self.std_csv_entry in result7)
282	return
283
284	def test_export_selected(self):
285	# we can export a filtered set of students (filtered by session/level)
286	self.setup_student(self.student)
287	self.app['students'].addStudent(self.student)
288	notify(grok.ObjectModifiedEvent(self.student))
289	exporter = StudentExporter()
290	exporter.export_selected(
291	self.app, self.outfile, selected=['A111111'])
292	result1 = open(self.outfile, 'rb').read()
293	exporter.export_selected(
294	self.app, self.outfile, selected=[])
295	result2 = open(self.outfile, 'rb').read()
296	self.assertTrue(self.std_csv_entry in result1)
297	self.assertFalse(self.std_csv_entry in result2)
298	return
299
300	def test_export_filtered_by_dept(self):
301	# we can export a set of students filtered by department
302	self.setup_student(self.student)
303	self.app['students'].addStudent(self.student)
304	notify(grok.ObjectModifiedEvent(self.student))
305	exporter = StudentExporter()
306	# current_session can be both a string ...
307	exporter.export_filtered(
308	self.app, self.outfile,
309	current_session='2012', current_level=u'200', depcode='NA')
310	result1 = open(self.outfile, 'rb').read()
311	# ... and an integer
312	exporter.export_filtered(
313	self.app, self.outfile,
314	current_session=2012, current_level=200, depcode='NODEPT')
315	result2 = open(self.outfile, 'rb').read()
316	self.assertTrue(self.std_csv_entry in result1)
317	self.assertTrue(self.std_csv_entry not in result2)
318	return
319
320	def test_export_filtered_by_faculty(self):
321	# we can export a set of students filtered by faculty
322	self.setup_student(self.student)
323	self.app['students'].addStudent(self.student)
324	notify(grok.ObjectModifiedEvent(self.student))
325	exporter = StudentExporter()
326
327	exporter.export_filtered(
328	self.app, self.outfile,
329	current_session=2012, current_level='200', faccode='NA')
330	result1 = open(self.outfile, 'rb').read()
331	exporter.export_filtered(
332	self.app, self.outfile,
333	current_session=2012, current_level=200, faccode='NOFAC')
334	result2 = open(self.outfile, 'rb').read()
335	self.assertTrue(self.std_csv_entry in result1)
336	self.assertTrue(self.std_csv_entry not in result2)
337	return
338
339
340
341	class StudentTrimmedDataExporterTest(StudentImportExportSetup):
342
343	layer = FunctionalLayer
344
345	std_csv_entry = (
346	'my adm code,my clr code,1981-02-04#,anna@sample.com,,'
347	'Anna,,Tester,234,M.,NG,,,"Studentroad 21\nLagos 123456\n",,'
348	'+234-123-12345#,123,f,A111111,0,,,created'
349	)
350
351	def setUp(self):
352	super(StudentTrimmedDataExporterTest, self).setUp()
353	self.setup_for_export()
354	return
355
356	def test_ifaces(self):
357	# make sure we fullfill interface contracts
358	obj = TrimmedDataExporter()
359	verifyObject(ICSVStudentExporter, obj)
360	verifyClass(ICSVStudentExporter, TrimmedDataExporter)
361	return
362
363	def test_get_as_utility(self):
364	# we can get an student exporter as utility
365	result = queryUtility(ICSVExporter, name="trimmed")
366	self.assertTrue(result is not None)
367	return
368
369	def test_export_all(self):
370	# we can really export students
371	# set values we can expect in export file
372	self.setup_student(self.student)
373	exporter = TrimmedDataExporter()
374	exporter.export_all(self.app, self.outfile)
375	result = open(self.outfile, 'rb').read()
376	self.assertTrue(
377	'student_id,matric_number,reg_number,firstname,middlename,'
378	'lastname,sex,email,phone,nationality,date_of_birth,state,'
379	'current_mode,certcode,faccode,depcode,current_level,'
380	'current_session,current_verdict,entry_session\r\n'
381	'A111111,234,123,Anna,M.,Tester,f,anna@sample.com,+234-123-12345#,'
382	'NG,1981-02-04#,created,ug_ft,CERT1,NA,NA,200,2012,0,2010'
383	in result
384	)
385	return
386
387	class StudentStudyCourseExporterTest(StudentImportExportSetup):
388
389	layer = FunctionalLayer
390
391	def setUp(self):
392	super(StudentStudyCourseExporterTest, self).setUp()
393	self.setup_for_export()
394	return
395
396	def test_ifaces(self):
397	# make sure we fullfill interface contracts
398	obj = StudentStudyCourseExporter()
399	verifyObject(ICSVStudentExporter, obj)
400	verifyClass(ICSVStudentExporter, StudentStudyCourseExporter)
401	return
402
403	def test_get_as_utility(self):
404	# we can get an student exporter as utility
405	result = queryUtility(ICSVExporter, name="studentstudycourses")
406	self.assertTrue(result is not None)
407	return
408
409	def test_export_empty(self):
410	# we can export a nearly empty study course
411	study_course = StudentStudyCourse()
412	exporter = StudentStudyCourseExporter()
413	exporter.export([study_course], self.outfile)
414	result = open(self.outfile, 'rb').read()
415	self.assertEqual(
416	result,
417	'certificate,current_level,current_session,current_verdict,'
418	'entry_mode,entry_session,previous_verdict,student_id,previous\r\n'
419
420	',,,0,,,0,,0\r\n'
421	)
422	return
423
424	def test_export(self):
425	# we can really export study courses.
426	# set values we can expect in export file
427	self.setup_student(self.student)
428	study_course = self.student.get('studycourse')
429	exporter = StudentStudyCourseExporter()
430	exporter.export([study_course], self.outfile)
431	result = open(self.outfile, 'rb').read()
432	self.assertEqual(
433	result,
434	'certificate,current_level,current_session,current_verdict,'
435	'entry_mode,entry_session,previous_verdict,student_id,previous\r\n'
436
437	'CERT1,200,2012,0,ug_ft,2010,0,A111111,0\r\n'
438	)
439	return
440
441	def test_export_all(self):
442	# we can really export students
443	# set values we can expect in export file
444	self.setup_student(self.student)
445	exporter = StudentStudyCourseExporter()
446	exporter.export_all(self.app, self.outfile)
447	result = open(self.outfile, 'rb').read()
448	self.assertEqual(
449	result,
450	'certificate,current_level,current_session,current_verdict,'
451	'entry_mode,entry_session,previous_verdict,student_id,previous\r\n'
452
453	'CERT1,200,2012,0,ug_ft,2010,0,A111111,0\r\n'
454	)
455	return
456
457	def test_export_student(self):
458	# we can export studycourse of a certain student
459	self.setup_student(self.student)
460	exporter = StudentStudyCourseExporter()
461	exporter.export_student(self.student, self.outfile)
462	result = open(self.outfile, 'rb').read()
463	self.assertEqual(
464	result,
465	'certificate,current_level,current_session,current_verdict,'
466	'entry_mode,entry_session,previous_verdict,student_id,previous\r\n'
467
468	'CERT1,200,2012,0,ug_ft,2010,0,A111111,0\r\n'
469	)
470	return
471
472	def test_export_filtered(self):
473	# we can export studycourses of a filtered set of students
474	self.setup_student(self.student)
475	self.app['students'].addStudent(self.student)
476	notify(grok.ObjectModifiedEvent(self.student))
477
478	exporter = StudentStudyCourseExporter()
479	exporter.export_filtered(
480	self.student, self.outfile, current_session=2012)
481	result = open(self.outfile, 'rb').read()
482	self.assertEqual(
483	result,
484	'certificate,current_level,current_session,current_verdict,'
485	'entry_mode,entry_session,previous_verdict,student_id,previous\r\n'
486
487	'CERT1,200,2012,0,ug_ft,2010,0,A111111,0\r\n'
488	)
489	return
490
491	def test_export_selected_student_id(self):
492	# we can export a filtered set of students (filtered by session/level)
493	self.setup_student(self.student)
494	self.app['students'].addStudent(self.student)
495	notify(grok.ObjectModifiedEvent(self.student))
496	exporter = StudentStudyCourseExporter()
497	exporter.export_selected(
498	self.app, self.outfile, selected=['A111111'])
499	result = open(self.outfile, 'rb').read()
500	self.assertEqual(
501	result,
502	'certificate,current_level,current_session,current_verdict,'
503	'entry_mode,entry_session,previous_verdict,student_id,previous\r\n'
504
505	'CERT1,200,2012,0,ug_ft,2010,0,A111111,0\r\n'
506	)
507	return
508
509	def test_export_selected_matric_number(self):
510	# we can export a filtered set of students (filtered by session/level)
511	self.setup_student(self.student)
512	self.app['students'].addStudent(self.student)
513	notify(grok.ObjectModifiedEvent(self.student))
514	exporter = StudentStudyCourseExporter()
515	exporter.export_selected(
516	self.app, self.outfile, selected=['234'])
517	result = open(self.outfile, 'rb').read()
518	self.assertEqual(
519	result,
520	'certificate,current_level,current_session,current_verdict,'
521	'entry_mode,entry_session,previous_verdict,student_id,previous\r\n'
522
523	'CERT1,200,2012,0,ug_ft,2010,0,A111111,0\r\n'
524	)
525	return
526
527	def test_export_selected_pid(self):
528	# we can export a filtered set of students (filtered by session/level)
529	self.setup_student(self.student)
530	self.app['students'].addStudent(self.student)
531	notify(grok.ObjectModifiedEvent(self.student))
532	exporter = StudentStudyCourseExporter()
533	exporter.export_selected(
534	self.app, self.outfile, selected=[self.payment.p_id])
535	result = open(self.outfile, 'rb').read()
536	self.assertEqual(
537	result,
538	'certificate,current_level,current_session,current_verdict,'
539	'entry_mode,entry_session,previous_verdict,student_id,previous\r\n'
540
541	'CERT1,200,2012,0,ug_ft,2010,0,A111111,0\r\n'
542	)
543	return
544
545	class PreviousStudyCourseExporterTests(StudentImportExportSetup):
546
547	layer = FunctionalLayer
548
549	def setUp(self):
550	super(PreviousStudyCourseExporterTests, self).setUp()
551	self.setup_for_export()
552	self.certificate2 = createObject('waeup.Certificate')
553	self.certificate2.code = 'CERT2'
554	self.certificate2.application_category = 'basic'
555	self.certificate2.start_level = 200
556	self.certificate2.end_level = 500
557	self.app['faculties']['fac1']['dep1'].certificates.addCertificate(
558	self.certificate2)
559	return
560
561	def test_export_studycourses(self):
562	self.setup_student(self.student)
563	exporter = FirstStudentStudyCourseExporter()
564	exporter.export_all(self.app, self.outfile)
565	result = open(self.outfile, 'rb').read()
566	self.assertEqual(
567	result,
568	'certificate,current_level,current_session,current_verdict,'
569	'entry_mode,entry_session,previous_verdict,student_id,previous\r\n'
570	)
571	exporter = SecondStudentStudyCourseExporter()
572	exporter.export_all(self.app, self.outfile)
573	result = open(self.outfile, 'rb').read()
574	self.assertEqual(
575	result,
576	'certificate,current_level,current_session,current_verdict,'
577	'entry_mode,entry_session,previous_verdict,student_id,previous\r\n'
578	)
579
580	# First Transfer
581	error = self.student.transfer(self.certificate2,
582	current_session=2013)
583	self.assertTrue(error == None)
584	exporter = FirstStudentStudyCourseExporter()
585	exporter.export_all(self.app, self.outfile)
586	result = open(self.outfile, 'rb').read()
587	# This is the original study course
588	self.assertEqual(
589	result,
590	'certificate,current_level,current_session,current_verdict,'
591	'entry_mode,entry_session,previous_verdict,student_id,previous\r\n'
592	'CERT1,200,2012,0,ug_ft,2010,0,A111111,1\r\n')
593	exporter = SecondStudentStudyCourseExporter()
594	exporter.export_all(self.app, self.outfile)
595	result = open(self.outfile, 'rb').read()
596	self.assertEqual(
597	result,
598	'certificate,current_level,current_session,current_verdict,'
599	'entry_mode,entry_session,previous_verdict,student_id,previous\r\n'
600	)
601
602	# Second transfer
603	error = self.student.transfer(self.certificate,
604	current_session=2014,
605	current_level=300)
606	self.assertTrue(error == None)
607	exporter = FirstStudentStudyCourseExporter()
608	exporter.export_all(self.app, self.outfile)
609	result = open(self.outfile, 'rb').read()
610	# This is the original study course
611	self.assertEqual(
612	result,
613	'certificate,current_level,current_session,current_verdict,'
614	'entry_mode,entry_session,previous_verdict,student_id,previous\r\n'
615	'CERT1,200,2012,0,ug_ft,2010,0,A111111,1\r\n')
616	# This is the second study course
617	exporter = SecondStudentStudyCourseExporter()
618	exporter.export_all(self.app, self.outfile)
619	result = open(self.outfile, 'rb').read()
620	self.assertEqual(
621	result,
622	'certificate,current_level,current_session,current_verdict,'
623	'entry_mode,entry_session,previous_verdict,student_id,previous\r\n'
624	'CERT2,,2013,,transferred,2010,,A111111,2\r\n')
625	# This is the third study course
626	exporter = StudentStudyCourseExporter()
627	exporter.export_all(self.app, self.outfile)
628	result = open(self.outfile, 'rb').read()
629	self.assertEqual(
630	result,
631	'certificate,current_level,current_session,current_verdict,'
632	'entry_mode,entry_session,previous_verdict,student_id,previous\r\n'
633	'CERT1,300,2014,,transferred,2010,,A111111,0\r\n')
634	return
635
636	def test_export_studylevels(self):
637	self.setup_student(self.student)
638	exporter = FirstStudentStudyLevelExporter()
639	exporter.export_all(self.app, self.outfile)
640	result = open(self.outfile, 'rb').read()
641	self.assertEqual(
642	result,
643	'gpa,level,level_session,level_verdict,total_credits,'
644	'transcript_remark,validated_by,validation_date,student_id,'
645	'number_of_tickets,certcode,previous\r\n'
646	)
647	error = self.student.transfer(self.certificate2, current_session=2013)
648	self.assertTrue(error == None)
649	exporter.export_all(self.app, self.outfile)
650	result = open(self.outfile, 'rb').read()
651	self.assertEqual(
652	result,
653	'gpa,level,level_session,level_verdict,total_credits,'
654	'transcript_remark,validated_by,validation_date,student_id,'
655	'number_of_tickets,certcode,previous\r\n'
656	'0.00,100,2012,A,100,,,,A111111,1,CERT1,1\r\n' )
657	study_level = StudentStudyLevel()
658	study_level.level_session = 2015
659	study_level.level_verdict = "C"
660	study_level.level = 400
661	self.student['studycourse'].addStudentStudyLevel(
662	self.certificate2, study_level)
663	error = self.student.transfer(self.certificate,
664	current_session=2014,
665	current_level=300)
666	self.assertTrue(error == None)
667	exporter = SecondStudentStudyLevelExporter()
668	exporter.export_all(self.app, self.outfile)
669	result = open(self.outfile, 'rb').read()
670	self.assertEqual(
671	result,
672	'gpa,level,level_session,level_verdict,total_credits,'
673	'transcript_remark,validated_by,validation_date,student_id,'
674	'number_of_tickets,certcode,previous\r\n'
675	'0.00,400,2015,C,0,,,,A111111,0,CERT2,2\r\n')
676	exporter = StudentStudyLevelExporter()
677	exporter.export_all(self.app, self.outfile)
678	result = open(self.outfile, 'rb').read()
679	self.assertEqual(
680	result,
681	'gpa,level,level_session,level_verdict,total_credits,'
682	'transcript_remark,validated_by,validation_date,student_id,'
683	'number_of_tickets,certcode,previous\r\n')
684	return
685
686	def test_export_coursetickets(self):
687	self.setup_student(self.student)
688	exporter = FirstCourseTicketExporter()
689	exporter.export_all(self.app, self.outfile)
690	result = open(self.outfile, 'rb').read()
691	self.assertEqual(
692	result,
693	'automatic,carry_over,code,course_category,credits,dcode,'
694	'fcode,level,level_session,mandatory,outstanding,passmark,'
695	'score,semester,ticket_session,title,student_id,certcode,'
696	'display_fullname,previous\r\n'
697	)
698	error = self.student.transfer(self.certificate2, current_session=2013)
699	self.assertTrue(error == None)
700	exporter.export_all(self.app, self.outfile)
701	result = open(self.outfile, 'rb').read()
702	self.assertEqual(
703	result,
704	'automatic,carry_over,code,course_category,credits,dcode,'
705	'fcode,level,level_session,mandatory,outstanding,passmark,'
706	'score,semester,ticket_session,title,student_id,certcode,'
707	'display_fullname,previous\r\n'
708	'1,1,CRS1,,100,DEP1,FAC1,100,2012,0,0,100,,2,,Course 1,'
709	'A111111,CERT1,Anna M. Tester,1\r\n')
710	study_level = StudentStudyLevel()
711	study_level.level_session = 2015
712	study_level.level_verdict = "C"
713	study_level.level = 400
714	self.student['studycourse'].addStudentStudyLevel(
715	self.certificate2, study_level)
716	ticket = CourseTicket()
717	ticket.automatic = True
718	ticket.carry_over = True
719	ticket.code = u'CRS9'
720	ticket.title = u'Course 9'
721	ticket.fcode = u'FAC9'
722	ticket.dcode = u'DEP9'
723	ticket.credits = 150
724	ticket.passmark = 100
725	ticket.semester = 2
726	study_level[ticket.code] = ticket
727	error = self.student.transfer(self.certificate,
728	current_session=2014,
729	current_level=300)
730	self.assertTrue(error == None)
731	exporter = SecondCourseTicketExporter()
732	exporter.export_all(self.app, self.outfile)
733	result = open(self.outfile, 'rb').read()
734	self.assertEqual(
735	result,
736	'automatic,carry_over,code,course_category,credits,dcode,'
737	'fcode,level,level_session,mandatory,outstanding,passmark,'
738	'score,semester,ticket_session,title,student_id,certcode,'
739	'display_fullname,previous\r\n1,1,CRS9,,150,DEP9,FAC9,400,2015,0,0,'
740	'100,,2,,Course 9,A111111,CERT2,Anna M. Tester,2\r\n')
741	exporter = CourseTicketExporter()
742	exporter.export_all(self.app, self.outfile)
743	result = open(self.outfile, 'rb').read()
744	self.assertEqual(
745	result,
746	'automatic,carry_over,code,course_category,credits,dcode,'
747	'fcode,level,level_session,mandatory,outstanding,passmark,'
748	'score,semester,ticket_session,title,student_id,certcode,'
749	'display_fullname,previous\r\n'
750	)
751	return
752
753	class StudentStudyLevelExporterTest(StudentImportExportSetup):
754
755	layer = FunctionalLayer
756
757	def setUp(self):
758	super(StudentStudyLevelExporterTest, self).setUp()
759	self.setup_for_export()
760	return
761
762	def test_ifaces(self):
763	# make sure we fullfill interface contracts
764	obj = StudentStudyLevelExporter()
765	verifyObject(ICSVStudentExporter, obj)
766	verifyClass(ICSVStudentExporter, StudentStudyLevelExporter)
767	return
768
769	def test_get_as_utility(self):
770	# we can get an student exporter as utility
771	result = queryUtility(ICSVExporter, name="studentstudylevels")
772	self.assertTrue(result is not None)
773	return
774
775	def test_export_empty(self):
776	# we can export a nearly empty study level
777	study_level = StudentStudyLevel()
778	exporter = StudentStudyLevelExporter()
779	exporter.export([study_level], self.outfile)
780	result = open(self.outfile, 'rb').read()
781	self.assertEqual(
782	result,
783	'gpa,level,level_session,level_verdict,total_credits,'
784	'transcript_remark,validated_by,validation_date,'
785	'student_id,number_of_tickets,certcode,previous\r\n'
786	'0.00,,,0,0,,,,,0,,0\r\n'
787	)
788	return
789
790	def test_export(self):
791	# we can really export study levels.
792	# set values we can expect in export file
793	self.setup_student(self.student)
794	study_course = self.student.get('studycourse')
795	study_level = study_course[study_course.keys()[0]]
796	exporter = StudentStudyLevelExporter()
797	exporter.export([study_level], self.outfile)
798	result = open(self.outfile, 'rb').read()
799	self.assertEqual(
800	result,
801	'gpa,level,level_session,level_verdict,total_credits,'
802	'transcript_remark,validated_by,validation_date,'
803	'student_id,number_of_tickets,certcode,previous\r\n'
804	'0.00,100,2012,A,100,,,,A111111,1,CERT1,0\r\n'
805	)
806	return
807
808	def test_export_all(self):
809	# we can really export study levels
810	# set values we can expect in export file
811	self.setup_student(self.student)
812	exporter = StudentStudyLevelExporter()
813	exporter.export_all(self.app, self.outfile)
814	result = open(self.outfile, 'rb').read()
815	self.assertEqual(
816	result,
817	'gpa,level,level_session,level_verdict,total_credits,'
818	'transcript_remark,validated_by,validation_date,'
819	'student_id,number_of_tickets,certcode,previous\r\n'
820	'0.00,100,2012,A,100,,,,A111111,1,CERT1,0\r\n'
821	)
822	return
823
824	def test_export_student(self):
825	# we can really export study levels of a certain student
826	self.setup_student(self.student)
827	exporter = StudentStudyLevelExporter()
828	exporter.export_student(self.student, self.outfile)
829	result = open(self.outfile, 'rb').read()
830	self.assertEqual(
831	result,
832	'gpa,level,level_session,level_verdict,total_credits,'
833	'transcript_remark,validated_by,validation_date,'
834	'student_id,number_of_tickets,certcode,previous\r\n'
835	'0.00,100,2012,A,100,,,,A111111,1,CERT1,0\r\n'
836	)
837	return
838
839	def test_export_filtered(self):
840	# we can export studylevels of a filtered set of students
841	self.setup_student(self.student)
842	self.app['students'].addStudent(self.student)
843	notify(grok.ObjectModifiedEvent(self.student))
844
845	exporter = StudentStudyLevelExporter()
846	exporter.export_filtered(
847	self.student, self.outfile)
848	result = open(self.outfile, 'rb').read()
849	self.assertEqual(
850	result,
851	'gpa,level,level_session,level_verdict,total_credits,'
852	'transcript_remark,validated_by,validation_date,'
853	'student_id,number_of_tickets,certcode,previous\r\n'
854	'0.00,100,2012,A,100,,,,A111111,1,CERT1,0\r\n'
855	)
856	return
857
858	def test_export_selected(self):
859	# we can export studylevels of a filtered set of students
860	self.setup_student(self.student)
861	self.app['students'].addStudent(self.student)
862	notify(grok.ObjectModifiedEvent(self.student))
863
864	exporter = StudentStudyLevelExporter()
865	exporter.export_selected(
866	self.app, self.outfile, selected=['A111111'])
867	result = open(self.outfile, 'rb').read()
868	self.assertEqual(
869	result,
870	'gpa,level,level_session,level_verdict,total_credits,'
871	'transcript_remark,validated_by,validation_date,'
872	'student_id,number_of_tickets,certcode,previous\r\n'
873	'0.00,100,2012,A,100,,,,A111111,1,CERT1,0\r\n'
874	)
875	return
876
877	class CourseTicketExporterTest(StudentImportExportSetup):
878
879	layer = FunctionalLayer
880
881	def setUp(self):
882	super(CourseTicketExporterTest, self).setUp()
883	self.setup_for_export()
884	return
885
886	def test_ifaces(self):
887	# make sure we fullfill interface contracts
888	obj = CourseTicketExporter()
889	verifyObject(ICSVStudentExporter, obj)
890	verifyClass(ICSVStudentExporter, CourseTicketExporter)
891	return
892
893	def test_get_as_utility(self):
894	# we can get an student exporter as utility
895	result = queryUtility(ICSVExporter, name="coursetickets")
896	self.assertTrue(result is not None)
897	return
898
899	def test_export_empty(self):
900	# we can export a nearly empty course ticket
901	ticket = CourseTicket()
902	exporter = CourseTicketExporter()
903	exporter.export([ticket], self.outfile)
904	result = open(self.outfile, 'rb').read()
905	self.assertEqual(
906	result,
907	'automatic,carry_over,code,course_category,credits,dcode,fcode,level,level_session,'
908	'mandatory,outstanding,passmark,score,semester,ticket_session,title,student_id,certcode,'
909	'display_fullname,previous\r\n'
910	'0,0,,,,,,,,0,0,,,,,,,,,0\r\n'
911	)
912	return
913
914	def test_export(self):
915	# we can really export course tickets.
916	# set values we can expect in export file
917	self.setup_student(self.student)
918	study_course = self.student.get('studycourse')
919	study_level = study_course[study_course.keys()[0]]
920	ticket = study_level['CRS1']
921	exporter = CourseTicketExporter()
922	exporter.export([ticket], self.outfile)
923	result = open(self.outfile, 'rb').read()
924	self.assertEqual(
925	result,
926	'automatic,carry_over,code,course_category,credits,dcode,fcode,level,level_session,'
927	'mandatory,outstanding,passmark,score,semester,ticket_session,title,student_id,certcode,'
928	'display_fullname,previous\r\n'
929	'1,1,CRS1,,100,DEP1,FAC1,100,2012,0,0,100,,2,,Course 1,A111111,CERT1,'
930	'Anna M. Tester,0\r\n'
931	)
932	return
933
934	def test_export_all(self):
935	# we can really export all course tickets
936	# set values we can expect in export file
937	self.setup_student(self.student)
938	exporter = CourseTicketExporter()
939	exporter.export_all(self.app, self.outfile)
940	result = open(self.outfile, 'rb').read()
941	self.assertEqual(
942	result,
943	'automatic,carry_over,code,course_category,credits,dcode,fcode,level,level_session,'
944	'mandatory,outstanding,passmark,score,semester,ticket_session,title,student_id,certcode,'
945	'display_fullname,previous\r\n'
946	'1,1,CRS1,,100,DEP1,FAC1,100,2012,0,0,100,,2,,Course 1,A111111,CERT1,'
947	'Anna M. Tester,0\r\n'
948	)
949	return
950
951	def test_export_student(self):
952	# we can really export all course tickets of a certain student
953	self.setup_student(self.student)
954	exporter = CourseTicketExporter()
955	exporter.export_student(self.student, self.outfile)
956	result = open(self.outfile, 'rb').read()
957	self.assertEqual(
958	result,
959	'automatic,carry_over,code,course_category,credits,dcode,fcode,level,level_session,'
960	'mandatory,outstanding,passmark,score,semester,ticket_session,title,student_id,certcode,'
961	'display_fullname,previous\r\n'
962	'1,1,CRS1,,100,DEP1,FAC1,100,2012,0,0,100,,2,,Course 1,A111111,CERT1,'
963	'Anna M. Tester,0\r\n'
964	)
965	return
966
967	def test_export_filtered(self):
968	# we can export course tickets of a filtered set of students
969	self.setup_student(self.student)
970	self.app['students'].addStudent(self.student)
971	notify(grok.ObjectModifiedEvent(self.student))
972
973	exporter = CourseTicketExporter()
974	exporter.export_filtered(self.student, self.outfile)
975	result = open(self.outfile, 'rb').read()
976	self.assertEqual(
977	result,
978	'automatic,carry_over,code,course_category,credits,dcode,fcode,level,level_session,'
979	'mandatory,outstanding,passmark,score,semester,ticket_session,title,student_id,certcode,'
980	'display_fullname,previous\r\n'
981	'1,1,CRS1,,100,DEP1,FAC1,100,2012,0,0,100,,2,,Course 1,A111111,CERT1,'
982	'Anna M. Tester,0\r\n'
983	)
984	# We can set the course tickets level, semester and level_session
985	# without code (used in the datacenter)
986	notify(grok.ObjectModifiedEvent(self.student['studycourse']['100']['CRS1']))
987	exporter.export_filtered(self.student, self.outfile, ct_level='100',
988	ct_session='2012', ct_semester='2')
989	result = open(self.outfile, 'rb').read()
990	self.assertEqual(
991	result,
992	'automatic,carry_over,code,course_category,credits,dcode,fcode,level,level_session,'
993	'mandatory,outstanding,passmark,score,semester,ticket_session,title,student_id,certcode,'
994	'display_fullname,previous\r\n'
995	'1,1,CRS1,,100,DEP1,FAC1,100,2012,0,0,100,,2,,Course 1,A111111,CERT1,'
996	'Anna M. Tester,0\r\n'
997	)
998	# 'all' does select all
999	notify(grok.ObjectModifiedEvent(self.student['studycourse']['100']['CRS1']))
1000	exporter.export_filtered(self.student, self.outfile, ct_level='all',
1001	ct_session='2012', ct_semester='all')
1002	result = open(self.outfile, 'rb').read()
1003	self.assertEqual(
1004	result,
1005	'automatic,carry_over,code,course_category,credits,dcode,fcode,level,level_session,'
1006	'mandatory,outstanding,passmark,score,semester,ticket_session,title,student_id,certcode,'
1007	'display_fullname,previous\r\n'
1008	'1,1,CRS1,,100,DEP1,FAC1,100,2012,0,0,100,,2,,Course 1,A111111,CERT1,'
1009	'Anna M. Tester,0\r\n'
1010	)
1011	# Level 200 tickets do not exist.
1012	notify(grok.ObjectModifiedEvent(self.student['studycourse']['100']['CRS1']))
1013	exporter.export_filtered(self.student, self.outfile, ct_level='200')
1014	result = open(self.outfile, 'rb').read()
1015	self.assertEqual(
1016	result,
1017	'automatic,carry_over,code,course_category,credits,dcode,fcode,level,level_session,'
1018	'mandatory,outstanding,passmark,score,semester,ticket_session,title,student_id,certcode,'
1019	'display_fullname,previous\r\n'
1020	)
1021	# Session 2013 tickets do not exist.
1022	notify(grok.ObjectModifiedEvent(self.student['studycourse']['100']['CRS1']))
1023	exporter.export_filtered(self.student, self.outfile,
1024	ct_level='all', ct_session='2013')
1025	result = open(self.outfile, 'rb').read()
1026	self.assertEqual(
1027	result,
1028	'automatic,carry_over,code,course_category,credits,dcode,fcode,level,level_session,'
1029	'mandatory,outstanding,passmark,score,semester,ticket_session,title,student_id,certcode,'
1030	'display_fullname,previous\r\n'
1031	)
1032	# 1st semester tickets do not exist.
1033	notify(grok.ObjectModifiedEvent(self.student['studycourse']['100']['CRS1']))
1034	exporter.export_filtered(self.student, self.outfile,
1035	ct_level='all', ct_session='all', ct_semester='1')
1036	result = open(self.outfile, 'rb').read()
1037	self.assertEqual(
1038	result,
1039	'automatic,carry_over,code,course_category,credits,dcode,fcode,level,level_session,'
1040	'mandatory,outstanding,passmark,score,semester,ticket_session,title,student_id,certcode,'
1041	'display_fullname,previous\r\n'
1042	)
1043	# If the coursetickets catalog is used to filter students
1044	# and (course) code is not None
1045	# only course tickets which belong to this course are exported
1046	exporter.export_filtered(
1047	self.student, self.outfile, catalog='coursetickets', code='CRS1')
1048	result = open(self.outfile, 'rb').read()
1049	self.assertEqual(
1050	result,
1051	'automatic,carry_over,code,course_category,credits,dcode,fcode,level,level_session,'
1052	'mandatory,outstanding,passmark,score,semester,ticket_session,title,student_id,certcode,'
1053	'display_fullname,previous\r\n'
1054	'1,1,CRS1,,100,DEP1,FAC1,100,2012,0,0,100,,2,,Course 1,A111111,CERT1,'
1055	'Anna M. Tester,0\r\n'
1056	)
1057	exporter.export_filtered(
1058	self.student, self.outfile, catalog='coursetickets', code='any code')
1059	result = open(self.outfile, 'rb').read()
1060	self.assertEqual(
1061	result,
1062	'automatic,carry_over,code,course_category,credits,dcode,fcode,level,level_session,'
1063	'mandatory,outstanding,passmark,score,semester,ticket_session,title,student_id,certcode,'
1064	'display_fullname,previous\r\n'
1065	)
1066	# Also tickets in probating levels are exported. Therefore
1067	# we change the level attribute to fake a 110 level.
1068	self.student['studycourse']['100'].level = 110
1069	notify(grok.ObjectModifiedEvent(self.student['studycourse']['100']['CRS1']))
1070	exporter.export_filtered(
1071	self.student, self.outfile, catalog='coursetickets', code='CRS1', level='100')
1072	result = open(self.outfile, 'rb').read()
1073	self.assertEqual(
1074	result,
1075	'automatic,carry_over,code,course_category,credits,dcode,fcode,level,level_session,'
1076	'mandatory,outstanding,passmark,score,semester,ticket_session,title,student_id,certcode,'
1077	'display_fullname,previous\r\n'
1078	'1,1,CRS1,,100,DEP1,FAC1,110,2012,0,0,100,,2,,Course 1,A111111,CERT1,'
1079	'Anna M. Tester,0\r\n'
1080	)
1081	return
1082
1083	class OutstandingCoursesExporterTest(StudentImportExportSetup):
1084
1085	layer = FunctionalLayer
1086
1087	def setUp(self):
1088	super(OutstandingCoursesExporterTest, self).setUp()
1089	self.setup_for_export()
1090	return
1091
1092	def test_ifaces(self):
1093	# make sure we fullfill interface contracts
1094	obj = OutstandingCoursesExporter()
1095	verifyObject(ICSVStudentExporter, obj)
1096	verifyClass(ICSVStudentExporter, OutstandingCoursesExporter)
1097	return
1098
1099	def test_get_as_utility(self):
1100	# we can get an student exporter as utility
1101	result = queryUtility(ICSVExporter, name="outstandingcourses")
1102	self.assertTrue(result is not None)
1103	return
1104
1105	def test_export_all(self):
1106	course1 = Course(u'Cheese Basics', 'C1')
1107	course2 = Course(u'Advanced Cheese Making', 'C2')
1108	course3 = Course(u'Selling Cheese', 'C3')
1109	self.app['faculties']['fac1']['dep1'].courses.addCourse(course1)
1110	self.app['faculties']['fac1']['dep1'].courses.addCourse(course2)
1111	self.app['faculties']['fac1']['dep1'].courses.addCourse(course3)
1112	self.certificate.addCertCourse(course1, 100, True)
1113	self.certificate.addCertCourse(course2, 400, False)
1114	self.certificate.addCertCourse(course3, 100, False)
1115	self.setup_student(self.student)
1116	self.student['studycourse']['100']['C3'].score = 25
1117	exporter = OutstandingCoursesExporter()
1118	exporter.export_all(self.app, self.outfile)
1119	result = open(self.outfile, 'rb').read()
1120	# The only student has registered C1, C3 and CRS1
1121	# She missed C2, has failed C3 and did not
1122	# take C1 and CRS1
1123	self.assertEqual(
1124	result,
1125	'student_id,matric_number,certcode,display_fullname,missed,failed,nottaken\r\n'
1126	'A111111,234,CERT1,Anna M. Tester,C2_400,C3,C1 CRS1\r\n'
1127	)
1128	return
1129
1130	class StudentPaymentExporterTest(StudentImportExportSetup):
1131
1132	layer = FunctionalLayer
1133
1134	def setUp(self):
1135	super(StudentPaymentExporterTest, self).setUp()
1136	self.setup_for_export()
1137	return
1138
1139	def test_ifaces(self):
1140	# make sure we fullfill interface contracts
1141	obj = StudentPaymentExporter()
1142	verifyObject(ICSVStudentExporter, obj)
1143	verifyClass(ICSVStudentExporter, StudentPaymentExporter)
1144	return
1145
1146	def test_get_as_utility(self):
1147	# we can get a payments exporter as utility
1148	result = queryUtility(ICSVExporter, name="studentpayments")
1149	self.assertTrue(result is not None)
1150	return
1151
1152	def test_export_empty(self):
1153	# we can export a nearly empty payment
1154	payment = StudentOnlinePayment()
1155	payment.creation_date = datetime.datetime(2012, 4, 1, 13, 12, 1)
1156	exporter = StudentPaymentExporter()
1157	exporter.export([payment], self.outfile)
1158	result = open(self.outfile, 'rb').read()
1159	self.assertEqual(
1160	result,
1161	'ac,amount_auth,creation_date,p_category,p_combi,p_current,p_id,'
1162	'p_item,p_level,p_session,p_state,payment_date,r_amount_approved,'
1163	'r_code,r_desc,student_id,state,current_session\r\n'
1164
1165	',0.0,2012-04-01 13:12:01#,,[],1,,,,,unpaid,,0.0,,,,,\r\n'
1166	)
1167	return
1168
1169	def test_export(self):
1170	# we can really export student payments.
1171	# set values we can expect in export file
1172	self.setup_student(self.student)
1173	payment = self.student['payments']['my-payment']
1174	exporter = StudentPaymentExporter()
1175	exporter.export([payment], self.outfile)
1176	result = open(self.outfile, 'rb').read()
1177	self.assertEqual(
1178	result,
1179	'ac,amount_auth,creation_date,p_category,p_combi,p_current,p_id,'
1180	'p_item,p_level,p_session,p_state,payment_date,r_amount_approved,'
1181	'r_code,r_desc,student_id,state,current_session\r\n'
1182
1183	'666,12.12,%s-04-01 13:12:01#,schoolfee,[],1,my-id,'
1184	'p-item,100,%s,paid,%s-04-01 14:12:01#,12.12,'
1185	'r-code,,A111111,created,2012\r\n'
1186	% (curr_year-6, curr_year-6, curr_year-6)
1187	)
1188	return
1189
1190	def test_export_all(self):
1191	# we can really export all payments
1192	# set values we can expect in export file
1193	self.setup_student(self.student)
1194	exporter = StudentPaymentExporter()
1195	exporter.export_all(self.app, self.outfile)
1196	result = open(self.outfile, 'rb').read()
1197	self.assertEqual(
1198	result,
1199	'ac,amount_auth,creation_date,p_category,p_combi,p_current,p_id,'
1200	'p_item,p_level,p_session,p_state,payment_date,r_amount_approved,'
1201	'r_code,r_desc,student_id,state,current_session\r\n'
1202
1203	'666,12.12,%s-04-01 13:12:01#,schoolfee,[],1,my-id,'
1204	'p-item,100,%s,paid,%s-04-01 14:12:01#,12.12,'
1205	'r-code,,A111111,created,2012\r\n'
1206	% (curr_year-6, curr_year-6, curr_year-6)
1207	)
1208	return
1209
1210	def test_export_student(self):
1211	# we can really export all payments of a certain student
1212	# set values we can expect in export file
1213	self.setup_student(self.student)
1214	exporter = StudentPaymentExporter()
1215	exporter.export_student(self.student, self.outfile)
1216	result = open(self.outfile, 'rb').read()
1217	self.assertEqual(
1218	result,
1219	'ac,amount_auth,creation_date,p_category,p_combi,p_current,p_id,'
1220	'p_item,p_level,p_session,p_state,payment_date,r_amount_approved,'
1221	'r_code,r_desc,student_id,state,current_session\r\n'
1222
1223	'666,12.12,%s-04-01 13:12:01#,schoolfee,[],1,my-id,'
1224	'p-item,100,%s,paid,%s-04-01 14:12:01#,12.12,'
1225	'r-code,,A111111,created,2012\r\n'
1226	% (curr_year-6, curr_year-6, curr_year-6)
1227	)
1228	return
1229
1230	def test_export_filtered(self):
1231	# we can export payments of a filtered set of students
1232	self.setup_student(self.student)
1233	self.app['students'].addStudent(self.student)
1234	notify(grok.ObjectModifiedEvent(self.student))
1235
1236	exporter = StudentPaymentExporter()
1237	exporter.export_filtered(
1238	self.student, self.outfile, current_level=200)
1239	result = open(self.outfile, 'rb').read()
1240	self.assertEqual(
1241	result,
1242	'ac,amount_auth,creation_date,p_category,p_combi,p_current,p_id,'
1243	'p_item,p_level,p_session,p_state,payment_date,r_amount_approved,'
1244	'r_code,r_desc,student_id,state,current_session\r\n'
1245
1246	'666,12.12,%s-04-01 13:12:01#,schoolfee,[],1,my-id,'
1247	'p-item,100,%s,paid,%s-04-01 14:12:01#,12.12,'
1248	'r-code,,A111111,created,2012\r\n'
1249	% (curr_year-6, curr_year-6, curr_year-6)
1250	)
1251	return
1252
1253	def test_export_filtered_by_date(self):
1254	# payments_start and payments_end are being ignored
1255	self.setup_student(self.student)
1256	self.app['students'].addStudent(self.student)
1257	notify(grok.ObjectModifiedEvent(self.student))
1258	exporter = StudentPaymentExporter()
1259	# A key xxx does not exist
1260	self.assertRaises(
1261	KeyError, exporter.export_filtered, self.app, self.outfile,
1262	current_session=None,
1263	current_level=None, xxx='nonsense')
1264	# payments_start and payments_end do exist but must match format '%Y-%m-%d'
1265	self.assertRaises(
1266	ValueError, exporter.export_filtered, self.app, self.outfile,
1267	current_session=None, current_level=None,
1268	payments_start='nonsense', payments_end='nonsense')
1269	# If they match the format they are ignored by get_filtered and the
1270	# exporter works properly.
1271	# Attention: End day is included!
1272	exporter.export_filtered(
1273	self.app, self.outfile,
1274	current_session=None, current_level=None,
1275	payments_start='01/04/%s' % (curr_year-6),
1276	payments_end='01/04/%s' % (curr_year-6))
1277	result = open(self.outfile, 'rb').read()
1278	self.assertEqual(
1279	result,
1280	'ac,amount_auth,creation_date,p_category,p_combi,p_current,p_id,'
1281	'p_item,p_level,p_session,p_state,payment_date,r_amount_approved,'
1282	'r_code,r_desc,student_id,state,current_session\r\n'
1283
1284	'666,12.12,%s-04-01 13:12:01#,schoolfee,[],1,my-id,'
1285	'p-item,100,%s,paid,%s-04-01 14:12:01#,12.12,'
1286	'r-code,,A111111,created,2012\r\n'
1287	% (curr_year-6, curr_year-6, curr_year-6)
1288	)
1289	# Payment date is 2012-04-01, 14:12:01.
1290	# No results if payment_date is outside the given period.
1291	exporter.export_filtered(
1292	self.app, self.outfile,
1293	current_session=None, current_level=None,
1294	payments_start='30/03/2012', payments_end='31/03/2012')
1295	result = open(self.outfile, 'rb').read()
1296	self.assertEqual(
1297	result,
1298	'ac,amount_auth,creation_date,p_category,p_combi,p_current,p_id,'
1299	'p_item,p_level,p_session,p_state,payment_date,r_amount_approved,'
1300	'r_code,r_desc,student_id,state,current_session\r\n'
1301	)
1302	exporter.export_filtered(
1303	self.app, self.outfile,
1304	current_session=None, current_level=None,
1305	payments_start='02/04/2012', payments_end='03/04/2012')
1306	result = open(self.outfile, 'rb').read()
1307	self.assertEqual(
1308	result,
1309	'ac,amount_auth,creation_date,p_category,p_combi,p_current,p_id,'
1310	'p_item,p_level,p_session,p_state,payment_date,r_amount_approved,'
1311	'r_code,r_desc,student_id,state,current_session\r\n'
1312	)
1313	# No results if payment_date is not set
1314	self.payment.payment_date = None
1315	exporter.export_filtered(
1316	self.app, self.outfile,
1317	current_session=None, current_level=None,
1318	payments_start='31/03/2012', payments_end='02/04/2012')
1319	result = open(self.outfile, 'rb').read()
1320	self.assertEqual(
1321	result,
1322	'ac,amount_auth,creation_date,p_category,p_combi,p_current,p_id,'
1323	'p_item,p_level,p_session,p_state,payment_date,r_amount_approved,'
1324	'r_code,r_desc,student_id,state,current_session\r\n'
1325	)
1326	return
1327
1328	class StudentTrimmedPaymentExporterTest(StudentImportExportSetup):
1329
1330	layer = FunctionalLayer
1331
1332	def setUp(self):
1333	super(StudentTrimmedPaymentExporterTest, self).setUp()
1334	self.setup_for_export()
1335	return
1336
1337	def test_ifaces(self):
1338	# make sure we fullfill interface contracts
1339	obj = StudentTrimmedPaymentExporter()
1340	verifyObject(ICSVStudentExporter, obj)
1341	verifyClass(ICSVStudentExporter, StudentTrimmedPaymentExporter)
1342	return
1343
1344	def test_get_as_utility(self):
1345	# we can get a payments exporter as utility
1346	result = queryUtility(ICSVExporter, name="trimmedpayments")
1347	self.assertTrue(result is not None)
1348	return
1349
1350	def test_export_all(self):
1351	# we can really export all payments
1352	# set values we can expect in export file
1353	self.setup_student(self.student)
1354	exporter = StudentTrimmedPaymentExporter()
1355	exporter.export_all(self.app, self.outfile)
1356	result = open(self.outfile, 'rb').read()
1357	self.assertEqual(
1358	result,
1359	'amount_auth,creation_date,p_category,p_combi,p_current,'
1360	'p_id,p_item,p_level,p_session,p_state,payment_date,'
1361	'r_amount_approved,r_code,r_desc,student_id,faccode,'
1362	'depcode,state,current_session\r\n'
1363
1364	'12.12,%s-04-01 13:12:01#,schoolfee,[],1,my-id,p-item,'
1365	'100,%s,paid,%s-04-01 14:12:01#,12.12,r-code,,'
1366	'A111111,NA,NA,created,2012\r\n'
1367	% (curr_year-6, curr_year-6, curr_year-6)
1368	)
1369	return
1370
1371
1372	class UnpaidPaymentsExporterTest(StudentImportExportSetup):
1373
1374	layer = FunctionalLayer
1375
1376	def setUp(self):
1377	super(UnpaidPaymentsExporterTest, self).setUp()
1378	self.setup_for_export()
1379	return
1380
1381	def test_export_all(self):
1382	# we can really export all payments
1383	# set values we can expect in export file
1384	self.setup_student(self.student)
1385	exporter = UnpaidPaymentsExporter()
1386	exporter.export_all(self.app, self.outfile)
1387	result = open(self.outfile, 'rb').read()
1388	# No unpaid ticket exists
1389	self.assertEqual(
1390	result,
1391	'ac,amount_auth,creation_date,p_category,p_combi,p_current,p_id,'
1392	'p_item,p_level,p_session,p_state,payment_date,r_amount_approved,'
1393	'r_code,r_desc,student_id,state,current_session\r\n'
1394	)
1395	# Make ticket unpaid
1396	self.payment.p_state = 'unpaid'
1397	exporter.export_all(self.app, self.outfile)
1398	result = open(self.outfile, 'rb').read()
1399	self.assertEqual(
1400	result,
1401	'ac,amount_auth,creation_date,p_category,p_combi,p_current,p_id,'
1402	'p_item,p_level,p_session,p_state,payment_date,r_amount_approved,'
1403	'r_code,r_desc,student_id,state,current_session\r\n'
1404
1405	'666,12.12,%s-04-01 13:12:01#,schoolfee,[],1,my-id,'
1406	'p-item,100,%s,unpaid,%s-04-01 14:12:01#,12.12,'
1407	'r-code,,A111111,created,2012\r\n'
1408	% (curr_year-6, curr_year-6, curr_year-6)
1409	)
1410	return
1411
1412	class BursaryDataExporterTest(StudentImportExportSetup):
1413
1414	layer = FunctionalLayer
1415
1416	def setUp(self):
1417	super(BursaryDataExporterTest, self).setUp()
1418	self.setup_for_export()
1419	return
1420
1421	def test_export_all(self):
1422	# we can really export all payments
1423	# set values we can expect in export file
1424	self.setup_student(self.student)
1425	exporter = DataForBursaryExporter()
1426	exporter.export_all(self.app, self.outfile)
1427	result = open(self.outfile, 'rb').read()
1428	self.assertEqual(
1429	result,
1430	'ac,amount_auth,creation_date,p_category,p_combi,p_current,p_id,p_item,'
1431	'p_level,p_session,p_state,payment_date,r_amount_approved,r_code,'
1432	'r_desc,student_id,matric_number,reg_number,firstname,middlename,lastname,'
1433	'sex,state,current_session,entry_session,entry_mode,faccode,depcode,certcode\r\n'
1434
1435	'666,12.12,%s-04-01 13:12:01#,schoolfee,[],1,my-id,p-item,100,%s,'
1436	'paid,%s-04-01 14:12:01#,12.12,r-code,,A111111,234,123,'
1437	'Anna,M.,Tester,f,created,2012,2010,ug_ft,NA,NA,CERT1\r\n'
1438	% (curr_year-6, curr_year-6, curr_year-6)
1439	)
1440	return
1441
1442	class AccommodationPaymentsExporterTest(StudentImportExportSetup):
1443
1444	layer = FunctionalLayer
1445
1446	def setUp(self):
1447	super(AccommodationPaymentsExporterTest, self).setUp()
1448	self.setup_for_export()
1449	return
1450
1451	def test_export_all(self):
1452	self.setup_student(self.student)
1453	# add accommodation payments
1454	payment = StudentOnlinePayment()
1455	payment.creation_date = datetime.datetime(curr_year-6, 4, 1, 13, 12, 1)
1456	payment.p_id = 'id1'
1457	payment.p_category = u'bed_allocation'
1458	payment.p_state = 'paid'
1459	payment.ac = u'abc'
1460	payment.p_item = u'xyz'
1461	payment.p_level = 100
1462	payment.p_session = curr_year - 6
1463	payment.payment_date = datetime.datetime(curr_year-6, 4, 1, 14, 12, 1)
1464	payment.amount_auth = 12.12
1465	payment.r_amount_approved = 12.12
1466	payment.r_code = u'cde'
1467	payment2 = StudentOnlinePayment()
1468	payment2.creation_date = datetime.datetime(curr_year-6, 4, 1, 13, 12, 1)
1469	payment2.p_id = 'id2'
1470	payment2.p_category = u'hostel_maintenance'
1471	payment2.p_state = 'paid'
1472	payment2.ac = u'abc'
1473	payment2.p_item = u'xyz'
1474	payment2.p_level = 100
1475	payment2.p_session = curr_year - 6
1476	payment2.payment_date = datetime.datetime(curr_year-6, 4, 1, 14, 12, 1)
1477	payment2.amount_auth = 12.12
1478	payment2.r_amount_approved = 12.12
1479	payment2.r_code = u'cde'
1480	# XXX: there is no addPayment method to give predictable names
1481	self.payment = self.student['payments']['id1'] = payment
1482	self.payment = self.student['payments']['id2'] = payment2
1483	exporter = AccommodationPaymentsExporter()
1484	exporter.export_all(self.app, self.outfile)
1485	result = open(self.outfile, 'rb').read()
1486	# only accommodation payments are exported
1487	self.assertEqual(
1488	result,
1489	'ac,amount_auth,creation_date,p_category,p_combi,p_current,p_id,p_item,'
1490	'p_level,p_session,p_state,payment_date,r_amount_approved,r_code,'
1491	'r_desc,student_id,matric_number,reg_number,firstname,middlename,lastname,sex,'
1492	'state,current_session,entry_session,entry_mode,faccode,depcode,certcode\r\n'
1493	'abc,12.12,%s-04-01 13:12:01#,bed_allocation,[],1,id1,xyz,100,%s,'
1494	'paid,%s-04-01 14:12:01#,12.12,cde,,A111111,234,123,'
1495	'Anna,M.,Tester,f,created,2012,2010,ug_ft,NA,NA,CERT1\r\n'
1496	'abc,12.12,%s-04-01 13:12:01#,hostel_maintenance,[],1,id2,xyz,100,%s,'
1497	'paid,%s-04-01 14:12:01#,12.12,cde,,A111111,234,123,'
1498	'Anna,M.,Tester,f,created,2012,2010,ug_ft,NA,NA,CERT1\r\n'
1499	% (curr_year-6, curr_year-6, curr_year-6,
1500	curr_year-6, curr_year-6, curr_year-6)
1501	)
1502	return
1503
1504	class BedTicketExporterTest(StudentImportExportSetup):
1505
1506	layer = FunctionalLayer
1507
1508	def setUp(self):
1509	super(BedTicketExporterTest, self).setUp()
1510	self.setup_for_export()
1511	return
1512
1513	def test_ifaces(self):
1514	# make sure we fullfill interface contracts
1515	obj = BedTicketExporter()
1516	verifyObject(ICSVStudentExporter, obj)
1517	verifyClass(ICSVStudentExporter, BedTicketExporter)
1518	return
1519
1520	def test_get_as_utility(self):
1521	# we can get a bedtickets exporter as utility
1522	result = queryUtility(ICSVExporter, name="bedtickets")
1523	self.assertTrue(result is not None)
1524	return
1525
1526	def test_export_empty(self):
1527	# we can export a nearly empty bedticket
1528	bedticket = BedTicket()
1529	bed = self.app['hostels']['hall-1']['hall-1_A_101_A']
1530	bedticket.bed = bed
1531	exporter = BedTicketExporter()
1532	exporter.export([bedticket], self.outfile)
1533	result = open(self.outfile, 'rb').read()
1534	self.assertMatches(
1535	result,
1536	'bed,bed_coordinates,bed_type,booking_code,booking_date,'
1537	'booking_session,student_id,actual_bed_type\r\n'
1538	'hall-1_A_101_A,,,,<YYYY-MM-DD hh:mm:ss>.<6-DIGITS>#,,,regular_male_fr\r\n'
1539	)
1540	return
1541
1542	def test_export(self):
1543	# we can really export student bedtickets.
1544	# set values we can expect in export file
1545	self.setup_student(self.student)
1546	bedticket = self.student['accommodation']['2004']
1547	exporter = BedTicketExporter()
1548	exporter.export([bedticket], self.outfile)
1549	result = open(self.outfile, 'rb').read()
1550	self.assertMatches(
1551	result,
1552	'bed,bed_coordinates,bed_type,booking_code,booking_date,'
1553	'booking_session,student_id,actual_bed_type\r\n'
1554	'hall-1_A_101_A,,any bed type,,<YYYY-MM-DD hh:mm:ss>.<6-DIGITS>#,2004,'
1555	'A111111,regular_male_fr\r\n'
1556	)
1557	return
1558
1559	def test_export_all(self):
1560	# we can really export all bedtickets
1561	# set values we can expect in export file
1562	self.setup_student(self.student)
1563	exporter = BedTicketExporter()
1564	exporter.export_all(self.app, self.outfile)
1565	result = open(self.outfile, 'rb').read()
1566	self.assertMatches(
1567	result,
1568	'bed,bed_coordinates,bed_type,booking_code,booking_date,'
1569	'booking_session,student_id,actual_bed_type\r\n'
1570	'hall-1_A_101_A,,any bed type,,<YYYY-MM-DD hh:mm:ss>.<6-DIGITS>#,2004,'
1571	'A111111,regular_male_fr\r\n'
1572	)
1573	return
1574
1575	def test_export_student(self):
1576	# we can really export all bedtickets of a certain student
1577	# set values we can expect in export file
1578	self.setup_student(self.student)
1579	exporter = BedTicketExporter()
1580	exporter.export_student(self.student, self.outfile)
1581	result = open(self.outfile, 'rb').read()
1582	self.assertMatches(
1583	result,
1584	'bed,bed_coordinates,bed_type,booking_code,booking_date,'
1585	'booking_session,student_id,actual_bed_type\r\n'
1586	'hall-1_A_101_A,,any bed type,,<YYYY-MM-DD hh:mm:ss>.<6-DIGITS>#,2004,'
1587	'A111111,regular_male_fr\r\n'
1588	)
1589	return
1590
1591	def test_export_filtered(self):
1592	# we can export payments of a filtered set of students
1593	self.setup_student(self.student)
1594	self.app['students'].addStudent(self.student)
1595	notify(grok.ObjectModifiedEvent(self.student))
1596
1597	exporter = BedTicketExporter()
1598	exporter.export_filtered(
1599	self.student, self.outfile, current_level=200)
1600	result = open(self.outfile, 'rb').read()
1601	self.assertMatches(
1602	result,
1603	'bed,bed_coordinates,bed_type,booking_code,booking_date,'
1604	'booking_session,student_id,actual_bed_type\r\n'
1605	'hall-1_A_101_A,,any bed type,,<YYYY-MM-DD hh:mm:ss>.<6-DIGITS>#,'
1606	'2004,A111111,regular_male_fr\r\n')
1607	return
1608
1609
1610	class SchoolFeePaymentsOverviewExporterTest(StudentImportExportSetup):
1611
1612	layer = FunctionalLayer
1613
1614	def setUp(self):
1615	super(SchoolFeePaymentsOverviewExporterTest, self).setUp()
1616	self.setup_for_export()
1617	return
1618
1619	def test_ifaces(self):
1620	# make sure we fullfill interface contracts
1621	obj = SchoolFeePaymentsOverviewExporter()
1622	verifyObject(ICSVStudentExporter, obj)
1623	verifyClass(ICSVStudentExporter, SchoolFeePaymentsOverviewExporter)
1624	return
1625
1626	def test_get_as_utility(self):
1627	# we can get a payments exporter as utility
1628	result = queryUtility(ICSVExporter, name="sfpaymentsoverview")
1629	self.assertTrue(result is not None)
1630	return
1631
1632	def test_export(self):
1633	self.setup_student(self.student)
1634	exporter = SchoolFeePaymentsOverviewExporter()
1635	exporter.export([self.student], self.outfile)
1636	result = open(self.outfile, 'rb').read()
1637	self.assertTrue(
1638	'student_id,matric_number,display_fullname,state,certcode,'
1639	'faccode,depcode,is_postgrad,'
1640	'current_level,current_session,current_mode,entry_session,'
1641	'reg_number,%s\r\n'
1642	'A111111,234,Anna M. Tester,created,CERT1,NA,NA,0,'
1643	'200,2012,ug_ft,2010,'
1644	% year_range_str in result
1645	)
1646	return
1647
1648	def test_export_all(self):
1649	# we can really export students
1650	# set values we can expect in export file
1651	self.setup_student(self.student)
1652	# We add successful payments.
1653	payment_2 = StudentOnlinePayment()
1654	payment_2.p_id = 'my-id'
1655	payment_2.p_session = curr_year - 5
1656	payment_2.amount_auth = 13.13
1657	payment_2.p_state = 'paid'
1658	payment_2.p_category = u'schoolfee'
1659	self.student['payments']['my-2ndpayment'] = payment_2
1660	# This one could be a balance payment.
1661	# The amount is being added.
1662	payment_3 = StudentOnlinePayment()
1663	payment_3.p_id = 'my-id_2'
1664	payment_3.p_session = curr_year - 5
1665	payment_3.amount_auth = 1.01
1666	payment_3.p_state = 'paid'
1667	payment_3.p_category = u'schoolfee'
1668	self.student['payments']['my-3rdpayment'] = payment_3
1669	# One session school fee has been waived
1670	payment_4 = StudentOnlinePayment()
1671	payment_4.p_id = 'my-id_2'
1672	payment_4.p_session = curr_year - 4
1673	payment_4.amount_auth = 1.01
1674	payment_4.p_state = 'waived'
1675	payment_4.p_category = u'schoolfee'
1676	self.student['payments']['my-4thpayment'] = payment_4
1677	exporter = SchoolFeePaymentsOverviewExporter()
1678	exporter.export_all(self.app, self.outfile)
1679	result = open(self.outfile, 'rb').read()
1680	self.assertTrue(
1681	'student_id,matric_number,display_fullname,state,'
1682	'certcode,faccode,depcode,is_postgrad,'
1683	'current_level,current_session,current_mode,entry_session,'
1684	'reg_number,%s\r\nA111111,234,Anna M. Tester,created,CERT1,NA,NA,0,'
1685	'200,2012,ug_ft,2010,123,,,,,,12.12,14.14,waived,,,,\r\n'
1686	% year_range_str in result
1687	)
1688	return
1689
1690	class SessionPaymentsOverviewExporterTest(StudentImportExportSetup):
1691
1692	layer = FunctionalLayer
1693
1694	def setUp(self):
1695	super(SessionPaymentsOverviewExporterTest, self).setUp()
1696	self.setup_for_export()
1697	paycats = ('schoolfee', 'clearance', 'gown', 'transcript')
1698	paycatyears = ''
1699	grok.getSite()['configuration'].current_academic_session = curr_year - 4
1700	year_range = range(curr_year-6, curr_year-3)
1701	year_range_tuple = tuple([str(year)[2:] for year in year_range])
1702	for cat in paycats:
1703	for year in year_range_tuple:
1704	paycatyears += '%s,'%(cat+str(year))
1705	self.paycatyears = paycatyears.strip(',')
1706	return
1707
1708	def test_ifaces(self):
1709	# make sure we fullfill interface contracts
1710	obj = SessionPaymentsOverviewExporter()
1711	verifyObject(ICSVStudentExporter, obj)
1712	verifyClass(ICSVStudentExporter, SessionPaymentsOverviewExporter)
1713	return
1714
1715	def test_get_as_utility(self):
1716	# we can get a payments exporter as utility
1717	result = queryUtility(ICSVExporter, name="sessionpaymentsoverview")
1718	self.assertTrue(result is not None)
1719	return
1720
1721	def test_export(self):
1722	self.setup_student(self.student)
1723	exporter = SessionPaymentsOverviewExporter()
1724	exporter.export([self.student], self.outfile)
1725	result = open(self.outfile, 'rb').read()
1726	self.assertTrue(
1727	'student_id,matric_number,display_fullname,state,certcode,'
1728	'faccode,depcode,is_postgrad,current_level,current_session,'
1729	'current_mode,entry_session,reg_number,%s\r\n'
1730	'A111111,234,Anna M. Tester,created,CERT1,NA,NA,0,200,'
1731	'2012,ug_ft,2010,123,'
1732	'12.12,,,,,,,,,,,\r\n' %self.paycatyears in result
1733	)
1734	return
1735
1736	def test_export_all(self):
1737	self.setup_student(self.student)
1738	# We add successful payments.
1739	payment_2 = StudentOnlinePayment()
1740	payment_2.p_id = 'my-id'
1741	payment_2.p_session = curr_year - 5
1742	payment_2.amount_auth = 13.13
1743	payment_2.p_state = 'paid'
1744	payment_2.p_category = u'schoolfee'
1745	self.student['payments']['my-2ndpayment'] = payment_2
1746	# This one could be a balance payment.
1747	# The amount is being added.
1748	payment_3 = StudentOnlinePayment()
1749	payment_3.p_id = 'my-id_2'
1750	payment_3.p_session = curr_year - 5
1751	payment_3.amount_auth = 1.01
1752	payment_3.p_state = 'paid'
1753	payment_3.p_category = u'schoolfee'
1754	self.student['payments']['my-3rdpayment'] = payment_3
1755	# One session school fee has been waived
1756	payment_4 = StudentOnlinePayment()
1757	payment_4.p_id = 'my-id_2'
1758	payment_4.p_session = curr_year - 4
1759	payment_4.amount_auth = 1.01
1760	payment_4.p_state = 'waived'
1761	payment_4.p_category = u'schoolfee'
1762	self.student['payments']['my-4thpayment'] = payment_4
1763	exporter = SessionPaymentsOverviewExporter()
1764	exporter.export_all(self.app, self.outfile)
1765	result = open(self.outfile, 'rb').read()
1766	self.assertTrue(
1767	'student_id,matric_number,display_fullname,state,certcode,faccode,'
1768	'depcode,is_postgrad,current_level,current_session,'
1769	'current_mode,entry_session,reg_number,%s\r\n'
1770	'A111111,234,Anna M. Tester,created,CERT1,NA,NA,0,200,2012,ug_ft,'
1771	'2010,123,'
1772	'12.12,14.14,1.01,,,,,,,,,\r\n'
1773	%self.paycatyears in result
1774	)
1775	return
1776
1777	class StudyLevelsOverviewExporterTest(StudentImportExportSetup):
1778
1779	layer = FunctionalLayer
1780
1781	def setUp(self):
1782	super(StudyLevelsOverviewExporterTest, self).setUp()
1783	self.setup_for_export()
1784	return
1785
1786	def test_ifaces(self):
1787	obj = StudyLevelsOverviewExporter()
1788	verifyObject(ICSVStudentExporter, obj)
1789	verifyClass(ICSVStudentExporter, StudyLevelsOverviewExporter)
1790	return
1791
1792	def test_get_as_utility(self):
1793	result = queryUtility(ICSVExporter, name="studylevelsoverview")
1794	self.assertTrue(result is not None)
1795	return
1796
1797	def test_export(self):
1798	self.setup_student(self.student)
1799	exporter = StudyLevelsOverviewExporter()
1800	exporter.export([self.student], self.outfile)
1801	result = open(self.outfile, 'rb').read()
1802	self.assertEqual(
1803	'student_id,state,certcode,faccode,depcode,is_postgrad,'
1804	'entry_session,current_level,current_session,'
1805	'0,10,100,110,120,200,210,220,300,310,320,400,410,420,500,'
1806	'510,520,600,610,620,700,710,720,800,810,820,900,910,920,999,1000\r\n'
1807	'A111111,created,CERT1,NA,NA,0,2010,200,2012,,,2012'
1808	',,,,,,,,,,,,,,,,,,,,,,,,,,,,\r\n',
1809	result
1810	)
1811	return
1812
1813	def test_export_all(self):
1814	self.setup_student(self.student)
1815	exporter = StudyLevelsOverviewExporter()
1816	exporter.export_all(self.app, self.outfile)
1817	result = open(self.outfile, 'rb').read()
1818	self.assertEqual(
1819	'student_id,state,certcode,faccode,depcode,is_postgrad,'
1820	'entry_session,current_level,current_session,'
1821	'0,10,100,110,120,200,210,220,300,310,320,400,410,420,500,'
1822	'510,520,600,610,620,700,710,720,800,810,820,900,910,920,999,1000\r\n'
1823	'A111111,created,CERT1,NA,NA,0,2010,200,2012,,,2012'
1824	',,,,,,,,,,,,,,,,,,,,,,,,,,,,\r\n',
1825	result
1826	)
1827	return
1828
1829	class ComboCardExporterTest(StudentImportExportSetup):
1830
1831	layer = FunctionalLayer
1832
1833	def setUp(self):
1834	super(ComboCardExporterTest, self).setUp()
1835	self.setup_for_export()
1836	return
1837
1838	def create_passport_img(self, student):
1839	# create some passport file for `student`
1840	storage = getUtility(IExtFileStore)
1841	image_path = os.path.join(os.path.dirname(__file__), 'test_image.jpg')
1842	self.image_contents = open(image_path, 'rb').read()
1843	file_id = IFileStoreNameChooser(student).chooseName(
1844	attr='passport.jpg')
1845	storage.createFile(file_id, StringIO(self.image_contents))
1846
1847	def test_export_all(self):
1848	self.setup_student(self.student)
1849	self.create_passport_img(self.student)
1850	exporter = ComboCardDataExporter()
1851	exporter.export_all(self.app, self.outfile)
1852	result = open(self.outfile, 'rb').read()
1853	self.assertTrue(
1854	'display_fullname,student_id,matric_number,certificate,faculty,'
1855	'department,passport_path\r\nAnna M. Tester,A111111,234,'
1856	'Unnamed Certificate,Faculty of Unnamed Faculty (NA),'
1857	'Department of Unnamed Department (NA),'
1858	'students/00110/A111111/passport_A111111.jpg\r\n'
1859	in result
1860	)
1861	return
1862
1863	class TranscriptDataExporterTest(StudentImportExportSetup):
1864
1865	layer = FunctionalLayer
1866
1867	def setUp(self):
1868	super(TranscriptDataExporterTest, self).setUp()
1869	self.setup_for_export()
1870	return
1871
1872	def test_export_all(self):
1873	self.setup_student(self.student)
1874	study_course = self.student.get('studycourse')
1875	study_level = study_course[study_course.keys()[0]]
1876	ticket = study_level['CRS1']
1877	ticket.score = 20
1878	exporter = TranscriptDataExporter()
1879	exporter.export_all(self.app, self.outfile)
1880	result = open(self.outfile, 'rb').read()
1881	self.assertTrue(
1882	'student_id,state,certcode,faccode,depcode,entry_session,'
1883	'current_level,current_session,transcript_data\r\n'
1884	'A111111,created,CERT1,NA,NA,2010,200,2012,'
1885	'Level 100; 1st: ; 2nd: CRS1; 3rd: ; sgpa: 0.0\r\n'
1886	in result
1887	)
1888	return

Note: See TracBrowser for help on using the repository browser.

Context navigation

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

Download in other formats: