############################################################################## # # Copyright (c) 2012 Zope Foundation and Contributors. # All Rights Reserved. # # This software is subject to the provisions of the Zope Public License, # Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution. # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # FOR A PARTICULAR PURPOSE. # ############################################################################## import unittest class BytesTests(unittest.TestCase): def _getTargetClass(self): from zope.schema._field import Bytes return Bytes def _makeOne(self, *args, **kw): return self._getTargetClass()(*args, **kw) def test_class_conforms_to_IBytes(self): from zope.interface.verify import verifyClass from zope.schema.interfaces import IBytes verifyClass(IBytes, self._getTargetClass()) def test_instance_conforms_to_IBytes(self): from zope.interface.verify import verifyObject from zope.schema.interfaces import IBytes verifyObject(IBytes, self._makeOne()) def test_validate_wrong_types(self): from zope.schema.interfaces import WrongType from zope.schema._compat import u field = self._makeOne() self.assertRaises(WrongType, field.validate, u('')) self.assertRaises(WrongType, field.validate, 1) self.assertRaises(WrongType, field.validate, 1.0) self.assertRaises(WrongType, field.validate, ()) self.assertRaises(WrongType, field.validate, []) self.assertRaises(WrongType, field.validate, {}) self.assertRaises(WrongType, field.validate, set()) self.assertRaises(WrongType, field.validate, frozenset()) self.assertRaises(WrongType, field.validate, object()) def test_validate_w_invalid_default(self): from zope.schema._compat import u from zope.schema.interfaces import ValidationError self.assertRaises(ValidationError, self._makeOne, default=u('')) def test_validate_not_required(self): from zope.schema._compat import b field = self._makeOne(required=False) field.validate(b('')) field.validate(b('abc')) field.validate(b('abc\ndef')) field.validate(None) def test_validate_required(self): from zope.schema.interfaces import RequiredMissing from zope.schema._compat import b field = self._makeOne() field.validate(b('')) field.validate(b('abc')) field.validate(b('abc\ndef')) self.assertRaises(RequiredMissing, field.validate, None) def test_fromUnicode_miss(self): from zope.schema._compat import u byt = self._makeOne() self.assertRaises(UnicodeEncodeError, byt.fromUnicode, u(chr(129))) def test_fromUnicode_hit(self): from zope.schema._compat import u from zope.schema._compat import b byt = self._makeOne() self.assertEqual(byt.fromUnicode(u('')), b('')) self.assertEqual(byt.fromUnicode(u('DEADBEEF')), b('DEADBEEF')) class ASCIITests(unittest.TestCase): def _getTargetClass(self): from zope.schema._field import ASCII return ASCII def _makeOne(self, *args, **kw): return self._getTargetClass()(*args, **kw) def test_class_conforms_to_IASCII(self): from zope.interface.verify import verifyClass from zope.schema.interfaces import IASCII verifyClass(IASCII, self._getTargetClass()) def test_instance_conforms_to_IASCII(self): from zope.interface.verify import verifyObject from zope.schema.interfaces import IASCII verifyObject(IASCII, self._makeOne()) def test_validate_wrong_types(self): from zope.schema.interfaces import WrongType from zope.schema._compat import non_native_string field = self._makeOne() self.assertRaises(WrongType, field.validate, non_native_string('')) self.assertRaises(WrongType, field.validate, 1) self.assertRaises(WrongType, field.validate, 1.0) self.assertRaises(WrongType, field.validate, ()) self.assertRaises(WrongType, field.validate, []) self.assertRaises(WrongType, field.validate, {}) self.assertRaises(WrongType, field.validate, set()) self.assertRaises(WrongType, field.validate, frozenset()) self.assertRaises(WrongType, field.validate, object()) def test__validate_empty(self): asc = self._makeOne() asc._validate('') # no error def test__validate_non_empty_miss(self): from zope.schema.interfaces import InvalidValue asc = self._makeOne() self.assertRaises(InvalidValue, asc._validate, chr(129)) def test__validate_non_empty_hit(self): asc = self._makeOne() for i in range(128): asc._validate(chr(i)) #doesn't raise class BytesLineTests(unittest.TestCase): def _getTargetClass(self): from zope.schema._field import BytesLine return BytesLine def _makeOne(self, *args, **kw): return self._getTargetClass()(*args, **kw) def test_class_conforms_to_IBytesLine(self): from zope.interface.verify import verifyClass from zope.schema.interfaces import IBytesLine verifyClass(IBytesLine, self._getTargetClass()) def test_instance_conforms_to_IBytesLine(self): from zope.interface.verify import verifyObject from zope.schema.interfaces import IBytesLine verifyObject(IBytesLine, self._makeOne()) def test_validate_wrong_types(self): from zope.schema.interfaces import WrongType from zope.schema._compat import u field = self._makeOne() self.assertRaises(WrongType, field.validate, u('')) self.assertRaises(WrongType, field.validate, 1) self.assertRaises(WrongType, field.validate, 1.0) self.assertRaises(WrongType, field.validate, ()) self.assertRaises(WrongType, field.validate, []) self.assertRaises(WrongType, field.validate, {}) self.assertRaises(WrongType, field.validate, set()) self.assertRaises(WrongType, field.validate, frozenset()) self.assertRaises(WrongType, field.validate, object()) def test_validate_not_required(self): from zope.schema._compat import b field = self._makeOne(required=False) field.validate(None) field.validate(b('')) field.validate(b('abc')) field.validate(b('\xab\xde')) def test_validate_required(self): from zope.schema.interfaces import RequiredMissing from zope.schema._compat import b field = self._makeOne() field.validate(b('')) field.validate(b('abc')) field.validate(b('\xab\xde')) self.assertRaises(RequiredMissing, field.validate, None) def test_constraint(self): from zope.schema._compat import b field = self._makeOne() self.assertEqual(field.constraint(b('')), True) self.assertEqual(field.constraint(b('abc')), True) self.assertEqual(field.constraint(b('abc')), True) self.assertEqual(field.constraint(b('\xab\xde')), True) self.assertEqual(field.constraint(b('abc\ndef')), False) class ASCIILineTests(unittest.TestCase): def _getTargetClass(self): from zope.schema._field import ASCIILine return ASCIILine def _makeOne(self, *args, **kw): return self._getTargetClass()(*args, **kw) def test_class_conforms_to_IASCIILine(self): from zope.interface.verify import verifyClass from zope.schema.interfaces import IASCIILine verifyClass(IASCIILine, self._getTargetClass()) def test_instance_conforms_to_IASCIILine(self): from zope.interface.verify import verifyObject from zope.schema.interfaces import IASCIILine verifyObject(IASCIILine, self._makeOne()) def test_validate_wrong_types(self): from zope.schema.interfaces import WrongType from zope.schema._compat import non_native_string field = self._makeOne() self.assertRaises(WrongType, field.validate, non_native_string('')) self.assertRaises(WrongType, field.validate, 1) self.assertRaises(WrongType, field.validate, 1.0) self.assertRaises(WrongType, field.validate, ()) self.assertRaises(WrongType, field.validate, []) self.assertRaises(WrongType, field.validate, {}) self.assertRaises(WrongType, field.validate, set()) self.assertRaises(WrongType, field.validate, frozenset()) self.assertRaises(WrongType, field.validate, object()) def test_validate_not_required(self): from zope.schema.interfaces import InvalidValue field = self._makeOne(required=False) field.validate(None) field.validate('') field.validate('abc') self.assertRaises(InvalidValue, field.validate, '\xab\xde') def test_validate_required(self): from zope.schema.interfaces import InvalidValue from zope.schema.interfaces import RequiredMissing field = self._makeOne() field.validate('') field.validate('abc') self.assertRaises(InvalidValue, field.validate, '\xab\xde') self.assertRaises(RequiredMissing, field.validate, None) def test_constraint(self): field = self._makeOne() self.assertEqual(field.constraint(''), True) self.assertEqual(field.constraint('abc'), True) self.assertEqual(field.constraint('abc'), True) # Non-ASCII byltes get checked in '_validate'. self.assertEqual(field.constraint('\xab\xde'), True) self.assertEqual(field.constraint('abc\ndef'), False) class FloatTests(unittest.TestCase): def _getTargetClass(self): from zope.schema._field import Float return Float def _makeOne(self, *args, **kw): return self._getTargetClass()(*args, **kw) def test_class_conforms_to_IFloat(self): from zope.interface.verify import verifyClass from zope.schema.interfaces import IFloat verifyClass(IFloat, self._getTargetClass()) def test_instance_conforms_to_IFloat(self): from zope.interface.verify import verifyObject from zope.schema.interfaces import IFloat verifyObject(IFloat, self._makeOne()) def test_validate_not_required(self): field = self._makeOne(required=False) field.validate(None) field.validate(10.0) field.validate(0.93) field.validate(1000.0003) def test_validate_required(self): from zope.schema.interfaces import RequiredMissing field = self._makeOne() field.validate(10.0) field.validate(0.93) field.validate(1000.0003) self.assertRaises(RequiredMissing, field.validate, None) def test_validate_min(self): from zope.schema.interfaces import TooSmall field = self._makeOne(min=10.5) field.validate(10.6) field.validate(20.2) self.assertRaises(TooSmall, field.validate, -9.0) self.assertRaises(TooSmall, field.validate, 10.4) def test_validate_max(self): from zope.schema.interfaces import TooBig field = self._makeOne(max=10.5) field.validate(5.3) field.validate(-9.1) self.assertRaises(TooBig, field.validate, 10.51) self.assertRaises(TooBig, field.validate, 20.7) def test_validate_min_and_max(self): from zope.schema.interfaces import TooBig from zope.schema.interfaces import TooSmall field = self._makeOne(min=-0.6, max=10.1) field.validate(0.0) field.validate(-0.03) field.validate(10.0001) self.assertRaises(TooSmall, field.validate, -10.0) self.assertRaises(TooSmall, field.validate, -1.6) self.assertRaises(TooBig, field.validate, 11.45) self.assertRaises(TooBig, field.validate, 20.02) def test_fromUnicode_miss(self): from zope.schema._compat import u flt = self._makeOne() self.assertRaises(ValueError, flt.fromUnicode, u('')) self.assertRaises(ValueError, flt.fromUnicode, u('abc')) self.assertRaises(ValueError, flt.fromUnicode, u('14.G')) def test_fromUnicode_hit(self): from zope.schema._compat import u flt = self._makeOne() self.assertEqual(flt.fromUnicode(u('0')), 0.0) self.assertEqual(flt.fromUnicode(u('1.23')), 1.23) self.assertEqual(flt.fromUnicode(u('1.23e6')), 1230000.0) class DecimalTests(unittest.TestCase): def _getTargetClass(self): from zope.schema._field import Decimal return Decimal def _makeOne(self, *args, **kw): return self._getTargetClass()(*args, **kw) def test_class_conforms_to_IDecimal(self): from zope.interface.verify import verifyClass from zope.schema.interfaces import IDecimal verifyClass(IDecimal, self._getTargetClass()) def test_instance_conforms_to_IDecimal(self): from zope.interface.verify import verifyObject from zope.schema.interfaces import IDecimal verifyObject(IDecimal, self._makeOne()) def test_validate_not_required(self): import decimal field = self._makeOne(required=False) field.validate(decimal.Decimal("10.0")) field.validate(decimal.Decimal("0.93")) field.validate(decimal.Decimal("1000.0003")) field.validate(None) def test_validate_required(self): import decimal from zope.schema.interfaces import RequiredMissing field = self._makeOne() field.validate(decimal.Decimal("10.0")) field.validate(decimal.Decimal("0.93")) field.validate(decimal.Decimal("1000.0003")) self.assertRaises(RequiredMissing, field.validate, None) def test_validate_min(self): import decimal from zope.schema.interfaces import TooSmall field = self._makeOne(min=decimal.Decimal("10.5")) field.validate(decimal.Decimal("10.6")) field.validate(decimal.Decimal("20.2")) self.assertRaises(TooSmall, field.validate, decimal.Decimal("-9.0")) self.assertRaises(TooSmall, field.validate, decimal.Decimal("10.4")) def test_validate_max(self): import decimal from zope.schema.interfaces import TooBig field = self._makeOne(max=decimal.Decimal("10.5")) field.validate(decimal.Decimal("5.3")) field.validate(decimal.Decimal("-9.1")) self.assertRaises(TooBig, field.validate, decimal.Decimal("10.51")) self.assertRaises(TooBig, field.validate, decimal.Decimal("20.7")) def test_validate_min_and_max(self): import decimal from zope.schema.interfaces import TooBig from zope.schema.interfaces import TooSmall field = self._makeOne(min=decimal.Decimal("-0.6"), max=decimal.Decimal("10.1")) field.validate(decimal.Decimal("0.0")) field.validate(decimal.Decimal("-0.03")) field.validate(decimal.Decimal("10.0001")) self.assertRaises(TooSmall, field.validate, decimal.Decimal("-10.0")) self.assertRaises(TooSmall, field.validate, decimal.Decimal("-1.6")) self.assertRaises(TooBig, field.validate, decimal.Decimal("11.45")) self.assertRaises(TooBig, field.validate, decimal.Decimal("20.02")) def test_fromUnicode_miss(self): from zope.schema._compat import u flt = self._makeOne() self.assertRaises(ValueError, flt.fromUnicode, u('')) self.assertRaises(ValueError, flt.fromUnicode, u('abc')) self.assertRaises(ValueError, flt.fromUnicode, u('1.4G')) def test_fromUnicode_hit(self): from decimal import Decimal from zope.schema._compat import u flt = self._makeOne() self.assertEqual(flt.fromUnicode(u('0')), Decimal('0.0')) self.assertEqual(flt.fromUnicode(u('1.23')), Decimal('1.23')) self.assertEqual(flt.fromUnicode(u('12345.6')), Decimal('12345.6')) class DatetimeTests(unittest.TestCase): def _getTargetClass(self): from zope.schema._field import Datetime return Datetime def _makeOne(self, *args, **kw): return self._getTargetClass()(*args, **kw) def test_class_conforms_to_IDatetime(self): from zope.interface.verify import verifyClass from zope.schema.interfaces import IDatetime verifyClass(IDatetime, self._getTargetClass()) def test_instance_conforms_to_IDatetime(self): from zope.interface.verify import verifyObject from zope.schema.interfaces import IDatetime verifyObject(IDatetime, self._makeOne()) def test_validate_wrong_types(self): from datetime import date from zope.schema.interfaces import WrongType from zope.schema._compat import u from zope.schema._compat import b field = self._makeOne() self.assertRaises(WrongType, field.validate, u('')) self.assertRaises(WrongType, field.validate, b('')) self.assertRaises(WrongType, field.validate, 1) self.assertRaises(WrongType, field.validate, 1.0) self.assertRaises(WrongType, field.validate, ()) self.assertRaises(WrongType, field.validate, []) self.assertRaises(WrongType, field.validate, {}) self.assertRaises(WrongType, field.validate, set()) self.assertRaises(WrongType, field.validate, frozenset()) self.assertRaises(WrongType, field.validate, object()) self.assertRaises(WrongType, field.validate, date.today()) def test_validate_not_required(self): from datetime import datetime field = self._makeOne(required=False) field.validate(None) #doesn't raise field.validate(datetime.now()) #doesn't raise def test_validate_required(self): from zope.schema.interfaces import RequiredMissing field = self._makeOne(required=True) self.assertRaises(RequiredMissing, field.validate, None) def test_validate_w_min(self): from datetime import datetime from zope.schema.interfaces import TooSmall d1 = datetime(2000,10,1) d2 = datetime(2000,10,2) field = self._makeOne(min=d1) field.validate(d1) #doesn't raise field.validate(d2) #doesn't raise self.assertRaises(TooSmall, field.validate, datetime(2000,9,30)) def test_validate_w_max(self): from datetime import datetime from zope.schema.interfaces import TooBig d1 = datetime(2000,10,1) d2 = datetime(2000,10,2) d3 = datetime(2000,10,3) field = self._makeOne(max=d2) field.validate(d1) #doesn't raise field.validate(d2) #doesn't raise self.assertRaises(TooBig, field.validate, d3) def test_validate_w_min_and_max(self): from datetime import datetime from zope.schema.interfaces import TooBig from zope.schema.interfaces import TooSmall d1 = datetime(2000,10,1) d2 = datetime(2000,10,2) d3 = datetime(2000,10,3) d4 = datetime(2000,10,4) d5 = datetime(2000,10,5) field = self._makeOne(min=d2, max=d4) field.validate(d2) #doesn't raise field.validate(d3) #doesn't raise field.validate(d4) #doesn't raise self.assertRaises(TooSmall, field.validate, d1) self.assertRaises(TooBig, field.validate, d5) class DateTests(unittest.TestCase): def _getTargetClass(self): from zope.schema._field import Date return Date def _makeOne(self, *args, **kw): return self._getTargetClass()(*args, **kw) def test_class_conforms_to_IDate(self): from zope.interface.verify import verifyClass from zope.schema.interfaces import IDate verifyClass(IDate, self._getTargetClass()) def test_instance_conforms_to_IDate(self): from zope.interface.verify import verifyObject from zope.schema.interfaces import IDate verifyObject(IDate, self._makeOne()) def test_validate_wrong_types(self): from datetime import datetime from zope.schema.interfaces import WrongType from zope.schema._compat import u from zope.schema._compat import b field = self._makeOne() self.assertRaises(WrongType, field.validate, u('')) self.assertRaises(WrongType, field.validate, b('')) self.assertRaises(WrongType, field.validate, 1) self.assertRaises(WrongType, field.validate, 1.0) self.assertRaises(WrongType, field.validate, ()) self.assertRaises(WrongType, field.validate, []) self.assertRaises(WrongType, field.validate, {}) self.assertRaises(WrongType, field.validate, set()) self.assertRaises(WrongType, field.validate, frozenset()) self.assertRaises(WrongType, field.validate, object()) self.assertRaises(WrongType, field.validate, datetime.now()) def test_validate_not_required(self): from datetime import date field = self._makeOne(required=False) field.validate(None) field.validate(date.today()) def test_validate_required(self): from datetime import datetime from zope.schema.interfaces import RequiredMissing field = self._makeOne() field.validate(datetime.now().date()) self.assertRaises(RequiredMissing, field.validate, None) def test_validate_w_min(self): from datetime import date from datetime import datetime from zope.schema.interfaces import TooSmall d1 = date(2000,10,1) d2 = date(2000,10,2) field = self._makeOne(min=d1) field.validate(d1) field.validate(d2) field.validate(datetime.now().date()) self.assertRaises(TooSmall, field.validate, date(2000,9,30)) def test_validate_w_max(self): from datetime import date from zope.schema.interfaces import TooBig d1 = date(2000,10,1) d2 = date(2000,10,2) d3 = date(2000,10,3) field = self._makeOne(max=d2) field.validate(d1) field.validate(d2) self.assertRaises(TooBig, field.validate, d3) def test_validate_w_min_and_max(self): from datetime import date from zope.schema.interfaces import TooBig from zope.schema.interfaces import TooSmall d1 = date(2000,10,1) d2 = date(2000,10,2) d3 = date(2000,10,3) d4 = date(2000,10,4) d5 = date(2000,10,5) field = self._makeOne(min=d2, max=d4) field.validate(d2) field.validate(d3) field.validate(d4) self.assertRaises(TooSmall, field.validate, d1) self.assertRaises(TooBig, field.validate, d5) class TimedeltaTests(unittest.TestCase): def _getTargetClass(self): from zope.schema._field import Timedelta return Timedelta def _makeOne(self, *args, **kw): return self._getTargetClass()(*args, **kw) def test_class_conforms_to_ITimedelta(self): from zope.interface.verify import verifyClass from zope.schema.interfaces import ITimedelta verifyClass(ITimedelta, self._getTargetClass()) def test_instance_conforms_to_ITimedelta(self): from zope.interface.verify import verifyObject from zope.schema.interfaces import ITimedelta verifyObject(ITimedelta, self._makeOne()) def test_validate_not_required(self): from datetime import timedelta field = self._makeOne(required=False) field.validate(None) field.validate(timedelta(minutes=15)) def test_validate_required(self): from datetime import timedelta from zope.schema.interfaces import RequiredMissing field = self._makeOne() field.validate(timedelta(minutes=15)) self.assertRaises(RequiredMissing, field.validate, None) def test_validate_min(self): from datetime import timedelta from zope.schema.interfaces import TooSmall t1 = timedelta(hours=2) t2 = timedelta(hours=3) field = self._makeOne(min=t1) field.validate(t1) field.validate(t2) self.assertRaises(TooSmall, field.validate, timedelta(hours=1)) def test_validate_max(self): from datetime import timedelta from zope.schema.interfaces import TooBig t1 = timedelta(minutes=1) t2 = timedelta(minutes=2) t3 = timedelta(minutes=3) field = self._makeOne(max=t2) field.validate(t1) field.validate(t2) self.assertRaises(TooBig, field.validate, t3) def test_validate_min_and_max(self): from datetime import timedelta from zope.schema.interfaces import TooBig from zope.schema.interfaces import TooSmall t1 = timedelta(days=1) t2 = timedelta(days=2) t3 = timedelta(days=3) t4 = timedelta(days=4) t5 = timedelta(days=5) field = self._makeOne(min=t2, max=t4) field.validate(t2) field.validate(t3) field.validate(t4) self.assertRaises(TooSmall, field.validate, t1) self.assertRaises(TooBig, field.validate, t5) class TimeTests(unittest.TestCase): def _getTargetClass(self): from zope.schema._field import Time return Time def _makeOne(self, *args, **kw): return self._getTargetClass()(*args, **kw) def test_class_conforms_to_ITime(self): from zope.interface.verify import verifyClass from zope.schema.interfaces import ITime verifyClass(ITime, self._getTargetClass()) def test_instance_conforms_to_ITime(self): from zope.interface.verify import verifyObject from zope.schema.interfaces import ITime verifyObject(ITime, self._makeOne()) def test_validate_not_required(self): from datetime import time field = self._makeOne(required=False) field.validate(None) field.validate(time(12,15,37)) def test_validate_required(self): from datetime import time from zope.schema.interfaces import RequiredMissing field = self._makeOne() field.validate(time(12,15,37)) self.assertRaises(RequiredMissing, field.validate, None) def test_validate_min(self): from datetime import time from zope.schema.interfaces import TooSmall t1 = time(12,15,37) t2 = time(12,25,18) t3 = time(12,42,43) field = self._makeOne(min=t2) field.validate(t2) field.validate(t3) self.assertRaises(TooSmall, field.validate, t1) def test_validate_max(self): from datetime import time from zope.schema.interfaces import TooBig t1 = time(12,15,37) t2 = time(12,25,18) t3 = time(12,42,43) field = self._makeOne(max=t2) field.validate(t1) field.validate(t2) self.assertRaises(TooBig, field.validate, t3) def test_validate_min_and_max(self): from datetime import time from zope.schema.interfaces import TooBig from zope.schema.interfaces import TooSmall t1 = time(12,15,37) t2 = time(12,25,18) t3 = time(12,42,43) t4 = time(13,7,12) t5 = time(14,22,9) field = self._makeOne(min=t2, max=t4) field.validate(t2) field.validate(t3) field.validate(t4) self.assertRaises(TooSmall, field.validate, t1) self.assertRaises(TooBig, field.validate, t5) class ChoiceTests(unittest.TestCase): def setUp(self): from zope.schema.vocabulary import _clear _clear() def tearDown(self): from zope.schema.vocabulary import _clear _clear() def _getTargetClass(self): from zope.schema._field import Choice return Choice def _makeOne(self, *args, **kw): return self._getTargetClass()(*args, **kw) def test_class_conforms_to_IChoice(self): from zope.interface.verify import verifyClass from zope.schema.interfaces import IChoice verifyClass(IChoice, self._getTargetClass()) def test_instance_conforms_to_IChoice(self): from zope.interface.verify import verifyObject from zope.schema.interfaces import IChoice verifyObject(IChoice, self._makeOne(values=[1, 2, 3])) def test_ctor_wo_values_vocabulary_or_source(self): self.assertRaises(ValueError, self._makeOne) def test_ctor_invalid_vocabulary(self): self.assertRaises(ValueError, self._makeOne, vocabulary=object()) def test_ctor_invalid_source(self): self.assertRaises(ValueError, self._makeOne, source=object()) def test_ctor_both_vocabulary_and_source(self): self.assertRaises(ValueError, self._makeOne, vocabulary='voc.name', source=object()) def test_ctor_both_vocabulary_and_values(self): self.assertRaises(ValueError, self._makeOne, vocabulary='voc.name', values=[1, 2]) def test_ctor_w_values(self): from zope.schema.vocabulary import SimpleVocabulary choose = self._makeOne(values=[1, 2]) self.assertTrue(isinstance(choose.vocabulary, SimpleVocabulary)) self.assertEqual(sorted(choose.vocabulary.by_value.keys()), [1, 2]) self.assertEqual(sorted(choose.source.by_value.keys()), [1, 2]) def test_ctor_w_named_vocabulary(self): choose = self._makeOne(vocabulary="vocab") self.assertEqual(choose.vocabularyName, 'vocab') def test_ctor_w_preconstructed_vocabulary(self): v = _makeSampleVocabulary() choose = self._makeOne(vocabulary=v) self.assertTrue(choose.vocabulary is v) self.assertTrue(choose.vocabularyName is None) def test_bind_w_preconstructed_vocabulary(self): from zope.schema.interfaces import ValidationError from zope.schema.vocabulary import setVocabularyRegistry v = _makeSampleVocabulary() setVocabularyRegistry(_makeDummyRegistry(v)) choose = self._makeOne(vocabulary='vocab') bound = choose.bind(None) self.assertEqual(bound.vocabulary, v) self.assertEqual(bound.vocabularyName, 'vocab') bound.default = 1 self.assertEqual(bound.default, 1) def _provoke(bound): bound.default = 42 self.assertRaises(ValidationError, _provoke, bound) def test_bind_w_voc_not_ICSB(self): from zope.interface import implementer from zope.schema.interfaces import ISource from zope.schema.interfaces import IBaseVocabulary @implementer(IBaseVocabulary) @implementer(ISource) class Vocab(object): def __init__(self): pass source = self._makeOne(vocabulary=Vocab()) instance = DummyInstance() target = source.bind(instance) self.assertTrue(target.vocabulary is source.vocabulary) def test_bind_w_voc_is_ICSB(self): from zope.interface import implementer from zope.schema.interfaces import IContextSourceBinder from zope.schema.interfaces import ISource @implementer(IContextSourceBinder) @implementer(ISource) class Vocab(object): def __init__(self, context): self.context = context def __call__(self, context): return self.__class__(context) # Chicken-egg source = self._makeOne(vocabulary='temp') source.vocabulary = Vocab(source) source.vocabularyName = None instance = DummyInstance() target = source.bind(instance) self.assertEqual(target.vocabulary.context, instance) def test_bind_w_voc_is_ICSB_but_not_ISource(self): from zope.interface import implementer from zope.schema.interfaces import IContextSourceBinder @implementer(IContextSourceBinder) class Vocab(object): def __init__(self, context): self.context = context def __call__(self, context): return self.__class__(context) # Chicken-egg source = self._makeOne(vocabulary='temp') source.vocabulary = Vocab(source) source.vocabularyName = None instance = DummyInstance() self.assertRaises(ValueError, source.bind, instance) def test_fromUnicode_miss(self): from zope.schema.interfaces import ConstraintNotSatisfied from zope.schema._compat import u flt = self._makeOne(values=(u('foo'), u('bar'), u('baz'))) self.assertRaises(ConstraintNotSatisfied, flt.fromUnicode, u('')) self.assertRaises(ConstraintNotSatisfied, flt.fromUnicode, u('abc')) self.assertRaises(ConstraintNotSatisfied, flt.fromUnicode, u('1.4G')) def test_fromUnicode_hit(self): from zope.schema._compat import u flt = self._makeOne(values=(u('foo'), u('bar'), u('baz'))) self.assertEqual(flt.fromUnicode(u('foo')), u('foo')) self.assertEqual(flt.fromUnicode(u('bar')), u('bar')) self.assertEqual(flt.fromUnicode(u('baz')), u('baz')) def test__validate_int(self): from zope.schema.interfaces import ConstraintNotSatisfied choice = self._makeOne(values=[1, 3]) choice._validate(1) #doesn't raise choice._validate(3) #doesn't raise self.assertRaises(ConstraintNotSatisfied, choice._validate, 4) def test__validate_string(self): from zope.schema._compat import u from zope.schema.interfaces import ConstraintNotSatisfied choice = self._makeOne(values=['a', 'c']) choice._validate('a') #doesn't raise choice._validate('c') #doesn't raise choice._validate(u('c')) #doesn't raise self.assertRaises(ConstraintNotSatisfied, choice._validate, 'd') def test__validate_tuple(self): from zope.schema.interfaces import ConstraintNotSatisfied choice = self._makeOne(values=[(1, 2), (5, 6)]) choice._validate((1, 2)) #doesn't raise choice._validate((5, 6)) #doesn't raise self.assertRaises(ConstraintNotSatisfied, choice._validate, [5, 6]) self.assertRaises(ConstraintNotSatisfied, choice._validate, ()) def test__validate_mixed(self): from zope.schema.interfaces import ConstraintNotSatisfied choice = self._makeOne(values=[1, 'b', (0.2,)]) choice._validate(1) #doesn't raise choice._validate('b') #doesn't raise choice._validate((0.2,)) #doesn't raise self.assertRaises(ConstraintNotSatisfied, choice._validate, '1') self.assertRaises(ConstraintNotSatisfied, choice._validate, 0.2) def test__validate_w_named_vocabulary_invalid(self): choose = self._makeOne(vocabulary='vocab') self.assertRaises(ValueError, choose._validate, 42) def test__validate_w_named_vocabulary(self): from zope.schema.interfaces import ConstraintNotSatisfied from zope.schema.vocabulary import setVocabularyRegistry v = _makeSampleVocabulary() setVocabularyRegistry(_makeDummyRegistry(v)) choose = self._makeOne(vocabulary='vocab') choose._validate(1) choose._validate(3) self.assertRaises(ConstraintNotSatisfied, choose._validate, 42) def test__validate_source_is_ICSB_unbound(self): from zope.interface import implementer from zope.schema.interfaces import IContextSourceBinder @implementer(IContextSourceBinder) class SampleContextSourceBinder(object): def __call__(self, context): pass choice = self._makeOne(source=SampleContextSourceBinder()) self.assertRaises(TypeError, choice.validate, 1) def test__validate_source_is_ICSB_bound(self): from zope.interface import implementer from zope.schema.interfaces import IContextSourceBinder from zope.schema.interfaces import ConstraintNotSatisfied from zope.schema.tests.test_vocabulary import _makeSampleVocabulary @implementer(IContextSourceBinder) class SampleContextSourceBinder(object): def __call__(self, context): return _makeSampleVocabulary() s = SampleContextSourceBinder() choice = self._makeOne(source=s) # raises not iterable with unbound field self.assertRaises(TypeError, choice.validate, 1) o = object() clone = choice.bind(o) clone._validate(1) clone._validate(3) self.assertRaises(ConstraintNotSatisfied, clone._validate, 42) class InterfaceFieldTests(unittest.TestCase): def _getTargetClass(self): from zope.schema._field import InterfaceField return InterfaceField def _makeOne(self, *args, **kw): return self._getTargetClass()(*args, **kw) def test_class_conforms_to_IInterfaceField(self): from zope.interface.verify import verifyClass from zope.schema.interfaces import IInterfaceField verifyClass(IInterfaceField, self._getTargetClass()) def test_instance_conforms_to_IInterfaceField(self): from zope.interface.verify import verifyObject from zope.schema.interfaces import IInterfaceField verifyObject(IInterfaceField, self._makeOne()) def test_validate_wrong_types(self): from datetime import date from zope.schema.interfaces import WrongType from zope.schema._compat import u from zope.schema._compat import b field = self._makeOne() self.assertRaises(WrongType, field.validate, u('')) self.assertRaises(WrongType, field.validate, b('')) self.assertRaises(WrongType, field.validate, 1) self.assertRaises(WrongType, field.validate, 1.0) self.assertRaises(WrongType, field.validate, ()) self.assertRaises(WrongType, field.validate, []) self.assertRaises(WrongType, field.validate, {}) self.assertRaises(WrongType, field.validate, set()) self.assertRaises(WrongType, field.validate, frozenset()) self.assertRaises(WrongType, field.validate, object()) self.assertRaises(WrongType, field.validate, date.today()) def test_validate_not_required(self): from zope.interface import Interface class DummyInterface(Interface): pass field = self._makeOne(required=False) field.validate(DummyInterface) field.validate(None) def test_validate_required(self): from zope.interface import Interface from zope.schema.interfaces import RequiredMissing class DummyInterface(Interface): pass field = self._makeOne(required=True) field.validate(DummyInterface) self.assertRaises(RequiredMissing, field.validate, None) class AbstractCollectionTests(unittest.TestCase): def _getTargetClass(self): from zope.schema._field import AbstractCollection return AbstractCollection def _makeOne(self, *args, **kw): return self._getTargetClass()(*args, **kw) def test_ctor_defaults(self): absc = self._makeOne() self.assertEqual(absc.value_type, None) self.assertEqual(absc.unique, False) def test_ctor_explicit(self): from zope.schema._bootstrapfields import Text text = Text() absc = self._makeOne(text, True) self.assertEqual(absc.value_type, text) self.assertEqual(absc.unique, True) def test_ctor_w_non_field_value_type(self): class NotAField(object): pass self.assertRaises(ValueError, self._makeOne, NotAField) def test_bind_wo_value_Type(self): absc = self._makeOne() context = object() bound = absc.bind(context) self.assertEqual(bound.context, context) self.assertEqual(bound.value_type, None) self.assertEqual(bound.unique, False) def test_bind_w_value_Type(self): from zope.schema._bootstrapfields import Text text = Text() absc = self._makeOne(text, True) context = object() bound = absc.bind(context) self.assertEqual(bound.context, context) self.assertEqual(isinstance(bound.value_type, Text), True) self.assertEqual(bound.value_type.context, context) self.assertEqual(bound.unique, True) def test__validate_wrong_contained_type(self): from zope.schema.interfaces import WrongContainedType from zope.schema._bootstrapfields import Text text = Text() absc = self._makeOne(text) self.assertRaises(WrongContainedType, absc.validate, [1]) def test__validate_miss_uniqueness(self): from zope.schema.interfaces import NotUnique from zope.schema._bootstrapfields import Text from zope.schema._compat import u text = Text() absc = self._makeOne(text, True) self.assertRaises(NotUnique, absc.validate, [u('a'), u('a')]) class TupleTests(unittest.TestCase): def _getTargetClass(self): from zope.schema._field import Tuple return Tuple def _makeOne(self, *args, **kw): return self._getTargetClass()(*args, **kw) def test_class_conforms_to_ITuple(self): from zope.interface.verify import verifyClass from zope.schema.interfaces import ITuple verifyClass(ITuple, self._getTargetClass()) def test_instance_conforms_to_ITuple(self): from zope.interface.verify import verifyObject from zope.schema.interfaces import ITuple verifyObject(ITuple, self._makeOne()) def test_validate_wrong_types(self): from zope.schema.interfaces import WrongType from zope.schema._compat import u from zope.schema._compat import b field = self._makeOne() self.assertRaises(WrongType, field.validate, u('')) self.assertRaises(WrongType, field.validate, b('')) self.assertRaises(WrongType, field.validate, 1) self.assertRaises(WrongType, field.validate, 1.0) self.assertRaises(WrongType, field.validate, []) self.assertRaises(WrongType, field.validate, {}) self.assertRaises(WrongType, field.validate, set()) self.assertRaises(WrongType, field.validate, frozenset()) self.assertRaises(WrongType, field.validate, object()) def test_validate_not_required(self): field = self._makeOne(required=False) field.validate(()) field.validate((1, 2)) field.validate((3,)) field.validate(None) def test_validate_required(self): from zope.schema.interfaces import RequiredMissing field = self._makeOne() field.validate(()) field.validate((1, 2)) field.validate((3,)) self.assertRaises(RequiredMissing, field.validate, None) def test_validate_min_length(self): from zope.schema.interfaces import TooShort field = self._makeOne(min_length=2) field.validate((1, 2)) field.validate((1, 2, 3)) self.assertRaises(TooShort, field.validate, ()) self.assertRaises(TooShort, field.validate, (1,)) def test_validate_max_length(self): from zope.schema.interfaces import TooLong field = self._makeOne(max_length=2) field.validate(()) field.validate((1, 2)) self.assertRaises(TooLong, field.validate, (1, 2, 3, 4)) self.assertRaises(TooLong, field.validate, (1, 2, 3)) def test_validate_min_length_and_max_length(self): from zope.schema.interfaces import TooLong from zope.schema.interfaces import TooShort field = self._makeOne(min_length=1, max_length=2) field.validate((1, )) field.validate((1, 2)) self.assertRaises(TooShort, field.validate, ()) self.assertRaises(TooLong, field.validate, (1, 2, 3)) class ListTests(unittest.TestCase): def _getTargetClass(self): from zope.schema._field import List return List def _makeOne(self, *args, **kw): return self._getTargetClass()(*args, **kw) def test_class_conforms_to_IList(self): from zope.interface.verify import verifyClass from zope.schema.interfaces import IList verifyClass(IList, self._getTargetClass()) def test_instance_conforms_to_IList(self): from zope.interface.verify import verifyObject from zope.schema.interfaces import IList verifyObject(IList, self._makeOne()) def test_validate_wrong_types(self): from zope.schema.interfaces import WrongType from zope.schema._compat import u from zope.schema._compat import b field = self._makeOne() self.assertRaises(WrongType, field.validate, u('')) self.assertRaises(WrongType, field.validate, b('')) self.assertRaises(WrongType, field.validate, 1) self.assertRaises(WrongType, field.validate, 1.0) self.assertRaises(WrongType, field.validate, ()) self.assertRaises(WrongType, field.validate, {}) self.assertRaises(WrongType, field.validate, set()) self.assertRaises(WrongType, field.validate, frozenset()) self.assertRaises(WrongType, field.validate, object()) def test_validate_not_required(self): field = self._makeOne(required=False) field.validate([]) field.validate([1, 2]) field.validate([3]) field.validate(None) def test_validate_required(self): from zope.schema.interfaces import RequiredMissing field = self._makeOne() field.validate([]) field.validate([1, 2]) field.validate([3]) self.assertRaises(RequiredMissing, field.validate, None) def test_validate_min_length(self): from zope.schema.interfaces import TooShort field = self._makeOne(min_length=2) field.validate([1, 2]) field.validate([1, 2, 3]) self.assertRaises(TooShort, field.validate, []) self.assertRaises(TooShort, field.validate, [1,]) def test_validate_max_length(self): from zope.schema.interfaces import TooLong field = self._makeOne(max_length=2) field.validate([]) field.validate([1]) field.validate([1, 2]) self.assertRaises(TooLong, field.validate, [1, 2, 3, 4]) self.assertRaises(TooLong, field.validate, [1, 2, 3]) def test_validate_min_length_and_max_length(self): from zope.schema.interfaces import TooLong from zope.schema.interfaces import TooShort field = self._makeOne(min_length=1, max_length=2) field.validate([1]) field.validate([1, 2]) self.assertRaises(TooShort, field.validate, []) self.assertRaises(TooLong, field.validate, [1, 2, 3]) class SetTests(unittest.TestCase): def _getTargetClass(self): from zope.schema._field import Set return Set def _makeOne(self, *args, **kw): return self._getTargetClass()(*args, **kw) def test_class_conforms_to_ISet(self): from zope.interface.verify import verifyClass from zope.schema.interfaces import ISet verifyClass(ISet, self._getTargetClass()) def test_instance_conforms_to_ISet(self): from zope.interface.verify import verifyObject from zope.schema.interfaces import ISet verifyObject(ISet, self._makeOne()) def test_ctor_disallows_unique(self): self.assertRaises(TypeError, self._makeOne, unique=False) self.assertRaises(TypeError, self._makeOne, unique=True) self.assertTrue(self._makeOne().unique) def test_validate_wrong_types(self): from zope.schema.interfaces import WrongType from zope.schema._compat import u from zope.schema._compat import b field = self._makeOne() self.assertRaises(WrongType, field.validate, u('')) self.assertRaises(WrongType, field.validate, b('')) self.assertRaises(WrongType, field.validate, 1) self.assertRaises(WrongType, field.validate, 1.0) self.assertRaises(WrongType, field.validate, ()) self.assertRaises(WrongType, field.validate, []) self.assertRaises(WrongType, field.validate, {}) self.assertRaises(WrongType, field.validate, frozenset()) self.assertRaises(WrongType, field.validate, object()) def test_validate_not_required(self): field = self._makeOne(required=False) field.validate(set()) field.validate(set((1, 2))) field.validate(set((3,))) field.validate(None) def test_validate_required(self): from zope.schema.interfaces import RequiredMissing field = self._makeOne() field.validate(set()) field.validate(set((1, 2))) field.validate(set((3,))) field.validate(set()) field.validate(set((1, 2))) field.validate(set((3,))) self.assertRaises(RequiredMissing, field.validate, None) def test_validate_min_length(self): from zope.schema.interfaces import TooShort field = self._makeOne(min_length=2) field.validate(set((1, 2))) field.validate(set((1, 2, 3))) self.assertRaises(TooShort, field.validate, set()) self.assertRaises(TooShort, field.validate, set((1,))) def test_validate_max_length(self): from zope.schema.interfaces import TooLong field = self._makeOne(max_length=2) field.validate(set()) field.validate(set((1,))) field.validate(set((1, 2))) self.assertRaises(TooLong, field.validate, set((1, 2, 3, 4))) self.assertRaises(TooLong, field.validate, set((1, 2, 3))) def test_validate_min_length_and_max_length(self): from zope.schema.interfaces import TooLong from zope.schema.interfaces import TooShort field = self._makeOne(min_length=1, max_length=2) field.validate(set((1,))) field.validate(set((1, 2))) self.assertRaises(TooShort, field.validate, set()) self.assertRaises(TooLong, field.validate, set((1, 2, 3))) class FrozenSetTests(unittest.TestCase): def _getTargetClass(self): from zope.schema._field import FrozenSet return FrozenSet def _makeOne(self, *args, **kw): return self._getTargetClass()(*args, **kw) def test_class_conforms_to_IFrozenSet(self): from zope.interface.verify import verifyClass from zope.schema.interfaces import IFrozenSet verifyClass(IFrozenSet, self._getTargetClass()) def test_instance_conforms_to_IFrozenSet(self): from zope.interface.verify import verifyObject from zope.schema.interfaces import IFrozenSet verifyObject(IFrozenSet, self._makeOne()) def test_ctor_disallows_unique(self): self.assertRaises(TypeError, self._makeOne, unique=False) self.assertRaises(TypeError, self._makeOne, unique=True) self.assertTrue(self._makeOne().unique) def test_validate_wrong_types(self): from zope.schema.interfaces import WrongType from zope.schema._compat import u from zope.schema._compat import b field = self._makeOne() self.assertRaises(WrongType, field.validate, u('')) self.assertRaises(WrongType, field.validate, b('')) self.assertRaises(WrongType, field.validate, 1) self.assertRaises(WrongType, field.validate, 1.0) self.assertRaises(WrongType, field.validate, ()) self.assertRaises(WrongType, field.validate, []) self.assertRaises(WrongType, field.validate, {}) self.assertRaises(WrongType, field.validate, set()) self.assertRaises(WrongType, field.validate, object()) def test_validate_not_required(self): field = self._makeOne(required=False) field.validate(frozenset()) field.validate(frozenset((1, 2))) field.validate(frozenset((3,))) field.validate(None) def test_validate_required(self): from zope.schema.interfaces import RequiredMissing field = self._makeOne() field.validate(frozenset()) field.validate(frozenset((1, 2))) field.validate(frozenset((3,))) self.assertRaises(RequiredMissing, field.validate, None) def test_validate_min_length(self): from zope.schema.interfaces import TooShort field = self._makeOne(min_length=2) field.validate(frozenset((1, 2))) field.validate(frozenset((1, 2, 3))) self.assertRaises(TooShort, field.validate, frozenset()) self.assertRaises(TooShort, field.validate, frozenset((1,))) def test_validate_max_length(self): from zope.schema.interfaces import TooLong field = self._makeOne(max_length=2) field.validate(frozenset()) field.validate(frozenset((1,))) field.validate(frozenset((1, 2))) self.assertRaises(TooLong, field.validate, frozenset((1, 2, 3, 4))) self.assertRaises(TooLong, field.validate, frozenset((1, 2, 3))) def test_validate_min_length_and_max_length(self): from zope.schema.interfaces import TooLong from zope.schema.interfaces import TooShort field = self._makeOne(min_length=1, max_length=2) field.validate(frozenset((1,))) field.validate(frozenset((1, 2))) self.assertRaises(TooShort, field.validate, frozenset()) self.assertRaises(TooLong, field.validate, frozenset((1, 2, 3))) class ObjectTests(unittest.TestCase): def setUp(self): from zope.event import subscribers self._before = subscribers[:] def tearDown(self): from zope.event import subscribers subscribers[:] = self._before def _getTargetClass(self): from zope.schema._field import Object return Object def _makeOne(self, schema=None, *args, **kw): if schema is None: schema = self._makeSchema() return self._getTargetClass()(schema, *args, **kw) def _makeSchema(self, **kw): from zope.interface import Interface from zope.interface.interface import InterfaceClass return InterfaceClass('ISchema', (Interface,), kw) def _getErrors(self, f, *args, **kw): from zope.schema.interfaces import WrongContainedType try: f(*args, **kw) except WrongContainedType as e: try: return e.args[0] except: return [] self.fail('Expected WrongContainedType Error') def _makeCycles(self): from zope.interface import Interface from zope.interface import implementer from zope.schema import Object from zope.schema import List from zope.schema._messageid import _ class IUnit(Interface): """A schema that participate to a cycle""" boss = Object( schema=Interface, title=_("Boss"), description=_("Boss description"), required=False, ) members = List( value_type=Object(schema=Interface), title=_("Member List"), description=_("Member list description"), required=False, ) class IPerson(Interface): """A schema that participate to a cycle""" unit = Object( schema=IUnit, title=_("Unit"), description=_("Unit description"), required=False, ) IUnit['boss'].schema = IPerson IUnit['members'].value_type.schema = IPerson @implementer(IUnit) class Unit(object): def __init__(self, person, person_list): self.boss = person self.members = person_list @implementer(IPerson) class Person(object): def __init__(self, unit): self.unit = unit return IUnit, Person, Unit def test_class_conforms_to_IObject(self): from zope.interface.verify import verifyClass from zope.schema.interfaces import IObject verifyClass(IObject, self._getTargetClass()) def test_instance_conforms_to_IObject(self): from zope.interface.verify import verifyObject from zope.schema.interfaces import IObject verifyObject(IObject, self._makeOne()) def test_ctor_w_bad_schema(self): from zope.schema.interfaces import WrongType self.assertRaises(WrongType, self._makeOne, object()) def test_validate_not_required(self): schema = self._makeSchema() objf = self._makeOne(schema, required=False) objf.validate(None) # doesn't raise def test_validate_required(self): from zope.schema.interfaces import RequiredMissing field = self._makeOne(required=True) self.assertRaises(RequiredMissing, field.validate, None) def test__validate_w_empty_schema(self): from zope.interface import Interface objf = self._makeOne(Interface) objf.validate(object()) # doesn't raise def test__validate_w_value_not_providing_schema(self): from zope.schema.interfaces import SchemaNotProvided from zope.schema._bootstrapfields import Text schema = self._makeSchema(foo=Text(), bar=Text()) objf = self._makeOne(schema) self.assertRaises(SchemaNotProvided, objf.validate, object()) def test__validate_w_value_providing_schema_but_missing_fields(self): from zope.interface import implementer from zope.schema.interfaces import SchemaNotFullyImplemented from zope.schema.interfaces import WrongContainedType from zope.schema._bootstrapfields import Text schema = self._makeSchema(foo=Text(), bar=Text()) @implementer(schema) class Broken(object): pass objf = self._makeOne(schema) self.assertRaises(WrongContainedType, objf.validate, Broken()) errors = self._getErrors(objf.validate, Broken()) self.assertEqual(len(errors), 2) errors = sorted(errors, key=lambda x: (type(x).__name__, str(x.args[0]))) err = errors[0] self.assertTrue(isinstance(err, SchemaNotFullyImplemented)) nested = err.args[0] self.assertTrue(isinstance(nested, AttributeError)) self.assertTrue("'bar'" in str(nested)) err = errors[1] self.assertTrue(isinstance(err, SchemaNotFullyImplemented)) nested = err.args[0] self.assertTrue(isinstance(nested, AttributeError)) self.assertTrue("'foo'" in str(nested)) def test__validate_w_value_providing_schema_but_invalid_fields(self): from zope.interface import implementer from zope.schema.interfaces import WrongContainedType from zope.schema.interfaces import RequiredMissing from zope.schema.interfaces import WrongType from zope.schema._bootstrapfields import Text from zope.schema._compat import text_type schema = self._makeSchema(foo=Text(), bar=Text()) @implementer(schema) class Broken(object): foo = None bar = 1 objf = self._makeOne(schema) self.assertRaises(WrongContainedType, objf.validate, Broken()) errors = self._getErrors(objf.validate, Broken()) self.assertEqual(len(errors), 2) errors = sorted(errors, key=lambda x: type(x).__name__) err = errors[0] self.assertTrue(isinstance(err, RequiredMissing)) self.assertEqual(err.args, ('foo',)) err = errors[1] self.assertTrue(isinstance(err, WrongType)) self.assertEqual(err.args, (1, text_type, 'bar')) def test__validate_w_value_providing_schema(self): from zope.interface import implementer from zope.schema._bootstrapfields import Text from zope.schema._field import Choice from zope.schema._compat import u schema = self._makeSchema(foo=Text(), bar=Text(), baz=Choice(values=[1, 2, 3]), ) @implementer(schema) class OK(object): foo = u('Foo') bar = u('Bar') baz = 2 objf = self._makeOne(schema) objf.validate(OK()) # doesn't raise def test_validate_w_cycles(self): IUnit, Person, Unit = self._makeCycles() field = self._makeOne(schema=IUnit) person1 = Person(None) person2 = Person(None) unit = Unit(person1, [person1, person2]) person1.unit = unit person2.unit = unit field.validate(unit) #doesn't raise def test_validate_w_cycles_object_not_valid(self): from zope.schema.interfaces import WrongContainedType IUnit, Person, Unit = self._makeCycles() field = self._makeOne(schema=IUnit) person1 = Person(None) person2 = Person(None) person3 = Person(DummyInstance()) unit = Unit(person3, [person1, person2]) person1.unit = unit person2.unit = unit self.assertRaises(WrongContainedType, field.validate, unit) def test_validate_w_cycles_collection_not_valid(self): from zope.schema.interfaces import WrongContainedType IUnit, Person, Unit = self._makeCycles() field = self._makeOne(schema=IUnit) person1 = Person(None) person2 = Person(None) person3 = Person(DummyInstance()) unit = Unit(person1, [person2, person3]) person1.unit = unit person2.unit = unit self.assertRaises(WrongContainedType, field.validate, unit) def test_set_emits_IBOAE(self): from zope.event import subscribers from zope.interface import implementer from zope.schema.interfaces import IBeforeObjectAssignedEvent from zope.schema._bootstrapfields import Text from zope.schema._field import Choice from zope.schema._compat import u schema = self._makeSchema(foo=Text(), bar=Text(), baz=Choice(values=[1, 2, 3]), ) @implementer(schema) class OK(object): foo = u('Foo') bar = u('Bar') baz = 2 log = [] subscribers.append(log.append) objf = self._makeOne(schema, __name__='field') inst = DummyInstance() value = OK() objf.set(inst, value) self.assertEqual(inst.field is value, True) self.assertEqual(len(log), 1) self.assertEqual(IBeforeObjectAssignedEvent.providedBy(log[0]), True) self.assertEqual(log[0].object, value) self.assertEqual(log[0].name, 'field') self.assertEqual(log[0].context, inst) def test_set_allows_IBOAE_subscr_to_replace_value(self): from zope.event import subscribers from zope.interface import implementer from zope.schema._bootstrapfields import Text from zope.schema._field import Choice from zope.schema._compat import u schema = self._makeSchema(foo=Text(), bar=Text(), baz=Choice(values=[1, 2, 3]), ) @implementer(schema) class OK(object): def __init__(self, foo=u('Foo'), bar=u('Bar'), baz=2): self.foo = foo self.bar = bar self.baz = baz ok1 = OK() ok2 = OK(u('Foo2'), u('Bar2'), 3) log = [] subscribers.append(log.append) def _replace(event): event.object = ok2 subscribers.append(_replace) objf = self._makeOne(schema, __name__='field') inst = DummyInstance() objf.set(inst, ok1) self.assertEqual(inst.field is ok2, True) self.assertEqual(len(log), 1) self.assertEqual(log[0].object, ok2) self.assertEqual(log[0].name, 'field') self.assertEqual(log[0].context, inst) class DictTests(unittest.TestCase): def _getTargetClass(self): from zope.schema._field import Dict return Dict def _makeOne(self, *args, **kw): return self._getTargetClass()(*args, **kw) def test_class_conforms_to_IDict(self): from zope.interface.verify import verifyClass from zope.schema.interfaces import IDict verifyClass(IDict, self._getTargetClass()) def test_instance_conforms_to_IDict(self): from zope.interface.verify import verifyObject from zope.schema.interfaces import IDict verifyObject(IDict, self._makeOne()) def test_ctor_key_type_not_IField(self): self.assertRaises(ValueError, self._makeOne, key_type=object()) def test_ctor_value_type_not_IField(self): self.assertRaises(ValueError, self._makeOne, value_type=object()) def test_validate_wrong_types(self): from zope.schema.interfaces import WrongType from zope.schema._compat import u from zope.schema._compat import b field = self._makeOne() self.assertRaises(WrongType, field.validate, u('')) self.assertRaises(WrongType, field.validate, b('')) self.assertRaises(WrongType, field.validate, 1) self.assertRaises(WrongType, field.validate, 1.0) self.assertRaises(WrongType, field.validate, ()) self.assertRaises(WrongType, field.validate, []) self.assertRaises(WrongType, field.validate, set()) self.assertRaises(WrongType, field.validate, frozenset()) self.assertRaises(WrongType, field.validate, object()) def test_validate_not_required(self): field = self._makeOne(required=False) field.validate({}) field.validate({1: 'b', 2: 'd'}) field.validate({3: 'a'}) field.validate(None) def test_validate_required(self): from zope.schema.interfaces import RequiredMissing field = self._makeOne() field.validate({}) field.validate({1: 'b', 2: 'd'}) field.validate({3: 'a'}) self.assertRaises(RequiredMissing, field.validate, None) def test_validate_invalid_key_type(self): from zope.schema.interfaces import WrongContainedType from zope.schema._bootstrapfields import Int field = self._makeOne(key_type=Int()) field.validate({}) field.validate({1: 'b', 2: 'd'}) field.validate({3: 'a'}) self.assertRaises(WrongContainedType, field.validate, {'a': 1}) def test_validate_invalid_value_type(self): from zope.schema.interfaces import WrongContainedType from zope.schema._bootstrapfields import Int field = self._makeOne(value_type=Int()) field.validate({}) field.validate({'b': 1, 'd': 2}) field.validate({'a': 3}) self.assertRaises(WrongContainedType, field.validate, {1: 'a'}) def test_validate_min_length(self): from zope.schema.interfaces import TooShort field = self._makeOne(min_length=1) field.validate({1: 'a'}) field.validate({1: 'a', 2: 'b'}) self.assertRaises(TooShort, field.validate, {}) def test_validate_max_length(self): from zope.schema.interfaces import TooLong field = self._makeOne(max_length=1) field.validate({}) field.validate({1: 'a'}) self.assertRaises(TooLong, field.validate, {1: 'a', 2: 'b'}) self.assertRaises(TooLong, field.validate, {1: 'a', 2: 'b', 3: 'c'}) def test_validate_min_length_and_max_length(self): from zope.schema.interfaces import TooLong from zope.schema.interfaces import TooShort field = self._makeOne(min_length=1, max_length=2) field.validate({1: 'a'}) field.validate({1: 'a', 2: 'b'}) self.assertRaises(TooShort, field.validate, {}) self.assertRaises(TooLong, field.validate, {1: 'a', 2: 'b', 3: 'c'}) def test_bind_binds_key_and_value_types(self): from zope.schema import Int field = self._makeOne(key_type=Int(), value_type=Int()) context = DummyInstance() field2 = field.bind(context) self.assertEqual(field2.key_type.context, context) self.assertEqual(field2.value_type.context, context) class URITests(unittest.TestCase): def _getTargetClass(self): from zope.schema._field import URI return URI def _makeOne(self, *args, **kw): return self._getTargetClass()(*args, **kw) def test_class_conforms_to_IURI(self): from zope.interface.verify import verifyClass from zope.schema.interfaces import IURI verifyClass(IURI, self._getTargetClass()) def test_instance_conforms_to_IURI(self): from zope.interface.verify import verifyObject from zope.schema.interfaces import IURI verifyObject(IURI, self._makeOne()) def test_validate_wrong_types(self): from zope.schema.interfaces import WrongType from zope.schema._compat import non_native_string field = self._makeOne() self.assertRaises(WrongType, field.validate, non_native_string('')) self.assertRaises(WrongType, field.validate, 1) self.assertRaises(WrongType, field.validate, 1.0) self.assertRaises(WrongType, field.validate, ()) self.assertRaises(WrongType, field.validate, []) self.assertRaises(WrongType, field.validate, {}) self.assertRaises(WrongType, field.validate, set()) self.assertRaises(WrongType, field.validate, frozenset()) self.assertRaises(WrongType, field.validate, object()) def test_validate_not_required(self): field = self._makeOne(required=False) field.validate('http://example.com/') field.validate(None) def test_validate_required(self): from zope.schema.interfaces import RequiredMissing field = self._makeOne() field.validate('http://example.com/') self.assertRaises(RequiredMissing, field.validate, None) def test_validate_not_a_uri(self): from zope.schema.interfaces import ConstraintNotSatisfied from zope.schema.interfaces import InvalidURI field = self._makeOne() self.assertRaises(InvalidURI, field.validate, '') self.assertRaises(InvalidURI, field.validate, 'abc') self.assertRaises(InvalidURI, field.validate, '\xab\xde') self.assertRaises(ConstraintNotSatisfied, field.validate, 'http://example.com/\nDAV:') def test_fromUnicode_ok(self): from zope.schema._compat import u field = self._makeOne() self.assertEqual(field.fromUnicode(u('http://example.com/')), 'http://example.com/') def test_fromUnicode_invalid(self): from zope.schema.interfaces import ConstraintNotSatisfied from zope.schema.interfaces import InvalidURI from zope.schema._compat import u field = self._makeOne() self.assertRaises(InvalidURI, field.fromUnicode, u('')) self.assertRaises(InvalidURI, field.fromUnicode, u('abc')) self.assertRaises(ConstraintNotSatisfied, field.fromUnicode, u('http://example.com/\nDAV:')) class IdTests(unittest.TestCase): def _getTargetClass(self): from zope.schema._field import Id return Id def _makeOne(self, *args, **kw): return self._getTargetClass()(*args, **kw) def test_class_conforms_to_IId(self): from zope.interface.verify import verifyClass from zope.schema.interfaces import IId verifyClass(IId, self._getTargetClass()) def test_instance_conforms_to_IId(self): from zope.interface.verify import verifyObject from zope.schema.interfaces import IId verifyObject(IId, self._makeOne()) def test_validate_wrong_types(self): from zope.schema.interfaces import WrongType from zope.schema._compat import non_native_string field = self._makeOne() self.assertRaises(WrongType, field.validate, non_native_string('')) self.assertRaises(WrongType, field.validate, 1) self.assertRaises(WrongType, field.validate, 1.0) self.assertRaises(WrongType, field.validate, ()) self.assertRaises(WrongType, field.validate, []) self.assertRaises(WrongType, field.validate, {}) self.assertRaises(WrongType, field.validate, set()) self.assertRaises(WrongType, field.validate, frozenset()) self.assertRaises(WrongType, field.validate, object()) def test_validate_not_required(self): field = self._makeOne(required=False) field.validate('http://example.com/') field.validate('dotted.name') field.validate(None) def test_validate_required(self): from zope.schema.interfaces import RequiredMissing field = self._makeOne() field.validate('http://example.com/') field.validate('dotted.name') self.assertRaises(RequiredMissing, field.validate, None) def test_validate_not_a_uri(self): from zope.schema.interfaces import ConstraintNotSatisfied from zope.schema.interfaces import InvalidId field = self._makeOne() self.assertRaises(InvalidId, field.validate, '') self.assertRaises(InvalidId, field.validate, 'abc') self.assertRaises(InvalidId, field.validate, '\xab\xde') self.assertRaises(ConstraintNotSatisfied, field.validate, 'http://example.com/\nDAV:') def test_fromUnicode_url_ok(self): from zope.schema._compat import u field = self._makeOne() self.assertEqual(field.fromUnicode(u('http://example.com/')), 'http://example.com/') def test_fromUnicode_dotted_name_ok(self): from zope.schema._compat import u field = self._makeOne() self.assertEqual(field.fromUnicode(u('dotted.name')), 'dotted.name') def test_fromUnicode_invalid(self): from zope.schema.interfaces import ConstraintNotSatisfied from zope.schema.interfaces import InvalidId from zope.schema._compat import u field = self._makeOne() self.assertRaises(InvalidId, field.fromUnicode, u('')) self.assertRaises(InvalidId, field.fromUnicode, u('abc')) self.assertRaises(ConstraintNotSatisfied, field.fromUnicode, u('http://example.com/\nDAV:')) class DottedNameTests(unittest.TestCase): def _getTargetClass(self): from zope.schema._field import DottedName return DottedName def _makeOne(self, *args, **kw): return self._getTargetClass()(*args, **kw) def test_class_conforms_to_IDottedName(self): from zope.interface.verify import verifyClass from zope.schema.interfaces import IDottedName verifyClass(IDottedName, self._getTargetClass()) def test_instance_conforms_to_IDottedName(self): from zope.interface.verify import verifyObject from zope.schema.interfaces import IDottedName verifyObject(IDottedName, self._makeOne()) def test_ctor_defaults(self): dotted = self._makeOne() self.assertEqual(dotted.min_dots, 0) self.assertEqual(dotted.max_dots, None) def test_ctor_min_dots_invalid(self): self.assertRaises(ValueError, self._makeOne, min_dots=-1) def test_ctor_min_dots_valid(self): dotted = self._makeOne(min_dots=1) self.assertEqual(dotted.min_dots, 1) def test_ctor_max_dots_invalid(self): self.assertRaises(ValueError, self._makeOne, min_dots=2, max_dots=1) def test_ctor_max_dots_valid(self): dotted = self._makeOne(max_dots=2) self.assertEqual(dotted.max_dots, 2) def test_validate_wrong_types(self): from zope.schema.interfaces import WrongType from zope.schema._compat import non_native_string field = self._makeOne() self.assertRaises(WrongType, field.validate, non_native_string('')) self.assertRaises(WrongType, field.validate, 1) self.assertRaises(WrongType, field.validate, 1.0) self.assertRaises(WrongType, field.validate, ()) self.assertRaises(WrongType, field.validate, []) self.assertRaises(WrongType, field.validate, {}) self.assertRaises(WrongType, field.validate, set()) self.assertRaises(WrongType, field.validate, frozenset()) self.assertRaises(WrongType, field.validate, object()) def test_validate_not_required(self): field = self._makeOne(required=False) field.validate('name') field.validate('dotted.name') field.validate(None) def test_validate_required(self): from zope.schema.interfaces import RequiredMissing field = self._makeOne() field.validate('name') field.validate('dotted.name') self.assertRaises(RequiredMissing, field.validate, None) def test_validate_w_min_dots(self): from zope.schema.interfaces import InvalidDottedName field = self._makeOne(min_dots=1) self.assertRaises(InvalidDottedName, field.validate, 'name') field.validate('dotted.name') field.validate('moar.dotted.name') def test_validate_w_max_dots(self): from zope.schema.interfaces import InvalidDottedName field = self._makeOne(max_dots=1) field.validate('name') field.validate('dotted.name') self.assertRaises(InvalidDottedName, field.validate, 'moar.dotted.name') def test_validate_not_a_dotted_name(self): from zope.schema.interfaces import ConstraintNotSatisfied from zope.schema.interfaces import InvalidDottedName field = self._makeOne() self.assertRaises(InvalidDottedName, field.validate, '') self.assertRaises(InvalidDottedName, field.validate, '\xab\xde') self.assertRaises(ConstraintNotSatisfied, field.validate, 'http://example.com/\nDAV:') def test_fromUnicode_dotted_name_ok(self): from zope.schema._compat import u field = self._makeOne() self.assertEqual(field.fromUnicode(u('dotted.name')), 'dotted.name') def test_fromUnicode_invalid(self): from zope.schema.interfaces import ConstraintNotSatisfied from zope.schema.interfaces import InvalidDottedName from zope.schema._compat import u field = self._makeOne() self.assertRaises(InvalidDottedName, field.fromUnicode, u('')) self.assertRaises(ConstraintNotSatisfied, field.fromUnicode, u('http://example.com/\nDAV:')) class DummyInstance(object): pass def _makeSampleVocabulary(): from zope.interface import implementer from zope.schema.interfaces import IVocabulary class SampleTerm(object): pass @implementer(IVocabulary) class SampleVocabulary(object): def __iter__(self): return iter([self.getTerm(x) for x in range(0, 10)]) def __contains__(self, value): return 0 <= value < 10 def __len__(self): return 10 def getTerm(self, value): if value in self: t = SampleTerm() t.value = value t.double = 2 * value return t raise LookupError("no such value: %r" % value) return SampleVocabulary() def _makeDummyRegistry(v): from zope.schema.vocabulary import VocabularyRegistry class DummyRegistry(VocabularyRegistry): def __init__(self, vocabulary): self._vocabulary = vocabulary def get(self, object, name): return self._vocabulary return DummyRegistry(v) def test_suite(): return unittest.TestSuite(( unittest.makeSuite(BytesTests), unittest.makeSuite(ASCIITests), unittest.makeSuite(BytesLineTests), unittest.makeSuite(ASCIILineTests), unittest.makeSuite(FloatTests), unittest.makeSuite(DecimalTests), unittest.makeSuite(DatetimeTests), unittest.makeSuite(DateTests), unittest.makeSuite(TimedeltaTests), unittest.makeSuite(TimeTests), unittest.makeSuite(ChoiceTests), unittest.makeSuite(InterfaceFieldTests), unittest.makeSuite(AbstractCollectionTests), unittest.makeSuite(TupleTests), unittest.makeSuite(ListTests), unittest.makeSuite(SetTests), unittest.makeSuite(FrozenSetTests), unittest.makeSuite(ObjectTests), unittest.makeSuite(DictTests), unittest.makeSuite(URITests), unittest.makeSuite(IdTests), unittest.makeSuite(DottedNameTests), ))