Python _compat.u函数代码示例

 def test_field_event(self):
     # fieldproperties are everywhere including in field themselfs
     # so event are triggered
     from zope.schema import Text
     from zope.schema._compat import u
     from zope.event import subscribers
     from zope.schema.fieldproperty import FieldUpdatedEvent
     log = []
     subscribers.append(log.append)
     self.assertEqual(log, [])
     field = Text(
         __name__='testing',
         description=u('DESCRIPTION'),
         default=u('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_filtered_handler(self):
        from zope.schema import Text
        from zope.schema._compat import u
        field = Text(
            __name__='testing',
            description=u('DESCRIPTION'),
            default=u('DEFAULT'),
            required=True,
        )
        prop = self._makeOne(field=field)

        class IFoo(interface.Interface):
            """
            """

        class Foo(object):
            interface.implements(IFoo)
            testing = prop
        foo = Foo()

        logs = []

        @component.adapter(IFoo, schema.Text, schema.interfaces.IFieldUpdatedEvent)
        def add_field_events(obj, field, event):
            logs.append((obj, field, event))

        component.provideHandler(add_field_events)

        self.assertEqual(len(logs), 0)
        foo.testing = u'Bla'
        self.assertEqual(len(logs), 1)
        event_inst, event_field, event = logs[0]
        self.assertEqual(event_inst, foo)
        self.assertEqual(event_field, field)

 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_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_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_subscriber(self):
        from zope.schema import Text
        from zope.schema._compat import u
        field = Text(
            __name__='testing',
            description=u('DESCRIPTION'),
            default=u('DEFAULT'),
            required=True,
        )
        prop = self._makeOne(field=field)

        class Foo(object):
            testing = prop
        foo = Foo()

        logs = []

        @component.adapter(schema.interfaces.IFieldUpdatedEvent)
        def add_field_event(event):
            logs.append(event)

        component.provideHandler(add_field_event)

        self.assertEqual(len(logs), 0)
        foo.testing = u'Bla'
        self.assertEqual(len(logs), 1)
        event = logs[0]
        self.assertEqual(event.field, field)
        self.assertEqual(event.inst, foo)

 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 __init__(self, title=u(''), description=u(''), __name__='',
                 required=True, readonly=False, constraint=None, default=None,
                 defaultFactory=None, missing_value=__missing_value_marker):
        """Pass in field values as keyword parameters.


        Generally, you want to pass either a title and description, or
        a doc string.  If you pass no doc string, it will be computed
        from the title and description.  If you pass a doc string that
        follows the Python coding style (title line separated from the
        body by a blank line), the title and description will be
        computed from the doc string.  Unfortunately, the doc string
        must be passed as a positional argument.

        Here are some examples:

        >>> from zope.schema._compat import u
        >>> f = Field()
        >>> f.__doc__, f.title, f.description
        ('', u'', u'')

        >>> f = Field(title=u('sample'))
        >>> f.__doc__, f.title, f.description
        (u'sample', u'sample', u'')

        >>> f = Field(title=u('sample'), description=u('blah blah\\nblah'))
        >>> f.__doc__, f.title, f.description
        (u'sample\\n\\nblah blah\\nblah', u'sample', u'blah blah\\nblah')
        """
        __doc__ = ''
        if title:
            if description:
                __doc__ = "%s\n\n%s" % (title, description)
            else:
                __doc__ = title
        elif description:
            __doc__ = description

        super(Field, self).__init__(__name__, __doc__)
        self.title = title
        self.description = description
        self.required = required
        self.readonly = readonly
        if constraint is not None:
            self.constraint = constraint
        self.default = default
        self.defaultFactory = defaultFactory

        # Keep track of the order of field definitions
        Field.order += 1
        self.order = Field.order

        if missing_value is not self.__missing_value_marker:
            self.missing_value = missing_value

 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_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_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_explicit(self):
     from zope.schema import Text
     from zope.schema._compat import u
     field = Text(__name__='testing',
                  description=u('DESCRIPTION'),
                  default=u('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)

 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_query_value_with_default(self):
        from zope.schema import Text
        from zope.schema._compat import u
        field = Text(
            __name__='testing',
            description=u('DESCRIPTION'),
            default=u('DEFAULT'),
            readonly=True,
            required=True,
        )

        prop = self._makeOne(field=field)

        class Foo(object):
            testing = prop
        foo = Foo()
        self.assertEqual(prop.queryValue(foo, 'test'), u('DEFAULT'))
        foo.testing = u('NO')
        self.assertEqual(prop.queryValue(foo, 'test'), u('NO'))

 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')