source: main/waeup.kofa/branches/0.2/src/waeup/kofa/tests/test_schoolgrades.py @ 16250

# Tests for schoolgrades module.
import unittest
from zope.component import getGlobalSiteManager
from zope.interface.verify import verifyObject, verifyClass
from zope.schema.interfaces import ConstraintNotSatisfied
from waeup.kofa.interfaces import IResultEntry, IResultEntryField, IKofaUtils
from waeup.kofa.schoolgrades import ResultEntry, ResultEntryField
from waeup.kofa.utils.utils import KofaUtils

class ResultEntryTests(unittest.TestCase):

    def setUp(self):
        self.utils = KofaUtils()
        self.gsm = getGlobalSiteManager()
        self.gsm.registerUtility(self.utils, IKofaUtils)
        self.valid_subj = self.utils.EXAM_SUBJECTS_DICT.keys()[0]
        self.valid_grade = self.utils.EXAM_GRADES[0][0]
        return

    def tearDown(self):
        self.gsm.unregisterUtility(self.utils)
        return

    def test_ifaces(self):
        # make sure we implement the promised interfaces.
        obj = ResultEntry()
        verifyObject(IResultEntry, obj)
        verifyClass(IResultEntry, ResultEntry)
        return

    def test_init(self):
        # we can pass initial values
        item1 = ResultEntry()
        item2 = ResultEntry(self.valid_subj, self.valid_grade)
        self.assertTrue(item1.subject is None)
        self.assertTrue(item1.grade is None)
        self.assertEqual(item2.subject, self.valid_subj)
        self.assertEqual(item2.grade, self.valid_grade)
        return

    def test_illegal_value(self):
        # we do not accept values not stored in KofaUtils
        item = ResultEntry()
        self.assertRaises(
            ConstraintNotSatisfied, ResultEntry, 'invalid', 'invalid')
        self.assertRaises(
            ConstraintNotSatisfied, ResultEntry, 'invalid')
        self.assertRaises(
            ConstraintNotSatisfied, setattr, item, 'subject', 'blah')
        self.assertRaises(
            ConstraintNotSatisfied, setattr, item, 'grade', 'blah')
        return

    def test_to_string(self):
        # the string representation is handy for export
        item1 = ResultEntry()
        item2 = ResultEntry(self.valid_subj, self.valid_grade)
        self.assertEqual(item1.to_string(), u"(None, None)")
        self.assertEqual(item2.to_string(), u"('%s', '%s')" % (
            self.valid_subj, self.valid_grade))
        return

    def test_from_string(self):
        # we can create new result entries based on strings
        myinput = u"(u'%s',u'%s')" % (
            self.valid_subj, self.valid_grade)
        item1 = ResultEntry.from_string(myinput)
        item2 = ResultEntry.from_string(u"(u'',u'')")
        item3 = ResultEntry.from_string(u"(None, None)")
        self.assertEqual(item1.subject, self.valid_subj)
        self.assertEqual(item1.grade, self.valid_grade)
        self.assertTrue(item2.subject is None)
        self.assertTrue(item2.grade is None)
        self.assertTrue(item3.subject is None)
        self.assertTrue(item3.grade is None)
        return

class ResultEntryFieldTests(unittest.TestCase):

    def test_ifaces(self):
        # make sure we implement the promised interfaces.
        obj = ResultEntryField()
        verifyObject(IResultEntryField, obj)
        verifyClass(IResultEntryField, ResultEntryField)
        return