def test_w_mixed(self):
from guillotina.schema import Text
from guillotina.schema import Bytes
from guillotina.schema import Int
from guillotina.schema import Float
from guillotina.schema import Decimal
self.assertEqual(self._callFUT([Text(), 0]), False)
self.assertEqual(
self._callFUT([Text(),
Bytes(),
Int(),
Float(),
Decimal(), 0]), False)
def test_w_fields(self):
from guillotina.schema import Text
from guillotina.schema import Bytes
from guillotina.schema import Int
from guillotina.schema import Float
from guillotina.schema import Decimal
self.assertEqual(self._callFUT([Text()]), True)
self.assertEqual(self._callFUT([Bytes()]), True)
self.assertEqual(self._callFUT([Int()]), True)
self.assertEqual(self._callFUT([Float()]), True)
self.assertEqual(self._callFUT([Decimal()]), True)
self.assertEqual(
self._callFUT([Text(), Bytes(),
Int(), Float(),
Decimal()]), True)
def test_w_read_and_write_accessors(self):
from zope.interface import Interface
from guillotina.schema import Text
field = Text(title='Hmm')
class IFoo(Interface):
getter, setter = self._callFUT(field)
getter = IFoo['getter']
self.assertEqual(getter.__name__, 'getter')
self.assertEqual(getter.getSignatureString(), '()')
info = getter.getSignatureInfo()
self.assertEqual(info['positional'], ())
self.assertEqual(info['required'], ())
self.assertEqual(info['optional'], ())
self.assertEqual(info['varargs'], None)
self.assertEqual(info['kwargs'], None)
setter = IFoo['setter']
self.assertEqual(setter.__name__, 'setter')
self.assertEqual(setter.getSignatureString(), '(newvalue)')
info = setter.getSignatureInfo()
self.assertEqual(info['positional'], ('newvalue', ))
self.assertEqual(info['required'], ('newvalue', ))
self.assertEqual(info['optional'], ())
self.assertEqual(info['varargs'], None)
self.assertEqual(info['kwargs'], None)
def test_field_event(self):
# fieldproperties are everywhere including in field themselfs
# so event are triggered
from guillotina.schema import Text
from guillotina.component.event import sync_subscribers
from guillotina.schema.fieldproperty import FieldUpdatedEvent
log = []
sync_subscribers.append(log.append)
self.assertEqual(log, [])
field = Text(
__name__='testing',
description='DESCRIPTION',
default='DEFAULT',
readonly=True,
required=True,
)
self.assertEqual(len(log), 6)
# these are fieldproperties in the field
self.assertEqual(
[ev.field.__name__ for ev in log],
['min_length', 'max_length', 'title', 'description', 'required', 'readonly'])
event = log[0]
self.assertTrue(isinstance(event, FieldUpdatedEvent))
self.assertEqual(event.inst, field)
self.assertEqual(event.old_value, 0)
self.assertEqual(event.new_value, 0)
def test_field_event_update(self):
from guillotina.schema import Text
from guillotina.component.event import sync_subscribers
from guillotina.schema.fieldproperty import FieldUpdatedEvent
field = Text(
__name__='testing',
description='DESCRIPTION',
default='DEFAULT',
required=True,
)
prop = self._makeOne(field=field)
class Foo(object):
testing = prop
foo = Foo()
log = []
sync_subscribers.append(log.append)
foo.testing = 'Bar'
foo.testing = 'Foo'
self.assertEqual(len(log), 2)
event = log[1]
self.assertTrue(isinstance(event, FieldUpdatedEvent))
self.assertEqual(event.inst, foo)
self.assertEqual(event.field, field)
self.assertEqual(event.old_value, 'Bar')
self.assertEqual(event.new_value, 'Foo')
def test_w_read_and_write_accessors(self):
from zope.interface import Interface
from guillotina.schema import Text
field = Text(title="Hmm")
class IFoo(Interface):
getter, setter = self._callFUT(field)
getter = IFoo["getter"] # type: ignore
self.assertEqual(getter.__name__, "getter")
self.assertEqual(getter.getSignatureString(), "()")
info = getter.getSignatureInfo()
self.assertEqual(info["positional"], ())
self.assertEqual(info["required"], ())
self.assertEqual(info["optional"], ())
self.assertEqual(info["varargs"], None)
self.assertEqual(info["kwargs"], None)
setter = IFoo["setter"] # type: ignore
self.assertEqual(setter.__name__, "setter")
self.assertEqual(setter.getSignatureString(), "(newvalue)")
info = setter.getSignatureInfo()
self.assertEqual(info["positional"], ("newvalue", ))
self.assertEqual(info["required"], ("newvalue", ))
self.assertEqual(info["optional"], ())
self.assertEqual(info["varargs"], None)
self.assertEqual(info["kwargs"], None)
def _makeOne(self, field=None, name=None):
from guillotina.schema import Text
if field is None:
field = Text(__name__='testing')
if name is None:
return self._getTargetClass()(field)
return self._getTargetClass()(field, name)
def test_ctor_not_created_inside_interface(self):
from guillotina.schema import Text
field = Text(title='Hmm')
wrapped = self._makeOne(field)
self.assertTrue(wrapped.field is field)
self.assertEqual(wrapped.__name__, '') # __name__ set when in iface
self.assertEqual(wrapped.__doc__, 'get Hmm')
def test_ctor_created_inside_interface(self):
from zope.interface import Interface
from guillotina.schema import Text
field = Text(title='Hmm')
class IFoo(Interface):
getter = self._makeOne(field)
getter = IFoo['getter']
self.assertEqual(getter.__name__, 'getter')
self.assertEqual(getter.__doc__, 'get Hmm')
def test_w_normal_fields(self):
from guillotina.schema import Text
from guillotina.schema import Bytes
from guillotina.schema import Int
from guillotina.schema import Float
from guillotina.schema import Decimal
self.assertEqual(self._callFUT(Text()), True)
self.assertEqual(self._callFUT(Bytes()), True)
self.assertEqual(self._callFUT(Int()), True)
self.assertEqual(self._callFUT(Float()), True)
self.assertEqual(self._callFUT(Decimal()), True)
def test_setValue(self):
from guillotina.schema import Text
class Foo(object):
pass
foo = Foo()
prop = self._makeOne()
field = Text(__name__="testing")
prop.setValue(foo, field, "123")
self.assertEqual(foo.testing, "123")
def test_queryValue_miss(self):
from guillotina.schema import Text
class Foo(object):
pass
foo = Foo()
prop = self._makeOne()
field = Text(__name__="testing")
default = object()
value = prop.queryValue(foo, field, default)
self.assertTrue(value is default)
def test_getValue_hit(self):
from guillotina.schema import Text
class Foo(object):
pass
foo = Foo()
foo.testing = "123"
prop = self._makeOne()
field = Text(__name__="testing")
value = prop.getValue(foo, field)
self.assertEqual(value, "123")
def test_getValue_miss(self):
from guillotina.schema import Text
from guillotina.schema.fieldproperty import _marker
class Foo(object):
pass
foo = Foo()
prop = self._makeOne()
field = Text(__name__="testing")
value = prop.getValue(foo, field)
self.assertTrue(value is _marker)
def test___provides___w_field_w_provides(self):
from zope.interface import implementedBy
from zope.interface import providedBy
from guillotina.schema import Text
field = Text()
field_provides = list(providedBy(field))
wrapped = self._makeOne(field)
wrapped_provides = list(providedBy(wrapped))
self.assertEqual(wrapped_provides[:len(field_provides)],
list(providedBy(field)))
for iface in list(implementedBy(self._getTargetClass())):
self.assertTrue(iface in wrapped_provides)
def test___get___from_instance_hit(self):
from guillotina.schema import Text
field = Text(__name__='testing')
prop = self._makeOne(field, name='other')
class Foo(object):
testing = prop
foo = Foo()
foo.__dict__['__st_testing_st'] = '456'
foo.other = '123'
self.assertEqual(foo.testing, '456')
def test_ctor_defaults(self):
from guillotina.schema import Text
field = Text(__name__='testing')
cname = self._getTargetClass().__name__
prop = self._makeOne(field)
self.assertTrue(getattr(prop, '_%s__field' % cname) is field)
self.assertEqual(getattr(prop, '_%s__name' % cname), 'testing')
self.assertEqual(prop.__name__, 'testing')
self.assertEqual(prop.description, field.description)
self.assertEqual(prop.default, field.default)
self.assertEqual(prop.readonly, field.readonly)
self.assertEqual(prop.required, field.required)
def test_ctor_created_inside_interface(self):
from zope.interface import Interface
from guillotina.schema import Text
field = Text(title="Hmm")
class IFoo(Interface):
getter = self._makeOne(field)
getter = IFoo["getter"] # type: ignore
self.assertEqual(getter.__name__, "getter")
self.assertEqual(getter.__doc__, "get Hmm")
def test___get___from_instance_hit(self):
from guillotina.schema import Text
field = Text(__name__="testing")
prop = self._makeOne(field, name="other")
class Foo(object):
testing = prop
foo = Foo()
foo.__dict__["__st_testing_st"] = "456"
foo.other = "123"
self.assertEqual(foo.testing, "456")
def test_queryValue_hit(self):
from guillotina.schema import Text
class Foo(object):
pass
foo = Foo()
foo.testing = '123'
prop = self._makeOne()
field = Text(__name__='testing')
default = object()
value = prop.queryValue(foo, field, default)
self.assertEqual(value, '123')
def test_query_value_without_default(self):
from guillotina.schema import Text
field = Text(__name__="testing", description="DESCRIPTION", readonly=True, required=True)
prop = self._makeOne(field=field)
class Foo(object):
testing = prop
foo = Foo()
# field initialize its default to None if it hasn't any default
# it should be guillotina.schema.NO_VALUE as 'None' has another semantic
self.assertEqual(prop.queryValue(foo, "test"), None)
def test_ctor_explicit(self):
from guillotina.schema import Text
field = Text(
__name__="testing", description="DESCRIPTION", default="DEFAULT", readonly=True, required=True
)
cname = self._getTargetClass().__name__
prop = self._makeOne(field, name="override")
self.assertTrue(getattr(prop, "_%s__field" % cname) is field)
self.assertEqual(getattr(prop, "_%s__name" % cname), "override")
self.assertEqual(prop.description, field.description)
self.assertEqual(prop.default, field.default)
self.assertEqual(prop.readonly, field.readonly)
self.assertEqual(prop.required, field.required)
class IRole(Interface):
"""A role object."""
id = TextLine(title=u"Id",
description=u"Id as which this role will be known and used.",
readonly=True,
required=True)
title = TextLine(title=u"Title",
description=u"Provides a title for the role.",
required=True)
description = Text(title=u"Description",
description=u"Provides a description for the role.",
required=False)
def test_ctor_defaults(self):
from guillotina.schema import Text
field = Text(__name__="testing")
cname = self._getTargetClass().__name__
prop = self._makeOne(field)
self.assertTrue(isinstance(prop.field, field.__class__))
self.assertFalse(prop.field is field)
self.assertEqual(prop.field.__name__, "__st_testing_st")
self.assertEqual(prop.__name__, "__st_testing_st")
self.assertEqual(getattr(prop, "_%s__name" % cname), "testing")
self.assertEqual(prop.description, field.description)
self.assertEqual(prop.default, field.default)
self.assertEqual(prop.readonly, field.readonly)
self.assertEqual(prop.required, field.required)
def test_set_readonly(self):
from zope.interface import Interface
from guillotina.schema import Text
field = Text(readonly=True)
class IFoo(Interface):
getter = self._makeOne(field)
getter = IFoo['getter']
class Foo(object):
def getter(self):
return '123'
self.assertRaises(TypeError, getter.set, Foo(), '456')
class IRole(Interface): # pylint: disable=E0239
"""A role object."""
id = TextLine(title='Id',
description='Id as which this role will be known and used.',
readonly=True,
required=True)
title = TextLine(title='Title',
description='Provides a title for the role.',
required=True)
description = Text(title='Description',
description='Provides a description for the role.',
required=False)
def test_query_value_with_default(self):
from guillotina.schema import Text
field = Text(
__name__="testing", description="DESCRIPTION", default="DEFAULT", readonly=True, required=True
)
prop = self._makeOne(field=field)
class Foo(object):
testing = prop
foo = Foo()
self.assertEqual(prop.queryValue(foo, "test"), "DEFAULT")
foo.testing = "NO"
self.assertEqual(prop.queryValue(foo, "test"), "NO")
class IPermission(Interface):
"""A permission object."""
id = TextLine(
title=_("Id"),
description=_("Id as which this permission will be known and used."),
readonly=True,
required=True)
title = TextLine(title=_("Title"),
description=_("Provides a title for the permission."),
required=True)
description = Text(
title=_("Description"),
description=_("Provides a description for the permission."),
required=False)
class IPermission(Interface): # pylint: disable=E0239
"""A permission object."""
id = TextLine(
title=_('Id'),
description=_('Id as which this permission will be known and used.'),
readonly=True,
required=True)
title = TextLine(title=_('Title'),
description=_('Provides a title for the permission.'),
required=True)
description = Text(
title=_('Description'),
description=_('Provides a description for the permission.'),
required=False)
def test_ctor_explicit(self):
from guillotina.schema import Text
field = Text(
__name__='testing',
description='DESCRIPTION',
default='DEFAULT',
readonly=True,
required=True,
)
cname = self._getTargetClass().__name__
prop = self._makeOne(field, name='override')
self.assertTrue(getattr(prop, '_%s__field' % cname) is field)
self.assertEqual(getattr(prop, '_%s__name' % cname), 'override')
self.assertEqual(prop.description, field.description)
self.assertEqual(prop.default, field.default)
self.assertEqual(prop.readonly, field.readonly)
self.assertEqual(prop.required, field.required)
