409 lines
15 KiB
Python
409 lines
15 KiB
Python
# -*- coding: utf-8; -*-
|
|
|
|
from unittest import TestCase
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
import colander
|
|
import deform
|
|
from pyramid import testing
|
|
|
|
from wuttjamaican.conf import WuttaConfig
|
|
from wuttaweb.forms import base
|
|
from wuttaweb import helpers
|
|
|
|
|
|
class TestFieldList(TestCase):
|
|
|
|
def test_insert_before(self):
|
|
fields = base.FieldList(['f1', 'f2'])
|
|
self.assertEqual(fields, ['f1', 'f2'])
|
|
|
|
# typical
|
|
fields.insert_before('f1', 'XXX')
|
|
self.assertEqual(fields, ['XXX', 'f1', 'f2'])
|
|
fields.insert_before('f2', 'YYY')
|
|
self.assertEqual(fields, ['XXX', 'f1', 'YYY', 'f2'])
|
|
|
|
# appends new field if reference field is invalid
|
|
fields.insert_before('f3', 'ZZZ')
|
|
self.assertEqual(fields, ['XXX', 'f1', 'YYY', 'f2', 'ZZZ'])
|
|
|
|
def test_insert_after(self):
|
|
fields = base.FieldList(['f1', 'f2'])
|
|
self.assertEqual(fields, ['f1', 'f2'])
|
|
|
|
# typical
|
|
fields.insert_after('f1', 'XXX')
|
|
self.assertEqual(fields, ['f1', 'XXX', 'f2'])
|
|
fields.insert_after('XXX', 'YYY')
|
|
self.assertEqual(fields, ['f1', 'XXX', 'YYY', 'f2'])
|
|
|
|
# appends new field if reference field is invalid
|
|
fields.insert_after('f3', 'ZZZ')
|
|
self.assertEqual(fields, ['f1', 'XXX', 'YYY', 'f2', 'ZZZ'])
|
|
|
|
|
|
class TestForm(TestCase):
|
|
|
|
def setUp(self):
|
|
self.config = WuttaConfig(defaults={
|
|
'wutta.web.menus.handler_spec': 'tests.utils:NullMenuHandler',
|
|
})
|
|
self.request = testing.DummyRequest(wutta_config=self.config, use_oruga=False)
|
|
|
|
self.pyramid_config = testing.setUp(request=self.request, settings={
|
|
'mako.directories': ['wuttaweb:templates'],
|
|
'pyramid_deform.template_search_path': 'wuttaweb:templates/deform',
|
|
})
|
|
|
|
def tearDown(self):
|
|
testing.tearDown()
|
|
|
|
def make_form(self, **kwargs):
|
|
return base.Form(self.request, **kwargs)
|
|
|
|
def make_schema(self):
|
|
schema = colander.Schema(children=[
|
|
colander.SchemaNode(colander.String(),
|
|
name='foo'),
|
|
colander.SchemaNode(colander.String(),
|
|
name='bar'),
|
|
])
|
|
return schema
|
|
|
|
def test_init_with_none(self):
|
|
form = self.make_form()
|
|
self.assertIsNone(form.fields)
|
|
|
|
def test_init_with_fields(self):
|
|
form = self.make_form(fields=['foo', 'bar'])
|
|
self.assertEqual(form.fields, ['foo', 'bar'])
|
|
|
|
def test_init_with_schema(self):
|
|
schema = self.make_schema()
|
|
form = self.make_form(schema=schema)
|
|
self.assertEqual(form.fields, ['foo', 'bar'])
|
|
|
|
def test_vue_tagname(self):
|
|
form = self.make_form()
|
|
self.assertEqual(form.vue_tagname, 'wutta-form')
|
|
|
|
def test_vue_component(self):
|
|
form = self.make_form()
|
|
self.assertEqual(form.vue_component, 'WuttaForm')
|
|
|
|
def test_contains(self):
|
|
form = self.make_form(fields=['foo', 'bar'])
|
|
self.assertIn('foo', form)
|
|
self.assertNotIn('baz', form)
|
|
|
|
def test_iter(self):
|
|
form = self.make_form(fields=['foo', 'bar'])
|
|
|
|
fields = list(iter(form))
|
|
self.assertEqual(fields, ['foo', 'bar'])
|
|
|
|
fields = []
|
|
for field in form:
|
|
fields.append(field)
|
|
self.assertEqual(fields, ['foo', 'bar'])
|
|
|
|
def test_set_fields(self):
|
|
form = self.make_form(fields=['foo', 'bar'])
|
|
self.assertEqual(form.fields, ['foo', 'bar'])
|
|
form.set_fields(['baz'])
|
|
self.assertEqual(form.fields, ['baz'])
|
|
|
|
def test_get_schema(self):
|
|
form = self.make_form()
|
|
self.assertIsNone(form.schema)
|
|
|
|
# provided schema is returned
|
|
schema = self.make_schema()
|
|
form = self.make_form(schema=schema)
|
|
self.assertIs(form.schema, schema)
|
|
self.assertIs(form.get_schema(), schema)
|
|
|
|
# schema is auto-generated if fields provided
|
|
form = self.make_form(fields=['foo', 'bar'])
|
|
schema = form.get_schema()
|
|
self.assertEqual(len(schema.children), 2)
|
|
self.assertEqual(schema['foo'].name, 'foo')
|
|
|
|
# but auto-generating without fields is not supported
|
|
form = self.make_form()
|
|
self.assertIsNone(form.schema)
|
|
self.assertRaises(NotImplementedError, form.get_schema)
|
|
|
|
# schema nodes are required by default
|
|
form = self.make_form(fields=['foo', 'bar'])
|
|
schema = form.get_schema()
|
|
self.assertIs(schema['foo'].missing, colander.required)
|
|
self.assertIs(schema['bar'].missing, colander.required)
|
|
|
|
# but fields can be marked *not* required
|
|
form = self.make_form(fields=['foo', 'bar'])
|
|
form.set_required('bar', False)
|
|
schema = form.get_schema()
|
|
self.assertIs(schema['foo'].missing, colander.required)
|
|
self.assertIsNone(schema['bar'].missing)
|
|
|
|
def test_get_deform(self):
|
|
schema = self.make_schema()
|
|
|
|
# basic
|
|
form = self.make_form(schema=schema)
|
|
self.assertFalse(hasattr(form, 'deform_form'))
|
|
dform = form.get_deform()
|
|
self.assertIsInstance(dform, deform.Form)
|
|
self.assertIs(form.deform_form, dform)
|
|
|
|
# with model instance / cstruct
|
|
myobj = {'foo': 'one', 'bar': 'two'}
|
|
form = self.make_form(schema=schema, model_instance=myobj)
|
|
dform = form.get_deform()
|
|
self.assertEqual(dform.cstruct, myobj)
|
|
|
|
def test_get_cancel_url(self):
|
|
|
|
# is referrer by default
|
|
form = self.make_form()
|
|
self.request.get_referrer = MagicMock(return_value='/cancel-default')
|
|
self.assertEqual(form.get_cancel_url(), '/cancel-default')
|
|
del self.request.get_referrer
|
|
|
|
# or can be static URL
|
|
form = self.make_form(cancel_url='/cancel-static')
|
|
self.assertEqual(form.get_cancel_url(), '/cancel-static')
|
|
|
|
# or can be fallback URL (nb. 'NOPE' indicates no referrer)
|
|
form = self.make_form(cancel_url_fallback='/cancel-fallback')
|
|
self.request.get_referrer = MagicMock(return_value='NOPE')
|
|
self.assertEqual(form.get_cancel_url(), '/cancel-fallback')
|
|
del self.request.get_referrer
|
|
|
|
# or can be referrer fallback, i.e. home page
|
|
form = self.make_form()
|
|
def get_referrer(default=None):
|
|
if default == 'NOPE':
|
|
return 'NOPE'
|
|
return '/home-page'
|
|
self.request.get_referrer = get_referrer
|
|
self.assertEqual(form.get_cancel_url(), '/home-page')
|
|
del self.request.get_referrer
|
|
|
|
def test_get_label(self):
|
|
form = self.make_form(fields=['foo', 'bar'])
|
|
self.assertEqual(form.get_label('foo'), "Foo")
|
|
form.set_label('foo', "Baz")
|
|
self.assertEqual(form.get_label('foo'), "Baz")
|
|
|
|
def test_set_label(self):
|
|
form = self.make_form(fields=['foo', 'bar'])
|
|
self.assertEqual(form.get_label('foo'), "Foo")
|
|
form.set_label('foo', "Baz")
|
|
self.assertEqual(form.get_label('foo'), "Baz")
|
|
|
|
# schema should be updated when setting label
|
|
schema = self.make_schema()
|
|
form = self.make_form(schema=schema)
|
|
form.set_label('foo', "Woohoo")
|
|
self.assertEqual(form.get_label('foo'), "Woohoo")
|
|
self.assertEqual(schema['foo'].title, "Woohoo")
|
|
|
|
def test_readonly_fields(self):
|
|
form = self.make_form(fields=['foo', 'bar'])
|
|
self.assertEqual(form.readonly_fields, set())
|
|
self.assertFalse(form.is_readonly('foo'))
|
|
|
|
form.set_readonly('foo')
|
|
self.assertEqual(form.readonly_fields, {'foo'})
|
|
self.assertTrue(form.is_readonly('foo'))
|
|
self.assertFalse(form.is_readonly('bar'))
|
|
|
|
form.set_readonly('bar')
|
|
self.assertEqual(form.readonly_fields, {'foo', 'bar'})
|
|
self.assertTrue(form.is_readonly('foo'))
|
|
self.assertTrue(form.is_readonly('bar'))
|
|
|
|
form.set_readonly('foo', False)
|
|
self.assertEqual(form.readonly_fields, {'bar'})
|
|
self.assertFalse(form.is_readonly('foo'))
|
|
self.assertTrue(form.is_readonly('bar'))
|
|
|
|
def test_required_fields(self):
|
|
form = self.make_form(fields=['foo', 'bar'])
|
|
self.assertEqual(form.required_fields, {})
|
|
self.assertIsNone(form.is_required('foo'))
|
|
|
|
form.set_required('foo')
|
|
self.assertEqual(form.required_fields, {'foo': True})
|
|
self.assertTrue(form.is_required('foo'))
|
|
self.assertIsNone(form.is_required('bar'))
|
|
|
|
form.set_required('bar')
|
|
self.assertEqual(form.required_fields, {'foo': True, 'bar': True})
|
|
self.assertTrue(form.is_required('foo'))
|
|
self.assertTrue(form.is_required('bar'))
|
|
|
|
form.set_required('foo', False)
|
|
self.assertEqual(form.required_fields, {'foo': False, 'bar': True})
|
|
self.assertFalse(form.is_required('foo'))
|
|
self.assertTrue(form.is_required('bar'))
|
|
|
|
def test_render_vue_tag(self):
|
|
schema = self.make_schema()
|
|
form = self.make_form(schema=schema)
|
|
html = form.render_vue_tag()
|
|
self.assertEqual(html, '<wutta-form></wutta-form>')
|
|
|
|
def test_render_vue_template(self):
|
|
self.pyramid_config.include('pyramid_mako')
|
|
self.pyramid_config.add_subscriber('wuttaweb.subscribers.before_render',
|
|
'pyramid.events.BeforeRender')
|
|
|
|
# form button is disabled on @submit by default
|
|
schema = self.make_schema()
|
|
form = self.make_form(schema=schema, cancel_url='/')
|
|
html = form.render_vue_template()
|
|
self.assertIn('<script type="text/x-template" id="wutta-form-template">', html)
|
|
self.assertIn('@submit', html)
|
|
|
|
# but not if form is configured otherwise
|
|
form = self.make_form(schema=schema, auto_disable_submit=False, cancel_url='/')
|
|
html = form.render_vue_template()
|
|
self.assertIn('<script type="text/x-template" id="wutta-form-template">', html)
|
|
self.assertNotIn('@submit', html)
|
|
|
|
def test_render_vue_field(self):
|
|
self.pyramid_config.include('pyramid_deform')
|
|
schema = self.make_schema()
|
|
form = self.make_form(schema=schema)
|
|
dform = form.get_deform()
|
|
|
|
# typical
|
|
html = form.render_vue_field('foo')
|
|
self.assertIn('<b-field :horizontal="true" label="Foo">', html)
|
|
self.assertIn('<b-input name="foo"', html)
|
|
# nb. no error message
|
|
self.assertNotIn('message', html)
|
|
|
|
# readonly
|
|
html = form.render_vue_field('foo', readonly=True)
|
|
self.assertIn('<b-field :horizontal="true" label="Foo">', html)
|
|
self.assertNotIn('<b-input name="foo"', html)
|
|
# nb. no error message
|
|
self.assertNotIn('message', html)
|
|
|
|
# with single "static" error
|
|
dform['foo'].error = MagicMock(msg="something is wrong")
|
|
html = form.render_vue_field('foo')
|
|
self.assertIn(' message="something is wrong"', html)
|
|
|
|
# with single "dynamic" error
|
|
dform['foo'].error = MagicMock(msg="`something is wrong`")
|
|
html = form.render_vue_field('foo')
|
|
self.assertIn(':message="`something is wrong`"', html)
|
|
|
|
# add another field, but not to deform, so it should still
|
|
# display but with no widget
|
|
form.fields.append('zanzibar')
|
|
html = form.render_vue_field('zanzibar')
|
|
self.assertIn('<b-field :horizontal="true" label="Zanzibar">', html)
|
|
self.assertNotIn('<b-input', html)
|
|
# nb. no error message
|
|
self.assertNotIn('message', html)
|
|
|
|
# try that once more but with a model record instance
|
|
with patch.object(form, 'model_instance', new={'zanzibar': 'omgwtfbbq'}):
|
|
html = form.render_vue_field('zanzibar')
|
|
self.assertIn('<b-field', html)
|
|
self.assertIn('label="Zanzibar"', html)
|
|
self.assertNotIn('<b-input', html)
|
|
self.assertIn('>omgwtfbbq<', html)
|
|
# nb. no error message
|
|
self.assertNotIn('message', html)
|
|
|
|
def test_get_field_errors(self):
|
|
schema = self.make_schema()
|
|
form = self.make_form(schema=schema)
|
|
dform = form.get_deform()
|
|
|
|
# no error
|
|
errors = form.get_field_errors('foo')
|
|
self.assertEqual(len(errors), 0)
|
|
|
|
# simple error
|
|
dform['foo'].error = MagicMock(msg="something is wrong")
|
|
errors = form.get_field_errors('foo')
|
|
self.assertEqual(len(errors), 1)
|
|
self.assertEqual(errors[0], "something is wrong")
|
|
|
|
def test_get_vue_field_value(self):
|
|
schema = self.make_schema()
|
|
form = self.make_form(schema=schema)
|
|
|
|
# null field value
|
|
value = form.get_vue_field_value('foo')
|
|
self.assertEqual(value, 'null')
|
|
|
|
# non-default / explicit value
|
|
# TODO: surely need a different approach to set value
|
|
dform = form.get_deform()
|
|
dform['foo'].cstruct = 'blarg'
|
|
value = form.get_vue_field_value('foo')
|
|
self.assertEqual(value, '"blarg"')
|
|
|
|
def test_jsonify_value(self):
|
|
form = self.make_form()
|
|
|
|
# null field value
|
|
value = form.jsonify_value(colander.null)
|
|
self.assertEqual(value, 'null')
|
|
value = form.jsonify_value(None)
|
|
self.assertEqual(value, 'null')
|
|
|
|
# string value
|
|
value = form.jsonify_value('blarg')
|
|
self.assertEqual(value, '"blarg"')
|
|
|
|
def test_validate(self):
|
|
schema = self.make_schema()
|
|
form = self.make_form(schema=schema)
|
|
self.assertFalse(hasattr(form, 'validated'))
|
|
|
|
# will not validate unless request is POST
|
|
self.request.POST = {'foo': 'blarg', 'bar': 'baz'}
|
|
self.request.method = 'GET'
|
|
self.assertFalse(form.validate())
|
|
self.request.method = 'POST'
|
|
data = form.validate()
|
|
self.assertEqual(data, {'foo': 'blarg', 'bar': 'baz'})
|
|
|
|
# validating a second time updates form.validated
|
|
self.request.POST = {'foo': 'BLARG', 'bar': 'BAZ'}
|
|
data = form.validate()
|
|
self.assertEqual(data, {'foo': 'BLARG', 'bar': 'BAZ'})
|
|
self.assertIs(form.validated, data)
|
|
|
|
# bad data does not validate
|
|
self.request.POST = {'foo': 42, 'bar': None}
|
|
self.assertFalse(form.validate())
|
|
dform = form.get_deform()
|
|
self.assertEqual(len(dform.error.children), 2)
|
|
self.assertEqual(dform['foo'].errormsg, "Pstruct is not a string")
|
|
|
|
# when a form has readonly fields, validating it will *remove*
|
|
# those fields from deform/schema as well as final data dict
|
|
schema = self.make_schema()
|
|
form = self.make_form(schema=schema)
|
|
form.set_readonly('foo')
|
|
self.request.POST = {'foo': 'one', 'bar': 'two'}
|
|
data = form.validate()
|
|
self.assertEqual(data, {'bar': 'two'})
|
|
dform = form.get_deform()
|
|
self.assertNotIn('foo', schema)
|
|
self.assertNotIn('foo', dform)
|
|
self.assertIn('bar', schema)
|
|
self.assertIn('bar', dform)
|