source: main/waeup.kofa/trunk/src/waeup/kofa/applicants/tests/test_export.py @ 7975

import datetime
import os
import shutil
import tempfile
import unittest
from zope.catalog.interfaces import ICatalog
from zope.component import queryUtility, getUtility, getUtilitiesFor
from zope.interface.verify import verifyObject, verifyClass
from zope.intid.interfaces import IIntIds
from waeup.kofa.applicants import ApplicantsContainer
from waeup.kofa.applicants.export import (
    ApplicantsContainerExporter, ApplicantsExporter)
from waeup.kofa.applicants.interfaces import (
    IApplicantsContainerProvider, AppCatSource, ApplicationTypeSource)
from waeup.kofa.applicants.tests.test_batching import (
    ApplicantImportExportSetup)
from waeup.kofa.interfaces import ICSVExporter
from waeup.kofa.schoolgrades import ResultEntry
from waeup.kofa.testing import KofaUnitTestLayer, FunctionalLayer
from waeup.kofa.utils.utils import KofaUtils

class ApplicantsContainersExporterTest(unittest.TestCase):

    layer = KofaUnitTestLayer

    def setUp(self):
        self.workdir = tempfile.mkdtemp()
        self.outfile = os.path.join(self.workdir, 'myoutput.csv')
        return

    def tearDown(self):
        shutil.rmtree(self.workdir)
        return

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

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

    def setup_container(self, container):
        # set all attributes of a container
        container.code = u'dp2012'
        container.title = u'General Studies 2012/13'
        container.prefix = list(ApplicationTypeSource()(container))[0]
        container.year = 2012
        provider = [
            x for x in getUtilitiesFor(IApplicantsContainerProvider)
            if x[0] == 'waeup.kofa.applicants.ApplicantsContainer'][0]
        container.provider = provider
        container.application_category = list(AppCatSource()(container))[0]
        container.description = u'Some Description\nwith linebreak\n'
        container.description += u'<<de>>man spriht deutsh'
        container.startdate = datetime.date(2012, 1, 1)
        container.enddate = datetime.date(2012, 1, 31)
        return container

    def test_export(self):
        # we can export a set of applicants containers (w/o applicants)
        container = ApplicantsContainer()
        container = self.setup_container(container)
        exporter = ApplicantsContainerExporter()
        exporter.export([container], self.outfile)
        result = open(self.outfile, 'rb').read()
        self.assertEqual(
            result,
            'code,title,prefix,entry_level,year,provider,application_category,'
            'description,startdate,enddate,strict_deadline\r\n'

            'dp2012,General Studies 2012/13,app,100,2012,'
            'waeup.kofa.applicants.ApplicantsContainer,basic,'
            '"Some Description\nwith linebreak\n<<de>>man spriht deutsh",'
            '2012-01-01,2012-01-31,1\r\n'
            )
        return

class ApplicantsExporterTest(ApplicantImportExportSetup):

    layer = FunctionalLayer

    def setUp(self):
        super(ApplicantsExporterTest, self).setUp()
        self.outfile = os.path.join(self.workdir, 'myoutput.csv')
        self.cat = getUtility(ICatalog, name='applicants_catalog')
        self.intids = getUtility(IIntIds)
        return

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

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

    def setup_applicant(self, applicant):
        # set predictable values for `applicant`
        applicant.reg_number = u'123456'
        applicant.applicant_id = u'dp2011_654321'
        applicant.firstname = u'Anna'
        applicant.lastname = u'Tester'
        applicant.middlename = u'M.'
        applicant.date_of_birth = datetime.date(1981, 2, 4)
        applicant.sex = 'f'
        applicant.email = 'anna@sample.com'
        applicant.phone = u'+234-123-12345'
        applicant.course1 = self.certificate
        applicant.course2 = self.certificate
        applicant.course_admitted = self.certificate
        applicant.notice = u'Some notice\nin lines.'
        applicant.screening_score = 98
        applicant.screening_venue = u'Exam Room'
        result_entry = ResultEntry(
            KofaUtils.EXAM_SUBJECTS_DICT.keys()[0],
            KofaUtils.EXAM_GRADES[0][0]
            )
        applicant.school_grades = [
            result_entry]
        return applicant

    def test_export(self):
        # we can really export applicants
        # set values we can expect in export file
        applicant = self.setup_applicant(self.applicant)
        exporter = ApplicantsExporter()
        exporter.export([applicant], self.outfile)
        result = open(self.outfile, 'rb').read()
        self.assertEqual(
            result,
            'applicant_id,course1,course2,course_admitted,date_of_birth,'
            'email,firstname,lastname,lga,middlename,notice,phone,'
            'reg_number,school_grades,screening_score,screening_venue,'
            'sex\r\n'

            'dp2011_654321,CERT1,CERT1,CERT1,1981-02-04,anna@sample.com,'
            'Anna,Tester,foreigner,M.,"Some notice\nin lines.",'
            '+234-123-12345,123456,'
            '"[(\'computer_science\', \'A\')]",98,Exam Room,f\r\n'
            )
        return