mirror of
https://github.com/nottinghamtec/PyRIGS.git
synced 2026-01-17 13:32:15 +00:00
823 lines
28 KiB
Python
823 lines
28 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 ValidatedPropertyTests(unittest.TestCase):
|
|
|
|
def _getTargetClass(self):
|
|
from zope.schema._bootstrapfields import ValidatedProperty
|
|
return ValidatedProperty
|
|
|
|
def _makeOne(self, *args, **kw):
|
|
return self._getTargetClass()(*args, **kw)
|
|
|
|
def test___set___not_missing_w_check(self):
|
|
_checked = []
|
|
|
|
def _check(inst, value):
|
|
_checked.append((inst, value))
|
|
|
|
class Test(DummyInst):
|
|
_prop = None
|
|
prop = self._makeOne('_prop', _check)
|
|
inst = Test()
|
|
inst.prop = 'PROP'
|
|
self.assertEqual(inst._prop, 'PROP')
|
|
self.assertEqual(_checked, [(inst, 'PROP')])
|
|
|
|
def test___set___not_missing_wo_check(self):
|
|
class Test(DummyInst):
|
|
_prop = None
|
|
prop = self._makeOne('_prop')
|
|
inst = Test(ValueError)
|
|
|
|
def _provoke(inst):
|
|
inst.prop = 'PROP'
|
|
self.assertRaises(ValueError, _provoke, inst)
|
|
self.assertEqual(inst._prop, None)
|
|
|
|
def test___set___w_missing_wo_check(self):
|
|
class Test(DummyInst):
|
|
_prop = None
|
|
prop = self._makeOne('_prop')
|
|
inst = Test(ValueError)
|
|
inst.prop = DummyInst.missing_value
|
|
self.assertEqual(inst._prop, DummyInst.missing_value)
|
|
|
|
def test___get__(self):
|
|
class Test(DummyInst):
|
|
_prop = None
|
|
prop = self._makeOne('_prop')
|
|
inst = Test()
|
|
inst._prop = 'PROP'
|
|
self.assertEqual(inst.prop, 'PROP')
|
|
|
|
|
|
class DefaultPropertyTests(unittest.TestCase):
|
|
|
|
def _getTargetClass(self):
|
|
from zope.schema._bootstrapfields import DefaultProperty
|
|
return DefaultProperty
|
|
|
|
def _makeOne(self, *args, **kw):
|
|
return self._getTargetClass()(*args, **kw)
|
|
|
|
def test___get___wo_defaultFactory_miss(self):
|
|
class Test(DummyInst):
|
|
_prop = None
|
|
prop = self._makeOne('_prop')
|
|
inst = Test()
|
|
inst.defaultFactory = None
|
|
|
|
def _provoke(inst):
|
|
return inst.prop
|
|
self.assertRaises(KeyError, _provoke, inst)
|
|
|
|
def test___get___wo_defaultFactory_hit(self):
|
|
class Test(DummyInst):
|
|
_prop = None
|
|
prop = self._makeOne('_prop')
|
|
inst = Test()
|
|
inst.defaultFactory = None
|
|
inst._prop = 'PROP'
|
|
self.assertEqual(inst.prop, 'PROP')
|
|
|
|
def test__get___wo_defaultFactory_in_dict(self):
|
|
class Test(DummyInst):
|
|
_prop = None
|
|
prop = self._makeOne('_prop')
|
|
inst = Test()
|
|
inst._prop = 'PROP'
|
|
self.assertEqual(inst.prop, 'PROP')
|
|
|
|
def test___get___w_defaultFactory_not_ICAF_no_check(self):
|
|
class Test(DummyInst):
|
|
_prop = None
|
|
prop = self._makeOne('_prop')
|
|
inst = Test(ValueError)
|
|
|
|
def _factory():
|
|
return 'PROP'
|
|
inst.defaultFactory = _factory
|
|
|
|
def _provoke(inst):
|
|
return inst.prop
|
|
self.assertRaises(ValueError, _provoke, inst)
|
|
|
|
def test___get___w_defaultFactory_w_ICAF_w_check(self):
|
|
from zope.interface import directlyProvides
|
|
from zope.schema._bootstrapinterfaces \
|
|
import IContextAwareDefaultFactory
|
|
_checked = []
|
|
|
|
def _check(inst, value):
|
|
_checked.append((inst, value))
|
|
|
|
class Test(DummyInst):
|
|
_prop = None
|
|
prop = self._makeOne('_prop', _check)
|
|
inst = Test(ValueError)
|
|
inst.context = object()
|
|
_called_with = []
|
|
|
|
def _factory(context):
|
|
_called_with.append(context)
|
|
return 'PROP'
|
|
directlyProvides(_factory, IContextAwareDefaultFactory)
|
|
inst.defaultFactory = _factory
|
|
self.assertEqual(inst.prop, 'PROP')
|
|
self.assertEqual(_checked, [(inst, 'PROP')])
|
|
self.assertEqual(_called_with, [inst.context])
|
|
|
|
|
|
class FieldTests(unittest.TestCase):
|
|
|
|
def _getTargetClass(self):
|
|
from zope.schema._bootstrapfields import Field
|
|
return Field
|
|
|
|
def _makeOne(self, *args, **kw):
|
|
return self._getTargetClass()(*args, **kw)
|
|
|
|
def test_ctor_defaults(self):
|
|
from zope.schema._compat import u
|
|
field = self._makeOne()
|
|
self.assertEqual(field.__name__, u(''))
|
|
self.assertEqual(field.__doc__, u(''))
|
|
self.assertEqual(field.title, u(''))
|
|
self.assertEqual(field.description, u(''))
|
|
self.assertEqual(field.required, True)
|
|
self.assertEqual(field.readonly, False)
|
|
self.assertEqual(field.constraint(object()), True)
|
|
self.assertEqual(field.default, None)
|
|
self.assertEqual(field.defaultFactory, None)
|
|
self.assertEqual(field.missing_value, None)
|
|
self.assertEqual(field.context, None)
|
|
|
|
def test_ctor_w_title_wo_description(self):
|
|
from zope.schema._compat import u
|
|
field = self._makeOne(u('TITLE'))
|
|
self.assertEqual(field.__name__, u(''))
|
|
self.assertEqual(field.__doc__, u('TITLE'))
|
|
self.assertEqual(field.title, u('TITLE'))
|
|
self.assertEqual(field.description, u(''))
|
|
|
|
def test_ctor_wo_title_w_description(self):
|
|
from zope.schema._compat import u
|
|
field = self._makeOne(description=u('DESC'))
|
|
self.assertEqual(field.__name__, u(''))
|
|
self.assertEqual(field.__doc__, u('DESC'))
|
|
self.assertEqual(field.title, u(''))
|
|
self.assertEqual(field.description, u('DESC'))
|
|
|
|
def test_ctor_w_both_title_and_description(self):
|
|
from zope.schema._compat import u
|
|
field = self._makeOne(u('TITLE'), u('DESC'), u('NAME'))
|
|
self.assertEqual(field.__name__, u('NAME'))
|
|
self.assertEqual(field.__doc__, u('TITLE\n\nDESC'))
|
|
self.assertEqual(field.title, u('TITLE'))
|
|
self.assertEqual(field.description, u('DESC'))
|
|
|
|
def test_ctor_order_madness(self):
|
|
klass = self._getTargetClass()
|
|
order_before = klass.order
|
|
field = self._makeOne()
|
|
order_after = klass.order
|
|
self.assertEqual(order_after, order_before + 1)
|
|
self.assertEqual(field.order, order_after)
|
|
|
|
def test_explicit_required_readonly_missingValue(self):
|
|
obj = object()
|
|
field = self._makeOne(required=False, readonly=True, missing_value=obj)
|
|
self.assertEqual(field.required, False)
|
|
self.assertEqual(field.readonly, True)
|
|
self.assertEqual(field.missing_value, obj)
|
|
|
|
def test_explicit_constraint_default(self):
|
|
_called_with = []
|
|
obj = object()
|
|
|
|
def _constraint(value):
|
|
_called_with.append(value)
|
|
return value is obj
|
|
field = self._makeOne(
|
|
required=False, readonly=True, constraint=_constraint, default=obj
|
|
)
|
|
self.assertEqual(field.required, False)
|
|
self.assertEqual(field.readonly, True)
|
|
self.assertEqual(_called_with, [obj])
|
|
self.assertEqual(field.constraint(self), False)
|
|
self.assertEqual(_called_with, [obj, self])
|
|
self.assertEqual(field.default, obj)
|
|
|
|
def test_explicit_defaultFactory(self):
|
|
_called_with = []
|
|
obj = object()
|
|
|
|
def _constraint(value):
|
|
_called_with.append(value)
|
|
return value is obj
|
|
|
|
def _factory():
|
|
return obj
|
|
field = self._makeOne(
|
|
required=False,
|
|
readonly=True,
|
|
constraint=_constraint,
|
|
defaultFactory=_factory,
|
|
)
|
|
self.assertEqual(field.required, False)
|
|
self.assertEqual(field.readonly, True)
|
|
self.assertEqual(field.constraint(self), False)
|
|
self.assertEqual(_called_with, [self])
|
|
self.assertEqual(field.default, obj)
|
|
self.assertEqual(_called_with, [self, obj])
|
|
self.assertEqual(field.defaultFactory, _factory)
|
|
|
|
def test_explicit_defaultFactory_returning_missing_value(self):
|
|
def _factory():
|
|
return None
|
|
field = self._makeOne(required=True,
|
|
defaultFactory=_factory)
|
|
self.assertEqual(field.default, None)
|
|
|
|
def test_bind(self):
|
|
obj = object()
|
|
field = self._makeOne()
|
|
bound = field.bind(obj)
|
|
self.assertEqual(bound.context, obj)
|
|
expected = dict(field.__dict__)
|
|
found = dict(bound.__dict__)
|
|
found.pop('context')
|
|
self.assertEqual(found, expected)
|
|
self.assertEqual(bound.__class__, field.__class__)
|
|
|
|
def test_validate_missing_not_required(self):
|
|
missing = object()
|
|
|
|
def _fail(value):
|
|
return False
|
|
field = self._makeOne(
|
|
required=False, missing_value=missing, constraint=_fail,
|
|
)
|
|
self.assertEqual(field.validate(missing), None) # doesn't raise
|
|
|
|
def test_validate_missing_and_required(self):
|
|
from zope.schema._bootstrapinterfaces import RequiredMissing
|
|
missing = object()
|
|
|
|
def _fail(value):
|
|
return False
|
|
field = self._makeOne(
|
|
required=True, missing_value=missing, constraint=_fail,
|
|
)
|
|
self.assertRaises(RequiredMissing, field.validate, missing)
|
|
|
|
def test_validate_wrong_type(self):
|
|
from zope.schema._bootstrapinterfaces import WrongType
|
|
|
|
def _fail(value):
|
|
return False
|
|
field = self._makeOne(required=True, constraint=_fail)
|
|
field._type = str
|
|
self.assertRaises(WrongType, field.validate, 1)
|
|
|
|
def test_validate_constraint_fails(self):
|
|
from zope.schema._bootstrapinterfaces import ConstraintNotSatisfied
|
|
|
|
def _fail(value):
|
|
return False
|
|
field = self._makeOne(required=True, constraint=_fail)
|
|
field._type = int
|
|
self.assertRaises(ConstraintNotSatisfied, field.validate, 1)
|
|
|
|
def test_validate_constraint_raises_StopValidation(self):
|
|
from zope.schema._bootstrapinterfaces import StopValidation
|
|
|
|
def _fail(value):
|
|
raise StopValidation
|
|
field = self._makeOne(required=True, constraint=_fail)
|
|
field._type = int
|
|
field.validate(1) # doesn't raise
|
|
|
|
def test___eq___different_type(self):
|
|
left = self._makeOne()
|
|
|
|
class Derived(self._getTargetClass()):
|
|
pass
|
|
right = Derived()
|
|
self.assertEqual(left == right, False)
|
|
self.assertEqual(left != right, True)
|
|
|
|
def test___eq___same_type_different_attrs(self):
|
|
left = self._makeOne(required=True)
|
|
right = self._makeOne(required=False)
|
|
self.assertEqual(left == right, False)
|
|
self.assertEqual(left != right, True)
|
|
|
|
def test___eq___same_type_same_attrs(self):
|
|
left = self._makeOne()
|
|
right = self._makeOne()
|
|
self.assertEqual(left == right, True)
|
|
self.assertEqual(left != right, False)
|
|
|
|
def test_get_miss(self):
|
|
field = self._makeOne(__name__='nonesuch')
|
|
inst = DummyInst()
|
|
self.assertRaises(AttributeError, field.get, inst)
|
|
|
|
def test_get_hit(self):
|
|
field = self._makeOne(__name__='extant')
|
|
inst = DummyInst()
|
|
inst.extant = 'EXTANT'
|
|
self.assertEqual(field.get(inst), 'EXTANT')
|
|
|
|
def test_query_miss_no_default(self):
|
|
field = self._makeOne(__name__='nonesuch')
|
|
inst = DummyInst()
|
|
self.assertEqual(field.query(inst), None)
|
|
|
|
def test_query_miss_w_default(self):
|
|
field = self._makeOne(__name__='nonesuch')
|
|
inst = DummyInst()
|
|
self.assertEqual(field.query(inst, 'DEFAULT'), 'DEFAULT')
|
|
|
|
def test_query_hit(self):
|
|
field = self._makeOne(__name__='extant')
|
|
inst = DummyInst()
|
|
inst.extant = 'EXTANT'
|
|
self.assertEqual(field.query(inst), 'EXTANT')
|
|
|
|
def test_set_readonly(self):
|
|
field = self._makeOne(__name__='lirame', readonly=True)
|
|
inst = DummyInst()
|
|
self.assertRaises(TypeError, field.set, inst, 'VALUE')
|
|
|
|
def test_set_hit(self):
|
|
field = self._makeOne(__name__='extant')
|
|
inst = DummyInst()
|
|
inst.extant = 'BEFORE'
|
|
field.set(inst, 'AFTER')
|
|
self.assertEqual(inst.extant, 'AFTER')
|
|
|
|
|
|
class ContainerTests(unittest.TestCase):
|
|
|
|
def _getTargetClass(self):
|
|
from zope.schema._bootstrapfields import Container
|
|
return Container
|
|
|
|
def _makeOne(self, *args, **kw):
|
|
return self._getTargetClass()(*args, **kw)
|
|
|
|
def test_validate_not_required(self):
|
|
field = self._makeOne(required=False)
|
|
field.validate(None)
|
|
|
|
def test_validate_required(self):
|
|
from zope.schema.interfaces import RequiredMissing
|
|
field = self._makeOne()
|
|
self.assertRaises(RequiredMissing, field.validate, None)
|
|
|
|
def test__validate_not_collection_not_iterable(self):
|
|
from zope.schema._bootstrapinterfaces import NotAContainer
|
|
cont = self._makeOne()
|
|
self.assertRaises(NotAContainer, cont._validate, object())
|
|
|
|
def test__validate_collection_but_not_iterable(self):
|
|
cont = self._makeOne()
|
|
|
|
class Dummy(object):
|
|
def __contains__(self, item):
|
|
return False
|
|
cont._validate(Dummy()) # doesn't raise
|
|
|
|
def test__validate_not_collection_but_iterable(self):
|
|
cont = self._makeOne()
|
|
|
|
class Dummy(object):
|
|
def __iter__(self):
|
|
return iter(())
|
|
cont._validate(Dummy()) # doesn't raise
|
|
|
|
def test__validate_w_collections(self):
|
|
cont = self._makeOne()
|
|
cont._validate(()) # doesn't raise
|
|
cont._validate([]) # doesn't raise
|
|
cont._validate('') # doesn't raise
|
|
cont._validate({}) # doesn't raise
|
|
|
|
|
|
class IterableTests(ContainerTests):
|
|
|
|
def _getTargetClass(self):
|
|
from zope.schema._bootstrapfields import Iterable
|
|
return Iterable
|
|
|
|
def test__validate_collection_but_not_iterable(self):
|
|
from zope.schema._bootstrapinterfaces import NotAnIterator
|
|
itr = self._makeOne()
|
|
|
|
class Dummy(object):
|
|
def __contains__(self, item):
|
|
return False
|
|
self.assertRaises(NotAnIterator, itr._validate, Dummy())
|
|
|
|
|
|
class OrderableTests(unittest.TestCase):
|
|
|
|
def _getTargetClass(self):
|
|
from zope.schema._bootstrapfields import Orderable
|
|
return Orderable
|
|
|
|
def _makeOne(self, *args, **kw):
|
|
# Orderable is a mixin for a type derived from Field
|
|
from zope.schema._bootstrapfields import Field
|
|
|
|
class Mixed(self._getTargetClass(), Field):
|
|
pass
|
|
return Mixed(*args, **kw)
|
|
|
|
def test_ctor_defaults(self):
|
|
ordb = self._makeOne()
|
|
self.assertEqual(ordb.min, None)
|
|
self.assertEqual(ordb.max, None)
|
|
self.assertEqual(ordb.default, None)
|
|
|
|
def test_ctor_default_too_small(self):
|
|
# This test exercises _validate, too
|
|
from zope.schema._bootstrapinterfaces import TooSmall
|
|
self.assertRaises(TooSmall, self._makeOne, min=0, default=-1)
|
|
|
|
def test_ctor_default_too_large(self):
|
|
# This test exercises _validate, too
|
|
from zope.schema._bootstrapinterfaces import TooBig
|
|
self.assertRaises(TooBig, self._makeOne, max=10, default=11)
|
|
|
|
|
|
class MinMaxLenTests(unittest.TestCase):
|
|
|
|
def _getTargetClass(self):
|
|
from zope.schema._bootstrapfields import MinMaxLen
|
|
return MinMaxLen
|
|
|
|
def _makeOne(self, *args, **kw):
|
|
# MinMaxLen is a mixin for a type derived from Field
|
|
from zope.schema._bootstrapfields import Field
|
|
|
|
class Mixed(self._getTargetClass(), Field):
|
|
pass
|
|
return Mixed(*args, **kw)
|
|
|
|
def test_ctor_defaults(self):
|
|
mml = self._makeOne()
|
|
self.assertEqual(mml.min_length, 0)
|
|
self.assertEqual(mml.max_length, None)
|
|
|
|
def test_validate_too_short(self):
|
|
from zope.schema._bootstrapinterfaces import TooShort
|
|
mml = self._makeOne(min_length=1)
|
|
self.assertRaises(TooShort, mml._validate, ())
|
|
|
|
def test_validate_too_long(self):
|
|
from zope.schema._bootstrapinterfaces import TooLong
|
|
mml = self._makeOne(max_length=2)
|
|
self.assertRaises(TooLong, mml._validate, (0, 1, 2))
|
|
|
|
|
|
class TextTests(unittest.TestCase):
|
|
|
|
def _getTargetClass(self):
|
|
from zope.schema._bootstrapfields import Text
|
|
return Text
|
|
|
|
def _makeOne(self, *args, **kw):
|
|
return self._getTargetClass()(*args, **kw)
|
|
|
|
def test_ctor_defaults(self):
|
|
from zope.schema._compat import text_type
|
|
txt = self._makeOne()
|
|
self.assertEqual(txt._type, text_type)
|
|
|
|
def test_validate_wrong_types(self):
|
|
from zope.schema.interfaces import WrongType
|
|
from zope.schema._compat import b
|
|
field = self._makeOne()
|
|
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())
|
|
|
|
def test_validate_w_invalid_default(self):
|
|
from zope.schema._compat import b
|
|
from zope.schema.interfaces import ValidationError
|
|
self.assertRaises(ValidationError, self._makeOne, default=b(''))
|
|
|
|
def test_validate_not_required(self):
|
|
from zope.schema._compat import u
|
|
field = self._makeOne(required=False)
|
|
field.validate(u(''))
|
|
field.validate(u('abc'))
|
|
field.validate(u('abc\ndef'))
|
|
field.validate(None)
|
|
|
|
def test_validate_required(self):
|
|
from zope.schema.interfaces import RequiredMissing
|
|
from zope.schema._compat import u
|
|
field = self._makeOne()
|
|
field.validate(u(''))
|
|
field.validate(u('abc'))
|
|
field.validate(u('abc\ndef'))
|
|
self.assertRaises(RequiredMissing, field.validate, None)
|
|
|
|
def test_fromUnicode_miss(self):
|
|
from zope.schema._bootstrapinterfaces import WrongType
|
|
from zope.schema._compat import b
|
|
deadbeef = b('DEADBEEF')
|
|
txt = self._makeOne()
|
|
self.assertRaises(WrongType, txt.fromUnicode, deadbeef)
|
|
|
|
def test_fromUnicode_hit(self):
|
|
from zope.schema._compat import u
|
|
deadbeef = u('DEADBEEF')
|
|
txt = self._makeOne()
|
|
self.assertEqual(txt.fromUnicode(deadbeef), deadbeef)
|
|
|
|
|
|
class TextLineTests(unittest.TestCase):
|
|
|
|
def _getTargetClass(self):
|
|
from zope.schema._field import TextLine
|
|
return TextLine
|
|
|
|
def _makeOne(self, *args, **kw):
|
|
return self._getTargetClass()(*args, **kw)
|
|
|
|
def test_class_conforms_to_ITextLine(self):
|
|
from zope.interface.verify import verifyClass
|
|
from zope.schema.interfaces import ITextLine
|
|
verifyClass(ITextLine, self._getTargetClass())
|
|
|
|
def test_instance_conforms_to_ITextLine(self):
|
|
from zope.interface.verify import verifyObject
|
|
from zope.schema.interfaces import ITextLine
|
|
verifyObject(ITextLine, self._makeOne())
|
|
|
|
def test_validate_wrong_types(self):
|
|
from zope.schema.interfaces import WrongType
|
|
from zope.schema._compat import b
|
|
field = self._makeOne()
|
|
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())
|
|
|
|
def test_validate_not_required(self):
|
|
from zope.schema._compat import u
|
|
field = self._makeOne(required=False)
|
|
field.validate(u(''))
|
|
field.validate(u('abc'))
|
|
field.validate(None)
|
|
|
|
def test_validate_required(self):
|
|
from zope.schema.interfaces import RequiredMissing
|
|
from zope.schema._compat import u
|
|
field = self._makeOne()
|
|
field.validate(u(''))
|
|
field.validate(u('abc'))
|
|
self.assertRaises(RequiredMissing, field.validate, None)
|
|
|
|
def test_constraint(self):
|
|
from zope.schema._compat import u
|
|
field = self._makeOne()
|
|
self.assertEqual(field.constraint(u('')), True)
|
|
self.assertEqual(field.constraint(u('abc')), True)
|
|
self.assertEqual(field.constraint(u('abc\ndef')), False)
|
|
|
|
|
|
class PasswordTests(unittest.TestCase):
|
|
|
|
def _getTargetClass(self):
|
|
from zope.schema._bootstrapfields import Password
|
|
return Password
|
|
|
|
def _makeOne(self, *args, **kw):
|
|
return self._getTargetClass()(*args, **kw)
|
|
|
|
def test_set_unchanged(self):
|
|
klass = self._getTargetClass()
|
|
pw = self._makeOne()
|
|
inst = DummyInst()
|
|
before = dict(inst.__dict__)
|
|
pw.set(inst, klass.UNCHANGED_PASSWORD) # doesn't raise, doesn't write
|
|
after = dict(inst.__dict__)
|
|
self.assertEqual(after, before)
|
|
|
|
def test_set_normal(self):
|
|
pw = self._makeOne(__name__='password')
|
|
inst = DummyInst()
|
|
pw.set(inst, 'PASSWORD')
|
|
self.assertEqual(inst.password, 'PASSWORD')
|
|
|
|
def test_validate_not_required(self):
|
|
from zope.schema._compat import u
|
|
field = self._makeOne(required=False)
|
|
field.validate(u(''))
|
|
field.validate(u('abc'))
|
|
field.validate(None)
|
|
|
|
def test_validate_required(self):
|
|
from zope.schema.interfaces import RequiredMissing
|
|
from zope.schema._compat import u
|
|
field = self._makeOne()
|
|
field.validate(u(''))
|
|
field.validate(u('abc'))
|
|
self.assertRaises(RequiredMissing, field.validate, None)
|
|
|
|
def test_validate_unchanged_not_already_set(self):
|
|
from zope.schema._bootstrapinterfaces import WrongType
|
|
klass = self._getTargetClass()
|
|
inst = DummyInst()
|
|
pw = self._makeOne(__name__='password').bind(inst)
|
|
self.assertRaises(WrongType,
|
|
pw.validate, klass.UNCHANGED_PASSWORD)
|
|
|
|
def test_validate_unchanged_already_set(self):
|
|
klass = self._getTargetClass()
|
|
inst = DummyInst()
|
|
inst.password = 'foobar'
|
|
pw = self._makeOne(__name__='password').bind(inst)
|
|
pw.validate(klass.UNCHANGED_PASSWORD) # doesn't raise
|
|
|
|
def test_constraint(self):
|
|
from zope.schema._compat import u
|
|
field = self._makeOne()
|
|
self.assertEqual(field.constraint(u('')), True)
|
|
self.assertEqual(field.constraint(u('abc')), True)
|
|
self.assertEqual(field.constraint(u('abc\ndef')), False)
|
|
|
|
|
|
class BoolTests(unittest.TestCase):
|
|
|
|
def _getTargetClass(self):
|
|
from zope.schema._bootstrapfields import Bool
|
|
return Bool
|
|
|
|
def _makeOne(self, *args, **kw):
|
|
return self._getTargetClass()(*args, **kw)
|
|
|
|
def test_ctor_defaults(self):
|
|
txt = self._makeOne()
|
|
self.assertEqual(txt._type, bool)
|
|
|
|
def test__validate_w_int(self):
|
|
boo = self._makeOne()
|
|
boo._validate(0) # doesn't raise
|
|
boo._validate(1) # doesn't raise
|
|
|
|
def test_set_w_int(self):
|
|
boo = self._makeOne(__name__='boo')
|
|
inst = DummyInst()
|
|
boo.set(inst, 0)
|
|
self.assertEqual(inst.boo, False)
|
|
boo.set(inst, 1)
|
|
self.assertEqual(inst.boo, True)
|
|
|
|
def test_fromUnicode_miss(self):
|
|
from zope.schema._compat import u
|
|
txt = self._makeOne()
|
|
self.assertEqual(txt.fromUnicode(u('')), False)
|
|
self.assertEqual(txt.fromUnicode(u('0')), False)
|
|
self.assertEqual(txt.fromUnicode(u('1')), False)
|
|
self.assertEqual(txt.fromUnicode(u('False')), False)
|
|
self.assertEqual(txt.fromUnicode(u('false')), False)
|
|
|
|
def test_fromUnicode_hit(self):
|
|
from zope.schema._compat import u
|
|
txt = self._makeOne()
|
|
self.assertEqual(txt.fromUnicode(u('True')), True)
|
|
self.assertEqual(txt.fromUnicode(u('true')), True)
|
|
|
|
|
|
class IntTests(unittest.TestCase):
|
|
|
|
def _getTargetClass(self):
|
|
from zope.schema._bootstrapfields import Int
|
|
return Int
|
|
|
|
def _makeOne(self, *args, **kw):
|
|
return self._getTargetClass()(*args, **kw)
|
|
|
|
def test_ctor_defaults(self):
|
|
from zope.schema._compat import integer_types
|
|
txt = self._makeOne()
|
|
self.assertEqual(txt._type, integer_types)
|
|
|
|
def test_validate_not_required(self):
|
|
field = self._makeOne(required=False)
|
|
field.validate(None)
|
|
field.validate(10)
|
|
field.validate(0)
|
|
field.validate(-1)
|
|
|
|
def test_validate_required(self):
|
|
from zope.schema.interfaces import RequiredMissing
|
|
field = self._makeOne()
|
|
field.validate(10)
|
|
field.validate(0)
|
|
field.validate(-1)
|
|
self.assertRaises(RequiredMissing, field.validate, None)
|
|
|
|
def test_validate_min(self):
|
|
from zope.schema.interfaces import TooSmall
|
|
field = self._makeOne(min=10)
|
|
field.validate(10)
|
|
field.validate(20)
|
|
self.assertRaises(TooSmall, field.validate, 9)
|
|
self.assertRaises(TooSmall, field.validate, -10)
|
|
|
|
def test_validate_max(self):
|
|
from zope.schema.interfaces import TooBig
|
|
field = self._makeOne(max=10)
|
|
field.validate(5)
|
|
field.validate(9)
|
|
field.validate(10)
|
|
self.assertRaises(TooBig, field.validate, 11)
|
|
self.assertRaises(TooBig, field.validate, 20)
|
|
|
|
def test_validate_min_and_max(self):
|
|
from zope.schema.interfaces import TooBig
|
|
from zope.schema.interfaces import TooSmall
|
|
field = self._makeOne(min=0, max=10)
|
|
field.validate(0)
|
|
field.validate(5)
|
|
field.validate(10)
|
|
self.assertRaises(TooSmall, field.validate, -10)
|
|
self.assertRaises(TooSmall, field.validate, -1)
|
|
self.assertRaises(TooBig, field.validate, 11)
|
|
self.assertRaises(TooBig, field.validate, 20)
|
|
|
|
def test_fromUnicode_miss(self):
|
|
from zope.schema._compat import u
|
|
txt = self._makeOne()
|
|
self.assertRaises(ValueError, txt.fromUnicode, u(''))
|
|
self.assertRaises(ValueError, txt.fromUnicode, u('False'))
|
|
self.assertRaises(ValueError, txt.fromUnicode, u('True'))
|
|
|
|
def test_fromUnicode_hit(self):
|
|
from zope.schema._compat import u
|
|
txt = self._makeOne()
|
|
self.assertEqual(txt.fromUnicode(u('0')), 0)
|
|
self.assertEqual(txt.fromUnicode(u('1')), 1)
|
|
self.assertEqual(txt.fromUnicode(u('-1')), -1)
|
|
|
|
|
|
class DummyInst(object):
|
|
missing_value = object()
|
|
|
|
def __init__(self, exc=None):
|
|
self._exc = exc
|
|
|
|
def validate(self, value):
|
|
if self._exc is not None:
|
|
raise self._exc()
|
|
|
|
|
|
def test_suite():
|
|
return unittest.TestSuite((
|
|
unittest.makeSuite(ValidatedPropertyTests),
|
|
unittest.makeSuite(DefaultPropertyTests),
|
|
unittest.makeSuite(FieldTests),
|
|
unittest.makeSuite(ContainerTests),
|
|
unittest.makeSuite(IterableTests),
|
|
unittest.makeSuite(OrderableTests),
|
|
unittest.makeSuite(MinMaxLenTests),
|
|
unittest.makeSuite(TextTests),
|
|
unittest.makeSuite(TextLineTests),
|
|
unittest.makeSuite(PasswordTests),
|
|
unittest.makeSuite(BoolTests),
|
|
unittest.makeSuite(IntTests),
|
|
))
|