mirror of
https://github.com/nottinghamtec/PyRIGS.git
synced 2026-01-18 14:02:15 +00:00
2123 lines
79 KiB
Python
2123 lines
79 KiB
Python
##############################################################################
|
|
#
|
|
# 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 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 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 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 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), 5)
|
|
self.assertEqual(IBeforeObjectAssignedEvent.providedBy(log[-1]), True)
|
|
self.assertEqual(log[-1].object, value)
|
|
self.assertEqual(log[-1].name, 'field')
|
|
self.assertEqual(log[-1].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()
|
|
self.assertEqual(len(log), 4)
|
|
objf.set(inst, ok1)
|
|
self.assertEqual(inst.field is ok2, True)
|
|
self.assertEqual(len(log), 5)
|
|
self.assertEqual(log[-1].object, ok2)
|
|
self.assertEqual(log[-1].name, 'field')
|
|
self.assertEqual(log[-1].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 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),
|
|
))
|