mirror of
https://github.com/nottinghamtec/PyRIGS.git
synced 2026-01-18 22:12:14 +00:00
316 lines
10 KiB
Python
316 lines
10 KiB
Python
##############################################################################
|
|
#
|
|
# Copyright (c) 2003 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.
|
|
#
|
|
##############################################################################
|
|
"""Test Interface accessor methods.
|
|
"""
|
|
import unittest
|
|
|
|
|
|
class FieldReadAccessorTests(unittest.TestCase):
|
|
|
|
def _getTargetClass(self):
|
|
from zope.schema.accessors import FieldReadAccessor
|
|
return FieldReadAccessor
|
|
|
|
def _makeOne(self, field=None):
|
|
from zope.schema import Text
|
|
if field is None:
|
|
field = Text(__name__='testing')
|
|
return self._getTargetClass()(field)
|
|
|
|
def test_ctor_not_created_inside_interface(self):
|
|
from zope.schema import Text
|
|
from zope.schema._compat import u
|
|
field = Text(title=u('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 zope.schema import Text
|
|
from zope.schema._compat import u
|
|
field = Text(title=u('Hmm'))
|
|
|
|
class IFoo(Interface):
|
|
getter = self._makeOne(field)
|
|
getter = IFoo['getter']
|
|
self.assertEqual(getter.__name__, 'getter')
|
|
self.assertEqual(getter.__doc__, 'get Hmm')
|
|
|
|
def test___provides___w_field_no_provides(self):
|
|
from zope.interface import implementedBy
|
|
from zope.interface import providedBy
|
|
wrapped = self._makeOne(object())
|
|
self.assertEqual(list(providedBy(wrapped)),
|
|
list(implementedBy(self._getTargetClass())))
|
|
|
|
def test___provides___w_field_w_provides(self):
|
|
from zope.interface import implementedBy
|
|
from zope.interface import providedBy
|
|
from zope.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_getSignatureString(self):
|
|
wrapped = self._makeOne()
|
|
self.assertEqual(wrapped.getSignatureString(), '()')
|
|
|
|
def test_getSignatureInfo(self):
|
|
wrapped = self._makeOne()
|
|
info = wrapped.getSignatureInfo()
|
|
self.assertEqual(info['positional'], ())
|
|
self.assertEqual(info['required'], ())
|
|
self.assertEqual(info['optional'], ())
|
|
self.assertEqual(info['varargs'], None)
|
|
self.assertEqual(info['kwargs'], None)
|
|
|
|
def test_get_miss(self):
|
|
from zope.interface import Interface
|
|
|
|
class IFoo(Interface):
|
|
getter = self._makeOne()
|
|
getter = IFoo['getter']
|
|
|
|
class Foo(object):
|
|
pass
|
|
self.assertRaises(AttributeError, getter.get, Foo())
|
|
|
|
def test_get_hit(self):
|
|
from zope.interface import Interface
|
|
|
|
class IFoo(Interface):
|
|
getter = self._makeOne()
|
|
getter = IFoo['getter']
|
|
|
|
class Foo(object):
|
|
def getter(self):
|
|
return '123'
|
|
self.assertEqual(getter.get(Foo()), '123')
|
|
|
|
def test_query_miss_implicit_default(self):
|
|
from zope.interface import Interface
|
|
|
|
class IFoo(Interface):
|
|
getter = self._makeOne()
|
|
getter = IFoo['getter']
|
|
|
|
class Foo(object):
|
|
pass
|
|
self.assertEqual(getter.query(Foo()), None)
|
|
|
|
def test_query_miss_explicit_default(self):
|
|
from zope.interface import Interface
|
|
|
|
class IFoo(Interface):
|
|
getter = self._makeOne()
|
|
getter = IFoo['getter']
|
|
|
|
class Foo(object):
|
|
pass
|
|
self.assertEqual(getter.query(Foo(), 234), 234)
|
|
|
|
def test_query_hit(self):
|
|
from zope.interface import Interface
|
|
|
|
class IFoo(Interface):
|
|
getter = self._makeOne()
|
|
getter = IFoo['getter']
|
|
|
|
class Foo(object):
|
|
def getter(self):
|
|
return '123'
|
|
|
|
self.assertEqual(getter.query(Foo()), '123')
|
|
|
|
def test_set_readonly(self):
|
|
from zope.interface import Interface
|
|
from zope.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')
|
|
|
|
def test_set_no_writer(self):
|
|
from zope.interface import Interface
|
|
|
|
class IFoo(Interface):
|
|
getter = self._makeOne()
|
|
getter = IFoo['getter']
|
|
|
|
class Foo(object):
|
|
def getter(self):
|
|
return '123'
|
|
|
|
self.assertRaises(AttributeError, getter.set, Foo(), '456')
|
|
|
|
def test_set_w_writer(self):
|
|
from zope.interface import Interface
|
|
|
|
class IFoo(Interface):
|
|
getter = self._makeOne()
|
|
|
|
getter = IFoo['getter']
|
|
_called_with = []
|
|
|
|
class Writer(object):
|
|
pass
|
|
|
|
writer = Writer()
|
|
writer.__name__ = 'setMe'
|
|
getter.writer = writer
|
|
|
|
class Foo(object):
|
|
def setMe(self, value):
|
|
_called_with.append(value)
|
|
|
|
getter.set(Foo(), '456')
|
|
self.assertEqual(_called_with, ['456'])
|
|
|
|
def test_bind(self):
|
|
from zope.interface import Interface
|
|
|
|
class IFoo(Interface):
|
|
getter = self._makeOne()
|
|
|
|
getter = IFoo['getter']
|
|
context = object()
|
|
bound = getter.bind(context)
|
|
self.assertEqual(bound.__name__, 'getter')
|
|
self.assertTrue(isinstance(bound.field, getter.field.__class__))
|
|
self.assertTrue(bound.field.context is context)
|
|
|
|
|
|
class FieldWriteAccessorTests(unittest.TestCase):
|
|
|
|
def _getTargetClass(self):
|
|
from zope.schema.accessors import FieldWriteAccessor
|
|
return FieldWriteAccessor
|
|
|
|
def _makeOne(self, field=None):
|
|
from zope.schema import Text
|
|
if field is None:
|
|
field = Text(__name__='testing')
|
|
return self._getTargetClass()(field)
|
|
|
|
def test_ctor_not_created_inside_interface(self):
|
|
from zope.schema import Text
|
|
from zope.schema._compat import u
|
|
field = Text(title=u('Hmm'))
|
|
wrapped = self._makeOne(field)
|
|
self.assertTrue(wrapped.field is field)
|
|
self.assertEqual(wrapped.__name__, '') # __name__ set when in iface
|
|
self.assertEqual(wrapped.__doc__, 'set Hmm')
|
|
|
|
def test_ctor_created_inside_interface(self):
|
|
from zope.interface import Interface
|
|
from zope.schema import Text
|
|
from zope.schema._compat import u
|
|
field = Text(title=u('Hmm'))
|
|
|
|
class IFoo(Interface):
|
|
setter = self._makeOne(field)
|
|
|
|
setter = IFoo['setter']
|
|
self.assertEqual(setter.__name__, 'setter')
|
|
self.assertEqual(setter.__doc__, 'set Hmm')
|
|
|
|
def test_getSignatureString(self):
|
|
wrapped = self._makeOne()
|
|
self.assertEqual(wrapped.getSignatureString(), '(newvalue)')
|
|
|
|
def test_getSignatureInfo(self):
|
|
wrapped = self._makeOne()
|
|
info = wrapped.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)
|
|
|
|
|
|
class Test_accessors(unittest.TestCase):
|
|
|
|
def _callFUT(self, *args, **kw):
|
|
from zope.schema.accessors import accessors
|
|
return accessors(*args, **kw)
|
|
|
|
def test_w_only_read_accessor(self):
|
|
from zope.interface import Interface
|
|
from zope.schema import Text
|
|
from zope.schema._compat import u
|
|
field = Text(title=u('Hmm'), readonly=True)
|
|
|
|
class IFoo(Interface):
|
|
getter, = self._callFUT(field)
|
|
|
|
getter = IFoo['getter']
|
|
self.assertEqual(getter.__name__, 'getter')
|
|
self.assertEqual(getter.__doc__, 'get Hmm')
|
|
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)
|
|
|
|
def test_w_read_and_write_accessors(self):
|
|
from zope.interface import Interface
|
|
from zope.schema import Text
|
|
from zope.schema._compat import u
|
|
field = Text(title=u('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_suite():
|
|
return unittest.TestSuite((
|
|
unittest.makeSuite(FieldReadAccessorTests),
|
|
unittest.makeSuite(FieldWriteAccessorTests),
|
|
unittest.makeSuite(Test_accessors),
|
|
))
|