def test_read_multiple(self):
        field_node1 = etree.Element('field')
        field_node1.set(ns("widget", self.namespace),
                        "z3c.form.browser.password.PasswordFieldWidget")
        field_node1.set(ns("mode", self.namespace), "hidden")
        field_node1.set(ns("omitted", self.namespace), "true")
        field_node1.set(ns("before", self.namespace), "somefield")

        field_node2 = etree.Element('field')
        field_node2.set(ns("mode", self.namespace), "display")
        field_node2.set(ns("omitted", self.namespace), "yes")

        class IDummy(Interface):
            dummy1 = zope.schema.TextLine(title=u"dummy1")
            dummy2 = zope.schema.TextLine(title=u"dummy2")

        handler = FormSchema()
        handler.read(field_node1, IDummy, IDummy['dummy1'])
        handler.read(field_node2, IDummy, IDummy['dummy2'])

        self.assertEquals(
            {'dummy1': 'z3c.form.browser.password.PasswordFieldWidget'},
            IDummy.getTaggedValue(WIDGETS_KEY))
        self.assertEquals([(Interface, 'dummy1', 'true'),
                           (Interface, 'dummy2', 'yes')],
                          IDummy.getTaggedValue(OMITTED_KEY))
        self.assertEquals([(Interface, 'dummy1', 'hidden'),
                           (Interface, 'dummy2', 'display')],
                          IDummy.getTaggedValue(MODES_KEY))
        self.assertEquals([(
            'dummy1',
            'before',
            'somefield',
        )], IDummy.getTaggedValue(ORDER_KEY))
    def test_read_parameterized_widget_default(self):
        from plone.autoform.widgets import ParameterizedWidget

        param_node = etree.Element('klass')
        param_node.text = 'custom'
        param2_node = etree.Element('placeholder')
        param2_node.text = 'help'
        widget_node = etree.Element(ns('widget', self.namespace))
        widget_node.append(param_node)
        widget_node.append(param2_node)
        field_node = etree.Element('field')
        field_node.append(widget_node)

        class IDummy(Interface):
            foo = zope.schema.TextLine(title=u'foo')

        handler = FormSchema()
        handler.read(field_node, IDummy, IDummy['foo'])

        widgets = IDummy.queryTaggedValue(WIDGETS_KEY)
        self.assertTrue(isinstance(widgets['foo'], ParameterizedWidget))
        self.assertTrue(widgets['foo'].widget_factory is None)
        self.assertIn('klass', widgets['foo'].params)
        self.assertEqual(widgets['foo'].params['klass'], 'custom')
        self.assertIn('placeholder', widgets['foo'].params)
        self.assertEqual(widgets['foo'].params['placeholder'], 'help')
    def test_read(self):
        field_node = etree.Element('field')
        field_node.set(ns("widget", self.namespace),
                       "z3c.form.browser.password.PasswordFieldWidget")
        field_node.set(ns("mode", self.namespace), "hidden")
        field_node.set(ns("omitted", self.namespace), "true")
        field_node.set(ns("before", self.namespace), "somefield")
        field_node.set(ns("validator", self.namespace),
                       "plone.autoform.tests.test_utils.TestValidator")

        class IDummy(Interface):
            dummy = zope.schema.TextLine(title=u"dummy")

        handler = FormSchema()
        handler.read(field_node, IDummy, IDummy['dummy'])

        self.assertEquals(
            {'dummy': 'z3c.form.browser.password.PasswordFieldWidget'},
            IDummy.getTaggedValue(WIDGETS_KEY))
        self.assertEquals([(Interface, 'dummy', 'true')],
                          IDummy.getTaggedValue(OMITTED_KEY))
        self.assertEquals([(Interface, 'dummy', 'hidden')],
                          IDummy.getTaggedValue(MODES_KEY))
        self.assertEquals([(
            'dummy',
            'before',
            'somefield',
        )], IDummy.getTaggedValue(ORDER_KEY))
        validator = getMultiAdapter((None, None, None, IDummy['dummy'], None),
                                    IValidator)
        from plone.autoform.tests.test_utils import TestValidator
        assert isinstance(validator, TestValidator)
    def test_read_values_with_interfaces(self):
        field_node1 = etree.Element('field')
        field_node1.set(ns("mode", self.namespace),
                        "z3c.form.interfaces.IForm:hidden")
        field_node1.set(ns("omitted", self.namespace),
                        "z3c.form.interfaces.IForm:true")

        field_node2 = etree.Element('field')
        field_node2.set(
            ns("mode", self.namespace),
            "z3c.form.interfaces.IForm:hidden z3c.form.interfaces.IEditForm:display"
        )
        field_node2.set(
            ns("omitted", self.namespace),
            "z3c.form.interfaces.IForm:true z3c.form.interfaces.IEditForm:false"
        )

        class IDummy(Interface):
            dummy1 = zope.schema.TextLine(title=u"dummy1")
            dummy2 = zope.schema.TextLine(title=u"dummy2")

        handler = FormSchema()
        handler.read(field_node1, IDummy, IDummy['dummy1'])
        handler.read(field_node2, IDummy, IDummy['dummy2'])

        expected_modes = [(IForm, u'dummy1', 'hidden'),
                          (IForm, u'dummy2', 'hidden'),
                          (IEditForm, u'dummy2', 'display')]
        self.assertEquals(expected_modes, IDummy.queryTaggedValue(MODES_KEY))
        expected_omitted = [(IForm, u'dummy1', 'true'),
                            (IForm, u'dummy2', 'true'),
                            (IEditForm, u'dummy2', 'false')]
        self.assertEquals(expected_omitted,
                          IDummy.queryTaggedValue(OMITTED_KEY))
 def test_read_multiple(self):
     field_node1 = ElementTree.Element('field')
     field_node1.set(ns("widget", self.namespace), "z3c.form.browser.password.PasswordFieldWidget")
     field_node1.set(ns("mode", self.namespace), "hidden")
     field_node1.set(ns("omitted", self.namespace), "true")
     field_node1.set(ns("before", self.namespace), "somefield")
     
     field_node2 = ElementTree.Element('field')
     field_node2.set(ns("mode", self.namespace), "display")
     field_node2.set(ns("omitted", self.namespace), "yes")
     
     class IDummy(Interface):
         dummy1 = zope.schema.TextLine(title=u"dummy1")
         dummy2 = zope.schema.TextLine(title=u"dummy2")
     
     handler = FormSchema()
     handler.read(field_node1, IDummy, IDummy['dummy1'])
     handler.read(field_node2, IDummy, IDummy['dummy2'])
 
     self.assertEquals({'dummy1': 'z3c.form.browser.password.PasswordFieldWidget'},
         IDummy.getTaggedValue(WIDGETS_KEY))
     self.assertEquals([(Interface, 'dummy1', 'true'), (Interface, 'dummy2', 'yes')],
                       IDummy.getTaggedValue(OMITTED_KEY))
     self.assertEquals([(Interface, 'dummy1', 'hidden'), (Interface, 'dummy2', 'display')],
                       IDummy.getTaggedValue(MODES_KEY))
     self.assertEquals([('dummy1', 'before', 'somefield',)], IDummy.getTaggedValue(ORDER_KEY))
Beispiel #6
0
    def test_read_parameterized_widget_default(self):
        from plone.autoform.widgets import ParameterizedWidget

        param_node = etree.Element('klass')
        param_node.text = 'custom'
        param2_node = etree.Element('placeholder')
        param2_node.text = 'help'
        widget_node = etree.Element(ns('widget', self.namespace))
        widget_node.append(param_node)
        widget_node.append(param2_node)
        field_node = etree.Element('field')
        field_node.append(widget_node)

        class IDummy(Interface):
            foo = zope.schema.TextLine(title=u'foo')

        handler = FormSchema()
        handler.read(field_node, IDummy, IDummy['foo'])

        widgets = IDummy.queryTaggedValue(WIDGETS_KEY)
        self.assertTrue(isinstance(widgets['foo'], ParameterizedWidget))
        self.assertTrue(widgets['foo'].widget_factory is None)
        self.assertIn('klass', widgets['foo'].params)
        self.assertEqual(widgets['foo'].params['klass'], 'custom')
        self.assertIn('placeholder', widgets['foo'].params)
        self.assertEqual(widgets['foo'].params['placeholder'], 'help')
    def test_read_no_data(self):
        field_node = etree.Element('field')

        class IDummy(Interface):
            dummy = zope.schema.TextLine(title=u"dummy1")

        handler = FormSchema()
        handler.read(field_node, IDummy, IDummy['dummy'])

        self.assertEquals(None, IDummy.queryTaggedValue(WIDGETS_KEY))
        self.assertEquals(None, IDummy.queryTaggedValue(OMITTED_KEY))
        self.assertEquals(None, IDummy.queryTaggedValue(MODES_KEY))
        self.assertEquals(None, IDummy.queryTaggedValue(ORDER_KEY))
    def test_read_no_data(self):
        field_node = etree.Element('field')

        class IDummy(Interface):
            dummy = zope.schema.TextLine(title=u'dummy1')

        handler = FormSchema()
        handler.read(field_node, IDummy, IDummy['dummy'])

        self.assertEqual(None, IDummy.queryTaggedValue(WIDGETS_KEY))
        self.assertEqual(None, IDummy.queryTaggedValue(OMITTED_KEY))
        self.assertEqual(None, IDummy.queryTaggedValue(MODES_KEY))
        self.assertEqual(None, IDummy.queryTaggedValue(ORDER_KEY))
    def test_read_values_with_interfaces(self):
        field_node1 = etree.Element('field')
        field_node1.set(
            ns('mode', self.namespace),
            'z3c.form.interfaces.IForm:hidden'
        )
        field_node1.set(
            ns('omitted', self.namespace),
            'z3c.form.interfaces.IForm:true'
        )

        field_node2 = etree.Element('field')
        field_node2.set(
            ns('mode', self.namespace),
            'z3c.form.interfaces.IForm:hidden '
            'z3c.form.interfaces.IEditForm:display'
        )
        field_node2.set(
            ns('omitted', self.namespace),
            'z3c.form.interfaces.IForm:true '
            'z3c.form.interfaces.IEditForm:false'
        )

        class IDummy(Interface):
            dummy1 = zope.schema.TextLine(title=u'dummy1')
            dummy2 = zope.schema.TextLine(title=u'dummy2')

        handler = FormSchema()
        handler.read(field_node1, IDummy, IDummy['dummy1'])
        handler.read(field_node2, IDummy, IDummy['dummy2'])

        expected_modes = [
            (IForm, u'dummy1', 'hidden'),
            (IForm, u'dummy2', 'hidden'),
            (IEditForm, u'dummy2', 'display')
        ]
        self.assertEqual(
            expected_modes,
            IDummy.queryTaggedValue(MODES_KEY)
        )
        expected_omitted = [
            (IForm, u'dummy1', 'true'),
            (IForm, u'dummy2', 'true'),
            (IEditForm, u'dummy2', 'false')
        ]
        self.assertEqual(
            expected_omitted,
            IDummy.queryTaggedValue(OMITTED_KEY)
        )
    def test_read(self):
        field_node = etree.Element('field')
        field_node.set(
            ns('widget', self.namespace),
            'z3c.form.browser.password.PasswordFieldWidget'
        )
        field_node.set(ns('mode', self.namespace), 'hidden')
        field_node.set(ns('omitted', self.namespace), 'true')
        field_node.set(ns('before', self.namespace), 'somefield')
        field_node.set(
            ns('validator', self.namespace),
            'plone.autoform.tests.test_utils.TestValidator'
        )

        class IDummy(Interface):
            dummy = zope.schema.TextLine(title=u'dummy')

        handler = FormSchema()
        handler.read(field_node, IDummy, IDummy['dummy'])

        self.assertEqual(
            {'dummy': 'z3c.form.browser.password.PasswordFieldWidget'},
            IDummy.getTaggedValue(WIDGETS_KEY)
        )
        self.assertEqual(
            [(Interface, 'dummy', 'true')],
            IDummy.getTaggedValue(OMITTED_KEY)
        )
        self.assertEqual(
            [(Interface, 'dummy', 'hidden')],
            IDummy.getTaggedValue(MODES_KEY)
        )
        self.assertEqual(
            [('dummy', 'before', 'somefield',)],
            IDummy.getTaggedValue(ORDER_KEY)
        )
        validator = getMultiAdapter(
            (None, None, None, IDummy['dummy'], None),
            IValidator
        )
        from plone.autoform.tests.test_utils import TestValidator
        assert isinstance(validator, TestValidator)
    def test_read_parameterized_widget(self):
        from plone.autoform.widgets import ParameterizedWidget

        param_node = etree.Element('klass')
        param_node.text = 'custom'
        widget_node = etree.Element(ns('widget', self.namespace))
        widget_node.set(
            'type', 'plone.autoform.tests.test_supermodel_handler.DummyWidget')
        widget_node.append(param_node)
        field_node = etree.Element('field')
        field_node.append(widget_node)

        class IDummy(Interface):
            foo = zope.schema.TextLine(title=u'foo')

        handler = FormSchema()
        handler.read(field_node, IDummy, IDummy['foo'])

        widgets = IDummy.queryTaggedValue(WIDGETS_KEY)
        self.assertTrue(isinstance(widgets['foo'], ParameterizedWidget))
        self.assertTrue(widgets['foo'].widget_factory is DummyWidget)
        self.assertEqual(widgets['foo'].params, {'klass': 'custom'})
    def test_read_multiple(self):
        field_node1 = etree.Element('field')
        field_node1.set(
            ns('widget', self.namespace),
            'z3c.form.browser.password.PasswordFieldWidget'
        )
        field_node1.set(ns('mode', self.namespace), 'hidden')
        field_node1.set(ns('omitted', self.namespace), 'true')
        field_node1.set(ns('before', self.namespace), 'somefield')

        field_node2 = etree.Element('field')
        field_node2.set(ns('mode', self.namespace), 'display')
        field_node2.set(ns('omitted', self.namespace), 'yes')

        class IDummy(Interface):
            dummy1 = zope.schema.TextLine(title=u'dummy1')
            dummy2 = zope.schema.TextLine(title=u'dummy2')

        handler = FormSchema()
        handler.read(field_node1, IDummy, IDummy['dummy1'])
        handler.read(field_node2, IDummy, IDummy['dummy2'])

        self.assertEqual(
            {'dummy1': 'z3c.form.browser.password.PasswordFieldWidget'},
            IDummy.getTaggedValue(WIDGETS_KEY)
        )
        self.assertEqual(
            [(Interface, 'dummy1', 'true'), (Interface, 'dummy2', 'yes')],
            IDummy.getTaggedValue(OMITTED_KEY)
        )
        self.assertEqual(
            [(Interface, 'dummy1', 'hidden'),
             (Interface, 'dummy2', 'display')],
            IDummy.getTaggedValue(MODES_KEY)
        )
        self.assertEqual(
            [('dummy1', 'before', 'somefield',)],
            IDummy.getTaggedValue(ORDER_KEY)
        )
    def test_read_parameterized_widget(self):
        from plone.autoform.widgets import ParameterizedWidget

        param_node = etree.Element('klass')
        param_node.text = 'custom'
        widget_node = etree.Element(ns('widget', self.namespace))
        widget_node.set('type',
            'plone.autoform.tests.test_supermodel_handler.DummyWidget')
        widget_node.append(param_node)
        field_node = etree.Element('field')
        field_node.append(widget_node)

        class IDummy(Interface):
            foo = zope.schema.TextLine(title=u'foo')

        handler = FormSchema()
        handler.read(field_node, IDummy, IDummy['foo'])

        widgets = IDummy.queryTaggedValue(WIDGETS_KEY)
        self.assertTrue(isinstance(widgets['foo'], ParameterizedWidget))
        self.assertTrue(widgets['foo'].widget_factory is DummyWidget)
        self.assertEqual(widgets['foo'].params, {'klass': 'custom'})