# Tests for schoolgrades module.
import unittest
from decimal import Decimal
from zope.component import getGlobalSiteManager
from zope.interface.verify import verifyObject, verifyClass
from zope.schema.interfaces import ConstraintNotSatisfied, WrongType
from waeup.ikoba.interfaces import IProductOptionEntry, IProductOptionEntryField, IIkobaUtils
from waeup.ikoba.schoolgrades import ProductOptionEntry, ProductOptionEntryField
from waeup.ikoba.utils.utils import IkobaUtils

class ProductOptionEntryTests(unittest.TestCase):

    def setUp(self):
        self.utils = IkobaUtils()
        self.gsm = getGlobalSiteManager()
        self.gsm.registerUtility(self.utils, IIkobaUtils)
        self.valid_title = u'Option 1'
        self.valid_fee = Decimal(55.5)
        self.valid_currency = 'usd'
        return

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

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

    def test_init(self):
        # we can pass initial values
        item1 = ProductOptionEntry()
        item2 = ProductOptionEntry(
            self.valid_title, self.valid_fee, self.valid_currency)
        self.assertTrue(item1.title is None)
        self.assertTrue(item1.fee is None)
        self.assertTrue(item1.currency is None)
        self.assertEqual(item2.title, self.valid_title)
        self.assertEqual(item2.fee, self.valid_fee)
        self.assertEqual(item2.currency, self.valid_currency)
        return

    def test_illegal_value(self):
        # we do not accept values which do not meet the interface
        item = ProductOptionEntry()
        self.assertRaises(
            WrongType, ProductOptionEntry, 6, 500, 'invalid')
        return

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

    def test_from_string(self):
        # we can create new result entries based on strings
        myinput = u"(u'%s',u'%s',u'%s')" % (
            self.valid_title, self.valid_fee, self.valid_currency)
        item1 = ProductOptionEntry.from_string(myinput)
        item2 = ProductOptionEntry.from_string(u"(u'', u'', u'')")
        item3 = ProductOptionEntry.from_string(u"(None, None, None)")
        self.assertEqual(item1.title, self.valid_title)
        self.assertEqual(item1.fee, self.valid_fee)
        self.assertEqual(item1.currency, self.valid_currency)
        self.assertTrue(item2.title is None)
        self.assertTrue(item2.fee is None)
        self.assertEqual(item2.currency, None)
        self.assertTrue(item3.title is None)
        self.assertTrue(item3.fee is None)
        self.assertEqual(item3.currency, None)
        return

class ProductOptionEntryFieldTests(unittest.TestCase):

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