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

import grok
import datetime
from zope.component import queryUtility
from zope.event import notify
from zope.interface.verify import verifyObject, verifyClass
from waeup.kofa.interfaces import ICSVExporter
from waeup.kofa.students.export import (
    StudentsExporter, StudentStudyCourseExporter, StudentStudyLevelExporter,
    CourseTicketExporter, PaymentsExporter, BedTicketsExporter,
    StudentPaymentsOverviewExporter, StudentStudyLevelsOverviewExporter,
    get_students, StudentsExportFilter)
from waeup.kofa.students.accommodation import BedTicket
from waeup.kofa.students.interfaces import ICSVStudentExporter
from waeup.kofa.students.payments import StudentOnlinePayment
from waeup.kofa.students.student import Student
from waeup.kofa.students.studycourse import StudentStudyCourse
from waeup.kofa.students.studylevel import StudentStudyLevel, CourseTicket
from waeup.kofa.students.tests.test_batching import StudentImportExportSetup
from waeup.kofa.testing import FunctionalLayer

curr_year = datetime.datetime.now().year
year_range = range(curr_year - 9, curr_year + 1)
year_range_str = ','.join([str(i) for i in year_range])

class ExportHelperTests(StudentImportExportSetup):
    layer = FunctionalLayer
    def setUp(self):
        super(ExportHelperTests, self).setUp()
        student = Student()
        self.app['students'].addStudent(student)
        student = self.setup_student(student)
        notify(grok.ObjectModifiedEvent(student))
        self.student = self.app['students'][student.student_id]
        return

    def test_get_students_plain(self):
        # without a filter we get all students
        result = get_students(self.app)
        self.assertEqual(len(list(result)), 1)
        return

    def test_get_students_by_session(self):
        # we can filter out students of a certain session
        my_filter1 = StudentsExportFilter(session=2012)
        result = get_students(self.app, stud_filter=my_filter1)
        self.assertEqual(len(list(result)), 1)

        my_filter2 = StudentsExportFilter(session=1964)
        result = get_students(self.app, stud_filter=my_filter2)
        self.assertEqual(len(list(result)), 0)
        return

    def test_get_students_by_level(self):
        # we can filter out students of a certain level
        my_filter1 = StudentsExportFilter(level=200)
        result = get_students(self.app, stud_filter=my_filter1)
        self.assertEqual(len(list(result)), 1)

        my_filter2 = StudentsExportFilter(level=300)
        result = get_students(self.app, stud_filter=my_filter2)
        self.assertEqual(len(list(result)), 0)
        return

class StudentsExporterTest(StudentImportExportSetup):

    layer = FunctionalLayer

    def setUp(self):
        super(StudentsExporterTest, self).setUp()
        self.setup_for_export()
        return

    def test_ifaces(self):
        # make sure we fullfill interface contracts
        obj = StudentsExporter()
        verifyObject(ICSVStudentExporter, obj)
        verifyClass(ICSVStudentExporter, StudentsExporter)
        return

    def test_get_as_utility(self):
        # we can get an student exporter as utility
        result = queryUtility(ICSVExporter, name="students")
        self.assertTrue(result is not None)
        return

    def test_export(self):
        # we can really export students
        # set values we can expect in export file
        self.setup_student(self.student)
        exporter = StudentsExporter()
        exporter.export([self.student], self.outfile)
        result = open(self.outfile, 'rb').read()
        self.assertTrue(
            'adm_code,clearance_locked,clr_code,date_of_birth,email,employer,'
            'firstname,lastname,matric_number,middlename,nationality,officer_comment,'
            'perm_address,personal_updated,'
            'phone,reg_number,sex,student_id,suspended,suspended_comment,password,'
            'state,history,certcode,is_postgrad,current_level,current_session\r\n'

            'my adm code,0,my clr code,1981-02-04#,anna@sample.com,,'
            'Anna,Tester,234,M.,NG,,"Studentroad 21\nLagos 123456\n",,'
            '+234-123-12345#,123,f,A111111,0,,,created'
            in result
            )
        return

    def test_export_all(self):
        # we can really export students
        # set values we can expect in export file
        self.setup_student(self.student)
        exporter = StudentsExporter()
        exporter.export_all(self.app, self.outfile)
        result = open(self.outfile, 'rb').read()
        self.assertTrue(
            'adm_code,clearance_locked,clr_code,date_of_birth,email,employer,'
            'firstname,lastname,matric_number,middlename,nationality,officer_comment,'
            'perm_address,personal_updated'
            ',phone,reg_number,sex,student_id,suspended,suspended_comment,password,'
            'state,history,certcode,is_postgrad,current_level,current_session\r\n'

            'my adm code,0,my clr code,1981-02-04#,anna@sample.com,,'
            'Anna,Tester,234,M.,NG,,"Studentroad 21\nLagos 123456\n",,'
            '+234-123-12345#,123,f,A111111,0,,,created'
            in result
            )
        return

    def test_export_student(self):
        # we can export a single student
        self.setup_student(self.student)
        exporter = StudentsExporter()
        exporter.export_student(self.student, self.outfile)
        result = open(self.outfile, 'rb').read()
        self.assertTrue(
            'adm_code,clearance_locked,clr_code,date_of_birth,email,employer,'
            'firstname,lastname,matric_number,middlename,nationality,officer_comment,'
            'perm_address,personal_updated'
            ',phone,reg_number,sex,student_id,suspended,suspended_comment,password,'
            'state,history,certcode,is_postgrad,current_level,current_session\r\n'

            'my adm code,0,my clr code,1981-02-04#,anna@sample.com,,'
            'Anna,Tester,234,M.,NG,,"Studentroad 21\nLagos 123456\n",,'
            '+234-123-12345#,123,f,A111111,0,,,created'
            in result
            )
        return


class StudentStudyCourseExporterTest(StudentImportExportSetup):

    layer = FunctionalLayer

    def setUp(self):
        super(StudentStudyCourseExporterTest, self).setUp()
        self.setup_for_export()
        return

    def test_ifaces(self):
        # make sure we fullfill interface contracts
        obj = StudentStudyCourseExporter()
        verifyObject(ICSVExporter, obj)
        verifyClass(ICSVExporter, StudentStudyCourseExporter)
        return

    def test_get_as_utility(self):
        # we can get an student exporter as utility
        result = queryUtility(ICSVExporter, name="studentstudycourses")
        self.assertTrue(result is not None)
        return

    def test_export_empty(self):
        # we can export a nearly empty study course
        study_course = StudentStudyCourse()
        exporter = StudentStudyCourseExporter()
        exporter.export([study_course], self.outfile)
        result = open(self.outfile, 'rb').read()
        self.assertEqual(
            result,
            'certificate,current_level,current_session,current_verdict,'
            'entry_mode,entry_session,previous_verdict,student_id\r\n'

            ',,,0,,,0,\r\n'
            )
        return

    def test_export(self):
        # we can really export study courses.
        # set values we can expect in export file
        self.setup_student(self.student)
        study_course = self.student.get('studycourse')
        exporter = StudentStudyCourseExporter()
        exporter.export([study_course], self.outfile)
        result = open(self.outfile, 'rb').read()
        self.assertEqual(
            result,
            'certificate,current_level,current_session,current_verdict,'
            'entry_mode,entry_session,previous_verdict,student_id\r\n'

            'CERT1,200,2012,0,ug_ft,2010,0,A111111\r\n'
            )
        return

    def test_export_all(self):
        # we can really export students
        # set values we can expect in export file
        self.setup_student(self.student)
        exporter = StudentStudyCourseExporter()
        exporter.export_all(self.app, self.outfile)
        result = open(self.outfile, 'rb').read()
        self.assertEqual(
            result,
            'certificate,current_level,current_session,current_verdict,'
            'entry_mode,entry_session,previous_verdict,student_id\r\n'

            'CERT1,200,2012,0,ug_ft,2010,0,A111111\r\n'
            )
        return

    def test_export_student(self):
        # we can export studycourse of a certain student
        self.setup_student(self.student)
        exporter = StudentStudyCourseExporter()
        exporter.export_student(self.student, self.outfile)
        result = open(self.outfile, 'rb').read()
        self.assertEqual(
            result,
            'certificate,current_level,current_session,current_verdict,'
            'entry_mode,entry_session,previous_verdict,student_id\r\n'

            'CERT1,200,2012,0,ug_ft,2010,0,A111111\r\n'
            )
        return

class StudentStudyLevelExporterTest(StudentImportExportSetup):

    layer = FunctionalLayer

    def setUp(self):
        super(StudentStudyLevelExporterTest, self).setUp()
        self.setup_for_export()
        return

    def test_ifaces(self):
        # make sure we fullfill interface contracts
        obj = StudentStudyLevelExporter()
        verifyObject(ICSVExporter, obj)
        verifyClass(ICSVExporter, StudentStudyLevelExporter)
        return

    def test_get_as_utility(self):
        # we can get an student exporter as utility
        result = queryUtility(ICSVExporter, name="studentstudylevels")
        self.assertTrue(result is not None)
        return

    def test_export_empty(self):
        # we can export a nearly empty study level
        study_level = StudentStudyLevel()
        exporter = StudentStudyLevelExporter()
        exporter.export([study_level], self.outfile)
        result = open(self.outfile, 'rb').read()
        self.assertEqual(
            result,
            'gpa,level,level_session,level_verdict,total_credits,'
            'validated_by,validation_date,'
            'student_id,number_of_tickets,certcode\r\n'
            '0.0,,,0,0,,,,0,\r\n'
            )
        return

    def test_export(self):
        # we can really export study levels.
        # set values we can expect in export file
        self.setup_student(self.student)
        study_course = self.student.get('studycourse')
        study_level = study_course[study_course.keys()[0]]
        exporter = StudentStudyLevelExporter()
        exporter.export([study_level], self.outfile)
        result = open(self.outfile, 'rb').read()
        self.assertEqual(
            result,
            'gpa,level,level_session,level_verdict,total_credits,'
            'validated_by,validation_date,'
            'student_id,number_of_tickets,certcode\r\n'
            '0.0,100,2012,A,100,,,A111111,1,CERT1\r\n'
            )
        return

    def test_export_all(self):
        # we can really export study levels
        # set values we can expect in export file
        self.setup_student(self.student)
        exporter = StudentStudyLevelExporter()
        exporter.export_all(self.app, self.outfile)
        result = open(self.outfile, 'rb').read()
        self.assertEqual(
            result,
            'gpa,level,level_session,level_verdict,total_credits,'
            'validated_by,validation_date,'
            'student_id,number_of_tickets,certcode\r\n'
            '0.0,100,2012,A,100,,,A111111,1,CERT1\r\n'
            )
        return

    def test_export_student(self):
        # we can really export study levels of a certain student
        self.setup_student(self.student)
        exporter = StudentStudyLevelExporter()
        exporter.export_student(self.student, self.outfile)
        result = open(self.outfile, 'rb').read()
        self.assertEqual(
            result,
            'gpa,level,level_session,level_verdict,total_credits,'
            'validated_by,validation_date,'
            'student_id,number_of_tickets,certcode\r\n'
            '0.0,100,2012,A,100,,,A111111,1,CERT1\r\n'
            )
        return

class CourseTicketExporterTest(StudentImportExportSetup):

    layer = FunctionalLayer

    def setUp(self):
        super(CourseTicketExporterTest, self).setUp()
        self.setup_for_export()
        return

    def test_ifaces(self):
        # make sure we fullfill interface contracts
        obj = CourseTicketExporter()
        verifyObject(ICSVExporter, obj)
        verifyClass(ICSVExporter, CourseTicketExporter)
        return

    def test_get_as_utility(self):
        # we can get an student exporter as utility
        result = queryUtility(ICSVExporter, name="coursetickets")
        self.assertTrue(result is not None)
        return

    def test_export_empty(self):
        # we can export a nearly empty course ticket
        ticket = CourseTicket()
        exporter = CourseTicketExporter()
        exporter.export([ticket], self.outfile)
        result = open(self.outfile, 'rb').read()
        self.assertEqual(
            result,
            'automatic,carry_over,code,credits,dcode,fcode,level,mandatory,'
            'passmark,score,semester,title,student_id,certcode\r\n'
            '0,0,,,,,,0,,,,,,\r\n'
            )
        return

    def test_export(self):
        # we can really export course tickets.
        # set values we can expect in export file
        self.setup_student(self.student)
        study_course = self.student.get('studycourse')
        study_level = study_course[study_course.keys()[0]]
        ticket = study_level['CRS1']
        exporter = CourseTicketExporter()
        exporter.export([ticket], self.outfile)
        result = open(self.outfile, 'rb').read()
        self.assertEqual(
            result,
            'automatic,carry_over,code,credits,dcode,fcode,level,mandatory,'
            'passmark,score,semester,title,student_id,certcode\r\n'
            '1,1,CRS1,100,DEP1,FAC1,100,0,100,,2,Course 1,A111111,CERT1\r\n'
            )
        return

    def test_export_all(self):
        # we can really export all course tickets
        # set values we can expect in export file
        self.setup_student(self.student)
        exporter = CourseTicketExporter()
        exporter.export_all(self.app, self.outfile)
        result = open(self.outfile, 'rb').read()
        self.assertEqual(
            result,
            'automatic,carry_over,code,credits,dcode,fcode,level,mandatory,'
            'passmark,score,semester,title,student_id,certcode\r\n'
            '1,1,CRS1,100,DEP1,FAC1,100,0,100,,2,Course 1,A111111,CERT1\r\n'
            )
        return

    def test_export_student(self):
        # we can really export all course tickets of a certain student
        self.setup_student(self.student)
        exporter = CourseTicketExporter()
        exporter.export_student(self.student, self.outfile)
        result = open(self.outfile, 'rb').read()
        self.assertEqual(
            result,
            'automatic,carry_over,code,credits,dcode,fcode,level,mandatory,'
            'passmark,score,semester,title,student_id,certcode\r\n'
            '1,1,CRS1,100,DEP1,FAC1,100,0,100,,2,Course 1,A111111,CERT1\r\n'
            )
        return

class PaymentsExporterTest(StudentImportExportSetup):

    layer = FunctionalLayer

    def setUp(self):
        super(PaymentsExporterTest, self).setUp()
        self.setup_for_export()
        return

    def test_ifaces(self):
        # make sure we fullfill interface contracts
        obj = PaymentsExporter()
        verifyObject(ICSVExporter, obj)
        verifyClass(ICSVExporter, PaymentsExporter)
        return

    def test_get_as_utility(self):
        # we can get a payments exporter as utility
        result = queryUtility(ICSVExporter, name="studentpayments")
        self.assertTrue(result is not None)
        return

    def test_export_empty(self):
        # we can export a nearly empty payment
        payment = StudentOnlinePayment()
        payment.creation_date = datetime.datetime(2012, 4, 1, 13, 12, 1)
        exporter = PaymentsExporter()
        exporter.export([payment], self.outfile)
        result = open(self.outfile, 'rb').read()
        self.assertEqual(
            result,
            'ac,amount_auth,creation_date,p_category,p_current,p_id,'
            'p_item,p_level,p_session,p_state,payment_date,r_amount_approved,'
            'r_code,r_desc,student_id,student_state,current_session\r\n'

            ',0.0,2012-04-01 13:12:01,schoolfee,1,,,,,unpaid,,0.0,,,,,\r\n'
            )
        return

    def test_export(self):
        # we can really export student payments.
        # set values we can expect in export file
        self.setup_student(self.student)
        payment = self.student['payments']['my-payment']
        exporter = PaymentsExporter()
        exporter.export([payment], self.outfile)
        result = open(self.outfile, 'rb').read()
        self.assertEqual(
            result,
            'ac,amount_auth,creation_date,p_category,p_current,p_id,'
            'p_item,p_level,p_session,p_state,payment_date,r_amount_approved,'
            'r_code,r_desc,student_id,student_state,current_session\r\n'

            '666,0.0,2012-04-01 13:12:01,schoolfee,1,my-id,'
            'p-item,100,2012,unpaid,2012-04-01 14:12:01,12.12,'
            'r-code,,A111111,created,2012\r\n'
            )
        return

    def test_export_all(self):
        # we can really export all payments
        # set values we can expect in export file
        self.setup_student(self.student)
        exporter = PaymentsExporter()
        exporter.export_all(self.app, self.outfile)
        result = open(self.outfile, 'rb').read()
        self.assertEqual(
            result,
            'ac,amount_auth,creation_date,p_category,p_current,p_id,'
            'p_item,p_level,p_session,p_state,payment_date,r_amount_approved,'
            'r_code,r_desc,student_id,student_state,current_session\r\n'

            '666,0.0,2012-04-01 13:12:01,schoolfee,1,my-id,'
            'p-item,100,2012,unpaid,2012-04-01 14:12:01,12.12,'
            'r-code,,A111111,created,2012\r\n'
            )
        return

    def test_export_student(self):
        # we can really export all payments of a certain student
        # set values we can expect in export file
        self.setup_student(self.student)
        exporter = PaymentsExporter()
        exporter.export_student(self.student, self.outfile)
        result = open(self.outfile, 'rb').read()
        self.assertEqual(
            result,
            'ac,amount_auth,creation_date,p_category,p_current,p_id,'
            'p_item,p_level,p_session,p_state,payment_date,r_amount_approved,'
            'r_code,r_desc,student_id,student_state,current_session\r\n'

            '666,0.0,2012-04-01 13:12:01,schoolfee,1,my-id,'
            'p-item,100,2012,unpaid,2012-04-01 14:12:01,12.12,'
            'r-code,,A111111,created,2012\r\n'
            )
        return

class BedTicketsExporterTest(StudentImportExportSetup):

    layer = FunctionalLayer

    def setUp(self):
        super(BedTicketsExporterTest, self).setUp()
        self.setup_for_export()
        return

    def test_ifaces(self):
        # make sure we fullfill interface contracts
        obj = BedTicketsExporter()
        verifyObject(ICSVExporter, obj)
        verifyClass(ICSVExporter, BedTicketsExporter)
        return

    def test_get_as_utility(self):
        # we can get a bedtickets exporter as utility
        result = queryUtility(ICSVExporter, name="bedtickets")
        self.assertTrue(result is not None)
        return

    def test_export_empty(self):
        # we can export a nearly empty bedticket
        bedticket = BedTicket()
        bed = self.app['hostels']['hall-1']['hall-1_A_101_A']
        bedticket.bed = bed
        exporter = BedTicketsExporter()
        exporter.export([bedticket], self.outfile)
        result = open(self.outfile, 'rb').read()
        self.assertMatches(
            result,
            'bed,bed_coordinates,bed_type,booking_code,booking_date,'
            'booking_session,student_id,actual_bed_type\r\n'
            'hall-1_A_101_A,,,,<YYYY-MM-DD hh:mm:ss>.<6-DIGITS>,,,regular_male_fr\r\n'
            )
        return

    def test_export(self):
        # we can really export student bedtickets.
        # set values we can expect in export file
        self.setup_student(self.student)
        bedticket = self.student['accommodation']['2004']
        exporter = BedTicketsExporter()
        exporter.export([bedticket], self.outfile)
        result = open(self.outfile, 'rb').read()
        self.assertMatches(
            result,
            'bed,bed_coordinates,bed_type,booking_code,booking_date,'
            'booking_session,student_id,actual_bed_type\r\n'
            'hall-1_A_101_A,,any bed type,,<YYYY-MM-DD hh:mm:ss>.<6-DIGITS>,2004,'
            'A111111,regular_male_fr\r\n'
            )
        return

    def test_export_all(self):
        # we can really export all bedtickets
        # set values we can expect in export file
        self.setup_student(self.student)
        exporter = BedTicketsExporter()
        exporter.export_all(self.app, self.outfile)
        result = open(self.outfile, 'rb').read()
        self.assertMatches(
            result,
            'bed,bed_coordinates,bed_type,booking_code,booking_date,'
            'booking_session,student_id,actual_bed_type\r\n'
            'hall-1_A_101_A,,any bed type,,<YYYY-MM-DD hh:mm:ss>.<6-DIGITS>,2004,'
            'A111111,regular_male_fr\r\n'
            )
        return

    def test_export_student(self):
        # we can really export all bedtickets of a certain student
        # set values we can expect in export file
        self.setup_student(self.student)
        exporter = BedTicketsExporter()
        exporter.export_student(self.student, self.outfile)
        result = open(self.outfile, 'rb').read()
        self.assertMatches(
            result,
            'bed,bed_coordinates,bed_type,booking_code,booking_date,'
            'booking_session,student_id,actual_bed_type\r\n'
            'hall-1_A_101_A,,any bed type,,<YYYY-MM-DD hh:mm:ss>.<6-DIGITS>,2004,'
            'A111111,regular_male_fr\r\n'
            )
        return

class StudentPaymentsOverviewExporterTest(StudentImportExportSetup):

    layer = FunctionalLayer

    def setUp(self):
        super(StudentPaymentsOverviewExporterTest, self).setUp()
        self.setup_for_export()
        return

    def test_ifaces(self):
        # make sure we fullfill interface contracts
        obj = StudentPaymentsOverviewExporter()
        verifyObject(ICSVExporter, obj)
        verifyClass(ICSVExporter, StudentPaymentsOverviewExporter)
        return

    def test_get_as_utility(self):
        # we can get a payments exporter as utility
        result = queryUtility(ICSVExporter, name="paymentsoverview")
        self.assertTrue(result is not None)
        return

    def test_export(self):
        self.setup_student(self.student)
        exporter = StudentPaymentsOverviewExporter()
        exporter.export([self.student], self.outfile)
        result = open(self.outfile, 'rb').read()
        self.assertEqual(
            'student_id,state,certcode,faccode,depcode,is_postgrad,'
            'current_level,current_session,'
            '%s\r\n'
            'A111111,created,CERT1,NA,NA,0,200,2012,'
            ',,,,,,,,,\r\n' % year_range_str,
            result
            )
        return

    def test_export_all(self):
        # we can really export students
        # set values we can expect in export file
        self.setup_student(self.student)
        # We add successful payments
        payment = StudentOnlinePayment()
        payment.p_id = 'my-id'
        payment.p_session = 2009
        payment.amount_auth = 12.12
        payment.p_state = u'paid'
        self.student['payments']['my-2ndpayment'] = payment
        exporter = StudentPaymentsOverviewExporter()
        exporter.export_all(self.app, self.outfile)
        result = open(self.outfile, 'rb').read()
        self.assertEqual(
            'student_id,state,certcode,faccode,depcode,is_postgrad,'
            'current_level,current_session,'
            '%s\r\nA111111,created,CERT1,NA,NA,0,'
            '200,2012,,,,,,,12.12,,,\r\n' % year_range_str,
            result
            )
        return

class StudentStudyLevelsOverviewExporterTest(StudentImportExportSetup):

    layer = FunctionalLayer

    def setUp(self):
        super(StudentStudyLevelsOverviewExporterTest, self).setUp()
        self.setup_for_export()
        return

    def test_ifaces(self):
        obj = StudentStudyLevelsOverviewExporter()
        verifyObject(ICSVExporter, obj)
        verifyClass(ICSVExporter, StudentStudyLevelsOverviewExporter)
        return

    def test_get_as_utility(self):
        result = queryUtility(ICSVExporter, name="studylevelsoverview")
        self.assertTrue(result is not None)
        return

    def test_export(self):
        self.setup_student(self.student)
        exporter = StudentStudyLevelsOverviewExporter()
        exporter.export([self.student], self.outfile)
        result = open(self.outfile, 'rb').read()
        self.assertEqual(
             'student_id,state,certcode,faccode,depcode,is_postgrad,'
             'entry_session,current_level,current_session,'
             '10,100,110,120,200,210,220,300,310,320,400,410,420,500,'
             '510,520,600,610,620,700,710,720,800,810,820,900,910,920,999\r\n'
             'A111111,created,CERT1,NA,NA,0,2010,200,2012,,2012'
             ',,,,,,,,,,,,,,,,,,,,,,,,,,,\r\n',
            result
            )
        return

    def test_export_all(self):
        self.setup_student(self.student)
        exporter = StudentStudyLevelsOverviewExporter()
        exporter.export_all(self.app, self.outfile)
        result = open(self.outfile, 'rb').read()
        self.assertEqual(
            'student_id,state,certcode,faccode,depcode,is_postgrad,'
            'entry_session,current_level,current_session,'
            '10,100,110,120,200,210,220,300,310,320,400,410,420,500,'
            '510,520,600,610,620,700,710,720,800,810,820,900,910,920,999\r\n'
            'A111111,created,CERT1,NA,NA,0,2010,200,2012,,2012'
            ',,,,,,,,,,,,,,,,,,,,,,,,,,,\r\n',
            result
            )
        return