(nothing selected) ...
An alternative to SourceSelectWidget for small numbers of items is
SourceRadioWidget that provides a radio button group for the items::
>>> request = TestRequest()
>>> widget = zope.formlib.source.SourceRadioWidget(
... dog, dog.source, request)
>>> print(widget()) # doctest: +NORMALIZE_WHITESPACE
We'll select an item by setting the appropriate fields in the request::
>>> request.form['field.dog-empty-marker'] = '1'
>>> request.form['field.dog'] = 'bGFzc2ll'
>>>
>>> widget = zope.formlib.source.SourceRadioWidget(
... dog, dog.source, request)
>>> print(widget()) # doctest: +NORMALIZE_WHITESPACE
For list-valued fields with items chosen from iterable sources, there are the
SourceMultiSelectWidget and SourceOrderedMultiSelectWidget widgets. The latter
widget includes support for re-ording the list items.
SourceOrderedMultiSelectWidget is configured as the default widget for lists of
choices.
If you don't need ordering support through the web UI, then you can use
the simpler SourceMultiSelectWidget::
>>> dogSource = SourceList([
... u'spot', u'bowser', u'prince', u'duchess', u'lassie'])
>>> dogs = zope.schema.List(
... __name__ = 'dogs',
... title=u"Dogs",
... value_type=zope.schema.Choice(
... source=dogSource,
... )
... )
>>> dogs = dogs.bind(object()) # give the field a context
>>> request = TestRequest()
>>> widget = zope.formlib.source.SourceMultiSelectWidget(
... dogs, dogSource, request)
Let's look at the rendered widget::
>>> print(widget()) # doctest: +NORMALIZE_WHITESPACE
spot
bowser
prince
duchess
lassie
We have no input yet::
>>> try:
... widget.getInputValue()
... except zope.formlib.interfaces.MissingInputError:
... print('no input')
no input
Select an item::
>>> request.form['field.dogs-empty-marker'] = '1'
>>> request.form['field.dogs'] = ['bGFzc2ll']
>>> widget.getInputValue()
['lassie']
and another::
>>> request.form['field.dogs'] = ['cHJpbmNl', 'bGFzc2ll']
>>> widget.getInputValue()
['prince', 'lassie']
Finally, what does the widget look like now::
>>> print(widget()) # doctest: +NORMALIZE_WHITESPACE
spot
bowser
prince
duchess
lassie
An alternative for small numbers of items is to use SourceMultiCheckBoxWidget::
>>> request = TestRequest()
>>> widget = zope.formlib.source.SourceMultiCheckBoxWidget(
... dogs, dogSource, request)
The rendered widget::
>>> print(widget()) # doctest: +NORMALIZE_WHITESPACE
We have no input yet::
>>> try:
... widget.getInputValue()
... except zope.formlib.interfaces.MissingInputError:
... print('no input')
no input
Select an item::
>>> request.form['field.dogs-empty-marker'] = '1'
>>> request.form['field.dogs'] = ['bGFzc2ll']
>>> widget.getInputValue()
['lassie']
and another::
>>> request.form['field.dogs'] = ['c3BvdA==', 'bGFzc2ll']
>>> widget.getInputValue()
['spot', 'lassie']
Finally, what does the widget look like now::
>>> print(widget()) # doctest: +NORMALIZE_WHITESPACE
For list ordering support, use SourceOrderedMultiSelectWidget::
>>> request = TestRequest()
>>> widget = zope.formlib.source.SourceOrderedMultiSelectWidget(
... dogs, dogSource, request)
The widget is too complicated to show in complete rendered form here.
Insted, we'll inspect the properties of the widget::
>>> from zope.formlib.interfaces import MissingInputError
>>> try:
... widget.getInputValue()
... except MissingInputError:
... print('no input')
no input
>>> widget.choices() == [
... {'text': u'spot', 'value': 'c3BvdA=='},
... {'text': u'bowser', 'value': 'Ym93c2Vy'},
... {'text': u'prince', 'value': 'cHJpbmNl'},
... {'text': u'duchess', 'value': 'ZHVjaGVzcw=='},
... {'text': u'lassie', 'value': 'bGFzc2ll'}
... ]
True
>>> widget.selected()
[]
Let's try out selecting items. Select one item::
>>> request.form['field.dogs-empty-marker'] = '1'
>>> request.form['field.dogs'] = ['bGFzc2ll']
>>> from pprint import pprint
>>> pprint(widget.selected()) # doctest: +NORMALIZE_WHITESPACE
[{'text': u'lassie', 'value': 'bGFzc2ll'}]
>>> widget.getInputValue()
['lassie']
Select two items::
>>> request.form['field.dogs'] = ['c3BvdA==', 'bGFzc2ll']
>>> pprint(widget.selected()) # doctest: +NORMALIZE_WHITESPACE
[{'text': u'spot', 'value': 'c3BvdA=='},
{'text': u'lassie', 'value': 'bGFzc2ll'}]
>>> widget.getInputValue()
['spot', 'lassie']
For set-valued fields, use SourceMultiSelectSetWidget::
>>> dogSet = zope.schema.Set(
... __name__ = 'dogSet',
... title=u"Dogs",
... value_type=zope.schema.Choice(
... source=dogSource,
... )
... )
>>> dogSet = dogSet.bind(object()) # give the field a context
>>> request = TestRequest()
>>> widget = zope.formlib.source.SourceMultiSelectSetWidget(
... dogSet, dogSource, request)
>>> try:
... widget.getInputValue()
... except zope.formlib.interfaces.MissingInputError:
... print('no input')
no input
>>> print(widget()) # doctest: +NORMALIZE_WHITESPACE
spot
bowser
prince
duchess
lassie
Let's try out selecting items. Select one item::
>>> request.form['field.dogSet-empty-marker'] = '1'
>>> request.form['field.dogSet'] = ['bGFzc2ll']
>>> widget.getInputValue()
set(['lassie'])
Select two items::
>>> request.form['field.dogSet'] = ['c3BvdA==', 'bGFzc2ll']
>>> sorted(widget.getInputValue())
['lassie', 'spot']
The rendered widget (still with the two items selected) looks like this::
>>> print(widget()) # doctest: +NORMALIZE_WHITESPACE
spot
bowser
prince
duchess
lassie
Source Widget Query Framework
=============================
An important aspect of sources is that they may have too many values to
enumerate. Rather than listing all of the values, we, instead, provide
interfaces for querying values and selecting values from query results.
Matters are further complicated by the fact that different sources may have
very different interfaces for querying them.
To make matters more interesting, a source may be an aggregation of several
collections, each with their own querying facilities. An example of such a
source is a principal source, where principals might come from a number of
places, such as an LDAP database and ZCML-based principal definitions.
The default widgets for selecting values from sources use the
following approach:
- One or more query objects are obtained from the source by adapting the source
to `zope.schema.ISourceQueriables`. If no adapter is obtained, then the
source itself is assumed to be queriable.
- For each queriable found, a
`zope.formlib.interfaces.ISourceQueryView` view is looked up. This
view is used to obtain the HTML for displaying a query form. The view is also
used to obtain search results.
Let's start with a simple example. We have a very trivial source,
which is basically a list:
>>> @zope.interface.implementer(zope.schema.interfaces.ISource)
... class SourceList(list):
... pass
We need to register our `ITerms` view::
>>> zope.component.provideAdapter(
... ListTerms,
... (SourceList, zope.publisher.interfaces.browser.IBrowserRequest))
We aren't going to provide an adapter to `ISourceQueriables`, so the source
itself will be used as it's own queriable. We need to provide a query view
for the source::
>>> @zope.interface.implementer(
... zope.formlib.interfaces.ISourceQueryView)
... @zope.component.adapter(
... SourceList,
... zope.publisher.interfaces.browser.IBrowserRequest,
... )
... class ListQueryView:
...
... def __init__(self, source, request):
... self.source = source
... self.request = request
...
... def render(self, name):
... return (
... '
zope.formlib-4.3.0a2/src/zope/formlib/subpageform.pt 0000664 0000000 0000000 00000011515 12243456432 021134 0 ustar root root
zope.formlib-4.3.0a2/src/zope/formlib/__init__.py 0000664 0000000 0000000 00000001145 12243456432 020364 0 ustar root root ##############################################################################
#
# Copyright (c) 2005 Zope Foundation and Contributors.
#
# 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.
#
##############################################################################
zope.formlib-4.3.0a2/src/zope/formlib/bugs.txt 0000664 0000000 0000000 00000003717 12243456432 017763 0 ustar root root Functional tests to verify bugs are gone
========================================
`setupWidgets` and `DISPLAY_UNWRITEABLE`
++++++++++++++++++++++++++++++++++++++++
This is to verify that bug #219948 is gone: setupWidgets doesn't check for
write access on the adapter.
Create a form containg two interfaces:
>>> import zope.formlib.tests
>>> class MyFormBase(object):
... form_fields = zope.formlib.form.FormFields(
... zope.formlib.tests.IOrder, zope.formlib.tests.IDescriptive,
... render_context=zope.formlib.interfaces.DISPLAY_UNWRITEABLE).omit(
... 'now')
>>> class MyEditForm(MyFormBase, zope.formlib.form.EditForm):
... pass
Instanciate the context objects and the form:
>>> import zope.publisher.browser
>>> request = zope.publisher.browser.TestRequest()
>>> order = zope.formlib.tests.Order()
>>> form = MyEditForm(order, request)
When we render the form, the fields of IDescriptive are read only because we
have no write access (this is configured in ftesting.zcml), the others are
writable[#needsinteraction]_:
>>> form.setUpWidgets()
>>> form.widgets['title']
>>> form.widgets['name']
Make sure we have the same behaviour for non-edit forms:
>>> class MyForm(MyFormBase, zope.formlib.form.Form):
... pass
>>> import zope.publisher.browser
>>> request = zope.publisher.browser.TestRequest()
>>> order = zope.formlib.tests.Order()
>>> form = MyForm(order, request)
>>> form.setUpWidgets()
>>> form.widgets['title']
>>> form.widgets['name']
Clean up:
>>> zope.security.management.endInteraction()
.. [#needsinteraction]
>>> import zope.security.management
>>> import zope.security.testing
>>> request.setPrincipal(zope.security.management.system_user)
>>> zope.security.management.newInteraction(request)
zope.formlib-4.3.0a2/src/zope/formlib/tests/ 0000775 0000000 0000000 00000000000 12355055056 017415 5 ustar root root zope.formlib-4.3.0a2/src/zope/formlib/tests/test_decimalwidget.py 0000664 0000000 0000000 00000004446 12243456432 023637 0 ustar root root ##############################################################################
#
# Copyright (c) 2001, 2002, 2006 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.
#
##############################################################################
"""Decimal Widget tests
"""
import unittest
import decimal
import doctest
from zope.formlib.tests.test_browserwidget import SimpleInputWidgetTest
from zope.formlib.interfaces import IInputWidget
from zope.formlib.widgets import DecimalWidget
from zope.formlib.interfaces import ConversionError, WidgetInputError
from zope.interface.verify import verifyClass
from zope.schema import Decimal
class DecimalWidgetTest(SimpleInputWidgetTest):
"""Documents and tests the float widget.
>>> verifyClass(IInputWidget, DecimalWidget)
True
"""
_FieldFactory = Decimal
_WidgetFactory = DecimalWidget
def test_hasInput(self):
del self._widget.request.form['field.foo']
self.failIf(self._widget.hasInput())
# widget has input, even if input is an empty string
self._widget.request.form['field.foo'] = u''
self.failUnless(self._widget.hasInput())
self._widget.request.form['field.foo'] = u'123'
self.failUnless(self._widget.hasInput())
def test_getInputValue(self):
self._widget.request.form['field.foo'] = u''
self.assertRaises(WidgetInputError, self._widget.getInputValue)
self._widget.request.form['field.foo'] = u'123.45'
self.assertEquals(self._widget.getInputValue(),
decimal.Decimal("123.45"))
self._widget.request.form['field.foo'] = u'abc'
self.assertRaises(ConversionError, self._widget.getInputValue)
def test_suite():
return unittest.TestSuite((
unittest.makeSuite(DecimalWidgetTest),
doctest.DocTestSuite(),
))
if __name__=='__main__':
unittest.main(defaultTest='test_suite')
zope.formlib-4.3.0a2/src/zope/formlib/tests/test_functional_booleanradiowidget.py 0000664 0000000 0000000 00000007326 12243456432 027121 0 ustar root root ##############################################################################
#
# Copyright (c) 2001, 2002 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.
#
##############################################################################
"""Radio Widget Functional Tests
"""
import unittest
from zope.interface import Interface, implementer
from zope.schema import Bool
from zope.formlib import form
from zope.publisher.browser import TestRequest
from zope.formlib.tests.support import patternExists
from zope.formlib.widgets import BooleanRadioWidget
from zope.formlib.tests.functionalsupport import FunctionalWidgetTestCase
import zope.schema.interfaces
class IFoo(Interface):
bar = Bool(title=u'Bar')
@implementer(IFoo)
class Foo(object):
def __init__(self):
self.bar = True
class Form(form.EditForm):
form_fields = form.fields(IFoo)
form_fields['bar'].custom_widget = BooleanRadioWidget
class Test(FunctionalWidgetTestCase):
widgets = [(zope.schema.interfaces.IBool, BooleanRadioWidget)]
def test_display_editform(self):
foo = Foo()
request = TestRequest()
html = Form(foo, request)()
# bar field should be displayed as two radio buttons
self.assert_(patternExists(
'.*' \
'*. ' % field
m = re.search(pattern, source, re.DOTALL)
if m is None:
return None
return parseDatetimetz(m.group(1))
def test_display_editform(self):
foo = DatetimeTest()
request = TestRequest()
html = Form(foo, request)()
# confirm date values in form with actual values
self.assertEqual(self.getDateForField('d1', html),
foo.d1)
self.assertEqual(self.getDateForField('d2', html),
foo.d2)
self.assert_(self.getDateForField('d3', html) is None)
def test_submit_editform(self):
foo = DatetimeTest()
request = TestRequest()
request.form['form.d1'] = u'2003-02-01 00:00:00+00:00'
request.form['form.d2'] = u'2003-02-02 00:00:00+00:00'
request.form['form.d3'] = u'2003-10-15 00:00:00+00:00'
request.form['form.actions.apply'] = u''
Form(foo, request)()
self.assertEqual(foo.d1, datetime(2003, 2, 1, tzinfo=tzinfo(0)))
self.assertEqual(foo.d2, datetime(2003, 2, 2, tzinfo=tzinfo(0)))
self.assertEqual(foo.d3, datetime(2003, 10, 15, tzinfo=tzinfo(0)))
def test_missing_value(self):
foo = DatetimeTest()
request = TestRequest()
# submit missing values for d2 and d3
request.form['form.d2'] = ''
request.form['form.d3-empty-marker'] = ''
request.form['form.actions.apply'] = u''
Form(foo, request)()
self.assert_(foo.d2 is None) # default missing_value for dates
# 2000-1-1 is missing_value for d3
self.assertEqual(foo.d3, datetime(2000, 1, 1, tzinfo=tzinfo(0)))
def test_required_validation(self):
foo = DatetimeTest()
request = TestRequest()
request.form['form.d1'] = ''
request.form['form.d2'] = ''
request.form['form.d3'] = ''
request.form['form.actions.apply'] = u''
html = Form(foo, request)()
# confirm error msgs
# only Required input is missing after d1
d1_index = html.find('form.d1')
self.assert_(html.find('Required input is missing', d1_index) != -1)
# but not after d2 or further
d2_index = html.find('form.d2')
self.assert_(html.find('Required input is missing', d2_index) == -1)
def test_invalid_value(self):
foo = DatetimeTest()
request = TestRequest()
# submit a value for d3 that isn't allowed
request.form['form.d3'] = u'2003-02-01 12:00:00+00:00'
request.form['form.actions.apply'] = u''
html = Form(foo, request)()
# Invalid value message for d3
d3_index = html.find('form.d3')
self.assert_(html.find('Invalid', d3_index) != -1)
def test_min_max_validation(self):
foo = DatetimeTest()
request = TestRequest()
# submit value for d1 that is too low
request.form['form.d1'] = u'2002-12-31 12:00:00+00:00'
request.form['form.actions.apply'] = u''
html = Form(foo, request)()
d1_index = html.find('form.d1')
self.assert_(html.find('Value is too small') != -1)
d2_index = html.find('form.d2')
self.assert_(html.find('Value is too small', d2_index) == -1)
request = TestRequest()
# submit value for d1 that is too high
request.form['form.d1'] = u'2021-12-01 12:00:00+00:00'
request.form['form.actions.apply'] = u''
html = Form(foo, request)()
self.assert_(html.find('Value is too big') != -1)
d2_index = html.find('form.d2')
self.assert_(html.find('Value is too big', d2_index) == -1)
def test_omitted_value(self):
foo = DatetimeTest()
request = TestRequest()
# remember default values
d1 = foo.d1
d2 = foo.d2
self.assert_(d2 is not None)
d3 = foo.d3
# submit change with only d2 present -- note that required
# field d1 is omitted, which should not cause a validation error
request.form['form.d2'] = ''
request.form['form.actions.apply'] = u''
Form(foo, request)()
# check new value in object
self.assertEqual(foo.d1, d1)
self.assert_(foo.d2 is None)
self.assertEqual(foo.d3, d3)
def test_suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(Test))
return suite
zope.formlib-4.3.0a2/src/zope/formlib/tests/registerWidgets.zcml 0000664 0000000 0000000 00000000512 12243456432 023454 0 ustar root root
zope.formlib-4.3.0a2/src/zope/formlib/tests/test_intwidget.py 0000664 0000000 0000000 00000004270 12243456432 023026 0 ustar root root ##############################################################################
#
# Copyright (c) 2001, 2002 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.
#
##############################################################################
"""Integer Widget Tests
"""
import unittest
import doctest
from zope.formlib.tests.test_browserwidget import SimpleInputWidgetTest
from zope.formlib.interfaces import IInputWidget
from zope.formlib.widgets import IntWidget
from zope.formlib.interfaces import ConversionError, WidgetInputError
from zope.interface.verify import verifyClass
from zope.schema import Int
class IntWidgetTest(SimpleInputWidgetTest):
"""Documents and tests the int widget.
>>> verifyClass(IInputWidget, IntWidget)
True
"""
_FieldFactory = Int
_WidgetFactory = IntWidget
def test_hasInput(self):
del self._widget.request.form['field.foo']
self.failIf(self._widget.hasInput())
# widget has input, even if input is an empty string
self._widget.request.form['field.foo'] = u''
self.failUnless(self._widget.hasInput())
self._widget.request.form['field.foo'] = u'123'
self.failUnless(self._widget.hasInput())
def test_getInputValue(self):
self._widget.request.form['field.foo'] = u''
self.assertRaises(WidgetInputError, self._widget.getInputValue)
self._widget.request.form['field.foo'] = u'123'
self.assertEquals(self._widget.getInputValue(), 123)
self._widget.request.form['field.foo'] = u'abc'
self.assertRaises(ConversionError, self._widget.getInputValue)
def test_suite():
return unittest.TestSuite((
unittest.makeSuite(IntWidgetTest),
doctest.DocTestSuite(),
))
if __name__=='__main__':
unittest.main(defaultTest='test_suite')
zope.formlib-4.3.0a2/src/zope/formlib/tests/test_radiowidget.py 0000664 0000000 0000000 00000011012 12243456432 023322 0 ustar root root ##############################################################################
#
# Copyright (c) 2001, 2002 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.
#
##############################################################################
"""Radio Widget Tests
"""
import unittest
import doctest
from zope.interface import Interface, implementer
from zope.interface.verify import verifyClass
from zope.publisher.browser import TestRequest
from zope.schema import Choice
from zope.formlib.interfaces import IInputWidget
from zope.formlib.widgets import RadioWidget
from zope.formlib.tests.test_browserwidget import SimpleInputWidgetTest
class RadioWidgetTest(SimpleInputWidgetTest):
"""Documents and tests the radio widget.
>>> verifyClass(IInputWidget, RadioWidget)
True
"""
_FieldFactory = Choice
_WidgetFactory = RadioWidget
def setUpContent(self, desc=u'', title=u'Foo Title'):
class ITestContent(Interface):
foo = self._FieldFactory(
title=title,
description=desc,
values=(u'foo', u'bar')
)
@implementer(ITestContent)
class TestObject(object):
pass
self.content = TestObject()
field = ITestContent['foo']
field = field.bind(self.content)
request = TestRequest(HTTP_ACCEPT_LANGUAGE='pl')
request.form['field.foo'] = u'Foo Value'
self._widget = self._WidgetFactory(field, field.vocabulary, request)
def testProperties(self):
self.assertEqual(self._widget.cssClass, "")
self.assertEqual(self._widget.extra, '')
self.assertEqual(self._widget.orientation, 'vertical')
def testRenderItem(self):
check_list = ('type="radio"', 'id="field.bar.0"',
'name="field.bar"', 'value="foo"', 'Foo')
self.verifyResult(
self._widget.renderItem(0, 'Foo', 'foo', 'field.bar', None),
check_list)
check_list += ('checked="checked"',)
self.verifyResult(
self._widget.renderSelectedItem(
0, 'Foo', 'foo', 'field.bar', None),
check_list)
def testRenderItems(self):
check_list = ('type="radio"', 'id="field.foo.0"', 'name="field.foo"',
'value="bar"', 'bar', 'value="foo"', 'foo',
'checked="checked"')
self.verifyResult('\n'.join(self._widget.renderItems('bar')),
check_list)
def testRender(self):
value = 'bar'
self._widget.setRenderedValue(value)
check_list = ('type="radio"', 'id="field.foo.0"',
'name="field.foo"', 'value="bar"', 'bar',
'value="foo"', 'foo', 'checked="checked"')
self.verifyResult(self._widget(), check_list)
check_list = ('type="hidden"', 'id="field.foo"',
'name="field.foo"', 'value="bar"')
self.verifyResult(self._widget.hidden(), check_list)
check_list = ('style="color: red"',) + check_list
self._widget.extra = 'style="color: red"'
self.verifyResult(self._widget.hidden(), check_list)
def testHasInput(self):
self._widget.request.form.clear()
self.assert_(not self._widget.hasInput())
self._widget.request.form['field.foo-empty-marker'] = '1'
self.assert_(self._widget.hasInput())
self._widget.request.form['field.foo'] = u'Foo Value'
self.assert_(self._widget.hasInput())
del self._widget.request.form['field.foo-empty-marker']
self.assert_(self._widget.hasInput())
def testRenderEmptyMarker(self):
self.verifyResult(self._widget(), ('field.foo-empty-marker',))
self._widget.setRenderedValue(u'bar')
self.verifyResult(self._widget(), ('field.foo-empty-marker',))
self._widget.setRenderedValue(u'not a legal value')
self.verifyResult(self._widget(), ('field.foo-empty-marker',))
def test_suite():
return unittest.TestSuite((
unittest.makeSuite(RadioWidgetTest),
doctest.DocTestSuite(),
))
if __name__=='__main__':
unittest.main(defaultTest='test_suite')
zope.formlib-4.3.0a2/src/zope/formlib/tests/test_form.py 0000664 0000000 0000000 00000003633 12243456432 021775 0 ustar root root ##############################################################################
#
# 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.
#
##############################################################################
"""Test Browser Widget
"""
import unittest
class FormBaseTests(unittest.TestCase):
def _getTargetClass(self):
from zope.formlib.form import FormBase
return FormBase
def _makeContext(self, **kw):
class _Context(object):
pass
context = _Context()
for k, v in kw.items():
setattr(context, k, v)
return context
def _makeRequest(self, **kw):
from zope.publisher.browser import TestRequest
return TestRequest(**kw)
def _makeOne(self, context=None, request=None):
if context is None:
context = self._makeContext()
if request is None:
request = self._makeRequest()
return self._getTargetClass()(context, request)
def test___call___does_not_render_on_redirects(self):
for status in (301, 302, 303, 307):
request = self._makeRequest()
request.response.setStatus(status)
def _raise(*args, **kw):
self.fail("DON'T GO HERE")
form = self._makeOne(request=request)
form.form_fields = form.actions = ()
form.template = _raise
self.assertEqual(form(), '')
def test_suite():
return unittest.TestSuite((
unittest.makeSuite(FormBaseTests),
))
zope.formlib-4.3.0a2/src/zope/formlib/tests/test_floatwidget.py 0000664 0000000 0000000 00000004324 12243456432 023341 0 ustar root root ##############################################################################
#
# Copyright (c) 2001, 2002 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.
#
##############################################################################
"""Float Widget tests
"""
import unittest
import doctest
from zope.formlib.tests.test_browserwidget import SimpleInputWidgetTest
from zope.formlib.interfaces import IInputWidget
from zope.formlib.widgets import FloatWidget
from zope.formlib.interfaces import ConversionError, WidgetInputError
from zope.interface.verify import verifyClass
from zope.schema import Float
class FloatWidgetTest(SimpleInputWidgetTest):
"""Documents and tests the float widget.
>>> verifyClass(IInputWidget, FloatWidget)
True
"""
_FieldFactory = Float
_WidgetFactory = FloatWidget
def test_hasInput(self):
del self._widget.request.form['field.foo']
self.failIf(self._widget.hasInput())
# widget has input, even if input is an empty string
self._widget.request.form['field.foo'] = u''
self.failUnless(self._widget.hasInput())
self._widget.request.form['field.foo'] = u'123'
self.failUnless(self._widget.hasInput())
def test_getInputValue(self):
self._widget.request.form['field.foo'] = u''
self.assertRaises(WidgetInputError, self._widget.getInputValue)
self._widget.request.form['field.foo'] = u'123.45'
self.assertEquals(self._widget.getInputValue(), 123.45)
self._widget.request.form['field.foo'] = u'abc'
self.assertRaises(ConversionError, self._widget.getInputValue)
def test_suite():
return unittest.TestSuite((
unittest.makeSuite(FloatWidgetTest),
doctest.DocTestSuite(),
))
if __name__=='__main__':
unittest.main(defaultTest='test_suite')
zope.formlib-4.3.0a2/src/zope/formlib/tests/test_functional_objectwidget.py 0000664 0000000 0000000 00000007504 12243456432 025727 0 ustar root root ##############################################################################
#
# Copyright (c) 2001, 2002 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 object widget
"""
import unittest
from zope.pagetemplate.pagetemplate import PageTemplate
import zope.traversing.interfaces
from zope.component import provideAdapter
from zope.traversing.adapters import DefaultTraversable
from zope.component.testing import PlacelessSetup
from zope.interface import Interface, implementer
from zope.schema import TextLine, Object
from zope.formlib import form
from zope.publisher.browser import TestRequest
from zope.formlib.widgets import ObjectWidget
from zope.formlib.tests.support import VerifyResults
import zope.schema.interfaces
from zope.traversing.testing import setUp as traversingSetUp
from zope.configuration import xmlconfig
import zope.formlib
import os
class ITestContact(Interface):
name = TextLine()
email = TextLine()
@implementer(ITestContact)
class TestContact(object):
pass
class Form(form.EditForm):
form_fields = form.fields(ITestContact)
class Test(PlacelessSetup, unittest.TestCase, VerifyResults):
def setUp(self):
super(Test, self).setUp()
traversingSetUp()
# XXX this whole test setup is rather involved. Is there a
# simpler way to publish widget_macros.pt? Probably.
# load the registrations for formlib
xmlconfig.file("configure.zcml",
zope.formlib)
# set up the widget_macros macro
macro_template = PageTemplate()
widget_macros = os.path.join(os.path.dirname(zope.formlib.__file__),
'widget_macros.pt')
f = open(widget_macros, 'r')
data = f.read()
f.close()
macro_template.write(data)
@zope.component.adapter(None, None)
@implementer(zope.traversing.interfaces.ITraversable)
class view:
def __init__(self, ob, r=None):
pass
def traverse(*args):
return macro_template.macros
provideAdapter(view, name='view')
provideAdapter(DefaultTraversable, [None])
def test_new(self):
request = TestRequest()
field = Object(ITestContact, __name__=u'foo')
widget = ObjectWidget(field, request, TestContact)
self.assertEquals(int(widget.hasInput()), 0)
check_list = (
'input', 'name="field.foo.name"',
'input', 'name="field.foo.email"'
)
self.verifyResult(widget(), check_list)
def test_edit(self):
request = TestRequest(form={
'field.foo.name': u'fred',
'field.foo.email': u'fred@fred.com'
})
field = Object(ITestContact, __name__=u'foo')
widget = ObjectWidget(field, request, TestContact)
self.assertEquals(int(widget.hasInput()), 1)
o = widget.getInputValue()
self.assertEquals(hasattr(o, 'name'), 1)
self.assertEquals(o.name, u'fred')
self.assertEquals(o.email, u'fred@fred.com')
check_list = (
'input', 'name="field.foo.name"', 'value="fred"',
'input', 'name="field.foo.email"', 'value="fred@fred.com"',
)
self.verifyResult(widget(), check_list)
def test_suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(Test))
return suite
zope.formlib-4.3.0a2/src/zope/formlib/tests/test_multicheckboxwidget.py 0000664 0000000 0000000 00000010576 12243456432 025103 0 ustar root root ##############################################################################
#
# Copyright (c) 2001, 2002 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.
#
##############################################################################
"""Multi-Checkbox Widget Tests
"""
import unittest
import doctest
from zope.interface import Interface, implementer
from zope.publisher.browser import TestRequest
from zope.schema import Choice, List
from zope.formlib.interfaces import IInputWidget
from zope.formlib.widgets import MultiCheckBoxWidget
from zope.formlib.tests.test_browserwidget import SimpleInputWidgetTest
from zope.interface.verify import verifyClass
class MultiCheckBoxWidgetTest(SimpleInputWidgetTest):
"""Documents and tests the multi checkbox widget.
>>> verifyClass(IInputWidget, MultiCheckBoxWidget)
True
"""
_WidgetFactory = MultiCheckBoxWidget
_FieldFactory = List
def setUpContent(self, desc=u'', title=u'Foo Title'):
class ITestContent(Interface):
foo = self._FieldFactory(
title=title,
description=desc,
value_type=Choice(values=[u'foo', u'bar'])
)
@implementer(ITestContent)
class TestObject(object):
pass
self.content = TestObject()
field = ITestContent['foo']
field = field.bind(self.content)
request = TestRequest(HTTP_ACCEPT_LANGUAGE='pl',
form={'field.foo': u'bar'})
self._widget = self._WidgetFactory(field, field.value_type.vocabulary,
request)
def testProperties(self):
self.assertEqual(self._widget.cssClass, "")
self.assertEqual(self._widget.extra, '')
self.assertEqual(self._widget.orientation, 'vertical')
def testRenderItem(self):
check_list = ('type="checkbox"', 'id="field.bar.',
'name="field.bar"', 'value="foo"', 'Foo')
self.verifyResult(
self._widget.renderItem(0, 'Foo', 'foo', 'field.bar', None),
check_list)
check_list += ('checked="checked"',)
self.verifyResult(
self._widget.renderSelectedItem(
0, 'Foo', 'foo', 'field.bar', None),
check_list)
def testRenderItemEscaped(self):
check_list = ('type="checkbox"', 'id="field.bar.',
'name="field.bar"', 'value="foo"',
'<h1>Foo</h1>')
self.verifyResult(
self._widget.renderItem(0, 'Foo ', 'foo', 'field.bar',
None),
check_list)
check_list += ('checked="checked"',)
self.verifyResult(
self._widget.renderSelectedItem(
0, 'Foo ', 'foo', 'field.bar', None),
check_list)
def testRenderItems(self):
check_list = ('type="checkbox"', 'id="field.foo.',
'name="field.foo"', 'value="bar"', 'bar',
'value="foo"', 'foo', 'checked="checked"')
self.verifyResult('\n'.join(self._widget.renderItems(['bar'])),
check_list)
def testRender(self):
check_list = ('type="checkbox"', 'id="field.foo.',
'name="field.foo"', 'value="bar"', 'bar',
'value="foo"', 'foo', 'checked="checked"')
self.verifyResult(self._widget(), check_list)
check_list = ('type="hidden"', 'id="field.foo', 'name="field.foo:list"',
'value="bar"')
self.verifyResult(self._widget.hidden(), check_list)
check_list = ('style="color: red"',) + check_list
self._widget.extra = 'style="color: red"'
self.verifyResult(self._widget.hidden(), check_list)
def test_suite():
return unittest.TestSuite((
unittest.makeSuite(MultiCheckBoxWidgetTest),
doctest.DocTestSuite(),
))
if __name__=='__main__':
unittest.main(defaultTest='test_suite')
zope.formlib-4.3.0a2/src/zope/formlib/tests/test_registrations.py 0000664 0000000 0000000 00000016120 12243456432 023722 0 ustar root root ##############################################################################
#
# Copyright (c) 2004 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 widget registrations.
"""
import unittest
from zope.component import getMultiAdapter
from zope.configuration import xmlconfig
from zope.interface import implementer
from zope.publisher.browser import TestRequest
from doctest import DocTestSuite
from zope.component import testing
# import all widgets (in this case, importing * is ok, since we
# absolutely know what we're importing)
from zope.formlib.widgets import *
from zope.formlib.interfaces import IDisplayWidget, IInputWidget
import zope.formlib
import zope.schema as fields
from zope.schema import interfaces
from zope.schema import vocabulary
class ISampleObject(interfaces.IField):
pass
@implementer(ISampleObject)
class SampleObject(object):
pass
class ISampleVocabulary(interfaces.IVocabularyTokenized,
interfaces.IVocabulary):
pass
@implementer(ISampleVocabulary)
class SampleVocabulary(vocabulary.SimpleVocabulary):
pass
request = TestRequest()
sample = SampleObject()
vocab = SampleVocabulary([])
def setUp(test):
testing.setUp()
xmlconfig.file("tests/registerWidgets.zcml",
zope.formlib)
class Tests(object):
"""Documents and tests widgets registration for specific field types.
Standard Widgets
------------------------------------------------------------------------
The relationships between field types and standard widgets are listed
below.
IField, IDisplayWidget -> DisplayWidget
>>> field = fields.Field()
>>> widget = getMultiAdapter((field, request), IDisplayWidget)
>>> isinstance(widget, DisplayWidget)
True
ITextLine, IInputWidget -> TextWidget
>>> field = fields.TextLine()
>>> widget = getMultiAdapter((field, request), IInputWidget)
>>> isinstance(widget, TextWidget)
True
IText, IInputWidget -> TextAreaWidget
>>> field = fields.Text()
>>> widget = getMultiAdapter((field, request), IInputWidget)
>>> isinstance(widget, TextAreaWidget)
True
ISourceText, IInputWidget -> TextAreaWidget
>>> field = fields.SourceText()
>>> widget = getMultiAdapter((field, request), IInputWidget)
>>> isinstance(widget, TextAreaWidget)
True
IBytesLine, IInputWidget -> BytesWidget
>>> field = fields.BytesLine()
>>> widget = getMultiAdapter((field, request), IInputWidget)
>>> isinstance(widget, BytesWidget)
True
IBytes, IInputWidget -> FileWidget
>>> field = fields.Bytes()
>>> widget = getMultiAdapter((field, request), IInputWidget)
>>> isinstance(widget, FileWidget)
True
IASCIILine, IInputWidget -> ASCIIWidget
>>> field = fields.ASCIILine()
>>> widget = getMultiAdapter((field, request), IInputWidget)
>>> isinstance(widget, ASCIIWidget)
True
IASCII, IInputWidget -> ASCIIAreaWidget
>>> field = fields.ASCII()
>>> widget = getMultiAdapter((field, request), IInputWidget)
>>> isinstance(widget, ASCIIAreaWidget)
True
IInt, IInputWidget -> IntWidget
>>> field = fields.Int()
>>> widget = getMultiAdapter((field, request), IInputWidget)
>>> isinstance(widget, IntWidget)
True
IFloat, IInputWidget -> FloatWidget
>>> field = fields.Float()
>>> widget = getMultiAdapter((field, request), IInputWidget)
>>> isinstance(widget, FloatWidget)
True
IDecimal, IInputWidget -> DecimalWidget
>>> field = fields.Decimal()
>>> widget = getMultiAdapter((field, request), IInputWidget)
>>> isinstance(widget, DecimalWidget)
True
IDatetime, IInputWidget -> DatetimeWidget
>>> field = fields.Datetime()
>>> widget = getMultiAdapter((field, request), IInputWidget)
>>> isinstance(widget, DatetimeWidget)
True
IDate, IInputWidget -> DateWidget
>>> field = fields.Date()
>>> widget = getMultiAdapter((field, request), IInputWidget)
>>> isinstance(widget, DateWidget)
True
IBool, IInputWidget -> CheckBoxWidget
>>> field = fields.Bool()
>>> widget = getMultiAdapter((field, request), IInputWidget)
>>> isinstance(widget, CheckBoxWidget)
True
ITuple, IInputWidget -> TupleSequenceWidget
>>> field = fields.Tuple(value_type=fields.Int())
>>> widget = getMultiAdapter((field, request), IInputWidget)
>>> isinstance(widget, TupleSequenceWidget)
True
IList, IInputWidget -> ListSequenceWidget
>>> field = fields.List(value_type=fields.Int())
>>> widget = getMultiAdapter((field, request), IInputWidget)
>>> isinstance(widget, ListSequenceWidget)
True
IPassword, IInputWidget -> PasswordWidget
>>> field = fields.Password()
>>> widget = getMultiAdapter((field, request), IInputWidget)
>>> isinstance(widget, PasswordWidget)
True
IChoice, IDisplayWidget -> ItemDisplayWidget
>>> field = fields.Choice(vocabulary=vocab)
>>> field = field.bind(sample)
>>> widget = getMultiAdapter((field, request), IDisplayWidget)
>>> isinstance(widget, ItemDisplayWidget)
True
IChoice, IInputWidget -> DropdownWidget
>>> field = fields.Choice(vocabulary=vocab)
>>> field = field.bind(sample)
>>> widget = getMultiAdapter((field, request), IInputWidget)
>>> isinstance(widget, DropdownWidget)
True
IList with IChoice value_type, IDisplayWidget -> ItemsMultiDisplayWidget
>>> field = fields.List(value_type=fields.Choice(vocabulary=vocab))
>>> field = field.bind(sample)
>>> widget = getMultiAdapter((field, request), IDisplayWidget)
>>> isinstance(widget, ItemsMultiDisplayWidget)
True
IList with IChoice value_type, IInputWidget -> MultiSelectWidget
>>> field = fields.List(value_type=fields.Choice(vocabulary=vocab))
>>> field = field.bind(sample)
>>> widget = getMultiAdapter((field, request), IInputWidget)
>>> isinstance(widget, OrderedMultiSelectWidget)
True
"""
def test_suite():
return DocTestSuite(setUp=setUp, tearDown=testing.tearDown)
if __name__=='__main__':
unittest.main(defaultTest='test_suite')
zope.formlib-4.3.0a2/src/zope/formlib/tests/test_textwidget.py 0000664 0000000 0000000 00000040521 12243456432 023217 0 ustar root root ##############################################################################
#
# Copyright (c) 2001, 2002, 2004, 2005 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.
#
##############################################################################
"""Text Widget tests
"""
import datetime
import unittest
import doctest
from zope.component.testing import setUp, tearDown
from zope.interface.verify import verifyClass
from zope.schema import TextLine
from zope.publisher.browser import TestRequest
from zope.schema import Password
from zope.formlib.interfaces import IInputWidget
from zope.formlib.widgets import TextWidget
from zope.formlib.widgets import TextAreaWidget
from zope.formlib.widgets import BytesAreaWidget
from zope.formlib.widgets import PasswordWidget
from zope.formlib.widgets import FileWidget
from zope.formlib.widgets import IntWidget
from zope.formlib.widgets import FloatWidget
from zope.formlib.widgets import BytesWidget
from zope.formlib.widgets import ASCIIWidget
from zope.formlib.widgets import DateDisplayWidget
from zope.formlib.widgets import DatetimeDisplayWidget
from zope.formlib.widgets import URIDisplayWidget
from zope.formlib.tests.test_browserwidget import BrowserWidgetTest
from zope.formlib.tests.test_browserwidget import SimpleInputWidgetTest
from zope.formlib.tests.support import checker
class TextWidgetTest(SimpleInputWidgetTest):
"""Documents and tests the text widget.
>>> setUp()
>>> verifyClass(IInputWidget, TextWidget)
True
Converting Missing Values
-------------------------
String fields (TextLine, Text, etc.) values can be classified as one of the
following:
- Non-empty string
- Empty string
- None
Text browser widgets only support the first two types: non-empty strings
and empty strings. There's no facility to explicitly set a None value in a
text browser widget.
However, it is possible to interpret an empty string as None for some
applications. For example, when inputing a User Name, an empty string means
'the user hasn't provided a value'. In another application, an empty string
may mean 'the user has provided a value, specifically '.
To support both modes, the text widget provides a 'convert_missing_value'
flag. When True, empty strings will be converted by the widget to the
field's 'missing_value' (None by default). This mode accommodates the
'user hasn't provided a value' scenario.
To illustrate this mode, we'll use an optional field, where missing_value
is None:
>>> field = TextLine(
... __name__='foo',
... missing_value=None,
... required=False)
The HTTP form submission contains an empty string for the field value:
>>> request = TestRequest(form={'field.foo':u''})
A text widget configured for the field, where convert_missing_value is True
(the default value)...
>>> widget = TextWidget(field, request)
>>> widget.convert_missing_value
True
will convert the form's empty string into the field's missing_value, which
is None:
>>> widget.getInputValue() is None
True
When 'convert_missing_value' is False, the text widget will not convert
an empty string to the field's missing_value. This supports the 'user has
provided a value, specifically ' mode:
>>> widget.convert_missing_value = False
>>> widget.getInputValue()
u''
>>> tearDown()
"""
_WidgetFactory = TextWidget
def testProperties(self):
self.assertEqual(self._widget.tag, 'input')
self.assertEqual(self._widget.type, 'text')
self.assertEqual(self._widget.cssClass, '')
self.assertEqual(self._widget.extra, '')
self.assertEqual(self._widget.default, '')
self.assertEqual(self._widget.displayWidth, 20)
self.assertEqual(self._widget.displayMaxWidth, '')
def testRender(self):
value = 'Foo Value'
self._widget.setRenderedValue(value)
check_list = ('type="text"', 'id="field.foo"', 'name="field.foo"',
'value="Foo Value"', 'size="20"')
self.verifyResult(self._widget(), check_list)
check_list = ('type="hidden"',) + check_list[1:-1]
self.verifyResult(self._widget.hidden(), check_list)
check_list = ('style="color: red"',) + check_list
self._widget.extra = 'style="color: red"'
self.verifyResult(self._widget.hidden(), check_list)
class URIDisplayWidgetTest(BrowserWidgetTest):
_WidgetFactory = URIDisplayWidget
def testProperties(self):
# check the default linkTarget
self.failIf(self._widget.linkTarget)
def testRender(self):
value = "uri:fake"
self._widget.setRenderedValue(value)
self.verifyResult(self._widget(), [">> from zope.schema import TextLine
>>> field = TextLine(__name__='foo', title=u'on',
... required=False, missing_value=u'')
>>> request = TestRequest()
>>> widget = TextWidget(field, request)
>>> def normalize(s):
... return '\\n '.join(filter(None, s.split(' ')))
>>> print(normalize( widget() ))
...
...
However, if we call getInputValue or hasValidInput, the
errors on the widgets are preserved and displayed:
>>> widget.hasValidInput()
False
>>> print(widget())
...
Required input is missing.
...
"""
class SequenceDisplayWidgetTest(
VerifyResults, SequenceWidgetTestHelper, unittest.TestCase):
def _WidgetFactory(self, *args, **kw):
w = SequenceDisplayWidget(*args, **kw)
w.cssClass = "testwidget"
return w
def setUp(self):
self.setUpContent()
self.request = TestRequest()
self.widget = self._WidgetFactory(
self.field, self.field.value_type, self.request)
provideAdapter(DisplayWidget, (ITextLine, IDefaultBrowserLayer),
IDisplayWidget)
def test_render_empty(self):
self.content.foo = ()
self.assertEquals(self.widget(), '(no values)')
def test_render_missing(self):
self.content.foo = self.field.missing_value
self.assertEquals(self.widget(), '(no value available)')
def test_render_single(self):
self.content.foo = (u'one value',)
check_list = ['',
html))
self.assert_(patternExists(
'',
html))
self.assert_(patternExists(
' ',
html))
self.assert_(patternExists(
' ',
html))
self.assert_(patternExists(
' ',
html))
self.assert_(patternExists(
' ',
html))
# S4
joined_body = "".join(html.split("\n"))
self.failIf(patternExists(
'.*',
joined_body))
self.assert_(patternExists(
'',
html))
self.assert_(patternExists(
'',
html))
self.assert_(patternExists(
' ',
html))
self.assert_(patternExists(
' ',
html))
request = TestRequest()
request.form['form.s3'] = u'Bob'
request.form['form.s4'] = u'2'
request.form['form.actions.apply'] = u''
# display edit view
html = Form(foo, request)()
self.assert_(patternExists(
' ',
html))
self.assert_(patternExists(
' ',
html))
html = Form(foo, request)()
self.assert_(patternExists(
' ',
html))
self.assert_(patternExists(
' ',
html))
request = TestRequest()
request.form['form.s3'] = u''
request.form['form.actions.apply'] = u''
html = Form(foo, request)()
self.assert_(patternExists(
' ',
html))
self.assert_(patternExists(
' ',
html))
request = TestRequest()
html = Form(foo, request)()
self.assert_(patternExists(
' ',
html))
def test_suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(Test))
return suite
zope.formlib-4.3.0a2/src/zope/formlib/tests/test_widget.py 0000664 0000000 0000000 00000015453 12243456432 022320 0 ustar root root ##############################################################################
#
# Copyright (c) 2001, 2002 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.
#
##############################################################################
"""Generic Widget Tests
"""
from unittest import TestSuite, main
from zope.component.testing import setUp, tearDown
from zope.publisher.browser import TestRequest
from doctest import DocTestSuite
from zope.formlib.widget import Widget
from .support import checker
class TestContext(object):
__name__ = 'Test'
title = 'My Test Context'
description = 'A test context.'
class FooWidget(Widget):
pass
context = TestContext()
request = TestRequest()
class TestWidget(object):
"""Tests basic widget characteristics.
Widget implements IWidget:
>>> from zope.interface.verify import verifyClass
>>> from zope.formlib.interfaces import IWidget
>>> verifyClass(IWidget, Widget)
True
>>> widget = Widget(context, request)
>>> from zope.interface.verify import verifyObject
>>> verifyObject(IWidget, widget)
True
The default values for widget are:
>>> widget.name
'field.Test'
>>> widget.label
'My Test Context'
>>> widget.hint
'A test context.'
>>> widget.visible
True
The `label` and `hint` attributes can be overriden, allowing views to
change them in specific contexts without needing to affect information
stored in the data model (the schema):
>>> widget.label = u'My Alternate Label'
>>> widget.label
u'My Alternate Label'
>>> widget.hint = u'Better help would be good.'
>>> widget.hint
u'Better help would be good.'
In the last example, the widget name consists of a prefix, a dot, and the
field name. You can change the prefix used by the widget as follows:
>>> widget.setPrefix('newprefix')
>>> widget.name
'newprefix.Test'
Using the empty string as prefix leaves the prefix off entirely:
>>> widget.setPrefix('')
>>> widget.name
'Test'
To configure a widget, call setRenderedValue with a value that the
widget should display:
>>> widget.setRenderedValue('Render Me')
The way a widget renders a value depends on the type of widget. E.g. a
browser widget will render the specified value in HTML.
"""
class TestInputWidget(object):
"""Tests the input widget mixin.
InputWidget is a simple mixin that provides default implementations for
some of the IInputWidget methods. Because the implementation of widgets
across UI frameworks is so different, most of the input widget methods
must be handled by UI specific classes.
To test the default methods, we must create a basic input widget
that provides a getInputValue method:
>>> from zope.formlib.widget import InputWidget
>>> from zope.formlib.interfaces import WidgetInputError
>>> class TestInputWidget(InputWidget):
... def getInputValue(self):
... if self.context.required:
... raise WidgetInputError('', '', None)
... else:
... return 'Foo Bar'
All widgets rely on a field and a request:
>>> from zope.schema import Field
>>> field = Field()
>>> widget = TestInputWidget(field, TestRequest())
The default implementation of hasValidInput relies on
getInputValue to perform the validation of the current widget input.
In this simple example, the widget will always raise an error when its
field is read only:
>>> field.readonly = True
>>> widget.getInputValue() # doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
WidgetInputError: ('', '', None)
A call to hasValidInput returns False instead of raising an error:
>>> widget.hasValidInput()
False
By changing the field's required attribute, getInputValue returns a
simple string:
>>> field.required = False
>>> widget.getInputValue()
'Foo Bar'
and hasValidInput returns True:
>>> widget.hasValidInput()
True
"""
class TestCustomWidgetFactory(object):
"""Tests the custom widget factory.
Custom widgets can be created using a custom widget factory. Factories
are used to assign attribute values to widgets they create.
The custom widget factory can be used for three widget types:
- Regular widgets
- Sequence widgets
- Vocabulary widgets
Test regular widget:
>>> from zope.formlib.widget import CustomWidgetFactory
>>> factory = CustomWidgetFactory(FooWidget, bar='baz')
>>> widget = factory(context, request)
>>> isinstance(widget, FooWidget)
True
>>> widget.bar
'baz'
Test sequence widget:
>>> from zope.schema import TextLine, List
>>> from zope.formlib.widgets import ListSequenceWidget
>>> value_type = TextLine(__name__=u'bar')
>>> field = List( __name__=u'foo', value_type=value_type )
>>> factory = CustomWidgetFactory(ListSequenceWidget,
... subwidget=CustomWidgetFactory(FooWidget, bar='baz'))
>>> widget = factory(field, request)
>>> widget.context.value_type is value_type
True
>>> isinstance(widget, ListSequenceWidget)
True
>>> isinstance(widget.subwidget, CustomWidgetFactory)
True
>>> subwidget = widget.subwidget(context, request)
>>> isinstance(subwidget, FooWidget)
True
>>> subwidget.bar
'baz'
Test vocabulary widget:
>>> from zope.schema import Choice
>>> from zope.formlib.widgets import RadioWidget
>>> field = Choice( __name__=u'foo', values=['1', '2', '3'] )
>>> bound = field.bind(context)
>>> factory = CustomWidgetFactory(RadioWidget,
... orientation = 'vertical')
>>> widget = factory(bound, request)
>>> [term.value for term in widget.context.vocabulary]
['1', '2', '3']
>>> isinstance(widget, RadioWidget)
True
>>> widget.orientation
'vertical'
"""
def test_suite():
return TestSuite((
DocTestSuite(setUp=setUp, tearDown=tearDown, checker=checker),
))
if __name__=='__main__':
main(defaultTest='test_suite')
zope.formlib-4.3.0a2/src/zope/formlib/tests/test_selectwidget.py 0000664 0000000 0000000 00000004462 12243456432 023516 0 ustar root root ##############################################################################
#
# Copyright (c) 2004 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.
#
##############################################################################
"""Select Widget Tests
"""
import unittest
from zope.schema import Choice, List
from zope.formlib.widgets import SelectWidget
from zope.publisher.browser import TestRequest
choice = Choice(
title=u"Number",
description=u"The Number",
values=[1, 2, 3])
sequence = List(
title=u"Numbers",
description=u"The Numbers",
value_type=choice)
class SelectWidgetTest(unittest.TestCase):
def _makeWidget(self, form):
request = TestRequest(form=form)
return SelectWidget(sequence, choice.vocabulary, request)
select_html = ''''''
class SelectWidgetHTMLEncodingTest(unittest.TestCase):
def testOptionEncoding(self):
choice = Choice(
title=u"Number",
description=u"The Number",
values=['< foo', 'bar/>', '&blah&'])
sequence = List(
__name__="terms",
title=u"Numbers",
description=u"The Numbers",
value_type=choice)
request = TestRequest()
sequence = sequence.bind(object())
widget = SelectWidget(sequence, choice.vocabulary, request)
self.assertEqual(widget(), select_html)
def test_suite():
return unittest.TestSuite((
unittest.makeSuite(SelectWidgetTest),
unittest.makeSuite(SelectWidgetHTMLEncodingTest)
))
if __name__ == '__main__':
unittest.main(defaultTest="test_suite")
zope.formlib-4.3.0a2/src/zope/formlib/tests/support.py 0000664 0000000 0000000 00000004656 12243456432 021515 0 ustar root root ##############################################################################
#
# 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.
#
##############################################################################
"""General test support.
"""
import re
from zope.testing import renormalizing
checker = renormalizing.RENormalizing([
# Python 3 unicode removed the "u".
(re.compile("u('.*?')"),
r"\1"),
(re.compile('u(".*?")'),
r"\1"),
# Python 3 bytes adds the "b".
(re.compile("b('.*?')"),
r"\1"),
(re.compile('b(".*?")'),
r"\1"),
# Python 3 changed the set representation.
(re.compile("set\(\[(.*)\]\)"),
r"{\1}"),
# Python 3 renames builtins.
(re.compile("__builtin__"),
r"builtins"),
# Python 3 adds module name to exceptions.
(re.compile("zope.schema.interfaces.SchemaNotProvided"),
r"SchemaNotProvided"),
])
class VerifyResults(object):
"""Mix-in for test classes with helpers for checking string data."""
def verifyResult(self, result, check_list, inorder=False):
start = 0
for check in check_list:
pos = result.find(check, start)
self.assert_(pos >= 0,
"%r not found in %r" % (check, result[start:]))
if inorder:
start = pos + len(check)
def verifyResultMissing(self, result, check_list):
for check in check_list:
self.assert_(result.find(check) < 0,
"%r unexpectedly found in %r" % (check, result))
def patternExists(pattern, source, flags=0):
return re.search(pattern, source, flags) is not None
def validationErrorExists(field, error_msg, source):
regex = re.compile(r'%s.*?name="form.(\w+)(?:\.[\w\.]+)?"' % (error_msg,),
re.DOTALL)
# compile it first because Python 2.3 doesn't allow flags in findall
return field in regex.findall(source)
def missingInputErrorExists(field, source):
return validationErrorExists(field, 'Required input is missing.', source)
zope.formlib-4.3.0a2/src/zope/formlib/tests/test_exception.py 0000664 0000000 0000000 00000001656 12243456432 023033 0 ustar root root ##############################################################################
#
# 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.
#
##############################################################################
"""Exception Views tests
"""
import unittest
from doctest import DocTestSuite
from .support import checker
def test_suite():
return unittest.TestSuite((
DocTestSuite('zope.formlib.exception', checker=checker),
))
if __name__ == '__main__':
unittest.main(defaultTest='test_suite')
zope.formlib-4.3.0a2/src/zope/formlib/tests/test_setprefix.py 0000664 0000000 0000000 00000005025 12243456432 023040 0 ustar root root ##############################################################################
#
# Copyright (c) 2001, 2002 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.
#
##############################################################################
"""Widget name prefix tests
"""
import unittest
from zope.formlib.widgets import TextWidget
from zope.formlib.tests import support
from zope.publisher.browser import TestRequest
from zope.schema import Text
class Test(support.VerifyResults, unittest.TestCase):
def setUp(self):
field = Text(__name__ = 'foo')
request = TestRequest()
request.form['spam.foo'] = u'Foo Value'
self._widget = TextWidget(field, request)
self._widget.setPrefix('spam')
def testGetData(self):
self.assertEqual(self._widget.getInputValue(), u'Foo Value')
def testRender(self):
value = 'Foo Value 2'
check_list = ('type="text"', 'id="spam.foo"', 'name="spam.foo"',
'value="Foo Value 2"', 'size="20"')
self._widget.setRenderedValue(value)
self.verifyResult(self._widget(), check_list)
check_list = ('type="hidden"',) + check_list[1:-1]
self.verifyResult(self._widget.hidden(), check_list)
check_list = ('style="color: red"',) + check_list
self._widget.extra = 'style="color: red"'
self.verifyResult(self._widget.hidden(), check_list)
class TestEmpty(support.VerifyResults, unittest.TestCase):
def setUp(self):
field = Text(__name__ = 'foo')
request = TestRequest()
request.form['foo'] = u'Foo Value'
self._widget = TextWidget(field, request)
self._widget.setPrefix('')
def testGetData(self):
self.assertEqual(self._widget.getInputValue(), u'Foo Value')
def testRender(self):
check_list = ('id="foo"', 'name="foo"')
self.verifyResult(self._widget(), check_list)
self.verifyResult(self._widget.hidden(), check_list)
def test_suite():
return unittest.TestSuite((
unittest.makeSuite(Test),
unittest.makeSuite(TestEmpty),
))
if __name__=='__main__':
unittest.main(defaultTest='test_suite')
zope.formlib-4.3.0a2/src/zope/formlib/tests/__init__.py 0000664 0000000 0000000 00000000000 12243456432 021513 0 ustar root root zope.formlib-4.3.0a2/src/zope/formlib/tests/test_textareawidget.py 0000664 0000000 0000000 00000004366 12243456432 024057 0 ustar root root ##############################################################################
#
# Copyright (c) 2001, 2002 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.
#
##############################################################################
"""Textarea Widget tests
"""
import unittest
import doctest
from zope.formlib.interfaces import IInputWidget
from zope.formlib.widgets import TextAreaWidget
from zope.formlib.tests.test_browserwidget import SimpleInputWidgetTest
from zope.interface.verify import verifyClass
class TextAreaWidgetTest(SimpleInputWidgetTest):
"""Documents and tests the text area widget.
>>> verifyClass(IInputWidget, TextAreaWidget)
True
"""
_WidgetFactory = TextAreaWidget
def testProperties(self):
self.assertEqual(self._widget.tag, 'input')
self.assertEqual(self._widget.type, 'text')
self.assertEqual(self._widget.cssClass, '')
self.assertEqual(self._widget.extra, '')
self.assertEqual(self._widget.width, 60)
self.assertEqual(self._widget.height, 15)
def testRender(self):
value = "Foo Value"
self._widget.setRenderedValue(value)
check_list = ('rows="15"', 'cols="60"', 'id="field.foo"',
'name="field.foo"', 'textarea')
self.verifyResult(self._widget(), check_list)
check_list = ('style="color: red"',) + check_list
self._widget.extra = 'style="color: red"'
self.verifyResult(self._widget(), check_list)
check_list = ('type="hidden"', 'id="field.foo"', 'name="field.foo"',
'value="Foo Value"')
self.verifyResult(self._widget.hidden(), check_list)
def test_suite():
return unittest.TestSuite((
unittest.makeSuite(TextAreaWidgetTest),
doctest.DocTestSuite(),
))
if __name__=='__main__':
unittest.main(defaultTest='test_suite')
zope.formlib-4.3.0a2/src/zope/formlib/tests/test_itemswidget.py 0000664 0000000 0000000 00000061322 12243456432 023356 0 ustar root root ##############################################################################
#
# Copyright (c) 2004 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.
#
##############################################################################
"""Select Widget Tests
"""
import unittest
from zope.component.testing import PlacelessSetup
from zope.interface import Interface, implementer
from zope.publisher.browser import TestRequest
from zope.schema import Choice, List, Set, FrozenSet
from zope.schema.vocabulary import SimpleVocabulary, SimpleTerm
import zope.formlib.itemswidgets
from zope.formlib.itemswidgets import ItemsWidgetBase
from zope.formlib.itemswidgets import ItemDisplayWidget
from zope.formlib.itemswidgets import ItemsMultiDisplayWidget
from zope.formlib.itemswidgets import ListDisplayWidget
from zope.formlib.itemswidgets import SetDisplayWidget
from zope.formlib.itemswidgets import ItemsEditWidgetBase
from zope.formlib.itemswidgets import SelectWidget, DropdownWidget
from zope.formlib.itemswidgets import RadioWidget
from zope.formlib.itemswidgets import ItemsMultiEditWidgetBase
from zope.formlib.itemswidgets import MultiSelectWidget
from zope.formlib.itemswidgets import OrderedMultiSelectWidget
from zope.formlib.itemswidgets import MultiCheckBoxWidget
from zope.formlib.tests.support import VerifyResults
vocab = SimpleVocabulary(
[SimpleTerm(value, token, title) for value, token, title in (
('one', 'token1', 'One'),
('two', 'token2', 'Two'),
('three', 'token3', 'Three'))])
class ICollector(Interface):
choice = Choice(
title=u"Number",
description=u"The Number",
# we want to be able to distinguish between tokens and values
vocabulary=vocab,
required=True)
numbers = List(
title=u"Numbers",
description=u"The Numbers",
value_type=choice,
required=False)
letters = Set(
title=u"Letters",
description=u"The Letters",
value_type=choice,
required=False)
frozenLetters = FrozenSet(
title=u"Frozen Letters",
description=u"The Frozen Letters",
value_type=choice,
required=False)
@implementer(ICollector)
class Collector(object):
def __init__(self, numbers=None):
self.numbers = numbers or []
class ItemsWidgetBaseTest(VerifyResults, PlacelessSetup, unittest.TestCase):
_widget = ItemsWidgetBase
_field = ICollector.get('choice')
_vocabulary = _field.vocabulary
def _makeWidget(self, form=None, nums=None):
request = TestRequest(form=form or {})
collector = Collector(nums)
bound = self._field.bind(collector)
return self._widget(bound, self._vocabulary, request)
def test_setPrefix(self):
widget = self._makeWidget()
name = self._field.getName()
# Default prefix
self.assertEqual(widget._prefix, 'field.')
self.assertEqual(widget.name, 'field.%s' %name)
self.assertEqual(widget.empty_marker_name,
'field.%s-empty-marker' %name)
# Declaring custom prefix
widget.setPrefix('foo')
self.assertEqual(widget._prefix, 'foo.')
self.assertEqual(widget.name, 'foo.%s' %name)
self.assertEqual(widget.empty_marker_name,
'foo.%s-empty-marker' %name)
# Declaring empty prefix
widget.setPrefix('')
self.assertEqual(widget._prefix, '')
self.assertEqual(widget.name, name)
self.assertEqual(widget.empty_marker_name,
'%s-empty-marker' %name)
def test_convertTokensToValues(self):
widget = self._makeWidget()
self.assertEqual(widget.convertTokensToValues(['token1', 'token2']),
['one', 'two'])
class ItemDisplayWidgetTest(ItemsWidgetBaseTest):
_widget = ItemDisplayWidget
def test_setVocabulary(self):
widget = self._makeWidget()
self.assert_(widget.vocabulary is not None)
self.assertEqual(widget.vocabulary, self._field.vocabulary)
def test__call__(self):
widget = self._makeWidget()
self.assertEqual(widget(), '')
widget = self._makeWidget(form={'field.choice': 'token1'})
self.assertEqual(widget(), 'One')
def test_not_required(self):
self.failIf(self._makeWidget().required)
def test_toFieldValue(self):
from zope.formlib.interfaces import ConversionError
widget = self._makeWidget()
self.assertEquals(
widget._toFieldValue(None), self._field.missing_value)
self.assertEquals(widget._toFieldValue('token1'), 'one')
self.assertRaises(
ConversionError, widget._toFieldValue, 'no_such_token')
self.assertRaises(
ConversionError, widget._toFieldValue, ['token1', 'token2'])
containerVocab = SimpleVocabulary(
[SimpleTerm(value, token, title) for value, token, title in (
((), 'container1', 'Container One'),
((1,), 'container2', 'Container Two'),
((2,), 'container3', 'Container Three'))])
class ITestContainer(Interface):
container = Choice(
title=u"Container",
description=u"The container",
vocabulary=containerVocab,
required=True)
@implementer(ITestContainer)
class TestContainer(object):
def __init__(self, container=None):
self.container = container
class ContainerItemDisplayWidgetTest(VerifyResults,
PlacelessSetup,
unittest.TestCase):
def test_handle_empty_containers(self):
# Regression test for bug 159232"""
field = ITestContainer.get('container')
request = TestRequest(form={'field.container': 'container1'})
container = TestContainer()
bound = field.bind(container)
widget = ItemDisplayWidget(bound, field.vocabulary, request)
self.assertEqual(widget(), 'Container One')
class ItemsMultiDisplayWidgetTest(ItemsWidgetBaseTest):
_widget = ItemsMultiDisplayWidget
_field = ICollector.get('numbers')
_vocabulary = _field.value_type.vocabulary
_tag = 'ol'
def test__call__(self):
widget = self._makeWidget()
self.assertEqual(widget(), '')
widget = self._makeWidget(form={'field.numbers': ['token1', 'token2']})
self.assertEqual(
widget(),
'<%s id="field.numbers" >'
'One \nTwo '
'' %(self._tag, self._tag))
def test_renderItems(self):
widget = self._makeWidget()
self.assertEqual(
widget.renderItems(['one', 'two']),
[u'One ', u'Two '])
self.assertRaises(LookupError, widget.renderItems, 'one')
self.assertRaises(TypeError, widget.renderItems, 1)
def test_not_required(self):
numbers = List(value_type=ICollector['choice']).bind(Collector(None))
request = TestRequest()
widget = self._widget(numbers, self._vocabulary, request)
self.failIf(widget.required)
class ListDisplayWidgetTest(ItemsMultiDisplayWidgetTest):
_widget = ListDisplayWidget
_tag = 'ol'
class SetDisplayWidgetTest(ItemsMultiDisplayWidgetTest):
_widget = SetDisplayWidget
_tag = 'ul'
class ItemsEditWidgetBaseTest(ItemsWidgetBaseTest):
_widget = ItemsEditWidgetBase
def test_div(self):
widget = self._makeWidget()
self.assertEqual(widget._div('', ''), '')
self.assertEqual(widget._div('foo', ''), '')
self.assertEqual(widget._div('', 'bar'), '\nbar\n
')
self.assertEqual(widget._div('foo', 'bar'),
'\nbar\n
')
self.assertEqual(widget._div('foo', 'bar', style='blah'),
'\nbar\n
')
def test_renderItem(self):
widget = self._makeWidget()
self.assertEqual(widget.renderItem('', 'Foo', 'foo', '', None),
' Foo ')
self.assertEqual(widget.renderItem('', 'Foo', 'foo', '', 'klass'),
'Foo ')
def test_renderSelectedItem(self):
widget = self._makeWidget()
self.verifyResult(
widget.renderSelectedItem('', 'Foo', 'foo', '', None),
['Foo '])
self.verifyResult(
widget.renderSelectedItem('', 'Foo', 'foo', '', 'klass'),
['Foo'])
def test_renderItemsWithValues(self):
widget = self._makeWidget()
self.assertEqual(
widget.renderItemsWithValues(['one', 'two']),
[u'One ',
u'Two ',
u'Three '])
self.assertEqual(
widget.renderItemsWithValues([]),
[u'One ',
u'Two ',
u'Three '])
# This test is disabled because it tests for the presense of a missfeature,
# which has been removed. Did someone actually *want* this?
## def test_error(self):
## widget = self._makeWidget(form={'field.choice': 'ten'})
## widget.setPrefix('field.')
## widget._getFormValue()
## self.assert_(isinstance(widget._error, ConversionError))
def test_hidden(self):
widget = self._makeWidget(form={'field.choice': 'token2'})
widget.setPrefix('field.')
widget.context.required = False
self.verifyResult(
widget.hidden(),
['\n'
'\n'
'\n'
'(nothing selected) \n'
'One \n'
'Two \n'
'Three \n'
' \n
\n'
' ' %self._size)
def test_renderValue(self):
widget = self._makeWidget()
widget.setPrefix('field.')
self.assertEqual(
widget.renderValue('one'),
'
\n'
'One \n'
'Two \n'
'Three \n'
' ' %self._size)
def test_renderItems(self):
widget = self._makeWidget()
widget.setPrefix('field.')
self.assertEqual(
widget.renderItems('one'),
[u'
One ',
u'
Two ',
u'
Three '])
self.assertEqual(
widget.renderItems('two'),
[u'
One ',
u'
Two ',
u'
Three '])
self.assertEqual(
widget.renderItems(None),
[u'
One ',
u'
Two ',
u'
Three '])
def test_renderItems_notRequired(self):
widget = self._makeWidget()
widget.setPrefix('field.')
widget.context.required = False
self.assertEqual(
widget.renderItems([]),
[u'
(nothing selected) ',
u'
One ',
u'
Two ',
u'
Three '])
def test_renderItems_firstItem(self):
widget = self._makeWidget()
widget.setPrefix('field.')
widget.firstItem = True
self.assertEqual(
widget.renderItems(widget._toFormValue(widget.context.missing_value)),
[u'
One ',
u'
Two ',
u'
Three '])
class DropdownWidgetTest(SelectWidgetTest):
_widget = DropdownWidget
_size = 1
def test_renderItems_firstItem(self):
widget = self._makeWidget()
widget.setPrefix('field.')
widget.firstItem = True
self.assertEqual(
widget.renderItems(widget._toFormValue(widget.context.missing_value)),
[u'
(nothing selected) ',
u'
One ',
u'
Two ',
u'
Three '])
try:
# test BBB starting with 3.6.0
zope.formlib.itemswidgets.EXPLICIT_EMPTY_SELECTION = False
self.assertEqual(
widget.renderItems(widget._toFormValue(widget.context.missing_value)),
[u'
One ',
u'
Two ',
u'
Three '])
finally:
zope.formlib.itemswidgets.EXPLICIT_EMPTY_SELECTION = True
class RadioWidgetTest(ItemsEditWidgetBaseTest):
_widget = RadioWidget
def test_renderItem(self):
widget = self._makeWidget()
self.verifyResult(
widget.renderItem('', 'Foo', 'foo', 'bar', None),
['
Foo'])
self.verifyResult(
widget.renderItem('bar', 'Foo', 'foo', 'bar', 'klass'),
[' Foo'])
def test_renderSelectedItem(self):
widget = self._makeWidget()
self.verifyResult(
widget.renderSelectedItem('', 'Foo', 'foo', 'bar', 'klass'),
[' Foo'])
self.verifyResult(
widget.renderSelectedItem('', 'Foo', 'foo', 'bar', 'klass'),
[' Foo'])
def test_renderItemsWithValues(self):
widget = self._makeWidget()
items = widget.renderItemsWithValues(['one'])
values = [('token1','One'), ('token2','Two'), ('token3','Three')]
for index, item in enumerate(items):
self.verifyResult(
item,
['One\n', 'value="token2"', '>Two\n',
'value="token3"', '>Three', ''])
def test_renderItemsWithValues(self):
widget = self._makeWidget()
self.assertEqual(
widget.renderItemsWithValues(['one', 'two']),
[u'One ',
u'Two ',
u'Three '])
self.assertEqual(
widget.renderItemsWithValues([]),
[u'One ',
u'Two ',
u'Three '])
# This test is disabled because it tests for the presense of a missfeature,
# which has been removed. Did someone actually *want* this?
## def test_error(self):
## widget = self._makeWidget(form={'field.numbers': ['ten']})
## widget.setPrefix('field.')
## widget._getFormValue()
## self.assert_(isinstance(widget._error, ConversionError))
def test_hidden(self):
widget = self._makeWidget(
form={'field.numbers': ['two','three']})
widget.setPrefix('field.')
widget.context.required = False
self.verifyResult(
widget.hidden(),
[' Foo'])
self.verifyResult(
widget.renderItem('bar', 'Foo', 'foo', 'bar', 'klass'),
[' Foo'])
def test_renderSelectedItem(self):
widget = self._makeWidget()
self.verifyResult(
widget.renderSelectedItem('', 'Foo', 'foo', 'bar', 'klass'),
[' Foo'])
self.verifyResult(
widget.renderSelectedItem('', 'Foo', 'foo', 'bar', 'klass'),
[' Foo'])
def test_renderValue(self):
widget = self._makeWidget()
self.verifyResult(widget.renderValue(None), ['', html))
self.assert_(patternExists(
'2.1 ',
html))
def test_submit_editform(self):
foo = FloatTest()
request = TestRequest()
# submit edit view
request.form['form.f1'] = '1.123'
request.form['form.f2'] = '2.23456789012345'
request.form['form.f3'] = '11.1'
request.form['form.actions.apply'] = u''
Form(foo, request)()
# check new values in object
self.assertEqual(foo.f1, 1.123)
self.assertEqual(foo.f2, 2.23456789012345)
self.assertEqual(foo.f3, 11.1)
def test_missing_value(self):
foo = FloatTest()
request = TestRequest()
# submit missing values for f2 and f3
request.form['form.f1'] = ''
request.form['form.f2'] = ''
request.form['form.f3'] = '1.1'
request.form['form.actions.apply'] = u''
Form(foo, request)()
# check new values in object
self.assertEqual(foo.f1, None)
self.assertEqual(foo.f2, None) # None is default missing_value
self.assertEqual(foo.f3, 1.1) # 0 is from f3.missing_value=0
def test_required_validation(self):
foo = FloatTest()
request = TestRequest()
# submit missing values for required field f1
request.form['form.f1'] = ''
request.form['form.f2'] = ''
request.form['form.f3'] = ''
request.form['form.actions.apply'] = u''
html = Form(foo, request)()
# confirm error msgs
f3_index = html.find('form.f3')
missing_index = html.find('missing')
self.assert_(missing_index > f3_index)
self.assert_(missing_index != -1)
def test_invalid_allowed_value(self):
foo = FloatTest()
request = TestRequest()
# submit a value for f3 that isn't allowed
request.form['form.f3'] = '10000'
request.form['form.actions.apply'] = u''
html = Form(foo, request)()
self.assert_('Invalid' in html)
def test_min_max_validation(self):
foo = FloatTest()
request = TestRequest()
# submit value for f1 that is too low
request.form['form.f1'] = '-1'
request.form['form.actions.apply'] = u''
html = Form(foo, request)()
self.assert_('Value is too small' in html)
request = TestRequest()
request.form['form.f1'] = '1000.2'
request.form['form.actions.apply'] = u''
html = Form(foo, request)()
self.assert_('Value is too big' in html)
def test_omitted_value(self):
foo = FloatTest()
request = TestRequest()
# confirm default values
self.assert_(foo.f1 is None)
self.assertEqual(foo.f2, 1.1)
self.assertEqual(foo.f3, 2.1)
# submit change with only f2 present -- note that required
# field f1 is omitted, which should not cause a validation error
request.form['form.f2'] = ''
request.form['form.actions.apply'] = u''
Form(foo, request)()
# check new value in object
self.assert_(foo.f1 is None)
self.assert_(foo.f2 is None)
self.assertEqual(foo.f3, 2.1)
def test_conversion(self):
foo = FloatTest()
request = TestRequest()
# submit value for f1 that cannot be convert to an float
request.form['form.f1'] = 'foo'
request.form['form.actions.apply'] = u''
html = Form(foo, request)()
self.assert_('Invalid floating point data' in html)
def test_suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(Test))
return suite
zope.formlib-4.3.0a2/src/zope/formlib/tests/test_checkboxwidget.py 0000664 0000000 0000000 00000013100 12243456432 024012 0 ustar root root ##############################################################################
#
# Copyright (c) 2001, 2002 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.
#
##############################################################################
"""Checkbox Widget tests
"""
import unittest
import doctest
from zope.formlib.interfaces import IInputWidget
from zope.formlib.widgets import CheckBoxWidget
from zope.publisher.browser import TestRequest
from zope.schema import Bool
from zope.interface.verify import verifyClass
from zope.formlib.interfaces import MissingInputError
from zope.formlib.tests.test_browserwidget import SimpleInputWidgetTest
class CheckBoxWidgetTest(SimpleInputWidgetTest):
"""Documents and tests thec checkbox widget.
>>> verifyClass(IInputWidget, CheckBoxWidget)
True
The checkbox widget works with Bool fields:
>>> field = Bool(__name__='foo', title=u'on')
>>> request = TestRequest()
>>> widget = CheckBoxWidget(field, request)
hasInput returns True when the request contains the field..used
value:
>>> 'field.foo.used' in request.form
False
>>> widget.hasInput()
False
>>> request.form['field.foo.used'] = ''
>>> widget.hasInput()
True
getInputValue returns True when field. equals (and only equals) 'on':
>>> 'field.foo' in request.form
False
>>> widget.getInputValue()
False
>>> request.form['field.foo'] = 'true'
>>> widget.getInputValue()
False
>>> request.form['field.foo'] = 'on'
>>> widget.getInputValue()
True
Below is HTML output of rendered checkbox widgets. We will first define
a helper method condense the HTML output for display in this test:
>>> def normalize(s):
... return '\\n '.join(s.split())
Default widget rendering:
>>> print(normalize( widget() ))
', html))
self.assert_(patternExists(
'2.1 ',
html))
def test_submit_editform(self):
foo = DecimalTest()
request = TestRequest()
request.form['form.f1'] = '1.123'
request.form['form.f2'] = '2.23456789012345'
request.form['form.f3'] = '11.1'
request.form['form.actions.apply'] = u''
Form(foo, request)()
# check new values in object
self.assertEqual(foo.f1, decimal.Decimal("1.123"))
self.assertEqual(foo.f2, decimal.Decimal("2.23456789012345"))
self.assertEqual(foo.f3, decimal.Decimal("11.1"))
def test_missing_value(self):
foo = DecimalTest()
request = TestRequest()
request.form['form.f1'] = ''
request.form['form.f2'] = ''
request.form['form.f3'] = '1.1'
request.form['form.actions.apply'] = u''
Form(foo, request)()
# check new values in object
self.assertEqual(foo.f1, None)
self.assertEqual(foo.f2, None) # None is default missing_value
self.assertEqual(foo.f3, decimal.Decimal("1.1")) # 0 is from f3.missing_value=0
def test_required_validation(self):
foo = DecimalTest()
request = TestRequest()
request.form['form.f1'] = ''
request.form['form.f2'] = ''
request.form['form.f3'] = ''
request.form['form.actions.apply'] = u''
html = Form(foo, request)()
# confirm error msgs
f3_index = html.find('form.f3')
missing_index = html.find('Required input is missing')
self.assert_(missing_index > f3_index)
def test_invalid_allowed_value(self):
foo = DecimalTest()
request = TestRequest()
# submit a value for f3 that isn't allowed
request.form['form.f3'] = '10000'
request.form['form.actions.apply'] = u''
html = Form(foo, request)()
f3_index = html.find('form.f3')
invalid_index = html.find('Invalid')
self.assert_(invalid_index > f3_index)
def test_min_max_validation(self):
foo = DecimalTest()
request = TestRequest()
# submit value for f1 that is too low
request.form['form.f1'] = '-1'
request.form['form.actions.apply'] = u''
html = Form(foo, request)()
f1_index = html.find('form.f1')
f2_index = html.find('form.f2')
too_small_index = html.find('Value is too small')
self.assert_(too_small_index > f1_index)
self.assert_(html.find('Value is too small', f2_index) == -1)
# submit value for f1 that is too high
request.form['form.f1'] = '1000.2'
request.form['form.actions.apply'] = u''
html = Form(foo, request)()
f1_index = html.find('form.f1')
f2_index = html.find('form.f2')
too_high_index = html.find('Value is too big')
self.assert_(too_high_index > f1_index)
self.assert_(html.find('Value is too small', f2_index) == -1)
def test_omitted_value(self):
foo = DecimalTest()
request = TestRequest()
# confirm default values
self.assert_(foo.f1 is None)
self.assertEqual(foo.f2, decimal.Decimal("1.1"))
self.assertEqual(foo.f3, decimal.Decimal("2.1"))
# submit change with only f2 present -- note that required
# field f1 is omitted, which should not cause a validation error
request.form['form.f2'] = ''
request.form['form.actions.apply'] = u''
Form(foo, request)()
# check new value in object
self.assert_(foo.f1 is None)
self.assert_(foo.f2 is None)
self.assertEqual(foo.f3, decimal.Decimal("2.1"))
def test_conversion(self):
foo = DecimalTest()
request = TestRequest()
# submit value for f1 that cannot be convert to an float
request.form['form.f1'] = 'foo'
request.form['form.actions.apply'] = u''
html = Form(foo, request)()
f1_index = html.find('form.f1')
f2_index = html.find('form.f2')
invalid_index = html.find('Invalid decimal data')
self.assert_(invalid_index > f1_index)
self.assert_(html.find('Invalid decimal data', f2_index) == -1)
def test_suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(Test))
return suite
zope.formlib-4.3.0a2/src/zope/formlib/tests/test_choicecollections.py 0000664 0000000 0000000 00000005725 12243456432 024527 0 ustar root root ##############################################################################
#
# Copyright (c) 2001, 2002 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 the choice collections widgets (function).
"""
import unittest
from zope.component.testing import PlacelessSetup
from zope.publisher.interfaces.browser import IBrowserRequest
from zope.publisher.browser import TestRequest
from zope.schema.interfaces import IList, IChoice, IIterableVocabulary
from zope.schema import Choice, List
from zope.component import provideAdapter
from zope.formlib.interfaces import IInputWidget, IDisplayWidget
from zope.formlib.widgets import CollectionDisplayWidget
from zope.formlib.widgets import CollectionInputWidget
from zope.formlib.widgets import ChoiceCollectionDisplayWidget
from zope.formlib.widgets import ChoiceCollectionInputWidget
from zope.formlib.widgets import ItemsMultiDisplayWidget, SelectWidget
class ListOfChoicesWidgetTest(PlacelessSetup, unittest.TestCase):
def test_ListOfChoicesDisplayWidget(self):
provideAdapter(ChoiceCollectionDisplayWidget,
(IList, IChoice, IBrowserRequest),
IDisplayWidget)
provideAdapter(ItemsMultiDisplayWidget,
(IList, IIterableVocabulary, IBrowserRequest),
IDisplayWidget)
field = List(value_type=Choice(values=[1, 2, 3]))
bound = field.bind(object())
widget = CollectionDisplayWidget(bound, TestRequest())
self.assert_(isinstance(widget, ItemsMultiDisplayWidget))
self.assertEqual(widget.context, bound)
self.assertEqual(widget.vocabulary, bound.value_type.vocabulary)
def test_ChoiceSequenceEditWidget(self):
provideAdapter(ChoiceCollectionInputWidget,
(IList, IChoice, IBrowserRequest),
IInputWidget)
provideAdapter(SelectWidget,
(IList, IIterableVocabulary, IBrowserRequest),
IInputWidget)
field = List(value_type=Choice(values=[1, 2, 3]))
bound = field.bind(object())
widget = CollectionInputWidget(bound, TestRequest())
self.assert_(isinstance(widget, SelectWidget))
self.assertEqual(widget.context, bound)
self.assertEqual(widget.vocabulary, bound.value_type.vocabulary)
def test_suite():
return unittest.TestSuite((
unittest.makeSuite(ListOfChoicesWidgetTest),
))
if __name__=='__main__':
unittest.main(defaultTest='test_suite')
zope.formlib-4.3.0a2/src/zope/formlib/tests/test_passwordwidget.py 0000664 0000000 0000000 00000004111 12243456432 024070 0 ustar root root ##############################################################################
#
# Copyright (c) 2001, 2002 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.
#
##############################################################################
"""Password Widget Tests
"""
import unittest
import doctest
from zope.formlib.interfaces import IInputWidget
from zope.formlib.widgets import PasswordWidget
from zope.formlib.tests.test_browserwidget import SimpleInputWidgetTest
from zope.interface.verify import verifyClass
class PasswordWidgetTest(SimpleInputWidgetTest):
"""Documents and tests the password widget.
>>> verifyClass(IInputWidget, PasswordWidget)
True
"""
_WidgetFactory = PasswordWidget
def testProperties(self):
self.assertEqual(self._widget.tag, 'input')
self.assertEqual(self._widget.type, 'password')
self.assertEqual(self._widget.cssClass, '')
self.assertEqual(self._widget.extra, '')
self.assertEqual(self._widget.default, '')
self.assertEqual(self._widget.displayWidth, 20)
self.assertEqual(self._widget.displayMaxWidth, '')
def testRender(self):
value = 'Foo Value'
self._widget.setRenderedValue(value)
check_list = ('type="password"', 'id="field.foo"',
'name="field.foo"', 'value=""', 'size="20"')
self.verifyResult(self._widget(), check_list)
def testHidden(self):
self.assertRaises(NotImplementedError, self._widget.hidden)
def test_suite():
return unittest.TestSuite((
unittest.makeSuite(PasswordWidgetTest),
doctest.DocTestSuite(),
))
if __name__=='__main__':
unittest.main(defaultTest='test_suite')
zope.formlib-4.3.0a2/src/zope/formlib/tests/test_formlib.py 0000664 0000000 0000000 00000061524 12243456432 022467 0 ustar root root ##############################################################################
#
# Copyright (c) 2005 Zope Foundation and Contributors.
#
# 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.
#
##############################################################################
from __future__ import print_function
import unittest
import re
import pytz
from zope.component.testing import setUp, tearDown
from zope.component import adapter
from zope.component import provideAdapter, provideUtility
from zope.i18n.testing import setUp as i18nSetUp
import zope.interface.common.idatetime
import zope.publisher.interfaces
import zope.publisher.interfaces.browser
import zope.schema.interfaces
import zope.testing.renormalizing
import zope.traversing.adapters
from zope.formlib.widgets import (
TextWidget, FloatWidget, UnicodeDisplayWidget, IntWidget,
DatetimeDisplayWidget, DatetimeWidget)
from zope.formlib import exception
from zope.formlib.interfaces import IWidgetInputErrorView
import zope.formlib
import zope.formlib.form
import zope.formlib.interfaces
from zope.formlib.tests import support
from zope.browserpage.namedtemplate import NamedTemplateImplementation
from zope.configuration.xmlconfig import XMLConfig
@zope.interface.implementer(zope.interface.common.idatetime.ITZInfo)
@adapter(zope.publisher.interfaces.IRequest)
def requestToTZInfo(request):
return pytz.timezone('US/Hawaii')
def pageSetUp(test):
setUp(test)
provideAdapter(
zope.traversing.adapters.DefaultTraversable,
[None],
)
@adapter(zope.formlib.interfaces.IForm)
@NamedTemplateImplementation
def TestTemplate(self):
# This "template" overrides the default page templates that is
# registered for forms.
status = self.status
if status:
status = zope.i18n.translate(status,
context=self.request,
default=self.status)
if getattr(status, 'mapping', 0):
status = zope.i18n.interpolate(status, status.mapping)
print(status)
result = []
if self.errors:
for error in self.errors:
result.append("%s: %s" % (error.__class__.__name__, error))
for w in self.widgets:
result.append(w())
error = w.error()
if error:
result.append(str(error))
if self.protected:
result.append(
'>> class MyForm(zope.formlib.form.EditForm):
... form_fields = zope.formlib.form.fields(
... IOrder, keep_readonly=['identifier'])
>>> from zope.publisher.browser import TestRequest
>>> myform = MyForm(Order(), TestRequest())
>>> print(myform.render()) # doctest: +NORMALIZE_WHITESPACE
1
]
"""
def test_form_template_i18n():
"""\
Let's try to check that the formlib templates handle i18n correctly.
We'll define a simple form:
>>> from zope.browserpage import ViewPageTemplateFile
>>> import zope.i18nmessageid
>>> _ = zope.i18nmessageid.MessageFactory('my.domain')
>>> class MyForm(zope.formlib.form.Form):
... label = _('The label')
... status = _('Success!')
... form_fields = zope.formlib.form.Fields(
... zope.schema.TextLine(__name__='name',
... title=_("Name"),
... description=_("Enter your name"),
... ),
... )
... @zope.formlib.form.action(_('Ok'))
... def ok(self, action, data):
... pass
... page = ViewPageTemplateFile("../pageform.pt")
... subpage = ViewPageTemplateFile("../subpageform.pt")
Now, we should be able to create a form instance:
>>> from zope.publisher.browser import TestRequest
>>> request = TestRequest()
>>> form = MyForm(object(), request)
Unfortunately, the "page" template uses a page macro. We need to
provide a template that it can get one from. Here, we'll set up a
view that provides the necessary macros:
>>> from zope.pagetemplate.pagetemplate import PageTemplate
>>> macro_template = PageTemplate()
>>> macro_template.write('''\
...
...
...
... ''')
We also need to provide a traversal adapter for the view namespace
that lets us look up the macros.
>>> import zope.traversing.interfaces
>>> @adapter(None, None)
... @zope.interface.implementer(zope.traversing.interfaces.ITraversable)
... class view:
... def __init__(self, ob, r=None):
... pass
... def traverse(*args):
... return macro_template.macros
>>> provideAdapter(view, name='view')
And we have to register the default traversable adapter (I wish we had
push templates):
>>> from zope.traversing.adapters import DefaultTraversable
>>> provideAdapter(DefaultTraversable, [None])
We need to set up the translation framework. We'll just provide a
negotiator that always decides to use the test language:
>>> import zope.i18n.interfaces
>>> @zope.interface.implementer(zope.i18n.interfaces.INegotiator)
... class Negotiator:
... def getLanguage(*ignored):
... return 'test'
>>> provideUtility(Negotiator())
And we'll set up the fallback-domain factory, which provides the test
language for all domains:
>>> from zope.i18n.testmessagecatalog import TestMessageFallbackDomain
>>> provideUtility(TestMessageFallbackDomain)
OK, so let's see what the page form looks like. First, we'll compute
the page:
>>> form.update()
>>> page = form.page()
We want to make sure that the page has the translations we expect and
that it doesn't double translate anything. We'll write a generator
that extracts the translations, complaining if any are nested:
>>> def find_translations(text):
... l = 0
... while 1:
... lopen = text.find('[[', l)
... lclose = text.find(']]', l)
... if lclose >= 0 and lclose < lopen:
... raise ValueError(lopen, lclose, text)
... if lopen < 0:
... break
... l = lopen + 2
... lopen = text.find('[[', l)
... lclose = text.find(']]', l)
... if lopen >= 0 and lopen < lclose:
... raise ValueError(lopen, lclose, text)
... if lclose < 0:
... raise ValueError(l, text)
... yield text[l-2:lclose+2]
... l = lclose + 2
>>> for t in find_translations(page):
... print(t)
[[my.domain][The label]]
[[my.domain][Success!]]
[[my.domain][Name]]
[[my.domain][Enter your name]]
[[my.domain][Ok]]
Now, let's try the same thing with the sub-page form:
>>> for t in find_translations(form.subpage()):
... print(t)
[[my.domain][The label]]
[[my.domain][Success!]]
[[my.domain][Name]]
[[my.domain][Enter your name]]
[[my.domain][Ok]]
"""
def test_setUpWidgets_prefix():
"""This is a regression test for field prefix handling in setUp*Widgets.
Let's set up fields with some interface and a prefix on fields:
>>> from zope.formlib import form
>>> from zope import interface, schema
>>> class ITrivial(interface.Interface):
... name = schema.TextLine(title=u"Name")
>>> form_fields = form.Fields(ITrivial, prefix='one')
>>> form_fields += form.Fields(ITrivial, prefix='two')
>>> form_fields += form.Fields(ITrivial, prefix='three')
Let's call setUpDataWidgets and see their names:
>>> @interface.implementer(ITrivial)
... class Trivial(object):
... name = 'foo'
>>> context = Trivial()
>>> from zope.publisher.browser import TestRequest
>>> request = TestRequest()
>>> widgets = form.setUpDataWidgets(form_fields, 'form', context,
... request, {})
>>> [w.name for w in widgets]
['form.one.name', 'form.two.name', 'form.three.name']
Let's try the same with setUpEditWidgets:
>>> widgets = form.setUpEditWidgets(form_fields, 'form', context,
... request)
>>> [w.name for w in widgets]
['form.one.name', 'form.two.name', 'form.three.name']
And setUpInputWidgets:
>>> widgets = form.setUpInputWidgets(form_fields, 'form', context,
... request)
>>> [w.name for w in widgets]
['form.one.name', 'form.two.name', 'form.three.name']
And setUpWidgets:
>>> widgets = form.setUpWidgets(form_fields, 'form', context, request)
>>> [w.name for w in widgets]
['form.one.name', 'form.two.name', 'form.three.name']
"""
def check_action_name():
"""
We want to make sure that Action name setting adheres to the specification.
With just label, with increasing complexity:
>>> action = zope.formlib.form.Action("MyAction")
>>> action.name
'myaction'
>>> action = zope.formlib.form.Action("8 Balls")
>>> action.name
'382042616c6c73'
>>> action = zope.formlib.form.Action(u"MyAction")
>>> action.name
u'myaction'
>>> action = zope.formlib.form.Action(u"8 Balls")
>>> action.name
'382042616c6c73'
>>> action = zope.formlib.form.Action(u'\u9001\u4fe1')
>>> action.name
'e98081e4bfa1'
>>> import zope.i18nmessageid
>>> _ = zope.i18nmessageid.MessageFactory('my.domain')
>>> action = zope.formlib.form.Action(_(u"MyAction"))
>>> action.name
u'myaction'
>>> action = zope.formlib.form.Action(_(u"8 Balls"))
>>> action.name
'382042616c6c73'
>>> action = zope.formlib.form.Action(_(u'\u9001\u4fe1'))
>>> action.name
'e98081e4bfa1'
With all lowercase name:
>>> action = zope.formlib.form.Action("MyAction", name='foobar')
>>> action.name
'foobar'
>>> action = zope.formlib.form.Action("8 Balls", name='foobar')
>>> action.name
'foobar'
>>> action = zope.formlib.form.Action(u"MyAction", name='foobar')
>>> action.name
'foobar'
>>> action = zope.formlib.form.Action(u"8 Balls", name='foobar')
>>> action.name
'foobar'
>>> action = zope.formlib.form.Action(u'\u9001\u4fe1', name='foobar')
>>> action.name
'foobar'
>>> action = zope.formlib.form.Action(_(u"MyAction"), name='foobar')
>>> action.name
'foobar'
>>> action = zope.formlib.form.Action(_(u"8 Balls"), name='foobar')
>>> action.name
'foobar'
>>> action = zope.formlib.form.Action(_(u'\u9001\u4fe1'), name='foobar')
>>> action.name
'foobar'
With some uppercase name:
>>> action = zope.formlib.form.Action("MyAction", name='FooBar')
>>> action.name
'FooBar'
>>> action = zope.formlib.form.Action("8 Balls", name='FooBar')
>>> action.name
'FooBar'
>>> action = zope.formlib.form.Action(u"MyAction", name='FooBar')
>>> action.name
'FooBar'
>>> action = zope.formlib.form.Action(u"8 Balls", name='FooBar')
>>> action.name
'FooBar'
>>> action = zope.formlib.form.Action(u'\u9001\u4fe1', name='FooBar')
>>> action.name
'FooBar'
>>> action = zope.formlib.form.Action(_(u"MyAction"), name='FooBar')
>>> action.name
'FooBar'
>>> action = zope.formlib.form.Action(_(u"8 Balls"), name='FooBar')
>>> action.name
'FooBar'
>>> action = zope.formlib.form.Action(_(u'\u9001\u4fe1'), name='FooBar')
>>> action.name
'FooBar'
"""
def validate_respects_ignoreContext_setting_on_form_when_checking_invariants():
"""
The `validate` method of the form respects the value of
``self.ignoreContext`` when calling `checkInvariants`. `checkInvariants` is
able to access the values from the form and the context (if not ignored) to
make sure invariants are not violated:
>>> class IFlexMaximum(zope.interface.Interface):
... max = zope.schema.Int(title=u"Maximum")
... value = zope.schema.Int(title=u"Value")
...
... @zope.interface.invariant
... def value_not_bigger_than_max(data):
... if data.value > data.max:
... raise zope.interface.Invalid('value bigger than max')
>>> @zope.interface.implementer(IFlexMaximum)
... class Content(object):
... max = 10
... value = 7
>>> class ValueForm(zope.formlib.form.FormBase):
... ignoreContext = False
... form_fields = zope.formlib.form.FormFields(
... IFlexMaximum).omit('max')
...
... @zope.formlib.form.action("Apply")
... def handle_apply(self, action, data):
... pass
`checkInvariants` is able to access the value on the context, so the
interface invariant triggers an error message:
>>> from zope.publisher.browser import TestRequest
>>> request = TestRequest(
... form={'form.value': 42, 'form.actions.apply': '1'})
>>> form = ValueForm(Content(), request)
>>> form.update()
>>> form.errors
(Invalid('value bigger than max',),)
`checkInvariants` if the entered value is small enough, the error message is
not triggered:
>>> from zope.publisher.browser import TestRequest
>>> request = TestRequest(
... form={'form.value': 8, 'form.actions.apply': '1'})
>>> form = ValueForm(Content(), request)
>>> form.update()
>>> form.errors
()
The error is not triggered, too, if ``ignoreContext`` is set to ``True`` as
`checkInvariants` does not access the context then:
>>> request = TestRequest(
... form={'form.value': 42, 'form.actions.apply': '1'})
>>> form = ValueForm(Content(), request)
>>> form.ignoreContext = True
>>> form.update()
>>> form.errors
()
"""
def FormData___getattr___handles_zope_interrface_attributes_correctly():
"""
`FormData.__getattr__` reads objects defined as zope.interface.Attribute in
interface correctly from context:
>>> class IStaticMaximum(zope.interface.Interface):
... max = zope.interface.Attribute("Predefined maximum")
>>> @zope.interface.implementer(IStaticMaximum)
... class Content(object):
... max = 10
>>> formdata = zope.formlib.form.FormData(IStaticMaximum, {}, Content())
>>> formdata.max
10
"""
def FormData___getattr___raises_NoInputData_if_unknown_how_to_access_value():
"""
`FormData.__getattr__` raises an exception if it cannot determine how to
read the object from context:
>>> class IStaticMaximum(zope.interface.Interface):
... def max(): pass
>>> @zope.interface.implementer(IStaticMaximum)
... class Content(object):
... pass
>>> formdata = zope.formlib.form.FormData(IStaticMaximum, {}, Content())
>>> formdata.max #doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
NoInputData: max
"""
def test_suite():
import doctest
checker = support.checker + zope.testing.renormalizing.RENormalizing([
(re.compile(r"\[WidgetInputError\('form.summary', 'summary', ValidationError\('A error message'\)\)\]"),
r"[]"),
(re.compile(r"\[WidgetInputError\('summary', u'Summary', None\)\]"),
r"[]"),
(re.compile(r" ValueError\('invalid literal for float\(\): (bob'|10/0'),\)"),
r"\n "),
(re.compile(r" ValueError\('could not convert string to float: bob',\)"),
r"\n "),
])
return unittest.TestSuite((
doctest.DocFileSuite(
'../errors.txt',
setUp=formSetUp, tearDown=tearDown, checker=checker,
optionflags=doctest.NORMALIZE_WHITESPACE|doctest.ELLIPSIS,
),
# The following test needs some zope.security test setup
#doctest.DocFileSuite(
# 'bugs.txt',
# setUp=formSetUp, tearDown=tearDown,
# optionflags=doctest.NORMALIZE_WHITESPACE|doctest.ELLIPSIS,
# ),
doctest.DocFileSuite(
'../form.txt',
setUp=formSetUp, tearDown=tearDown,
optionflags=doctest.NORMALIZE_WHITESPACE|doctest.ELLIPSIS,
checker=checker
),
doctest.DocTestSuite(
setUp=formSetUp, tearDown=tearDown,
checker=checker
),
doctest.DocTestSuite(
'zope.formlib.errors', checker=checker),
))
zope.formlib-4.3.0a2/src/zope/formlib/tests/test_browserwidget.py 0000664 0000000 0000000 00000017001 12243456432 023713 0 ustar root root ##############################################################################
#
# Copyright (c) 2001, 2002 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 Browser Widget
"""
import unittest
from zope.component.testing import PlacelessSetup
from zope.interface import Interface, implementer
from zope.publisher.browser import TestRequest
from zope.schema import Text, Int
from doctest import DocTestSuite
from zope.formlib.widget import SimpleInputWidget
from zope.formlib.interfaces import ConversionError
from zope.formlib.interfaces import WidgetInputError, MissingInputError
from zope.formlib.tests import support
class BrowserWidgetTest(PlacelessSetup,
support.VerifyResults,
unittest.TestCase):
_FieldFactory = Text
_WidgetFactory = None
def setUpContent(self, desc=u'', title=u'Foo Title'):
field = self._FieldFactory(
__name__='foo', title=title, description=desc)
class ITestContent(Interface):
foo = field
@implementer(ITestContent)
class TestObject:
pass
self.content = TestObject()
field = ITestContent['foo']
field = field.bind(self.content)
request = TestRequest(HTTP_ACCEPT_LANGUAGE='ru')
request.form['field.foo'] = u'Foo Value'
self._widget = self._WidgetFactory(field, request)
def setUp(self):
super(BrowserWidgetTest, self).setUp()
self.setUpContent()
class SimpleInputWidgetTest(BrowserWidgetTest):
_WidgetFactory = SimpleInputWidget
def test_required(self):
# widget required defaults to its context required
self.assert_(self._widget.required)
self.assert_(self._widget.context.required)
# changing widget context required has no effect on widget required
self._widget.context.required = False
self.assert_(self._widget.required)
self.assert_(not self._widget.context.required)
def test_hasInput(self):
self.failUnless(self._widget.hasInput())
del self._widget.request.form['field.foo']
self.failIf(self._widget.hasInput())
def testProperties(self):
self.assertEqual(self._widget.tag, 'input')
self.assertEqual(self._widget.type, 'text')
self.assertEqual(self._widget.cssClass, '')
self.assertEqual(self._widget.extra, '')
def testRender(self, value=None, check_list=None):
if value is None:
value = 'Foo Value'
if check_list is None:
check_list = ('type="text"', 'id="field.foo"', 'name="field.foo"',
'value="Foo Value"')
self._widget.setRenderedValue(value)
self.verifyResult(self._widget(), check_list)
check_list = ('type="hidden"',) + check_list[1:]
self.verifyResult(self._widget.hidden(), check_list)
check_list = ('type="hidden"', 'style="color: red"') + check_list[1:]
self._widget.extra = 'style="color: red"'
self.verifyResult(self._widget.hidden(), check_list)
def testLabel(self):
self.setUpContent(title=u'Foo:')
self.assertEqual(self._widget.label, u'Foo:')
def testHint(self):
self.setUpContent(desc=u'Foo Description')
self.assertEqual(self._widget.hint, u'Foo Description')
class TestWidget(SimpleInputWidget):
def _toFieldValue(self, v):
if v == u'barf!':
raise ConversionError('ralph')
return v or None
class Test(BrowserWidgetTest):
_WidgetFactory = TestWidget
def test_getFormValue(self):
class W(SimpleInputWidget):
def _toFieldValue(self, v):
return u'X' + (v or '')
def _toFormValue(self, v):
return v and v[1:] or ''
field = Text(__name__ = 'foo', title = u"Foo Title")
request = TestRequest()
w = W(field, request)
self.assertEqual(w._getFormValue(), '')
request.form['field.foo'] = 'val'
self.assertEqual(w._getFormValue(), 'val')
w.setRenderedValue('Xfoo')
self.assertEqual(w._getFormValue(), 'foo')
def test_hasValidInput(self):
self.assertEqual(self._widget.getInputValue(), u'Foo Value')
self._widget.request.form['field.foo'] = (1, 2)
self.failIf(self._widget.hasValidInput())
self._widget.request.form['field.foo'] = u'barf!'
self.failIf(self._widget.hasValidInput())
del self._widget.request.form['field.foo']
self._widget.context.required = True
self.failIf(self._widget.hasValidInput())
self._widget.context.required = False
self._widget.request.form['field.foo'] = u''
self.failUnless(self._widget.hasValidInput())
def test_getInputValue(self):
self.assertEqual(self._widget.getInputValue(), u'Foo Value')
self._widget.request.form['field.foo'] = (1, 2)
self.assertRaises(WidgetInputError, self._widget.getInputValue)
self._widget.request.form['field.foo'] = u'barf!'
self.assertRaises(ConversionError, self._widget.getInputValue)
del self._widget.request.form['field.foo']
self._widget.context.required = True
self.assertRaises(MissingInputError, self._widget.getInputValue)
self._widget.context.required = False
self._widget.request.form['field.foo'] = u''
self.assertEqual(self._widget.getInputValue(), None)
def test_applyChanges(self):
self.assertEqual(self._widget.applyChanges(self.content), True)
def test_hasInput(self):
self.failUnless(self._widget.hasInput())
del self._widget.request.form['field.foo']
self.failIf(self._widget.hasInput())
self._widget.request.form['field.foo'] = u'foo'
self.failUnless(self._widget.hasInput())
# widget has input, even if input is an empty string
self._widget.request.form['field.foo'] = u''
self.failUnless(self._widget.hasInput())
def test_getFormValue_w_default(self):
field = Text(__name__ = 'foo', title = u"Foo Title", default=u"def")
request = TestRequest()
widget = self._WidgetFactory(field, request)
self.assertEqual(widget._getFormValue(), u'def')
def test_getFormValue_preserves_errors(self):
field = Int(__name__ = 'foo', title = u"Foo Title", default=42)
request = TestRequest()
widget = self._WidgetFactory(field, request)
# Sometimes you want to set a custom error on a widget.
widget._error = 'my error'
# _getFormValue shouldn't replace it.
request.form['field.foo'] = u'barf!'
widget._getFormValue()
self.assertEquals(widget._error, 'my error')
# _getFormValue shouldn't clear it either
request.form['field.foo'] = 33
widget._getFormValue()
self.assertEquals(widget._error, 'my error')
def test_suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(Test))
suite.addTest(DocTestSuite("zope.formlib.widget", checker=support.checker))
return suite
if __name__ == '__main__':
unittest.main(defaultTest='test_suite')
zope.formlib-4.3.0a2/src/zope/formlib/tests/test_choicewidget.py 0000664 0000000 0000000 00000004635 12243456432 023473 0 ustar root root ##############################################################################
#
# Copyright (c) 2001, 2002 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 the Choice display and edit widget (function).
"""
import unittest
from zope.component.testing import PlacelessSetup
from zope.publisher.interfaces.browser import IBrowserRequest
from zope.publisher.browser import TestRequest
from zope.schema.interfaces import IChoice, IIterableVocabulary
from zope.schema import Choice
from zope.component import provideAdapter
from zope.formlib.interfaces import IInputWidget, IDisplayWidget
from zope.formlib.widgets import ChoiceDisplayWidget, ChoiceInputWidget
from zope.formlib.widgets import ItemDisplayWidget, DropdownWidget
class ChoiceWidgetTest(PlacelessSetup, unittest.TestCase):
def test_ChoiceDisplayWidget(self):
provideAdapter(ItemDisplayWidget,
(IChoice, IIterableVocabulary, IBrowserRequest),
IDisplayWidget)
field = Choice(values=[1, 2, 3])
bound = field.bind(object())
widget = ChoiceDisplayWidget(bound, TestRequest())
self.assert_(isinstance(widget, ItemDisplayWidget))
self.assertEqual(widget.context, bound)
self.assertEqual(widget.vocabulary, bound.vocabulary)
def test_ChoiceInputWidget(self):
provideAdapter(DropdownWidget,
(IChoice, IIterableVocabulary, IBrowserRequest),
IInputWidget)
field = Choice(values=[1, 2, 3])
bound = field.bind(object())
widget = ChoiceInputWidget(bound, TestRequest())
self.assert_(isinstance(widget, DropdownWidget))
self.assertEqual(widget.context, bound)
self.assertEqual(widget.vocabulary, bound.vocabulary)
def test_suite():
return unittest.TestSuite((
unittest.makeSuite(ChoiceWidgetTest),
))
if __name__=='__main__':
unittest.main(defaultTest='test_suite')
zope.formlib-4.3.0a2/src/zope/formlib/tests/test_functional_textwidget.py 0000664 0000000 0000000 00000014550 12243456432 025444 0 ustar root root ##############################################################################
#
# Copyright (c) 2001, 2002 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.
#
##############################################################################
"""TextWidget Tests
"""
import unittest
from zope.interface import Interface, implementer
from zope.schema import TextLine, Choice
from zope.formlib import form
from zope.publisher.browser import TestRequest
from zope.formlib.tests.support import patternExists
from zope.formlib.widgets import (
TextWidget,
DropdownWidget, ChoiceInputWidget)
from zope.formlib.tests.functionalsupport import FunctionalWidgetTestCase
import zope.schema.interfaces
class ITextLineTest(Interface):
s1 = TextLine(
required=True,
min_length=2,
max_length=10)
s2 = TextLine(
required=False,
missing_value=u'')
s3 = Choice(
required=False,
values=(u'Bob', u'is', u'Your', u'Uncle'))
@implementer(ITextLineTest)
class TextLineTest(object):
def __init__(self):
self.s1 = ''
self.s2 = u'foo'
self.s3 = None
class Form(form.EditForm):
form_fields = form.fields(ITextLineTest)
class Test(FunctionalWidgetTestCase):
widgets = [
(zope.schema.interfaces.ITextLine, TextWidget),
(zope.schema.interfaces.IChoice, ChoiceInputWidget),
((zope.schema.interfaces.IChoice, zope.schema.interfaces.IVocabularyTokenized),
DropdownWidget)]
def test_display_editform(self):
foo = TextLineTest()
request = TestRequest()
# display edit view
html = Form(foo, request)()
# s1 and s2 should be displayed in text fields
self.assert_(patternExists(
'', html))
self.assert_(patternExists(
'.* ',
html))
def test_submit_editform(self):
foo = TextLineTest()
request = TestRequest()
# submit edit view
request.form['form.s1'] = u'foo'
request.form['form.s2'] = u'bar'
request.form['form.s3'] = u'Uncle'
request.form['form.actions.apply'] = u''
Form(foo, request)()
# check new values in object
self.assertEqual(foo.s1, u'foo')
self.assertEqual(foo.s2, u'bar')
self.assertEqual(foo.s3, u'Uncle')
def test_invalid_type(self):
"""Tests text widget's handling of invalid unicode input.
The text widget will succeed in converting any form input into
unicode.
"""
foo = TextLineTest()
request = TestRequest()
# submit invalid type for text line
request.form['form.s1'] = ''
request.form['form.actions.apply'] = u''
html = Form(foo, request)()
# We don't have a invalid field value
# since we convert the value to unicode
self.assert_('Object is of wrong type.' not in html)
def test_missing_value(self):
foo = TextLineTest()
request = TestRequest()
request.form['form.s1'] = u'foo'
request.form['form.s2'] = u''
request.form['form.s3'] = u''
request.form['form.actions.apply'] = u''
Form(foo, request)()
# check new values in object
self.assertEqual(foo.s1, u'foo')
self.assertEqual(foo.s2, u'') # default missing_value
self.assertEqual(foo.s3, None) # None is s3's missing_value
def test_required_validation(self):
foo = TextLineTest()
request = TestRequest()
request.form['form.s1'] = u''
request.form['form.s2'] = u''
request.form['form.s3'] = u''
request.form['form.actions.apply'] = u''
html = Form(foo, request)()
# confirm error msgs
s1_index = html.find('form.s1')
s2_index = html.find('form.s2')
missing_index = html.find('missing')
self.assert_(s1_index < missing_index < s2_index)
self.assert_(html.find('missing', s2_index) == -1)
def test_invalid_value(self):
foo = TextLineTest()
request = TestRequest()
# submit a value for s3 that isn't allowed
request.form['form.s3'] = u'Bob is *Not* My Uncle'
request.form['form.actions.apply'] = u''
html = Form(foo, request)()
s3_index = html.find('form.s3')
invalid_index = html.find('Invalid')
self.assert_(invalid_index != -1)
self.assert_(invalid_index > s3_index)
def test_length_validation(self):
foo = TextLineTest()
request = TestRequest()
# submit value for s1 that is too short
request.form['form.s1'] = u'a'
request.form['form.actions.apply'] = u''
html = Form(foo, request)()
self.assert_('Value is too short' in html)
# submit value for s1 that is too long
request.form['form.s1'] = u'12345678901'
request.form['form.actions.apply'] = u''
html = Form(foo, request)()
self.assert_('Value is too long' in html)
def test_omitted_value(self):
foo = TextLineTest()
request = TestRequest()
# confirm default values
self.assertEqual(foo.s1, '')
self.assertEqual(foo.s2, u'foo')
self.assert_(foo.s3 is None)
# submit change with only s2 present -- note that required
# field s1 is omitted, which should not cause a validation error
request.form['form.s2'] = u'bar'
request.form['form.actions.apply'] = u''
Form(foo, request)()
# check new value in object
self.assertEqual(foo.s1, '')
self.assertEqual(foo.s2, u'bar')
self.assert_(foo.s3 is None)
def test_suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(Test))
return suite
zope.formlib-4.3.0a2/src/zope/formlib/tests/test_datetimewidget.py 0000664 0000000 0000000 00000015307 12243456432 024033 0 ustar root root ##############################################################################
#
# Copyright (c) 2001, 2002 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.
#
##############################################################################
"""Datetime Widget Tests
"""
import datetime
import unittest
import doctest
from zope.schema import Datetime
from zope.datetime import parseDatetimetz, tzinfo
from zope.interface.verify import verifyClass
from zope.formlib.tests.test_browserwidget import SimpleInputWidgetTest
from zope.formlib.interfaces import IInputWidget
from zope.formlib.widgets import DatetimeWidget
from zope.formlib.widgets import DatetimeI18nWidget
from zope.formlib.interfaces import ConversionError, WidgetInputError
class DatetimeWidgetTest(SimpleInputWidgetTest):
"""Documents and tests the datetime widget.
>>> verifyClass(IInputWidget, DatetimeWidget)
True
"""
_FieldFactory = Datetime
_WidgetFactory = DatetimeWidget
def testRender(self):
super(DatetimeWidgetTest, self).testRender(
datetime.datetime(2004, 3, 26, 12, 58, 59),
('type="text"', 'id="field.foo"', 'name="field.foo"',
'value="2004-03-26 12:58:59"'))
def test_hasInput(self):
del self._widget.request.form['field.foo']
self.failIf(self._widget.hasInput())
# widget has input, even if input is an empty string
self._widget.request.form['field.foo'] = u''
self.failUnless(self._widget.hasInput())
self._widget.request.form['field.foo'] = u'2003-03-26 12:00:00'
self.failUnless(self._widget.hasInput())
def test_getInputValue(self,
value=u'2004-03-26 12:58:59',
check_value=parseDatetimetz('2004-03-26 12:58:59')):
self._widget.request.form['field.foo'] = u''
self.assertRaises(WidgetInputError, self._widget.getInputValue)
self._widget.request.form['field.foo'] = value
self.assertEquals(self._widget.getInputValue(), check_value)
self._widget.request.form['field.foo'] = u'abc'
self.assertRaises(ConversionError, self._widget.getInputValue)
class DatetimeI18nWidgetTest(SimpleInputWidgetTest):
"""Documents and tests the i18n datetime widget.
>>> verifyClass(IInputWidget, DatetimeI18nWidget)
True
"""
_FieldFactory = Datetime
_WidgetFactory = DatetimeI18nWidget
def testDefaultDisplayStyle(self):
self.failIf(self._widget.displayStyle)
def testRender(self):
super(DatetimeI18nWidgetTest, self).testRender(
datetime.datetime(2004, 3, 26, 12, 58, 59),
('type="text"', 'id="field.foo"', 'name="field.foo"',
'value="26.03.2004 12:58:59"'))
def testRenderShort(self):
self._widget.displayStyle = "short"
super(DatetimeI18nWidgetTest, self).testRender(
datetime.datetime(2004, 3, 26, 12, 58, 59),
('type="text"', 'id="field.foo"', 'name="field.foo"',
'value="26.03.04 12:58"'))
def testRenderMedium(self):
self._widget.displayStyle = "medium"
super(DatetimeI18nWidgetTest, self).testRender(
datetime.datetime(2004, 3, 26, 12, 58, 59),
('type="text"', 'id="field.foo"', 'name="field.foo"',
'value="26.03.2004 12:58:59"'))
def testRenderLong(self):
self._widget.displayStyle = "long"
super(DatetimeI18nWidgetTest, self).testRender(
datetime.datetime(2004, 3, 26, 12, 58, 59),
('type="text"', 'id="field.foo"', 'name="field.foo"',
u'value="26 \u043c\u0430\u0440\u0442\u0430 2004 \u0433.'
u' 12:58:59 +000"'))
def testRenderFull(self):
self._widget.displayStyle = "full"
super(DatetimeI18nWidgetTest, self).testRender(
datetime.datetime(2004, 3, 26, 12, 58, 59),
('type="text"', 'id="field.foo"', 'name="field.foo"',
u'value="26 \u043c\u0430\u0440\u0442\u0430 2004 \u0433.'
u' 12:58:59 +000"'))
def test_hasInput(self):
del self._widget.request.form['field.foo']
self.failIf(self._widget.hasInput())
# widget has input, even if input is an empty string
self._widget.request.form['field.foo'] = u''
self.failUnless(self._widget.hasInput())
self._widget.request.form['field.foo'] = u'26.03.2003 12:00:00'
self.failUnless(self._widget.hasInput())
def test_getDefaultInputValue(self,
value=u'26.03.2004 12:58:59',
check_value=datetime.datetime(2004, 3, 26, 12, 58, 59)):
self._widget.request.form['field.foo'] = u''
self.assertRaises(WidgetInputError, self._widget.getInputValue)
self._widget.request.form['field.foo'] = value
self.assertEquals(self._widget.getInputValue(), check_value)
self._widget.request.form['field.foo'] = u'abc'
self.assertRaises(ConversionError, self._widget.getInputValue)
def test_getShortInputValue(self):
self._widget.displayStyle = "short"
self.test_getDefaultInputValue(
value=u'26.03.04 12:58',
check_value=datetime.datetime(2004, 3, 26, 12, 58)
)
def test_getMediumInputValue(self):
self._widget.displayStyle = "medium"
self.test_getDefaultInputValue(
value=u'26.03.2004 12:58:59',
check_value=datetime.datetime(2004, 3, 26, 12, 58, 59)
)
def test_getLongInputValue(self):
self._widget.displayStyle = "long"
self.test_getDefaultInputValue(
value=(u'26 \u043c\u0430\u0440\u0442\u0430 2004 \u0433.'
u' 12:58:59 +030'),
check_value=datetime.datetime(2004, 3, 26, 12, 58, 59,
tzinfo=tzinfo(30))
)
def test_getFullInputValue(self):
self._widget.displayStyle = "full"
self.test_getDefaultInputValue(
value=(u'26 \u043c\u0430\u0440\u0442\u0430 2004 \u0433.'
u' 12:58:59 +030'),
check_value=datetime.datetime(2004, 3, 26, 12, 58, 59,
tzinfo=tzinfo(30))
)
def test_suite():
return unittest.TestSuite((
unittest.makeSuite(DatetimeWidgetTest),
unittest.makeSuite(DatetimeI18nWidgetTest),
doctest.DocTestSuite(),
))
if __name__=='__main__':
unittest.main(defaultTest='test_suite')
zope.formlib-4.3.0a2/src/zope/formlib/tests/test_functional_filewidget.py 0000664 0000000 0000000 00000011322 12243456432 025371 0 ustar root root ##############################################################################
#
# Copyright (c) 2001, 2002 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.
#
##############################################################################
"""File Widget Tests
"""
import unittest
from zope.publisher.browser import TestRequest
from zope.interface import Interface, implementer
from zope.schema import Field
from zope.schema.interfaces import IField
from zope.formlib import form, _compat
from zope.formlib._compat import StringIO
from zope.formlib.tests.support import patternExists
from zope.formlib.widgets import FileWidget
from zope.formlib.tests.functionalsupport import FunctionalWidgetTestCase
class IFileField(IField):
"""Field for representing a file that can be edited by FileWidget."""
@implementer(IFileField)
class FileField(Field):
pass
class IFileTest(Interface):
f1 = FileField(required=True)
f2 = FileField(required=False)
@implementer(IFileTest)
class FileTest(object):
def __init__(self):
self.f1 = None
self.f2 = 'foo'
class Form(form.EditForm):
form_fields = form.fields(IFileTest)
form_fields['f1'].custom_widget = FileWidget
form_fields['f2'].custom_widget = FileWidget
class SampleTextFile(StringIO):
def __init__(self, buf, filename=''):
StringIO.__init__(self, buf)
self.filename = filename
class Test(FunctionalWidgetTestCase):
sampleText = "The quick brown fox\njumped over the lazy dog."
sampleTextFile = SampleTextFile(sampleText)
emptyFileName = 'empty.txt'
emptyFile = SampleTextFile('', emptyFileName)
def test_display_editform(self):
foo = FileTest()
request = TestRequest()
# display edit view
html = Form(foo, request)()
# field should be displayed in a file input element
self.assert_(patternExists(
'', html))
self.assert_(patternExists(
'2 ',
html))
def test_submit_editform(self):
foo = IntTest()
request = TestRequest()
request.form['form.i1'] = '1'
request.form['form.i2'] = '2'
request.form['form.i3'] = '3'
request.form['form.actions.apply'] = u''
Form(foo, request)()
# check new values in object
self.assertEqual(foo.i1, 1)
self.assertEqual(foo.i2, 2)
self.assertEqual(foo.i3, 3)
def test_missing_value(self):
foo = IntTest()
request = TestRequest()
# submit missing values for i2 and i3
request.form['form.i1'] = '1'
request.form['form.i2'] = ''
request.form['form.i3-empty-marker'] = ''
request.form['form.actions.apply'] = u''
Form(foo, request)()
# check new values in object
self.assertEqual(foo.i1, 1)
self.assertEqual(foo.i2, None) # None is default missing_value
self.assertEqual(foo.i3, 0) # 0 is from i3.missing_value=0
def test_alternative_missing_value(self):
"""Tests the addition of an empty value at the top of the dropdown
that, when selected, updates the field with form.missing_value.
"""
foo = IntTest2() # note alt. class
request = TestRequest()
html = Form2(foo, request)()
# confirm that i1 is has a blank item at top with value=""
self.assert_(patternExists(
'', html))
self.assert_(patternExists(
'.* ', html))
self.assert_(patternExists(
'10 ',
html))
# submit form as if top item is selected
request.form['form.i1-empty-marker'] = '1'
request.form['form.actions.apply'] = u''
html = Form2(foo, request)()
# confirm new value is -1 -- i1.missing_value
self.assertEqual(foo.i1, -1)
def test_required_validation(self):
foo = IntTest()
request = TestRequest()
# submit missing values for required field i1
request.form['form.i1'] = ''
request.form['form.i2'] = ''
request.form['form.i3'] = ''
request.form['form.actions.apply'] = u''
html = Form(foo, request)()
# confirm error msgs
i1_index = html.find('form.i1')
i2_index = html.find('form.i2')
i3_index = html.find('form.i3')
self.assert_(i1_index < html.find('missing') < i2_index)
self.assert_(html.find('missing', i2_index) == -1)
self.assert_(html.find('missing', i3_index) == -1)
def test_invalid_allowed_value(self):
foo = IntTest()
request = TestRequest()
# submit a value for i3 that isn't allowed
request.form['form.i3'] = '12'
request.form['form.actions.apply'] = u''
html = Form(foo, request)()
i3_index = html.find('form.i3')
invalid_index = html.find('Invalid')
self.assert_(invalid_index != -1)
self.assert_(invalid_index > i3_index)
def test_min_max_validation(self):
foo = IntTest()
request = TestRequest()
# submit value for i1 that is too low
request.form['form.i1'] = '-1'
request.form['form.actions.apply'] = u''
html = Form(foo, request)()
self.assert_('Value is too small' in html)
# submit value for i1 that is too high
request.form['form.i1'] = '11'
request.form['form.actions.apply'] = u''
html = Form(foo, request)()
self.assert_('Value is too big' in html)
def test_omitted_value(self):
foo = IntTest()
request = TestRequest()
self.assert_(foo.i1 is None)
self.assertEqual(foo.i2, 1)
self.assertEqual(foo.i3, 2)
# submit change with only i2 present -- note that required
# field i1 is omitted, which should not cause a validation error
request.form['form.i2'] = ''
request.form['form.actions.apply'] = u''
Form(foo, request)()
# check new value in object
self.assert_(foo.i1 is None)
self.assert_(foo.i2 is None)
self.assertEqual(foo.i3, 2)
def test_conversion(self):
foo = IntTest()
request = TestRequest()
request.form['form.i1'] = 'foo'
request.form['form.actions.apply'] = u''
html = Form(foo, request)()
self.assert_('Invalid integer data' in html)
def test_suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(Test))
return suite
zope.formlib-4.3.0a2/src/zope/formlib/tests/test_datewidget.py 0000664 0000000 0000000 00000013410 12243456432 023145 0 ustar root root ##############################################################################
#
# Copyright (c) 2001, 2002 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.
#
##############################################################################
"""Date Widget tests
"""
import datetime
import unittest
import doctest
from zope.schema import Date
from zope.interface.verify import verifyClass
from zope.formlib.tests.test_browserwidget import SimpleInputWidgetTest
from zope.formlib.interfaces import IInputWidget
from zope.formlib.widgets import DateWidget
from zope.formlib.widgets import DateI18nWidget
from zope.formlib.interfaces import ConversionError, WidgetInputError
class DateWidgetTest(SimpleInputWidgetTest):
"""Documents and tests the date widget.
>>> verifyClass(IInputWidget, DateWidget)
True
"""
_FieldFactory = Date
_WidgetFactory = DateWidget
def testRender(self):
super(DateWidgetTest, self).testRender(
datetime.date(2003, 3, 26),
('type="text"', 'id="field.foo"', 'name="field.foo"',
'value="2003-03-26"'))
def test_hasInput(self):
del self._widget.request.form['field.foo']
self.failIf(self._widget.hasInput())
self._widget.request.form['field.foo'] = u''
self.failUnless(self._widget.hasInput())
self._widget.request.form['field.foo'] = u'2003-03-26'
self.failUnless(self._widget.hasInput())
def test_getInputValue(self,
value=u'2004-03-26',
check_value=datetime.date(2004, 3, 26)):
self._widget.request.form['field.foo'] = u''
self.assertRaises(WidgetInputError, self._widget.getInputValue)
self._widget.request.form['field.foo'] = value
self.assertEquals(self._widget.getInputValue(), check_value)
self._widget.request.form['field.foo'] = u'abc'
self.assertRaises(ConversionError, self._widget.getInputValue)
class DateI18nWidgetTest(SimpleInputWidgetTest):
"""Documents and tests the i18n date widget.
>>> verifyClass(IInputWidget, DateI18nWidget)
True
"""
_FieldFactory = Date
_WidgetFactory = DateI18nWidget
def testDefaultDisplayStyle(self):
self.failIf(self._widget.displayStyle)
def testRender(self):
super(DateI18nWidgetTest, self).testRender(
datetime.date(2003, 3, 26),
('type="text"', 'id="field.foo"', 'name="field.foo"',
'value="26.03.2003"'))
def testRenderShort(self):
self._widget.displayStyle = "short"
super(DateI18nWidgetTest, self).testRender(
datetime.datetime(2004, 3, 26, 12, 58, 59),
('type="text"', 'id="field.foo"', 'name="field.foo"',
'value="26.03.04"'))
def testRenderMedium(self):
self._widget.displayStyle = "medium"
super(DateI18nWidgetTest, self).testRender(
datetime.datetime(2004, 3, 26, 12, 58, 59),
('type="text"', 'id="field.foo"', 'name="field.foo"',
'value="26.03.2004"'))
def testRenderLong(self):
self._widget.displayStyle = "long"
super(DateI18nWidgetTest, self).testRender(
datetime.datetime(2004, 3, 26, 12, 58, 59),
('type="text"', 'id="field.foo"', 'name="field.foo"',
u'value="26 \u043c\u0430\u0440\u0442\u0430 2004 \u0433."'))
def testRenderFull(self):
self._widget.displayStyle = "full"
super(DateI18nWidgetTest, self).testRender(
datetime.datetime(2004, 3, 26, 12, 58, 59),
('type="text"', 'id="field.foo"', 'name="field.foo"',
u'value="26 \u043c\u0430\u0440\u0442\u0430 2004 \u0433."'))
def test_hasInput(self):
del self._widget.request.form['field.foo']
self.failIf(self._widget.hasInput())
self._widget.request.form['field.foo'] = u''
self.failUnless(self._widget.hasInput())
self._widget.request.form['field.foo'] = u'26.03.2003'
self.failUnless(self._widget.hasInput())
def test_getDefaultInputValue(self,
value=u'26.03.2004',
check_value=datetime.date(2004, 3, 26)):
self._widget.request.form['field.foo'] = u''
self.assertRaises(WidgetInputError, self._widget.getInputValue)
self._widget.request.form['field.foo'] = value
self.assertEquals(self._widget.getInputValue(), check_value)
self._widget.request.form['field.foo'] = u'abc'
self.assertRaises(ConversionError, self._widget.getInputValue)
def test_getShortInputValue(self):
self._widget.displayStyle = "short"
self.test_getDefaultInputValue(u'26.03.04')
def test_getMediumInputValue(self):
self._widget.displayStyle = "medium"
self.test_getDefaultInputValue(u'26.03.2004')
def test_getLongInputValue(self):
self._widget.displayStyle = "long"
self.test_getDefaultInputValue(
u'26 \u043c\u0430\u0440\u0442\u0430 2004 \u0433.'
)
def test_getFullInputValue(self):
self._widget.displayStyle = "full"
self.test_getDefaultInputValue(
u'26 \u043c\u0430\u0440\u0442\u0430 2004 \u0433.'
)
def test_suite():
return unittest.TestSuite((
unittest.makeSuite(DateWidgetTest),
unittest.makeSuite(DateI18nWidgetTest),
doctest.DocTestSuite(),
))
if __name__=='__main__':
unittest.main(defaultTest='test_suite')
zope.formlib-4.3.0a2/src/zope/formlib/tests/test_displaywidget.py 0000664 0000000 0000000 00000007453 12243456432 023707 0 ustar root root ##############################################################################
#
# Copyright (c) 2001, 2002 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.
#
##############################################################################
"""Generic Text Widgets tests
"""
import unittest
from zope.interface.verify import verifyClass
from zope.interface.exceptions import DoesNotImplement
from zope.publisher.browser import TestRequest
from zope.schema import TextLine
from doctest import DocTestSuite
from zope.formlib.widget import DisplayWidget, UnicodeDisplayWidget
from .support import checker
def test_implemented_interfaces():
"""Make sure that the display widget implements the correct interfaces.
Like all browser-used widgets, DisplayWidget must implement
`IBrowserWidget`.
>>> from zope.formlib.interfaces import IBrowserWidget
>>> verifyClass(IBrowserWidget, DisplayWidget)
True
But unlike most other widgets in this package, the display widget is *not*
an `IInputWidget`.
>>> from zope.formlib.interfaces import IInputWidget
>>> try:
... verifyClass(IInputWidget, DisplayWidget)
... except DoesNotImplement:
... 'not implemented'
'not implemented'
"""
def test_not_required():
"""Make sure that display widgets are not required
>>> field = TextLine(title = u'Title',
... __name__ = u'title',
... default = u'')
>>> widget = DisplayWidget(field, TestRequest())
>>> widget.required
False
"""
def test_value_escaping():
"""Make sure that the returned values are correctly escaped.
First we need to create a field that is the context of the display widget.
>>> field = TextLine(title = u'Title',
... __name__ = u'title',
... default = u'')
>>> field = field.bind(None)
Now we are ready to instantiate our widget.
>>> widget = DisplayWidget(field, TestRequest())
If no data was specified in the widget, the field's default value will be
chosen.
>>> widget()
u'<My Title>'
Now let's set a value and make sure that, when output, it is also
correctly escaped.
>>> widget.setRenderedValue(u'')
>>> widget()
u'<Another Title>'
When the value is the missing_value, the empty string should be
displayed::
>>> field = TextLine(title = u'Title',
... __name__ = u'title',
... required = False)
>>> field = field.bind(None)
>>> widget = DisplayWidget(field, TestRequest())
>>> widget.setRenderedValue(field.missing_value)
>>> widget()
''
If there's no default for the field and the value is missing on
the bound object, the empty string should still be displayed::
>>> field = TextLine(title=u'Title',
... __name__=u'title',
... required=False)
>>> class Thing:
... title = field.missing_value
>>> field = field.bind(Thing())
>>> widget = DisplayWidget(field, TestRequest())
>>> widget()
''
"""
def test_suite():
suite = unittest.TestSuite()
suite.addTest(DocTestSuite(checker=checker))
suite.addTest(DocTestSuite(
checker=checker,
extraglobs={"DisplayWidget": UnicodeDisplayWidget}))
return suite
if __name__ == '__main__':
unittest.main(defaultTest='test_suite')
zope.formlib-4.3.0a2/src/zope/formlib/sequencewidget.pt 0000664 0000000 0000000 00000002016 12243456432 021632 0 ustar root root
© '})
>>> widget = TextWidget(field, request)
>>> widget.getInputValue()
u'© '
>>> print(normalize( widget() ))
© '})
>>> widget = TextAreaWidget(field, request)
>>> widget.getInputValue()
u'© '
>>> print(normalize( widget() ))
There was a but which caused the content of
>>> request = TestRequest(form={'field.description': u'foo
'})
>>> widget = TestTextAreaWidget(field, request)
>>> try:
... widget.getInputValue()
... except ConversionError as error:
... print(error.doc())
I don't like foo.
>>> print(normalize( widget() ))
"""
default = ""
width = 60
height = 15
extra = ""
style = ''
def _toFieldValue(self, value):
value = super(TextAreaWidget, self)._toFieldValue(value)
if value:
try:
value = toUnicode(value)
except ValueError as v:
raise ConversionError(_("Invalid unicode data"), v)
else:
value = value.replace("\r\n", "\n")
return value
def _toFormValue(self, value):
value = super(TextAreaWidget, self)._toFormValue(value)
if value:
value = value.replace("\n", "\r\n")
else:
value = u''
return value
def __call__(self):
return renderElement("textarea",
name=self.name,
id=self.name,
cssClass=self.cssClass,
rows=self.height,
cols=self.width,
style=self.style,
contents=escape(self._getFormValue()),
extra=self.extra)
class BytesAreaWidget(Bytes, TextAreaWidget):
"""BytesArea widget.
Multi-line string input.
>>> from zope.publisher.browser import TestRequest
>>> from zope.schema import Bytes
>>> field = Bytes(__name__='foo', title=u'on')
>>> request = TestRequest(form={'field.foo': u'Hello\\r\\nworld!'})
>>> widget = BytesAreaWidget(field, request)
>>> widget.hasInput()
True
>>> widget.getInputValue()
'Hello\\nworld!'
"""
class ASCIIAreaWidget(NativeString, TextAreaWidget):
"""ASCIIArea widget.
Multi-line string input.
>>> from zope.publisher.browser import TestRequest
>>> from zope.schema import ASCII
>>> field = ASCII(__name__='foo', title=u'on')
>>> request = TestRequest(form={'field.foo': u'Hello\\r\\nworld!'})
>>> widget = ASCIIAreaWidget(field, request)
>>> widget.hasInput()
True
>>> widget.getInputValue()
'Hello\\nworld!'
"""
class PasswordWidget(TextWidget):
"""Password Widget"""
type = 'password'
def __call__(self):
displayMaxWidth = self.displayMaxWidth or 0
if displayMaxWidth > 0:
return renderElement(self.tag,
type=self.type,
name=self.name,
id=self.name,
value='',
cssClass=self.cssClass,
style=self.style,
size=self.displayWidth,
maxlength=displayMaxWidth,
extra=self.extra)
else:
return renderElement(self.tag,
type=self.type,
name=self.name,
id=self.name,
value='',
cssClass=self.cssClass,
style=self.style,
size=self.displayWidth,
extra=self.extra)
def _toFieldValue(self, input):
try:
existing = self.context.get(self.context.context)
except AttributeError:
existing = False
if (not input) and existing:
return self.context.UNCHANGED_PASSWORD
return super(PasswordWidget, self)._toFieldValue(input)
def hidden(self):
raise NotImplementedError(
'Cannot get a hidden tag for a password field')
class FileWidget(TextWidget):
"""File Widget"""
type = 'file'
def __call__(self):
displayMaxWidth = self.displayMaxWidth or 0
hidden = renderElement(self.tag,
type='hidden',
name=self.name+".used",
id=self.name+".used",
value="")
if displayMaxWidth > 0:
elem = renderElement(self.tag,
type=self.type,
name=self.name,
id=self.name,
cssClass=self.cssClass,
size=self.displayWidth,
maxlength=displayMaxWidth,
extra=self.extra)
else:
elem = renderElement(self.tag,
type=self.type,
name=self.name,
id=self.name,
cssClass=self.cssClass,
size=self.displayWidth,
extra=self.extra)
return "%s %s" % (hidden, elem)
def _toFieldValue(self, input):
if input is None or input == '':
return self.context.missing_value
try:
seek = input.seek
read = input.read
except AttributeError as e:
raise ConversionError(_('Form input is not a file object'), e)
else:
seek(0)
data = read()
if data or getattr(input, 'filename', ''):
return data
else:
return self.context.missing_value
def hasInput(self):
return ((self.name+".used" in self.request.form)
or
(self.name in self.request.form)
)
class IntWidget(TextWidget):
"""Integer number widget.
Let's make sure that zeroes are rendered properly:
>>> from zope.schema import Int
>>> field = Int(__name__='foo', title=u'on')
>>> widget = IntWidget(field, None)
>>> widget.setRenderedValue(0)
>>> 'value="0"' in widget()
True
"""
displayWidth = 10
def _toFieldValue(self, input):
if input == self._missing:
return self.context.missing_value
else:
try:
return int(input)
except ValueError as v:
raise ConversionError(_("Invalid integer data"), v)
@implementer(IInputWidget)
class FloatWidget(TextWidget):
displayWidth = 10
def _toFieldValue(self, input):
if input == self._missing:
return self.context.missing_value
else:
try:
return float(input)
except ValueError as v:
raise ConversionError(_("Invalid floating point data"), v)
@implementer(IInputWidget)
class DecimalWidget(TextWidget):
displayWidth = 10
def _toFieldValue(self, input):
if input == self._missing:
return self.context.missing_value
else:
try:
return decimal.Decimal(input)
except decimal.InvalidOperation as v:
raise ConversionError(_("Invalid decimal data"), v)
def _toFormValue(self, value):
if value == self.context.missing_value:
value = self._missing
else:
return toUnicode(value)
class DatetimeWidget(TextWidget):
"""Datetime entry widget."""
displayWidth = 20
def _toFieldValue(self, input):
if input == self._missing:
return self.context.missing_value
else:
try:
# TODO: Currently datetimes return in local (server)
# time zone if no time zone information was given.
# Maybe offset-naive datetimes should be returned in
# this case? (DV)
return parseDatetimetz(input)
except (DateTimeError, ValueError, IndexError) as v:
raise ConversionError(_("Invalid datetime data"), v)
class DateWidget(DatetimeWidget):
"""Date entry widget.
"""
def _toFieldValue(self, input):
v = super(DateWidget, self)._toFieldValue(input)
if v != self.context.missing_value:
v = v.date()
return v
class DateI18nWidget(TextWidget):
"""I18n date entry widget.
The `displayStyle` attribute may be set to control the formatting of the
value.
`displayStyle` must be one of 'full', 'long', 'medium', 'short',
or None ('' is accepted an an alternative to None to support
provision of a value from ZCML).
"""
_category = "date"
displayWidth = 20
displayStyle = None
def _toFieldValue(self, input):
if input == self._missing:
return self.context.missing_value
else:
try:
formatter = self.request.locale.dates.getFormatter(
self._category, (self.displayStyle or None))
return formatter.parse(input)
except (DateTimeParseError, ValueError) as v:
raise ConversionError(_("Invalid datetime data"),
"%s (%r)" % (v, input))
def _toFormValue(self, value):
value = super(DateI18nWidget, self)._toFormValue(value)
if value:
formatter = self.request.locale.dates.getFormatter(
self._category, (self.displayStyle or None))
value = formatter.format(value)
return value
class DatetimeI18nWidget(DateI18nWidget):
"""I18n datetime entry widget.
The `displayStyle` attribute may be set to control the formatting of the
value.
`displayStyle` must be one of 'full', 'long', 'medium', 'short',
or None ('' is accepted an an alternative to None to support
provision of a value from ZCML).
NOTE: If you need timezone information you need to set `displayStyle`
to either 'long' or 'full' since other display styles just ignore it.
"""
_category = "dateTime"
class DateDisplayWidget(DisplayWidget):
"""Date display widget.
The `cssClass` and `displayStyle` attributes may be set to control
the formatting of the value.
`displayStyle` must be one of 'full', 'long', 'medium', 'short',
or None ('' is accepted an an alternative to None to support
provision of a value from ZCML).
"""
cssClass = "date"
displayStyle = None
_category = "date"
def __call__(self):
if self._renderedValueSet():
content = self._data
else:
content = self.context.default
if content == self.context.missing_value:
return ""
formatter = self.request.locale.dates.getFormatter(
self._category, (self.displayStyle or None))
content = formatter.format(content)
return renderElement("span", contents=escape(content),
cssClass=self.cssClass)
class DatetimeDisplayWidget(DateDisplayWidget):
"""Datetime display widget.
The `cssClass` and `displayStyle` attributes may be set to control
the formatting of the value.
`displayStyle` must be one of 'full', 'long', 'medium', 'short',
or None ('' is accepted an an alternative to None to support
provision of a value from ZCML).
"""
cssClass = "dateTime"
_category = "dateTime"
zope.formlib-4.3.0a2/src/zope/formlib/widgets.py 0000664 0000000 0000000 00000007276 12243456432 020306 0 ustar root root ##############################################################################
#
# Copyright (c) 2004 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.
#
##############################################################################
"""Browser widgets
"""
__docformat__ = 'restructuredtext'
from zope.formlib.widget import BrowserWidget, DisplayWidget
from zope.formlib.widget import UnicodeDisplayWidget
from zope.formlib.textwidgets import TextWidget, BytesWidget
from zope.formlib.textwidgets import TextAreaWidget, BytesAreaWidget
from zope.formlib.textwidgets import PasswordWidget, FileWidget
from zope.formlib.textwidgets import ASCIIWidget, ASCIIAreaWidget
from zope.formlib.textwidgets import IntWidget, FloatWidget
from zope.formlib.textwidgets import DecimalWidget
from zope.formlib.textwidgets import DatetimeWidget, DateWidget
from zope.formlib.textwidgets import DatetimeI18nWidget
from zope.formlib.textwidgets import DateI18nWidget
from zope.formlib.textwidgets import DatetimeDisplayWidget
from zope.formlib.textwidgets import DateDisplayWidget
from zope.formlib.textwidgets import BytesDisplayWidget
from zope.formlib.textwidgets import ASCIIDisplayWidget
from zope.formlib.textwidgets import URIDisplayWidget
# Widgets for boolean fields
from zope.formlib.boolwidgets import CheckBoxWidget
from zope.formlib.boolwidgets import BooleanRadioWidget
from zope.formlib.boolwidgets import BooleanSelectWidget
from zope.formlib.boolwidgets import BooleanDropdownWidget
from zope.formlib.boolwidgets import BooleanDisplayWidget
# Choice and Sequence Display Widgets
from zope.formlib.itemswidgets import ItemDisplayWidget
from zope.formlib.itemswidgets import ItemsMultiDisplayWidget
from zope.formlib.itemswidgets import SetDisplayWidget
from zope.formlib.itemswidgets import ListDisplayWidget
# Widgets for fields with vocabularies.
# Note that these are only dispatchers for the widgets below.
from zope.formlib.itemswidgets import ChoiceDisplayWidget
from zope.formlib.itemswidgets import ChoiceInputWidget
from zope.formlib.itemswidgets import CollectionDisplayWidget
from zope.formlib.itemswidgets import CollectionInputWidget
from zope.formlib.itemswidgets import ChoiceCollectionDisplayWidget
from zope.formlib.itemswidgets import ChoiceCollectionInputWidget
# Widgets that let you choose a single item from a list
# These widgets are multi-views on (field, vocabulary)
from zope.formlib.itemswidgets import SelectWidget
from zope.formlib.itemswidgets import DropdownWidget
from zope.formlib.itemswidgets import RadioWidget
# Widgets that let you choose several items from a list
# These widgets are multi-views on (field, vocabulary)
from zope.formlib.itemswidgets import MultiSelectWidget
from zope.formlib.itemswidgets import MultiSelectSetWidget
from zope.formlib.itemswidgets import MultiSelectFrozenSetWidget
from zope.formlib.itemswidgets import MultiCheckBoxWidget
from zope.formlib.itemswidgets import OrderedMultiSelectWidget
# Widgets that let you enter several items in a sequence
# These widgets are multi-views on (sequence type, value type)
from zope.formlib.sequencewidget import SequenceWidget
from zope.formlib.sequencewidget import TupleSequenceWidget
from zope.formlib.sequencewidget import ListSequenceWidget
from zope.formlib.sequencewidget import SequenceDisplayWidget
from zope.formlib.objectwidget import ObjectWidget
zope.formlib-4.3.0a2/src/zope/formlib/widget.py 0000664 0000000 0000000 00000051572 12243456432 020121 0 ustar root root ##############################################################################
#
# Copyright (c) 2001-2004 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.
#
##############################################################################
"""Browser Widget Definitions
"""
__docformat__ = 'restructuredtext'
from xml.sax.saxutils import quoteattr, escape
from zope.component import getMultiAdapter, provideAdapter
from zope.interface import implementer
from zope.schema.interfaces import ValidationError
from zope.publisher.browser import BrowserView
from zope.publisher.interfaces.browser import IDefaultBrowserLayer
from zope.formlib.interfaces import ConversionError
from zope.formlib.interfaces import WidgetInputError, MissingInputError
from zope.formlib.interfaces import IBrowserWidget
from zope.formlib.interfaces import ISimpleInputWidget
from zope.formlib.interfaces import IWidgetInputErrorView
from zope.formlib.interfaces import IWidget, InputErrors, IWidgetFactory
from zope.formlib._compat import toUnicode
from zope.i18n import translate
from zope.schema.interfaces import IChoice, ICollection
import warnings
if quoteattr("\r") != '"&13;"':
_quoteattr = quoteattr
def quoteattr(data):
return _quoteattr(
data, {'\n': '
', '\r': '
', '\t':' '})
@implementer(IWidget)
class Widget(object):
"""Mixin class providing functionality common across widget types."""
_prefix = 'field.'
_data_marker = object()
_data = _data_marker
visible = True
def __init__(self, context, request):
self.context = context
self.request = request
self.name = self._prefix + context.__name__
self.label = self.context.title
self.hint = self.context.description
def _translate(self, text):
return translate(text, context=self.request, default=text)
def _renderedValueSet(self):
"""Returns ``True`` if the the widget's rendered value has been set.
This is a convenience method that widgets can use to check whether
or not `setRenderedValue` was called.
"""
return self._data is not self._data_marker
def setPrefix(self, prefix):
if prefix and not prefix.endswith("."):
prefix += '.'
self._prefix = prefix
self.name = prefix + self.context.__name__
def setRenderedValue(self, value):
self._data = value
class InputWidget(Widget):
"""Mixin class providing some default input widget methods."""
def hasValidInput(self):
try:
self.getInputValue()
return True
except InputErrors:
return False
def applyChanges(self, content):
field = self.context
value = self.getInputValue()
if field.query(content, self) != value:
field.set(content, value)
return True
else:
return False
@implementer(IWidgetFactory)
class CustomWidgetFactory(object):
"""Custom Widget Factory."""
def __init__(self, widget_factory, *args, **kw):
self._widget_factory = widget_factory
self.args = args
self.kw = kw
def _create(self, args):
instance = self._widget_factory(*args)
for name, value in self.kw.items():
setattr(instance, name, value)
return instance
def __call__(self, context, request):
# Sequence widget factory
if ICollection.providedBy(context):
args = (context, context.value_type, request) + self.args
# Vocabulary widget factory
elif IChoice.providedBy(context):
args = (context, context.vocabulary, request) + self.args
# Regular widget factory
else:
args = (context, request) + self.args
return self._create(args)
@implementer(IBrowserWidget)
class BrowserWidget(Widget, BrowserView):
"""Base class for browser widgets.
>>> setUp()
The class provides some basic functionality common to all browser widgets.
Browser widgets have a `required` attribute, which indicates whether or
not the underlying field requires input. By default, the widget's required
attribute is equal to the field's required attribute:
>>> from zope.schema import Field
>>> from zope.publisher.browser import TestRequest
>>> field = Field(required=True)
>>> widget = BrowserWidget(field, TestRequest())
>>> widget.required
True
>>> field.required = False
>>> widget = BrowserWidget(field, TestRequest())
>>> widget.required
False
However, the two `required` values are independent of one another:
>>> field.required = True
>>> widget.required
False
Browser widgets have an error state, which can be rendered in a form using
the `error()` method. The error method delegates the error rendering to a
view that is registered as providing `IWidgetInputErrorView`. To
illustrate, we can create and register a simple error display view:
>>> from zope.formlib.interfaces import IWidgetInputError
>>> @implementer(IWidgetInputErrorView)
... class SnippetErrorView:
... def __init__(self, context, request):
... self.context = context
... def snippet(self):
... return "The error: " + str(self.context.errors)
>>> provideAdapter(SnippetErrorView,
... (IWidgetInputError, IDefaultBrowserLayer),
... IWidgetInputErrorView, '')
Whever an error occurs, widgets should set _error:
>>> widget._error = WidgetInputError('foo', 'Foo', ('Err1', 'Err2'))
so that it can be displayed using the error() method:
>>> widget.error()
"The error: ('Err1', 'Err2')"
>>> tearDown()
"""
_error = None
def __init__(self, context, request):
super(BrowserWidget, self).__init__(context, request)
self.required = context.required
def error(self):
if self._error:
return getMultiAdapter((self._error, self.request),
IWidgetInputErrorView).snippet()
return ""
def hidden(self):
return ""
@implementer(ISimpleInputWidget)
class SimpleInputWidget(BrowserWidget, InputWidget):
"""A baseclass for simple HTML form widgets.
>>> setUp()
Simple input widgets read input from a browser form. To illustrate, we
will use a test request with two form values:
>>> from zope.publisher.browser import TestRequest
>>> request = TestRequest(form={
... 'field.foo': u'hello\\r\\nworld',
... 'baz.foo': u'bye world'})
Like all widgets, simple input widgets are a view to a field context:
>>> from zope.schema import Field
>>> field = Field(__name__='foo', title=u'Foo')
>>> widget = SimpleInputWidget(field, request)
Widgets are named using their field's name:
>>> widget.name
'field.foo'
The default implementation for the widget label is to use the field title:
>>> widget.label
u'Foo'
According the request, the widget has input because 'field.foo' is
present:
>>> widget.hasInput()
True
>>> widget.getInputValue()
u'hello\\r\\nworld'
Widgets maintain an error state, which is used to communicate invalid
input or other errors:
>>> widget._error is None
True
>>> widget.error()
''
`setRenderedValue` is used to specify the value displayed by the widget to
the user. This value, however, is not the same as the input value, which
is read from the request:
>>> widget.setRenderedValue('Hey\\nfolks')
>>> widget.getInputValue()
u'hello\\r\\nworld'
>>> widget._error is None
True
>>> widget.error()
''
You can use 'setPrefix' to remove or modify the prefix used to create the
widget name as follows:
>>> widget.setPrefix('')
>>> widget.name
'foo'
>>> widget.setPrefix('baz')
>>> widget.name
'baz.foo'
`getInputValue` always returns a value that can legally be assigned to
the widget field. To illustrate widget validation, we can add a constraint
to its field:
>>> import re
>>> field.constraint = re.compile('.*hello.*').match
Because we modified the widget's name, the widget will now read different
form input:
>>> request.form[widget.name]
u'bye world'
This input violates the new field constraint and therefore causes an
error when `getInputValue` is called:
>>> widget.getInputValue() #doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
WidgetInputError: ('foo', u'Foo', ConstraintNotSatisfied(u'bye world'))
Simple input widgets require that input be available in the form request.
If input is not present, a ``MissingInputError`` is raised:
>>> del request.form[widget.name]
>>> widget.getInputValue() #doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
MissingInputError: ('baz.foo', u'Foo', None)
A ``MissingInputError`` indicates that input is missing from the form
altogether. It does not indicate that the user failed to provide a value
for a required field. The ``MissingInputError`` above was caused by the
fact that the form does have any input for the widget:
>>> request.form[widget.name] #doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
KeyError: 'baz.foo'
If a user fails to provide input for a field, the form will contain the
input provided by the user, namely an empty string:
>>> request.form[widget.name] = ''
In such a case, if the field is required, a ``WidgetInputError`` will be
raised on a call to `getInputValue`:
>>> field.required = True
>>> widget.getInputValue() #doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
WidgetInputError: ('foo', u'Foo', RequiredMissing('foo'))
However, if the field is not required, the empty string will be converted
by the widget into the field's `missing_value` and read as a legal field
value:
>>> field.required = False
>>> widget.getInputValue() is field.missing_value
True
Another type of exception is a conversion error. It is raised when a value
cannot be converted to the desired Python object. Here is an example of a
floating point.
>>> from zope.schema import Float
>>> field = Float(__name__='price', title=u'Price')
>>> from zope.formlib.interfaces import ConversionError
>>> class FloatWidget(SimpleInputWidget):
... def _toFieldValue(self, input):
... try:
... return float(input)
... except ValueError as v:
... raise ConversionError('Invalid floating point data', v)
...
... def _toFormValue(self, value):
... value = super(FloatWidget, self)._toFormValue(value)
... return '%.2f' % value
>>> request = TestRequest(form={'field.price': u'32.0'})
>>> widget = FloatWidget(field, request)
>>> widget.getInputValue()
32.0
>>> widget()
u'foo
'})
>>> widget = FloatWidget(field, request)
>>> try:
... widget.getInputValue()
... except ConversionError as error:
... print(error.doc())
Invalid floating point data
>>> widget()
u'Required input is missing.
Required input is missing.
Invalid floating point data
Required input is missing.
Required input is missing.
Required input is missing.
Required input is missing.
{'min_size': 42.0}
Edit Forms
==========
A common application of forms is edit forms. Edit forms are special
in 2 ways:
- We want to get the initial data for widgets from the object being
edited.
- If there are no errors, we want to apply the changes back to the
object being edited.
The form package provides some functions to assist with creating edit
forms. When we set up our form_fields, we use the `render_context`
option, which uses data from the context passed to setUpWidgets.
Let's create a content class that provides `IOrder` and a simple form
that uses it:
>>> import datetime
>>> @interface.implementer(IOrder)
... class Order:
...
... def __init__(self, identifier):
... self.identifier = identifier
... self.name = 'unknown'
... self.min_size = 0.0
... self.max_size = 0.0
...
... now = property(lambda self: datetime.datetime.now())
>>> order = Order(1)
>>> class MyForm:
... form_fields = form.Fields(
... IOrder, omit_readonly=True, render_context=True)
...
... def __init__(self, context, request):
... self.context, self.request = context, request
...
... def __call__(self, ignore_request=False):
... widgets = form.setUpWidgets(
... self.form_fields, 'form', self.context, self.request,
... ignore_request=ignore_request)
...
... return '\n'.join([w() for w in widgets])
>>> print(MyForm(order, request)()) # doctest: +NORMALIZE_WHITESPACE
Invalid floating point data
Note that we didn't get data from the request because we are using all
display widgets.
Passing `ignore_request=True` to the `setUpWidgets` function ignores
the request for all values passed in the data dictionary, in order to
help with redrawing a form after a successful action handler. We'll
fake that quickly by forcing ignore_request to be `True`.
>>> class MyForm(form.Form):
...
... form_fields = form.Fields(IOrder)
... form_fields = form_fields.omit('now')
...
... actions = ()
...
... def setUpWidgets(self, ignore_request=False):
... self.widgets = form.setUpWidgets(
... self.form_fields, self.prefix, self.context, self.request,
... data=dict(identifier=42, name=u'sally'),
... ignore_request=True # =ignore_request
... )
>>> print(MyForm(None, request)()) # doctest: +NORMALIZE_WHITESPACE
42
2005-05-04 '
To set the custom widget factory for a field, assign to the
`custom_widget` attribute of the form field object::
>>> class MyForm(form.Form):
... actions = ()
...
... form_fields = form.Fields(IOrder).select("now")
...
... # Here we set the custom widget:
...
... form_fields["now"].custom_widget = ISODisplayWidget
>>> print(MyForm(None, request)())
2005-05-04
Specifying Fields individually
------------------------------
All of the previous examples set up fields as collections. We can
also set up forms individually and pass them to the Fields
constructor. This is especially useful for passing options that
really only apply to a single field. The previous example can be
written more simply as:
>>> class MyForm(form.Form):
... actions = ()
...
... form_fields = form.Fields(
... form.Field(IOrder['now'], custom_widget=ISODisplayWidget),
... )
>>> print(MyForm(None, request)())
2005-05-04
Computing default values
------------------------
We saw earlier that we could provide initial widget data by passing a
dictionary to setUpWidgets. We can also supply a function or method
name when we set up form fields.
We might like to include the `now` field in our forms. We can provide
a function for getting the needed initial value:
>>> import datetime
>>> class MyForm(form.Form):
... actions = ()
...
... def now(self):
... return datetime.datetime(2002, 12, 2, 12, 30)
...
... form_fields = form.Fields(
... form.Fields(IOrder).omit('now'),
... form.Field(IOrder['now'], get_rendered=now),
... )
>>> print(MyForm(None, request)()) # doctest: +NORMALIZE_WHITESPACE
2002 12 2 12:30:00
Now try the same with the AddFormBase which uses a setUpInputWidget:
>>> class MyAddForm(form.AddFormBase):
... actions = ()
...
... def now(self):
... return datetime.datetime(2002, 12, 2, 12, 30)
...
... form_fields = form.Fields(
... form.Fields(IOrder).omit('now'),
... form.Field(IOrder['now'], get_rendered=now),
... )
...
... def setUpWidgets(self, ignore_request=True):
... super(MyAddForm, self).setUpWidgets(ignore_request)
>>> print(MyAddForm(None, request)()) # doctest: +NORMALIZE_WHITESPACE
Note: If this behavior ever changes, the formlib can be simplified again.
>>> @zope.interface.implementer(IFooBar)
... class FooBar(object):
... title = u'initial'
>>> foobar = FooBar()
>>> class Blah(object):
... def __conform__(self, iface):
... if iface is IFooBar:
... return foobar
>>> blah = Blah()
Let's now generate the form fields and instantiate the widgets:
>>> from zope.formlib import form
>>> form_fields = form.FormFields(IFooBar)
>>> request = TestRequest()
>>> widgets = form.setUpEditWidgets(form_fields, 'form', blah, request)
>>> print(widgets.get('title')())
: ['title']}
The events are annotated with these descriptions. We need a subscriber to log these
infos:
>>> def eventLog(event):
... desc = event.descriptions[0]
... print('Modified:', desc.interface.__identifier__, desc.attributes)
>>> zope.event.subscribers.append(eventLog)
>>> class MyForm(form.EditForm):
... form_fields = form.FormFields(IFooBar)
>>> request = TestRequest()
>>> request.form['form.title'] = u'again modified'
>>> request.form['form.actions.apply'] = u''
>>> MyForm(FooBar(), request)()
Modified: __builtin__.IFooBar ('title',)
...
Cleanup:
>>> zope.event.subscribers.remove(eventLog)
Actions that cause a redirect
-----------------------------
When an action causes a redirect, the following `render` phase is omitted as
the result will not be displayed anyway. This is both a performance
improvement and for avoiding application bugs with one-time session
information.
>>> class MyForm(form.Form):
... form_fields = form.FormFields(IFooBar)
... @form.action("Redirect")
... def redirect(self, action, data):
... print('Action: redirect')
... self.request.response.redirect('foo')
... @form.action("Stay")
... def redirect(self, action, data):
... print('Action: stay')
... pass
... def render(self):
... print('render was called')
... return ''
>>> request = TestRequest()
>>> print(MyForm(None, request)()) # doctest: +NORMALIZE_WHITESPACE
render was called
>>> request.form['form.actions.redirect'] = u''
>>> print(MyForm(None, request)()) # doctest: +NORMALIZE_WHITESPACE
Action: redirect
>>> request = TestRequest()
>>> request.form['form.actions.stay'] = u''
>>> print(MyForm(None, request)()) # doctest: +NORMALIZE_WHITESPACE
Action: stay
render was called
Prevent form submit for GET requests
------------------------------------
It can be useful to only accept form submits over POST requests. This, for
example, prevents replaying data-modifying actions when reloading a page in a
web browser (most web browsers warn users for re-submitting the form when
reloading a page that was the result of a POST request). This also helps (but
is not enough by itself!) in preventing CSRF attacks.
Whenever a form component has set the ``method`` attribute on the class, it
is used when validating the form data.
>>> class MyPOSTForm(form.Form):
... method = 'POST'
...
... form_fields = form.FormFields(IFooBar)
...
... @form.action("Handle")
... def handle(self, action, data):
... print('Action: handle %s' % data)
...
... def render(self):
... return ''
This is a GET request for a form that specifies it can only validate POST
requests::
>>> request = TestRequest()
>>> request.form['form.title'] = u'Submitted Title'
>>> request.form['form.actions.handle'] = u''
>>> MyPOSTForm(None, request)() # doctest: +NORMALIZE_WHITESPACE +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
MethodNotAllowed: None,
By setting the correct request method we validate input::
>>> request = TestRequest()
>>> request.method = 'POST'
>>> request.form['form.title'] = u'Submitted Title'
>>> request.form['form.actions.handle'] = u''
>>> print(MyPOSTForm(None, request)()) # doctest: +NORMALIZE_WHITESPACE
Action: handle {'title': 'Submitted Title'}
Although slightly convoluted, we could require the submit to go over a
GET request::
>>> class MyGETForm(form.Form):
... method = 'GET'
...
... form_fields = form.FormFields(IFooBar)
...
... @form.action("Handle")
... def handle(self, action, data):
... print('Action: handle %s' % data)
...
... def render(self):
... return ''
>>> request = TestRequest()
>>> request.method = 'POST'
>>> request.form['form.actions.handle'] = u''
>>> MyGETForm(None, request)() # doctest: +NORMALIZE_WHITESPACE +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
MethodNotAllowed: None,
>>> request = TestRequest()
>>> request.form['form.title'] = u'Submitted Title'
>>> request.form['form.actions.handle'] = u''
>>> print(MyGETForm(None, request)()) # doctest: +NORMALIZE_WHITESPACE
Action: handle {'title': 'Submitted Title'}
Note how the default value for ``method`` is None, meaning all request
methods are accepted::
>>> class MyForm(form.Form):
... form_fields = form.FormFields(IFooBar)
...
... @form.action("Handle")
... def handle(self, action, data):
... print('Action: handle %s' % data)
...
... def render(self):
... return ''
>>> request = TestRequest()
>>> request.method = 'POST'
>>> request.form['form.title'] = u'Submitted Title'
>>> request.form['form.actions.handle'] = u''
>>> print(MyForm(None, request)()) # doctest: +NORMALIZE_WHITESPACE
Action: handle {'title': 'Submitted Title'}
>>> request = TestRequest()
>>> request.form['form.title'] = u'Submitted Title'
>>> request.form['form.actions.handle'] = u''
>>> print(MyForm(None, request)()) # doctest: +NORMALIZE_WHITESPACE
Action: handle {'title': 'Submitted Title'}
Prevent Cross-site Request Forgery (CSRF) attacks
-------------------------------------------------
See also: http://en.wikipedia.org/wiki/Cross-site_request_forgery.
The CSRF protection in zope.formlib assumes the attacker cannot get hold of
information stored in a cookie that is send to the domain handling the form
submit. zope.formlib verifies that the token as sent with the cookie is
identical to the value as sent with the form (as a hidden input field).
zope.formlib will set a random token in the cookie when first accessing the
form. Any subsequent form rendering and submit handling will use the token
stored in this cookie.
Thus this token is reused for all forms for as long the cookie is available.
The cookie is set to expiry when the web browser quits.
This protection works best when used in combination with the afformentioned
acceptable request method restriction.
Issues to research:
* Is the name "__csrftoken__ acceptable?
* I do not see a scheme for having a token per form without keep server-
side, which I try to avoid.
* One cannot *submit* a form as the very first request to that form, as the
token will not have been set just yet. I think this acceptable.
* Tests for applications that use form components with CSRF protection
enabled, is cumbersome. Can we help that somehow?
* Is using os.urandom() for generating a token sufficient *and*
available cross-platform? Could uuid.uuid4() be an alternative?
When first visting a form, a CSRF token will be set in the cookie::
>>> class MyForm(form.Form):
... protected = True
...
... form_fields = form.FormFields(IFooBar)
...
... @form.action("Handle")
... def handle(self, action, data):
... print('Action: handle %s' % data)
>>> request = TestRequest()
>>> myform = MyForm(None, request)
>>> _ = myform() # "render" the form.
>>> csrfcookie = request.response.getCookie('__csrftoken__')
>>> csrfcookie['httponly']
True
>>> csrftoken = csrfcookie['value']
>>> csrftoken == myform.csrftoken
True
When submitting the form, the token in the cookie (that will be sent
as part of the request) needs to be identical to the value of the
hidden form field "__csrftoken__"::
>>> request = TestRequest(
... **{'HTTP_COOKIE': '__csrftoken__=%s;' % csrftoken})
>>> request.form['form.title'] = 'Submitted title'
>>> request.form['form.actions.handle'] = 'true'
>>> request.form['__csrftoken__'] = csrftoken
>>> myform = MyForm(None, request)
>>> _ = myform()
Action: handle {'title': u'Submitted title'}
If for some reason the cookie is not set, the form will raise an error::
>>> request = TestRequest(**{'HTTP_COOKIE': ''})
>>> request.form['form.title'] = 'Submitted title'
>>> request.form['form.actions.handle'] = 'true'
>>> request.form['__csrftoken__'] = csrftoken
>>> myform = MyForm(None, request)
>>> _ = myform() #doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
InvalidCSRFTokenError: Invalid CSRF token
As an attacker cannot read the cookie value, he can only guess the
corresponding form value, that is hard get right, so most proably wrong::
>>> request = TestRequest(
... **{'HTTP_COOKIE': '__csrftoken__=%s;' % csrftoken})
>>> request.form['form.title'] = 'Submitted title'
>>> request.form['form.actions.handle'] = 'true'
>>> request.form['__csrftoken__'] = 'a guessed value'
>>> myform = MyForm(None, request)
>>> _ = myform() #doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
InvalidCSRFTokenError: Invalid CSRF token
When the form value is missing altogether, the form obviously raises an error
too::
>>> request = TestRequest(
... **{'HTTP_COOKIE': '__csrftoken__=%s;' % csrftoken})
>>> request.form['form.title'] = 'Submitted title'
>>> request.form['form.actions.handle'] = 'true'
>>> myform = MyForm(None, request)
>>> _ = myform() #doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
InvalidCSRFTokenError: Invalid CSRF token
To repeat: this protection works as long as the cookie value is identical to
the submitted form value. No state is kept on the server. We can demonstrate
this by inventing a token value here in the test ourselves::
>>> csrftoken = 'MYNICETOKENVALUE'
>>> request = TestRequest(
... **{'HTTP_COOKIE': '__csrftoken__=%s;' % csrftoken})
>>> request.form['form.title'] = 'Submitted title'
>>> request.form['form.actions.handle'] = 'true'
>>> request.form['__csrftoken__'] = csrftoken
>>> myform = MyForm(None, request)
>>> _ = myform()
Action: handle {'title': u'Submitted title'}
It is possible to have multiple forms in one page. Of course only one of
these forms can be submitted at one point in time, but the CSRF token should
not confuse things::
>>> class FormOne(form.Form):
... prefix = 'form_one'
...
... protected = True
...
... form_fields = form.FormFields(IFooBar)
...
... @form.action("Handle")
... def handle(self, action, data):
... print('Action: handle in Form One')
>>> class FormTwo(form.Form):
... prefix = 'form_two'
...
... protected = True
...
... form_fields = form.FormFields(IFooBar)
...
... @form.action("Handle")
... def handle(self, action, data):
... print('Action: handle in Form Two')
>>> from zope.publisher.browser import BrowserPage
>>> class MultiForm(BrowserPage):
... def __init__(self, context, request):
... self.formone = FormOne(context, request)
... self.formtwo = FormTwo(context, request)
...
... def __call__(self):
... return '\n'.join((self.formone(), self.formtwo()))
...
Render the initial multi form view::
>>> request = TestRequest()
>>> multi = MultiForm(None, request)
>>> result = multi()
>>> print(result)
Foo input < 1 '
The only method that IWidgetInputError promises to implement is
`doc()`. Therefore, other implementations of the interface should also
work.
>>> from zope.formlib.interfaces import ConversionError
>>> err = ConversionError('Could not convert to float.')
>>> view = WidgetInputErrorView(err, None)
>>> view.snippet()
u'Could not convert to float. '
"""
message = self.context.doc()
translated = translate(message, context=self.request, default=message)
return u'%s ' % escape(translated)
zope.formlib-4.3.0a2/src/zope/formlib/errors.py 0000664 0000000 0000000 00000005074 12243456432 020146 0 ustar root root ##############################################################################
#
# Copyright (c) 2006 Zope Foundation and Contributors.
#
# 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.
#
##############################################################################
"""Error related things.
"""
from cgi import escape
from zope.component import adapter
from zope.interface import implementer
from zope.interface import Invalid
from zope.i18n import Message
from zope.i18n import translate
from zope.publisher.interfaces.browser import IBrowserRequest
from zope.publisher.interfaces.browser import IBrowserPage
from zope.publisher.browser import BrowserPage
from zope.formlib.interfaces import IWidgetInputErrorView
from zope.formlib.interfaces import IInvalidCSRFTokenError
@implementer(IWidgetInputErrorView)
@adapter(Invalid, IBrowserRequest)
class InvalidErrorView(object):
"""Display a validation error as a snippet of text."""
def __init__(self, context, request):
self.context = context
self.request = request
def snippet(self):
"""Convert a widget input error to an html snippet
>>> from zope.interface.exceptions import Invalid
>>> error = Invalid("You made an error!")
>>> InvalidErrorView(error, None).snippet()
u'You made an error! '
"""
msg = self.context.args[0]
if isinstance(msg, Message):
msg = translate(msg, context=self.request)
return u'%s ' % escape(msg)
@implementer(IBrowserPage)
@adapter(IInvalidCSRFTokenError, IBrowserRequest)
class InvalidCSRFTokenErrorView(BrowserPage):
def update(self):
self.request.response.setStatus(403)
self.request.response.setHeader(
'Expires', 'Jan, 1 Jan 1970 00:00:00 GMT')
self.request.response.setHeader(
'Cache-Control', 'no-store, no-cache, must-revalidate')
self.request.response.setHeader(
'Pragma', 'no-cache')
def render(self):
msg = self.context.args[0]
if isinstance(msg, Message):
msg = translate(msg, context=self.request)
return escape(msg)
def __call__(self):
self.update()
return self.render()
zope.formlib-4.3.0a2/src/zope/formlib/objectwidget.pt 0000664 0000000 0000000 00000000370 12243456432 021271 0 ustar root root
The Legend
zope.formlib-4.3.0a2/src/zope/__init__.py 0000664 0000000 0000000 00000000070 12243456432 016726 0 ustar root root __import__('pkg_resources').declare_namespace(__name__)
zope.formlib-4.3.0a2/src/zope.formlib.egg-info/ 0000775 0000000 0000000 00000000000 12355055056 017744 5 ustar root root zope.formlib-4.3.0a2/src/zope.formlib.egg-info/top_level.txt 0000664 0000000 0000000 00000000005 12243456446 022475 0 ustar root root zope
zope.formlib-4.3.0a2/src/zope.formlib.egg-info/dependency_links.txt 0000664 0000000 0000000 00000000001 12243456446 024016 0 ustar root root
zope.formlib-4.3.0a2/src/zope.formlib.egg-info/SOURCES.txt 0000664 0000000 0000000 00000006437 12243456446 021646 0 ustar root root CHANGES.txt
COPYRIGHT.txt
LICENSE.txt
MANIFEST.in
README.txt
bootstrap.py
buildout.cfg
setup.py
tox.ini
src/zope/__init__.py
src/zope.formlib.egg-info/PKG-INFO
src/zope.formlib.egg-info/SOURCES.txt
src/zope.formlib.egg-info/dependency_links.txt
src/zope.formlib.egg-info/namespace_packages.txt
src/zope.formlib.egg-info/not-zip-safe
src/zope.formlib.egg-info/requires.txt
src/zope.formlib.egg-info/top_level.txt
src/zope/formlib/TODO.txt
src/zope/formlib/__init__.py
src/zope/formlib/_compat.py
src/zope/formlib/boolwidgets.py
src/zope/formlib/bugs.txt
src/zope/formlib/configure.zcml
src/zope/formlib/errors.py
src/zope/formlib/errors.txt
src/zope/formlib/exception.py
src/zope/formlib/form.py
src/zope/formlib/form.txt
src/zope/formlib/ftesting.zcml
src/zope/formlib/i18n.py
src/zope/formlib/interfaces.py
src/zope/formlib/itemswidgets.py
src/zope/formlib/namedtemplate.py
src/zope/formlib/objectwidget.pt
src/zope/formlib/objectwidget.py
src/zope/formlib/objectwidget.txt
src/zope/formlib/orderedSelectionList.pt
src/zope/formlib/pageform.pt
src/zope/formlib/sequencewidget.pt
src/zope/formlib/sequencewidget.py
src/zope/formlib/source.py
src/zope/formlib/source.txt
src/zope/formlib/subpageform.pt
src/zope/formlib/textwidgets.py
src/zope/formlib/utility.py
src/zope/formlib/widget.py
src/zope/formlib/widget_macros.pt
src/zope/formlib/widgets.py
src/zope/formlib/widgets.txt
src/zope/formlib/tests/__init__.py
src/zope/formlib/tests/functionalsupport.py
src/zope/formlib/tests/registerWidgets.zcml
src/zope/formlib/tests/support.py
src/zope/formlib/tests/test_browserwidget.py
src/zope/formlib/tests/test_checkboxwidget.py
src/zope/formlib/tests/test_choicecollections.py
src/zope/formlib/tests/test_choicewidget.py
src/zope/formlib/tests/test_datetimewidget.py
src/zope/formlib/tests/test_datewidget.py
src/zope/formlib/tests/test_decimalwidget.py
src/zope/formlib/tests/test_displaywidget.py
src/zope/formlib/tests/test_exception.py
src/zope/formlib/tests/test_filewidget.py
src/zope/formlib/tests/test_floatwidget.py
src/zope/formlib/tests/test_form.py
src/zope/formlib/tests/test_formlib.py
src/zope/formlib/tests/test_functional_booleanradiowidget.py
src/zope/formlib/tests/test_functional_checkboxwidget.py
src/zope/formlib/tests/test_functional_datetimewidget.py
src/zope/formlib/tests/test_functional_decimalwidget.py
src/zope/formlib/tests/test_functional_filewidget.py
src/zope/formlib/tests/test_functional_floatwidget.py
src/zope/formlib/tests/test_functional_intwidget.py
src/zope/formlib/tests/test_functional_objectwidget.py
src/zope/formlib/tests/test_functional_selectwidget.py
src/zope/formlib/tests/test_functional_textareawidget.py
src/zope/formlib/tests/test_functional_textwidget.py
src/zope/formlib/tests/test_intwidget.py
src/zope/formlib/tests/test_itemswidget.py
src/zope/formlib/tests/test_multicheckboxwidget.py
src/zope/formlib/tests/test_objectwidget.py
src/zope/formlib/tests/test_passwordwidget.py
src/zope/formlib/tests/test_radiowidget.py
src/zope/formlib/tests/test_registrations.py
src/zope/formlib/tests/test_selectwidget.py
src/zope/formlib/tests/test_sequencewidget.py
src/zope/formlib/tests/test_setprefix.py
src/zope/formlib/tests/test_source.py
src/zope/formlib/tests/test_textareawidget.py
src/zope/formlib/tests/test_textwidget.py
src/zope/formlib/tests/test_widget.py
src/zope/formlib/tests/test_widgetdocs.py zope.formlib-4.3.0a2/src/zope.formlib.egg-info/namespace_packages.txt 0000664 0000000 0000000 00000000005 12243456446 024276 0 ustar root root zope
zope.formlib-4.3.0a2/src/zope.formlib.egg-info/requires.txt 0000664 0000000 0000000 00000000412 12243456446 022345 0 ustar root root setuptools
pytz
zope.browser>=1.1
zope.browserpage>=3.11.0
zope.component
zope.event
zope.i18n
zope.i18nmessageid
zope.interface
zope.lifecycleevent
zope.publisher
zope.schema>=3.5.1
zope.security
zope.traversing
zope.datetime
[test]
zope.configuration
zope.testing zope.formlib-4.3.0a2/src/zope.formlib.egg-info/PKG-INFO 0000664 0000000 0000000 00000351245 12243456446 021057 0 ustar root root Metadata-Version: 1.1
Name: zope.formlib
Version: 4.3.0a2
Summary: Form generation and validation library for Zope
Home-page: http://pypi.python.org/pypi/zope.formlib
Author: Zope Foundation and Contributors
Author-email: zope-dev@zope.org
License: ZPL 2.1
Description: .. contents::
========
Overview
========
Forms are web components that use widgets to display and input data.
Typically a template displays the widgets by accessing an attribute or
method on an underlying class.
=====
Forms
=====
Forms are web components that use widgets to display and input data.
Typically a template displays the widgets by accessing an attribute or
method on an underlying class.
This document describes some tools to assist in form development. In
the examples, we will show "forms" that are generated with simple
print statements to keep the examples simpler. Most forms will use
templates in practice.
This document starts with low-level APIs. We eventually build up to
higher-level APIs that allow forms to be defined with just a little bit
of meta data. Impatient readers may wish to skip to the later
sections, especially the section on `Helpful base classes`_. :)
A form class can define ordered collections of "form fields" using
the `Fields` constructor. Form fields are distinct from and build on
schema fields. A schema field specified attribute values. Form
fields specify how a schema field should be used in a form. The
simplest way to define a collection of form fields is by passing a
schema to the `Fields` constructor:
>>> from zope import interface, schema
>>> class IOrder(interface.Interface):
... identifier = schema.Int(title=u"Identifier", readonly=True)
... name = schema.TextLine(title=u"Name")
... min_size = schema.Float(title=u"Minimum size")
... max_size = schema.Float(title=u"Maximum size")
... color = schema.TextLine(title=u"Color", required=False)
... now = schema.Datetime(title=u"Now", readonly=True)
>>> from zope.formlib import form
>>> class MyForm:
... form_fields = form.Fields(IOrder)
This sets up a set of form fields from the interface, IOrder.
>>> len(MyForm.form_fields)
6
>>> [w.__name__ for w in MyForm.form_fields]
['identifier', 'name', 'min_size', 'max_size', 'color', 'now']
We can access individual form fields by name:
>>> MyForm.form_fields['name'].__name__
'name'
We can also select and order subsets using the select method of form fields:
>>> [w.__name__ for w in MyForm.form_fields.select('name', 'identifier')]
['name', 'identifier']
or by omitting fields:
>>> [w.__name__ for w in MyForm.form_fields.omit('now', 'identifier')]
['name', 'min_size', 'max_size', 'color']
We can omit read-only fields using the omit_readonly option when
setting up the fields:
>>> class MyForm:
... form_fields = form.Fields(IOrder, omit_readonly=True)
>>> [w.__name__ for w in MyForm.form_fields]
['name', 'min_size', 'max_size', 'color']
Getting HTML
============
Having defined form fields, we can use them to generate HTML
forms. Typically, this is done at run time by form class
instances. Let's look at an example that displays some input widgets:
>>> class MyForm:
... form_fields = form.Fields(IOrder, omit_readonly=True)
...
... def __init__(self, context, request):
... self.context, self.request = context, request
...
... def __call__(self, ignore_request=False):
... widgets = form.setUpWidgets(
... self.form_fields, 'form', self.context, self.request,
... ignore_request=ignore_request)
... return '\n'.join([w() for w in widgets])
Here we used ``form.setUpWidgets`` to create widget instances from our
form-field specifications. The second argument to ``setUpWidgets`` is a
form prefix. All of the widgets on this form are given the same
prefix. This allows multiple forms to be used within a single form
tag, assuming that each form uses a different form prefix.
Now, we can display the form:
>>> from zope.publisher.browser import TestRequest
>>> request = TestRequest()
>>> print(MyForm(None, request)()) # doctest: +NORMALIZE_WHITESPACE
Required input is missing.
Required input is missing.
Invalid floating point data
Required input is missing.
Required input is missing.
Required input is missing.
Required input is missing.
{'min_size': 42.0}
Edit Forms
==========
A common application of forms is edit forms. Edit forms are special
in 2 ways:
- We want to get the initial data for widgets from the object being
edited.
- If there are no errors, we want to apply the changes back to the
object being edited.
The form package provides some functions to assist with creating edit
forms. When we set up our form_fields, we use the `render_context`
option, which uses data from the context passed to setUpWidgets.
Let's create a content class that provides `IOrder` and a simple form
that uses it:
>>> import datetime
>>> @interface.implementer(IOrder)
... class Order:
...
... def __init__(self, identifier):
... self.identifier = identifier
... self.name = 'unknown'
... self.min_size = 0.0
... self.max_size = 0.0
...
... now = property(lambda self: datetime.datetime.now())
>>> order = Order(1)
>>> class MyForm:
... form_fields = form.Fields(
... IOrder, omit_readonly=True, render_context=True)
...
... def __init__(self, context, request):
... self.context, self.request = context, request
...
... def __call__(self, ignore_request=False):
... widgets = form.setUpWidgets(
... self.form_fields, 'form', self.context, self.request,
... ignore_request=ignore_request)
...
... return '\n'.join([w() for w in widgets])
>>> print(MyForm(order, request)()) # doctest: +NORMALIZE_WHITESPACE
Invalid floating point data
Note that we didn't get data from the request because we are using all
display widgets.
Passing `ignore_request=True` to the `setUpWidgets` function ignores
the request for all values passed in the data dictionary, in order to
help with redrawing a form after a successful action handler. We'll
fake that quickly by forcing ignore_request to be `True`.
>>> class MyForm(form.Form):
...
... form_fields = form.Fields(IOrder)
... form_fields = form_fields.omit('now')
...
... actions = ()
...
... def setUpWidgets(self, ignore_request=False):
... self.widgets = form.setUpWidgets(
... self.form_fields, self.prefix, self.context, self.request,
... data=dict(identifier=42, name=u'sally'),
... ignore_request=True # =ignore_request
... )
>>> print(MyForm(None, request)()) # doctest: +NORMALIZE_WHITESPACE
42
2005-05-04 '
To set the custom widget factory for a field, assign to the
`custom_widget` attribute of the form field object::
>>> class MyForm(form.Form):
... actions = ()
...
... form_fields = form.Fields(IOrder).select("now")
...
... # Here we set the custom widget:
...
... form_fields["now"].custom_widget = ISODisplayWidget
>>> print(MyForm(None, request)())
2005-05-04
Specifying Fields individually
------------------------------
All of the previous examples set up fields as collections. We can
also set up forms individually and pass them to the Fields
constructor. This is especially useful for passing options that
really only apply to a single field. The previous example can be
written more simply as:
>>> class MyForm(form.Form):
... actions = ()
...
... form_fields = form.Fields(
... form.Field(IOrder['now'], custom_widget=ISODisplayWidget),
... )
>>> print(MyForm(None, request)())
2005-05-04
Computing default values
------------------------
We saw earlier that we could provide initial widget data by passing a
dictionary to setUpWidgets. We can also supply a function or method
name when we set up form fields.
We might like to include the `now` field in our forms. We can provide
a function for getting the needed initial value:
>>> import datetime
>>> class MyForm(form.Form):
... actions = ()
...
... def now(self):
... return datetime.datetime(2002, 12, 2, 12, 30)
...
... form_fields = form.Fields(
... form.Fields(IOrder).omit('now'),
... form.Field(IOrder['now'], get_rendered=now),
... )
>>> print(MyForm(None, request)()) # doctest: +NORMALIZE_WHITESPACE
2002 12 2 12:30:00
Now try the same with the AddFormBase which uses a setUpInputWidget:
>>> class MyAddForm(form.AddFormBase):
... actions = ()
...
... def now(self):
... return datetime.datetime(2002, 12, 2, 12, 30)
...
... form_fields = form.Fields(
... form.Fields(IOrder).omit('now'),
... form.Field(IOrder['now'], get_rendered=now),
... )
...
... def setUpWidgets(self, ignore_request=True):
... super(MyAddForm, self).setUpWidgets(ignore_request)
>>> print(MyAddForm(None, request)()) # doctest: +NORMALIZE_WHITESPACE
Note: If this behavior ever changes, the formlib can be simplified again.
>>> @zope.interface.implementer(IFooBar)
... class FooBar(object):
... title = u'initial'
>>> foobar = FooBar()
>>> class Blah(object):
... def __conform__(self, iface):
... if iface is IFooBar:
... return foobar
>>> blah = Blah()
Let's now generate the form fields and instantiate the widgets:
>>> from zope.formlib import form
>>> form_fields = form.FormFields(IFooBar)
>>> request = TestRequest()
>>> widgets = form.setUpEditWidgets(form_fields, 'form', blah, request)
>>> print(widgets.get('title')())
: ['title']}
The events are annotated with these descriptions. We need a subscriber to log these
infos:
>>> def eventLog(event):
... desc = event.descriptions[0]
... print('Modified:', desc.interface.__identifier__, desc.attributes)
>>> zope.event.subscribers.append(eventLog)
>>> class MyForm(form.EditForm):
... form_fields = form.FormFields(IFooBar)
>>> request = TestRequest()
>>> request.form['form.title'] = u'again modified'
>>> request.form['form.actions.apply'] = u''
>>> MyForm(FooBar(), request)()
Modified: __builtin__.IFooBar ('title',)
...
Cleanup:
>>> zope.event.subscribers.remove(eventLog)
Actions that cause a redirect
-----------------------------
When an action causes a redirect, the following `render` phase is omitted as
the result will not be displayed anyway. This is both a performance
improvement and for avoiding application bugs with one-time session
information.
>>> class MyForm(form.Form):
... form_fields = form.FormFields(IFooBar)
... @form.action("Redirect")
... def redirect(self, action, data):
... print('Action: redirect')
... self.request.response.redirect('foo')
... @form.action("Stay")
... def redirect(self, action, data):
... print('Action: stay')
... pass
... def render(self):
... print('render was called')
... return ''
>>> request = TestRequest()
>>> print(MyForm(None, request)()) # doctest: +NORMALIZE_WHITESPACE
render was called
>>> request.form['form.actions.redirect'] = u''
>>> print(MyForm(None, request)()) # doctest: +NORMALIZE_WHITESPACE
Action: redirect
>>> request = TestRequest()
>>> request.form['form.actions.stay'] = u''
>>> print(MyForm(None, request)()) # doctest: +NORMALIZE_WHITESPACE
Action: stay
render was called
Prevent form submit for GET requests
------------------------------------
It can be useful to only accept form submits over POST requests. This, for
example, prevents replaying data-modifying actions when reloading a page in a
web browser (most web browsers warn users for re-submitting the form when
reloading a page that was the result of a POST request). This also helps (but
is not enough by itself!) in preventing CSRF attacks.
Whenever a form component has set the ``method`` attribute on the class, it
is used when validating the form data.
>>> class MyPOSTForm(form.Form):
... method = 'POST'
...
... form_fields = form.FormFields(IFooBar)
...
... @form.action("Handle")
... def handle(self, action, data):
... print('Action: handle %s' % data)
...
... def render(self):
... return ''
This is a GET request for a form that specifies it can only validate POST
requests::
>>> request = TestRequest()
>>> request.form['form.title'] = u'Submitted Title'
>>> request.form['form.actions.handle'] = u''
>>> MyPOSTForm(None, request)() # doctest: +NORMALIZE_WHITESPACE +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
MethodNotAllowed: None,
By setting the correct request method we validate input::
>>> request = TestRequest()
>>> request.method = 'POST'
>>> request.form['form.title'] = u'Submitted Title'
>>> request.form['form.actions.handle'] = u''
>>> print(MyPOSTForm(None, request)()) # doctest: +NORMALIZE_WHITESPACE
Action: handle {'title': 'Submitted Title'}
Although slightly convoluted, we could require the submit to go over a
GET request::
>>> class MyGETForm(form.Form):
... method = 'GET'
...
... form_fields = form.FormFields(IFooBar)
...
... @form.action("Handle")
... def handle(self, action, data):
... print('Action: handle %s' % data)
...
... def render(self):
... return ''
>>> request = TestRequest()
>>> request.method = 'POST'
>>> request.form['form.actions.handle'] = u''
>>> MyGETForm(None, request)() # doctest: +NORMALIZE_WHITESPACE +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
MethodNotAllowed: None,
>>> request = TestRequest()
>>> request.form['form.title'] = u'Submitted Title'
>>> request.form['form.actions.handle'] = u''
>>> print(MyGETForm(None, request)()) # doctest: +NORMALIZE_WHITESPACE
Action: handle {'title': 'Submitted Title'}
Note how the default value for ``method`` is None, meaning all request
methods are accepted::
>>> class MyForm(form.Form):
... form_fields = form.FormFields(IFooBar)
...
... @form.action("Handle")
... def handle(self, action, data):
... print('Action: handle %s' % data)
...
... def render(self):
... return ''
>>> request = TestRequest()
>>> request.method = 'POST'
>>> request.form['form.title'] = u'Submitted Title'
>>> request.form['form.actions.handle'] = u''
>>> print(MyForm(None, request)()) # doctest: +NORMALIZE_WHITESPACE
Action: handle {'title': 'Submitted Title'}
>>> request = TestRequest()
>>> request.form['form.title'] = u'Submitted Title'
>>> request.form['form.actions.handle'] = u''
>>> print(MyForm(None, request)()) # doctest: +NORMALIZE_WHITESPACE
Action: handle {'title': 'Submitted Title'}
Prevent Cross-site Request Forgery (CSRF) attacks
-------------------------------------------------
See also: http://en.wikipedia.org/wiki/Cross-site_request_forgery.
The CSRF protection in zope.formlib assumes the attacker cannot get hold of
information stored in a cookie that is send to the domain handling the form
submit. zope.formlib verifies that the token as sent with the cookie is
identical to the value as sent with the form (as a hidden input field).
zope.formlib will set a random token in the cookie when first accessing the
form. Any subsequent form rendering and submit handling will use the token
stored in this cookie.
Thus this token is reused for all forms for as long the cookie is available.
The cookie is set to expiry when the web browser quits.
This protection works best when used in combination with the afformentioned
acceptable request method restriction.
Issues to research:
* Is the name "__csrftoken__ acceptable?
* I do not see a scheme for having a token per form without keep server-
side, which I try to avoid.
* One cannot *submit* a form as the very first request to that form, as the
token will not have been set just yet. I think this acceptable.
* Tests for applications that use form components with CSRF protection
enabled, is cumbersome. Can we help that somehow?
* Is using os.urandom() for generating a token sufficient *and*
available cross-platform? Could uuid.uuid4() be an alternative?
When first visting a form, a CSRF token will be set in the cookie::
>>> class MyForm(form.Form):
... protected = True
...
... form_fields = form.FormFields(IFooBar)
...
... @form.action("Handle")
... def handle(self, action, data):
... print('Action: handle %s' % data)
>>> request = TestRequest()
>>> myform = MyForm(None, request)
>>> _ = myform() # "render" the form.
>>> csrfcookie = request.response.getCookie('__csrftoken__')
>>> csrfcookie['httponly']
True
>>> csrftoken = csrfcookie['value']
>>> csrftoken == myform.csrftoken
True
When submitting the form, the token in the cookie (that will be sent
as part of the request) needs to be identical to the value of the
hidden form field "__csrftoken__"::
>>> request = TestRequest(
... **{'HTTP_COOKIE': '__csrftoken__=%s;' % csrftoken})
>>> request.form['form.title'] = 'Submitted title'
>>> request.form['form.actions.handle'] = 'true'
>>> request.form['__csrftoken__'] = csrftoken
>>> myform = MyForm(None, request)
>>> _ = myform()
Action: handle {'title': u'Submitted title'}
If for some reason the cookie is not set, the form will raise an error::
>>> request = TestRequest(**{'HTTP_COOKIE': ''})
>>> request.form['form.title'] = 'Submitted title'
>>> request.form['form.actions.handle'] = 'true'
>>> request.form['__csrftoken__'] = csrftoken
>>> myform = MyForm(None, request)
>>> _ = myform() #doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
InvalidCSRFTokenError: Invalid CSRF token
As an attacker cannot read the cookie value, he can only guess the
corresponding form value, that is hard get right, so most proably wrong::
>>> request = TestRequest(
... **{'HTTP_COOKIE': '__csrftoken__=%s;' % csrftoken})
>>> request.form['form.title'] = 'Submitted title'
>>> request.form['form.actions.handle'] = 'true'
>>> request.form['__csrftoken__'] = 'a guessed value'
>>> myform = MyForm(None, request)
>>> _ = myform() #doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
InvalidCSRFTokenError: Invalid CSRF token
When the form value is missing altogether, the form obviously raises an error
too::
>>> request = TestRequest(
... **{'HTTP_COOKIE': '__csrftoken__=%s;' % csrftoken})
>>> request.form['form.title'] = 'Submitted title'
>>> request.form['form.actions.handle'] = 'true'
>>> myform = MyForm(None, request)
>>> _ = myform() #doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
InvalidCSRFTokenError: Invalid CSRF token
To repeat: this protection works as long as the cookie value is identical to
the submitted form value. No state is kept on the server. We can demonstrate
this by inventing a token value here in the test ourselves::
>>> csrftoken = 'MYNICETOKENVALUE'
>>> request = TestRequest(
... **{'HTTP_COOKIE': '__csrftoken__=%s;' % csrftoken})
>>> request.form['form.title'] = 'Submitted title'
>>> request.form['form.actions.handle'] = 'true'
>>> request.form['__csrftoken__'] = csrftoken
>>> myform = MyForm(None, request)
>>> _ = myform()
Action: handle {'title': u'Submitted title'}
It is possible to have multiple forms in one page. Of course only one of
these forms can be submitted at one point in time, but the CSRF token should
not confuse things::
>>> class FormOne(form.Form):
... prefix = 'form_one'
...
... protected = True
...
... form_fields = form.FormFields(IFooBar)
...
... @form.action("Handle")
... def handle(self, action, data):
... print('Action: handle in Form One')
>>> class FormTwo(form.Form):
... prefix = 'form_two'
...
... protected = True
...
... form_fields = form.FormFields(IFooBar)
...
... @form.action("Handle")
... def handle(self, action, data):
... print('Action: handle in Form Two')
>>> from zope.publisher.browser import BrowserPage
>>> class MultiForm(BrowserPage):
... def __init__(self, context, request):
... self.formone = FormOne(context, request)
... self.formtwo = FormTwo(context, request)
...
... def __call__(self):
... return '\n'.join((self.formone(), self.formtwo()))
...
Render the initial multi form view::
>>> request = TestRequest()
>>> multi = MultiForm(None, request)
>>> result = multi()
>>> print(result)
You are wrong! '
Interface invariant methods raise zope.interface.Invalid exception. Test if
this exception gets handled by the error_views.
>>> myError = Invalid('My error message')
>>> import zope.formlib.form
>>> mybase = zope.formlib.form.FormBase(None, TestRequest())
>>> mybase.errors = (myError,)
>>> save = mybase.error_views()
>>> next(save)
u'My error message '
Now we need to set up the translation framework:
>>> from zope import component, interface
>>> from zope.i18n.interfaces import INegotiator
>>> @interface.implementer(INegotiator)
... class Negotiator:
... def getLanguage(*ignored): return 'test'
>>> component.provideUtility(Negotiator())
>>> from zope.i18n.testmessagecatalog import TestMessageFallbackDomain
>>> component.provideUtility(TestMessageFallbackDomain)
And yes, we can even handle an i18n message in an Invalid exception:
>>> from zope.i18nmessageid import MessageFactory
>>> _ = MessageFactory('my.domain')
>>> myError = Invalid(_('My i18n error message'))
>>> mybase = zope.formlib.form.FormBase(None, TestRequest())
>>> mybase.errors = (myError,)
>>> save = mybase.error_views()
>>> next(save)
u'[[my.domain][My i18n error message]] '
Displaying widget input errors
==============================
WidgetInputError exceptions also work with i18n messages:
>>> from zope.formlib.interfaces import WidgetInputError
>>> myError = WidgetInputError(
... field_name='summary',
... widget_title=_(u'Summary'),
... errors=_(u'Foo'))
>>> mybase = zope.formlib.form.FormBase(None, TestRequest())
>>> mybase.errors = (myError,)
>>> save = mybase.error_views()
>>> next(save)
u'[[my.domain][Summary]]: [[my.domain][Foo]] '
=======
Changes
=======
4.3.0a2 (2013-11-21)
====================
- Support for CSRF protection.
- Added support for restricting the acceptable request method for the
form submit.
4.3.0a1 (2013-02-27)
====================
- Added support for Python 3.3.
4.2.1 (2013-02-22)
==================
- Moved default values for the `BooleanDisplayWidget` from module to class
definition to make them changeable in instance.
4.2.0 (2012-11-27)
==================
- LP #1017884: Add redirect status codes (303, 307) to the set which prevent
form rendering.
- Replaced deprecated ``zope.component.adapts`` usage with equivalent
``zope.component.adapter`` decorator.
- Replaced deprecated ``zope.interface.implements`` usage with equivalent
``zope.interface.implementer`` decorator.
- Dropped support for Python 2.5.
- Make separator of ``SourceSequenceDisplayWidget`` configurable.
4.1.1 (2012-03-16)
==================
- Added `ignoreContext` attribute to form classes to control whether
`checkInvariants` takes the context of the form into account when
checking interface invariants.
By default `ignoreContext` is set to ``False``. On the `AddForm` it is
``True`` by default because the context of this form is naturally not
suitable as context for the interface invariant.
4.1.0 (2012-03-15)
==================
- `checkInvariants` now takes the context of the form into account when
checking interface invariants.
- Tests are no longer compatible with Python 2.4.
4.0.6 (2011-08-20)
==================
- Fixed bug in ``orderedSelectionList.pt`` template.
4.0.5 (2010-09-16)
==================
- Fixed Action name parameter handling, since 4.0.3 all passed names were
lowercased.
4.0.4 (2010-07-06)
==================
- Fixed tests to pass under Python 2.7.
- Fix validation of "multiple" attributes in orderedSelectionList.pt.
4.0.3 (2010-05-06)
==================
- Keep Actions from raising exceptions when passed Unicode lables [LP:528468].
- Improve display of the "nothing selected" case for optional Choice fields
[LP:269782].
- Improve truth testing for ItemDisplayWidget [LP:159232].
- Don't blow up if TypeError raised during token conversion [LP:98491].
4.0.2 (2010-03-07)
==================
- Adapted tests for Python 2.4 (enforce sorting for short pprint output)
4.0.1 (2010-02-21)
==================
- Documentation uploaded to PyPI now contains widget documentation.
- Escape MultiCheckBoxWidget content [LP:302427].
4.0 (2010-01-08)
================
- Widget implementation and all widgets from zope.app.form have been
moved into zope.formlib, breaking zope.formlib's dependency on
zope.app.form (instead zope.app.form now depends on zope.formlib).
Widgets can all be imported from ``zope.formlib.widgets``.
Widget base classes and render functionality is in
``zope.formlib.widget``.
All relevant widget interfaces are now in ``zope.formlib.interfaces``.
3.10.0 (2009-12-22)
===================
- Use named template from zope.browserpage in favor of zope.app.pagetemplate.
3.9.0 (2009-12-22)
==================
- Use ViewPageTemplateFile from zope.browserpage.
3.8.0 (2009-12-22)
==================
- Adjusted test output to new zope.schema release.
3.7.0 (2009-12-18)
==================
- Rid ourselves from zope.app test dependencies.
- Fix: Button label needs escaping
3.6.0 (2009-05-18)
==================
- Remove deprecated imports.
- Remove dependency on zope.app.container (use ``IAdding`` from
``zope.browser.interfaces``) instead. Depend on
``zope.browser>=1.1`` (the version with ``IAdding``).
- Moved ``namedtemplate`` to ``zope.app.pagetemplate``, to cut some
dependencies on ``zope.formlib`` when using this feature. Left BBB
imports here.
3.5.2 (2009-02-21)
==================
- Adapt tests for Python 2.5 output.
3.5.1 (2009-01-31)
==================
- Adapt tests to upcoming zope.schema release 3.5.1.
3.5.0 (2009-01-26)
==================
New Features
------------
- Test dependencies are declared in a `test` extra now.
- Introduced ``zope.formlib.form.applyData`` which works like
``applyChanges`` but returns a dictionary with information about
which attribute of which schema changed. This information is then
sent along with the ``IObjectModifiedEvent``.
This fixes https://bugs.launchpad.net/zope3/+bug/98483.
Bugs Fixed
----------
- Actions that cause a redirect (301, 302) do not cause the `render` method to
be called anymore.
- The zope.formlib.form.Action class didn't fully implement
zope.formlib.interfaces.IAction.
- zope.formlib.form.setupWidgets and zope.formlib.form.setupEditWidgets did
not check for write access on the adapter but on context. This fixes
https://bugs.launchpad.net/zope3/+bug/219948
3.4.0 (2007-09-28)
==================
No further changes since 3.4.0a1.
3.4.0a1 (2007-04-22)
====================
Initial release as a separate project, corresponds to zope.formlib
from Zope 3.4.0a1
Keywords: zope3 form widget
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Environment :: Web Environment
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: Zope Public License
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.6
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: Implementation :: CPython
Classifier: Natural Language :: English
Classifier: Operating System :: OS Independent
Classifier: Topic :: Internet :: WWW/HTTP
Classifier: Framework :: Zope3
zope.formlib-4.3.0a2/src/zope.formlib.egg-info/not-zip-safe 0000664 0000000 0000000 00000000001 12243456432 022171 0 ustar root root
zope.formlib-4.3.0a2/setup.cfg 0000664 0000000 0000000 00000000073 12243456452 014677 0 ustar root root [egg_info]
tag_build =
tag_date = 0
tag_svn_revision = 0
zope.formlib-4.3.0a2/COPYRIGHT.txt 0000664 0000000 0000000 00000000040 12243456432 015157 0 ustar root root Zope Foundation and Contributors zope.formlib-4.3.0a2/MANIFEST.in 0000664 0000000 0000000 00000000246 12243456432 014614 0 ustar root root include *.rst
include *.txt
include *.py
include buildout.cfg
include tox.ini
recursive-include src *
global-exclude *.pyc
global-exclude *.so
global-exclude *.dll
zope.formlib-4.3.0a2/PKG-INFO 0000664 0000000 0000000 00000351245 12243456452 014165 0 ustar root root Metadata-Version: 1.1
Name: zope.formlib
Version: 4.3.0a2
Summary: Form generation and validation library for Zope
Home-page: http://pypi.python.org/pypi/zope.formlib
Author: Zope Foundation and Contributors
Author-email: zope-dev@zope.org
License: ZPL 2.1
Description: .. contents::
========
Overview
========
Forms are web components that use widgets to display and input data.
Typically a template displays the widgets by accessing an attribute or
method on an underlying class.
=====
Forms
=====
Forms are web components that use widgets to display and input data.
Typically a template displays the widgets by accessing an attribute or
method on an underlying class.
This document describes some tools to assist in form development. In
the examples, we will show "forms" that are generated with simple
print statements to keep the examples simpler. Most forms will use
templates in practice.
This document starts with low-level APIs. We eventually build up to
higher-level APIs that allow forms to be defined with just a little bit
of meta data. Impatient readers may wish to skip to the later
sections, especially the section on `Helpful base classes`_. :)
A form class can define ordered collections of "form fields" using
the `Fields` constructor. Form fields are distinct from and build on
schema fields. A schema field specified attribute values. Form
fields specify how a schema field should be used in a form. The
simplest way to define a collection of form fields is by passing a
schema to the `Fields` constructor:
>>> from zope import interface, schema
>>> class IOrder(interface.Interface):
... identifier = schema.Int(title=u"Identifier", readonly=True)
... name = schema.TextLine(title=u"Name")
... min_size = schema.Float(title=u"Minimum size")
... max_size = schema.Float(title=u"Maximum size")
... color = schema.TextLine(title=u"Color", required=False)
... now = schema.Datetime(title=u"Now", readonly=True)
>>> from zope.formlib import form
>>> class MyForm:
... form_fields = form.Fields(IOrder)
This sets up a set of form fields from the interface, IOrder.
>>> len(MyForm.form_fields)
6
>>> [w.__name__ for w in MyForm.form_fields]
['identifier', 'name', 'min_size', 'max_size', 'color', 'now']
We can access individual form fields by name:
>>> MyForm.form_fields['name'].__name__
'name'
We can also select and order subsets using the select method of form fields:
>>> [w.__name__ for w in MyForm.form_fields.select('name', 'identifier')]
['name', 'identifier']
or by omitting fields:
>>> [w.__name__ for w in MyForm.form_fields.omit('now', 'identifier')]
['name', 'min_size', 'max_size', 'color']
We can omit read-only fields using the omit_readonly option when
setting up the fields:
>>> class MyForm:
... form_fields = form.Fields(IOrder, omit_readonly=True)
>>> [w.__name__ for w in MyForm.form_fields]
['name', 'min_size', 'max_size', 'color']
Getting HTML
============
Having defined form fields, we can use them to generate HTML
forms. Typically, this is done at run time by form class
instances. Let's look at an example that displays some input widgets:
>>> class MyForm:
... form_fields = form.Fields(IOrder, omit_readonly=True)
...
... def __init__(self, context, request):
... self.context, self.request = context, request
...
... def __call__(self, ignore_request=False):
... widgets = form.setUpWidgets(
... self.form_fields, 'form', self.context, self.request,
... ignore_request=ignore_request)
... return '\n'.join([w() for w in widgets])
Here we used ``form.setUpWidgets`` to create widget instances from our
form-field specifications. The second argument to ``setUpWidgets`` is a
form prefix. All of the widgets on this form are given the same
prefix. This allows multiple forms to be used within a single form
tag, assuming that each form uses a different form prefix.
Now, we can display the form:
>>> from zope.publisher.browser import TestRequest
>>> request = TestRequest()
>>> print(MyForm(None, request)()) # doctest: +NORMALIZE_WHITESPACE
Required input is missing.
Required input is missing.
Invalid floating point data
Required input is missing.
Required input is missing.
Required input is missing.
Required input is missing.
{'min_size': 42.0}
Edit Forms
==========
A common application of forms is edit forms. Edit forms are special
in 2 ways:
- We want to get the initial data for widgets from the object being
edited.
- If there are no errors, we want to apply the changes back to the
object being edited.
The form package provides some functions to assist with creating edit
forms. When we set up our form_fields, we use the `render_context`
option, which uses data from the context passed to setUpWidgets.
Let's create a content class that provides `IOrder` and a simple form
that uses it:
>>> import datetime
>>> @interface.implementer(IOrder)
... class Order:
...
... def __init__(self, identifier):
... self.identifier = identifier
... self.name = 'unknown'
... self.min_size = 0.0
... self.max_size = 0.0
...
... now = property(lambda self: datetime.datetime.now())
>>> order = Order(1)
>>> class MyForm:
... form_fields = form.Fields(
... IOrder, omit_readonly=True, render_context=True)
...
... def __init__(self, context, request):
... self.context, self.request = context, request
...
... def __call__(self, ignore_request=False):
... widgets = form.setUpWidgets(
... self.form_fields, 'form', self.context, self.request,
... ignore_request=ignore_request)
...
... return '\n'.join([w() for w in widgets])
>>> print(MyForm(order, request)()) # doctest: +NORMALIZE_WHITESPACE
Invalid floating point data
Note that we didn't get data from the request because we are using all
display widgets.
Passing `ignore_request=True` to the `setUpWidgets` function ignores
the request for all values passed in the data dictionary, in order to
help with redrawing a form after a successful action handler. We'll
fake that quickly by forcing ignore_request to be `True`.
>>> class MyForm(form.Form):
...
... form_fields = form.Fields(IOrder)
... form_fields = form_fields.omit('now')
...
... actions = ()
...
... def setUpWidgets(self, ignore_request=False):
... self.widgets = form.setUpWidgets(
... self.form_fields, self.prefix, self.context, self.request,
... data=dict(identifier=42, name=u'sally'),
... ignore_request=True # =ignore_request
... )
>>> print(MyForm(None, request)()) # doctest: +NORMALIZE_WHITESPACE
42
2005-05-04 '
To set the custom widget factory for a field, assign to the
`custom_widget` attribute of the form field object::
>>> class MyForm(form.Form):
... actions = ()
...
... form_fields = form.Fields(IOrder).select("now")
...
... # Here we set the custom widget:
...
... form_fields["now"].custom_widget = ISODisplayWidget
>>> print(MyForm(None, request)())
2005-05-04
Specifying Fields individually
------------------------------
All of the previous examples set up fields as collections. We can
also set up forms individually and pass them to the Fields
constructor. This is especially useful for passing options that
really only apply to a single field. The previous example can be
written more simply as:
>>> class MyForm(form.Form):
... actions = ()
...
... form_fields = form.Fields(
... form.Field(IOrder['now'], custom_widget=ISODisplayWidget),
... )
>>> print(MyForm(None, request)())
2005-05-04
Computing default values
------------------------
We saw earlier that we could provide initial widget data by passing a
dictionary to setUpWidgets. We can also supply a function or method
name when we set up form fields.
We might like to include the `now` field in our forms. We can provide
a function for getting the needed initial value:
>>> import datetime
>>> class MyForm(form.Form):
... actions = ()
...
... def now(self):
... return datetime.datetime(2002, 12, 2, 12, 30)
...
... form_fields = form.Fields(
... form.Fields(IOrder).omit('now'),
... form.Field(IOrder['now'], get_rendered=now),
... )
>>> print(MyForm(None, request)()) # doctest: +NORMALIZE_WHITESPACE
2002 12 2 12:30:00
Now try the same with the AddFormBase which uses a setUpInputWidget:
>>> class MyAddForm(form.AddFormBase):
... actions = ()
...
... def now(self):
... return datetime.datetime(2002, 12, 2, 12, 30)
...
... form_fields = form.Fields(
... form.Fields(IOrder).omit('now'),
... form.Field(IOrder['now'], get_rendered=now),
... )
...
... def setUpWidgets(self, ignore_request=True):
... super(MyAddForm, self).setUpWidgets(ignore_request)
>>> print(MyAddForm(None, request)()) # doctest: +NORMALIZE_WHITESPACE
Note: If this behavior ever changes, the formlib can be simplified again.
>>> @zope.interface.implementer(IFooBar)
... class FooBar(object):
... title = u'initial'
>>> foobar = FooBar()
>>> class Blah(object):
... def __conform__(self, iface):
... if iface is IFooBar:
... return foobar
>>> blah = Blah()
Let's now generate the form fields and instantiate the widgets:
>>> from zope.formlib import form
>>> form_fields = form.FormFields(IFooBar)
>>> request = TestRequest()
>>> widgets = form.setUpEditWidgets(form_fields, 'form', blah, request)
>>> print(widgets.get('title')())
: ['title']}
The events are annotated with these descriptions. We need a subscriber to log these
infos:
>>> def eventLog(event):
... desc = event.descriptions[0]
... print('Modified:', desc.interface.__identifier__, desc.attributes)
>>> zope.event.subscribers.append(eventLog)
>>> class MyForm(form.EditForm):
... form_fields = form.FormFields(IFooBar)
>>> request = TestRequest()
>>> request.form['form.title'] = u'again modified'
>>> request.form['form.actions.apply'] = u''
>>> MyForm(FooBar(), request)()
Modified: __builtin__.IFooBar ('title',)
...
Cleanup:
>>> zope.event.subscribers.remove(eventLog)
Actions that cause a redirect
-----------------------------
When an action causes a redirect, the following `render` phase is omitted as
the result will not be displayed anyway. This is both a performance
improvement and for avoiding application bugs with one-time session
information.
>>> class MyForm(form.Form):
... form_fields = form.FormFields(IFooBar)
... @form.action("Redirect")
... def redirect(self, action, data):
... print('Action: redirect')
... self.request.response.redirect('foo')
... @form.action("Stay")
... def redirect(self, action, data):
... print('Action: stay')
... pass
... def render(self):
... print('render was called')
... return ''
>>> request = TestRequest()
>>> print(MyForm(None, request)()) # doctest: +NORMALIZE_WHITESPACE
render was called
>>> request.form['form.actions.redirect'] = u''
>>> print(MyForm(None, request)()) # doctest: +NORMALIZE_WHITESPACE
Action: redirect
>>> request = TestRequest()
>>> request.form['form.actions.stay'] = u''
>>> print(MyForm(None, request)()) # doctest: +NORMALIZE_WHITESPACE
Action: stay
render was called
Prevent form submit for GET requests
------------------------------------
It can be useful to only accept form submits over POST requests. This, for
example, prevents replaying data-modifying actions when reloading a page in a
web browser (most web browsers warn users for re-submitting the form when
reloading a page that was the result of a POST request). This also helps (but
is not enough by itself!) in preventing CSRF attacks.
Whenever a form component has set the ``method`` attribute on the class, it
is used when validating the form data.
>>> class MyPOSTForm(form.Form):
... method = 'POST'
...
... form_fields = form.FormFields(IFooBar)
...
... @form.action("Handle")
... def handle(self, action, data):
... print('Action: handle %s' % data)
...
... def render(self):
... return ''
This is a GET request for a form that specifies it can only validate POST
requests::
>>> request = TestRequest()
>>> request.form['form.title'] = u'Submitted Title'
>>> request.form['form.actions.handle'] = u''
>>> MyPOSTForm(None, request)() # doctest: +NORMALIZE_WHITESPACE +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
MethodNotAllowed: None,
By setting the correct request method we validate input::
>>> request = TestRequest()
>>> request.method = 'POST'
>>> request.form['form.title'] = u'Submitted Title'
>>> request.form['form.actions.handle'] = u''
>>> print(MyPOSTForm(None, request)()) # doctest: +NORMALIZE_WHITESPACE
Action: handle {'title': 'Submitted Title'}
Although slightly convoluted, we could require the submit to go over a
GET request::
>>> class MyGETForm(form.Form):
... method = 'GET'
...
... form_fields = form.FormFields(IFooBar)
...
... @form.action("Handle")
... def handle(self, action, data):
... print('Action: handle %s' % data)
...
... def render(self):
... return ''
>>> request = TestRequest()
>>> request.method = 'POST'
>>> request.form['form.actions.handle'] = u''
>>> MyGETForm(None, request)() # doctest: +NORMALIZE_WHITESPACE +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
MethodNotAllowed: None,
>>> request = TestRequest()
>>> request.form['form.title'] = u'Submitted Title'
>>> request.form['form.actions.handle'] = u''
>>> print(MyGETForm(None, request)()) # doctest: +NORMALIZE_WHITESPACE
Action: handle {'title': 'Submitted Title'}
Note how the default value for ``method`` is None, meaning all request
methods are accepted::
>>> class MyForm(form.Form):
... form_fields = form.FormFields(IFooBar)
...
... @form.action("Handle")
... def handle(self, action, data):
... print('Action: handle %s' % data)
...
... def render(self):
... return ''
>>> request = TestRequest()
>>> request.method = 'POST'
>>> request.form['form.title'] = u'Submitted Title'
>>> request.form['form.actions.handle'] = u''
>>> print(MyForm(None, request)()) # doctest: +NORMALIZE_WHITESPACE
Action: handle {'title': 'Submitted Title'}
>>> request = TestRequest()
>>> request.form['form.title'] = u'Submitted Title'
>>> request.form['form.actions.handle'] = u''
>>> print(MyForm(None, request)()) # doctest: +NORMALIZE_WHITESPACE
Action: handle {'title': 'Submitted Title'}
Prevent Cross-site Request Forgery (CSRF) attacks
-------------------------------------------------
See also: http://en.wikipedia.org/wiki/Cross-site_request_forgery.
The CSRF protection in zope.formlib assumes the attacker cannot get hold of
information stored in a cookie that is send to the domain handling the form
submit. zope.formlib verifies that the token as sent with the cookie is
identical to the value as sent with the form (as a hidden input field).
zope.formlib will set a random token in the cookie when first accessing the
form. Any subsequent form rendering and submit handling will use the token
stored in this cookie.
Thus this token is reused for all forms for as long the cookie is available.
The cookie is set to expiry when the web browser quits.
This protection works best when used in combination with the afformentioned
acceptable request method restriction.
Issues to research:
* Is the name "__csrftoken__ acceptable?
* I do not see a scheme for having a token per form without keep server-
side, which I try to avoid.
* One cannot *submit* a form as the very first request to that form, as the
token will not have been set just yet. I think this acceptable.
* Tests for applications that use form components with CSRF protection
enabled, is cumbersome. Can we help that somehow?
* Is using os.urandom() for generating a token sufficient *and*
available cross-platform? Could uuid.uuid4() be an alternative?
When first visting a form, a CSRF token will be set in the cookie::
>>> class MyForm(form.Form):
... protected = True
...
... form_fields = form.FormFields(IFooBar)
...
... @form.action("Handle")
... def handle(self, action, data):
... print('Action: handle %s' % data)
>>> request = TestRequest()
>>> myform = MyForm(None, request)
>>> _ = myform() # "render" the form.
>>> csrfcookie = request.response.getCookie('__csrftoken__')
>>> csrfcookie['httponly']
True
>>> csrftoken = csrfcookie['value']
>>> csrftoken == myform.csrftoken
True
When submitting the form, the token in the cookie (that will be sent
as part of the request) needs to be identical to the value of the
hidden form field "__csrftoken__"::
>>> request = TestRequest(
... **{'HTTP_COOKIE': '__csrftoken__=%s;' % csrftoken})
>>> request.form['form.title'] = 'Submitted title'
>>> request.form['form.actions.handle'] = 'true'
>>> request.form['__csrftoken__'] = csrftoken
>>> myform = MyForm(None, request)
>>> _ = myform()
Action: handle {'title': u'Submitted title'}
If for some reason the cookie is not set, the form will raise an error::
>>> request = TestRequest(**{'HTTP_COOKIE': ''})
>>> request.form['form.title'] = 'Submitted title'
>>> request.form['form.actions.handle'] = 'true'
>>> request.form['__csrftoken__'] = csrftoken
>>> myform = MyForm(None, request)
>>> _ = myform() #doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
InvalidCSRFTokenError: Invalid CSRF token
As an attacker cannot read the cookie value, he can only guess the
corresponding form value, that is hard get right, so most proably wrong::
>>> request = TestRequest(
... **{'HTTP_COOKIE': '__csrftoken__=%s;' % csrftoken})
>>> request.form['form.title'] = 'Submitted title'
>>> request.form['form.actions.handle'] = 'true'
>>> request.form['__csrftoken__'] = 'a guessed value'
>>> myform = MyForm(None, request)
>>> _ = myform() #doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
InvalidCSRFTokenError: Invalid CSRF token
When the form value is missing altogether, the form obviously raises an error
too::
>>> request = TestRequest(
... **{'HTTP_COOKIE': '__csrftoken__=%s;' % csrftoken})
>>> request.form['form.title'] = 'Submitted title'
>>> request.form['form.actions.handle'] = 'true'
>>> myform = MyForm(None, request)
>>> _ = myform() #doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
InvalidCSRFTokenError: Invalid CSRF token
To repeat: this protection works as long as the cookie value is identical to
the submitted form value. No state is kept on the server. We can demonstrate
this by inventing a token value here in the test ourselves::
>>> csrftoken = 'MYNICETOKENVALUE'
>>> request = TestRequest(
... **{'HTTP_COOKIE': '__csrftoken__=%s;' % csrftoken})
>>> request.form['form.title'] = 'Submitted title'
>>> request.form['form.actions.handle'] = 'true'
>>> request.form['__csrftoken__'] = csrftoken
>>> myform = MyForm(None, request)
>>> _ = myform()
Action: handle {'title': u'Submitted title'}
It is possible to have multiple forms in one page. Of course only one of
these forms can be submitted at one point in time, but the CSRF token should
not confuse things::
>>> class FormOne(form.Form):
... prefix = 'form_one'
...
... protected = True
...
... form_fields = form.FormFields(IFooBar)
...
... @form.action("Handle")
... def handle(self, action, data):
... print('Action: handle in Form One')
>>> class FormTwo(form.Form):
... prefix = 'form_two'
...
... protected = True
...
... form_fields = form.FormFields(IFooBar)
...
... @form.action("Handle")
... def handle(self, action, data):
... print('Action: handle in Form Two')
>>> from zope.publisher.browser import BrowserPage
>>> class MultiForm(BrowserPage):
... def __init__(self, context, request):
... self.formone = FormOne(context, request)
... self.formtwo = FormTwo(context, request)
...
... def __call__(self):
... return '\n'.join((self.formone(), self.formtwo()))
...
Render the initial multi form view::
>>> request = TestRequest()
>>> multi = MultiForm(None, request)
>>> result = multi()
>>> print(result)
You are wrong! '
Interface invariant methods raise zope.interface.Invalid exception. Test if
this exception gets handled by the error_views.
>>> myError = Invalid('My error message')
>>> import zope.formlib.form
>>> mybase = zope.formlib.form.FormBase(None, TestRequest())
>>> mybase.errors = (myError,)
>>> save = mybase.error_views()
>>> next(save)
u'My error message '
Now we need to set up the translation framework:
>>> from zope import component, interface
>>> from zope.i18n.interfaces import INegotiator
>>> @interface.implementer(INegotiator)
... class Negotiator:
... def getLanguage(*ignored): return 'test'
>>> component.provideUtility(Negotiator())
>>> from zope.i18n.testmessagecatalog import TestMessageFallbackDomain
>>> component.provideUtility(TestMessageFallbackDomain)
And yes, we can even handle an i18n message in an Invalid exception:
>>> from zope.i18nmessageid import MessageFactory
>>> _ = MessageFactory('my.domain')
>>> myError = Invalid(_('My i18n error message'))
>>> mybase = zope.formlib.form.FormBase(None, TestRequest())
>>> mybase.errors = (myError,)
>>> save = mybase.error_views()
>>> next(save)
u'[[my.domain][My i18n error message]] '
Displaying widget input errors
==============================
WidgetInputError exceptions also work with i18n messages:
>>> from zope.formlib.interfaces import WidgetInputError
>>> myError = WidgetInputError(
... field_name='summary',
... widget_title=_(u'Summary'),
... errors=_(u'Foo'))
>>> mybase = zope.formlib.form.FormBase(None, TestRequest())
>>> mybase.errors = (myError,)
>>> save = mybase.error_views()
>>> next(save)
u'[[my.domain][Summary]]: [[my.domain][Foo]] '
=======
Changes
=======
4.3.0a2 (2013-11-21)
====================
- Support for CSRF protection.
- Added support for restricting the acceptable request method for the
form submit.
4.3.0a1 (2013-02-27)
====================
- Added support for Python 3.3.
4.2.1 (2013-02-22)
==================
- Moved default values for the `BooleanDisplayWidget` from module to class
definition to make them changeable in instance.
4.2.0 (2012-11-27)
==================
- LP #1017884: Add redirect status codes (303, 307) to the set which prevent
form rendering.
- Replaced deprecated ``zope.component.adapts`` usage with equivalent
``zope.component.adapter`` decorator.
- Replaced deprecated ``zope.interface.implements`` usage with equivalent
``zope.interface.implementer`` decorator.
- Dropped support for Python 2.5.
- Make separator of ``SourceSequenceDisplayWidget`` configurable.
4.1.1 (2012-03-16)
==================
- Added `ignoreContext` attribute to form classes to control whether
`checkInvariants` takes the context of the form into account when
checking interface invariants.
By default `ignoreContext` is set to ``False``. On the `AddForm` it is
``True`` by default because the context of this form is naturally not
suitable as context for the interface invariant.
4.1.0 (2012-03-15)
==================
- `checkInvariants` now takes the context of the form into account when
checking interface invariants.
- Tests are no longer compatible with Python 2.4.
4.0.6 (2011-08-20)
==================
- Fixed bug in ``orderedSelectionList.pt`` template.
4.0.5 (2010-09-16)
==================
- Fixed Action name parameter handling, since 4.0.3 all passed names were
lowercased.
4.0.4 (2010-07-06)
==================
- Fixed tests to pass under Python 2.7.
- Fix validation of "multiple" attributes in orderedSelectionList.pt.
4.0.3 (2010-05-06)
==================
- Keep Actions from raising exceptions when passed Unicode lables [LP:528468].
- Improve display of the "nothing selected" case for optional Choice fields
[LP:269782].
- Improve truth testing for ItemDisplayWidget [LP:159232].
- Don't blow up if TypeError raised during token conversion [LP:98491].
4.0.2 (2010-03-07)
==================
- Adapted tests for Python 2.4 (enforce sorting for short pprint output)
4.0.1 (2010-02-21)
==================
- Documentation uploaded to PyPI now contains widget documentation.
- Escape MultiCheckBoxWidget content [LP:302427].
4.0 (2010-01-08)
================
- Widget implementation and all widgets from zope.app.form have been
moved into zope.formlib, breaking zope.formlib's dependency on
zope.app.form (instead zope.app.form now depends on zope.formlib).
Widgets can all be imported from ``zope.formlib.widgets``.
Widget base classes and render functionality is in
``zope.formlib.widget``.
All relevant widget interfaces are now in ``zope.formlib.interfaces``.
3.10.0 (2009-12-22)
===================
- Use named template from zope.browserpage in favor of zope.app.pagetemplate.
3.9.0 (2009-12-22)
==================
- Use ViewPageTemplateFile from zope.browserpage.
3.8.0 (2009-12-22)
==================
- Adjusted test output to new zope.schema release.
3.7.0 (2009-12-18)
==================
- Rid ourselves from zope.app test dependencies.
- Fix: Button label needs escaping
3.6.0 (2009-05-18)
==================
- Remove deprecated imports.
- Remove dependency on zope.app.container (use ``IAdding`` from
``zope.browser.interfaces``) instead. Depend on
``zope.browser>=1.1`` (the version with ``IAdding``).
- Moved ``namedtemplate`` to ``zope.app.pagetemplate``, to cut some
dependencies on ``zope.formlib`` when using this feature. Left BBB
imports here.
3.5.2 (2009-02-21)
==================
- Adapt tests for Python 2.5 output.
3.5.1 (2009-01-31)
==================
- Adapt tests to upcoming zope.schema release 3.5.1.
3.5.0 (2009-01-26)
==================
New Features
------------
- Test dependencies are declared in a `test` extra now.
- Introduced ``zope.formlib.form.applyData`` which works like
``applyChanges`` but returns a dictionary with information about
which attribute of which schema changed. This information is then
sent along with the ``IObjectModifiedEvent``.
This fixes https://bugs.launchpad.net/zope3/+bug/98483.
Bugs Fixed
----------
- Actions that cause a redirect (301, 302) do not cause the `render` method to
be called anymore.
- The zope.formlib.form.Action class didn't fully implement
zope.formlib.interfaces.IAction.
- zope.formlib.form.setupWidgets and zope.formlib.form.setupEditWidgets did
not check for write access on the adapter but on context. This fixes
https://bugs.launchpad.net/zope3/+bug/219948
3.4.0 (2007-09-28)
==================
No further changes since 3.4.0a1.
3.4.0a1 (2007-04-22)
====================
Initial release as a separate project, corresponds to zope.formlib
from Zope 3.4.0a1
Keywords: zope3 form widget
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Environment :: Web Environment
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: Zope Public License
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.6
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: Implementation :: CPython
Classifier: Natural Language :: English
Classifier: Operating System :: OS Independent
Classifier: Topic :: Internet :: WWW/HTTP
Classifier: Framework :: Zope3
zope.formlib-4.3.0a2/LICENSE.txt 0000664 0000000 0000000 00000004026 12243456432 014701 0 ustar root root Zope Public License (ZPL) Version 2.1
A copyright notice accompanies this license document that identifies the
copyright holders.
This license has been certified as open source. It has also been designated as
GPL compatible by the Free Software Foundation (FSF).
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions in source code must retain the accompanying copyright
notice, this list of conditions, and the following disclaimer.
2. Redistributions in binary form must reproduce the accompanying copyright
notice, this list of conditions, and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Names of the copyright holders must not be used to endorse or promote
products derived from this software without prior written permission from the
copyright holders.
4. The right to distribute this software or to use it for any purpose does not
give you the right to use Servicemarks (sm) or Trademarks (tm) of the
copyright
holders. Use of them is covered by separate agreement with the copyright
holders.
5. If any files are modified, you must cause the modified files to carry
prominent notices stating that you changed the files and the date of any
change.
Disclaimer
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY EXPRESSED
OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
zope.formlib-4.3.0a2/README.txt 0000664 0000000 0000000 00000000326 12243456432 014553 0 ustar root root .. contents::
========
Overview
========
Forms are web components that use widgets to display and input data.
Typically a template displays the widgets by accessing an attribute or
method on an underlying class.
zope.formlib-4.3.0a2/setup.py 0000664 0000000 0000000 00000010043 12243456432 014564 0 ustar root root ##############################################################################
#
# Copyright (c) 2006-2009 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.
#
##############################################################################
# This package is developed by the Zope Toolkit project, documented here:
# http://docs.zope.org/zopetoolkit
# When developing and releasing this package, please follow the documented
# Zope Toolkit policies as described by this documentation.
##############################################################################
"""Setup for zope.formlib package
"""
import os
from setuptools import setup, find_packages
def read(*rnames):
return open(os.path.join(os.path.dirname(__file__), *rnames)).read()
def alltests():
import os
import sys
import unittest
# use the zope.testrunner machinery to find all the
# test suites we've put under ourselves
import zope.testrunner.find
import zope.testrunner.options
here = os.path.abspath(os.path.join(os.path.dirname(__file__), 'src'))
args = sys.argv[:]
defaults = ["--test-path", here]
options = zope.testrunner.options.get_options(args, defaults)
suites = list(zope.testrunner.find.find_suites(options))
return unittest.TestSuite(suites)
setup(name='zope.formlib',
version='4.3.0a2',
author='Zope Foundation and Contributors',
author_email='zope-dev@zope.org',
description='Form generation and validation library for Zope',
long_description=(read('README.txt')
+ '\n\n' +
read('src', 'zope', 'formlib', 'form.txt')
+ '\n\n' +
read('src', 'zope', 'formlib', 'widgets.txt')
+ '\n\n' +
read('src', 'zope', 'formlib', 'errors.txt')
+ '\n\n' +
read('CHANGES.txt')
),
license='ZPL 2.1',
keywords="zope3 form widget",
classifiers=[
'Development Status :: 5 - Production/Stable',
'Environment :: Web Environment',
'Intended Audience :: Developers',
'License :: OSI Approved :: Zope Public License',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: Implementation :: CPython',
'Natural Language :: English',
'Operating System :: OS Independent',
'Topic :: Internet :: WWW/HTTP',
'Framework :: Zope3',
],
url='http://pypi.python.org/pypi/zope.formlib',
packages=find_packages('src'),
package_dir = {'': 'src'},
namespace_packages=['zope',],
extras_require=dict(
test=['zope.configuration',
'zope.testing',
]
),
install_requires=[
'setuptools',
'pytz',
'zope.browser>=1.1',
'zope.browserpage>=3.11.0',
'zope.component',
'zope.event',
'zope.i18n',
'zope.i18nmessageid',
'zope.interface',
'zope.lifecycleevent',
'zope.publisher',
'zope.schema>=3.5.1',
'zope.security',
'zope.traversing',
'zope.datetime',
],
tests_require = [
'zope.configuration',
'zope.testing',
'zope.testrunner',
],
test_suite = '__main__.alltests',
include_package_data = True,
zip_safe = False,
)