1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
|
from sprox.formbase import FormBase, AddRecordForm, DisabledForm, EditableForm, Field
from sprox.viewbase import ViewBaseError
from sprox.test.base import setup_database, sorted_user_columns, SproxTest, setup_records, Example, Document, assert_in_xml
from sprox.test.model import User, Group
from sprox.widgetselector import SAWidgetSelector
from sprox.metadata import FieldsMetadata
from nose.tools import raises, eq_
from formencode import Invalid, Schema
from formencode.validators import FieldsMatch, NotEmpty, OpenId
from tw.forms import PasswordField, TextField
class MyTextField(TextField):pass
session = None
engine = None
connection = None
user = None
def setup():
global session, engine, metadata, user
session, engine, metadata = setup_database()
user = setup_records(session)
class UserForm(FormBase):
__entity__ = User
class TestField:
def setup(self):
self.field = Field(TextField, NotEmpty)
def test_create(self):
assert self.field.widget == TextField
assert self.field.validator == NotEmpty
class TestsEmptyDropdownWorks:
def setup(self):
self.base = UserForm(session)
def test__widget__(self):
rendered = self.base.__widget__()
assert_in_xml("""<td class="fieldcol" >
<select name="town" class="propertysingleselectfield" id="town">
<option value="" selected="selected">-----------</option>
</select>
</td>""", rendered)
class TestFormBase(SproxTest):
def setup(self):
super(TestFormBase, self).setup()
self.base = UserForm(session)
def test_create(self):
pass
def test_formbase_with_validator_class(self):
class UserForm(FormBase):
__entity__ = User
user_name = OpenId
user_form = UserForm(session)
widget = user_form.__widget__
try:
widget.validate({'user_name':'something'})
except Invalid, e:
assert u'"something" is not a valid OpenId (it is neither an URL nor an XRI)' in e.msg, e.msg
def test_formbase_with_validator_instance(self):
class UserForm(FormBase):
__entity__ = User
user_name = OpenId()
user_form = UserForm(session)
widget = user_form.__widget__
try:
widget.validate({'user_name':'something'})
except Invalid, e:
assert u'"something" is not a valid OpenId (it is neither an URL nor an XRI)' in e.msg, e.msg
def test_formbase_with_field_validator_instance(self):
class UserForm(FormBase):
__entity__ = User
user_name = Field(validator=OpenId())
user_form = UserForm(session)
widget = user_form.__widget__
try:
widget.validate({'user_name':'something'})
except Invalid, e:
assert u'"something" is not a valid OpenId (it is neither an URL nor an XRI)' in e.msg, e.msg
def test_formbase_with_field_validator_class(self):
class UserForm(FormBase):
__entity__ = User
user_name = Field(validator=OpenId())
user_form = UserForm(session)
widget = user_form.__widget__
try:
widget.validate({'user_name':'something'})
except Invalid, e:
assert u'"something" is not a valid OpenId (it is neither an URL nor an XRI)' in e.msg, e.msg
def test_formbase_with_field_widget_class(self):
class UserForm(FormBase):
__entity__ = User
user_name = Field(MyTextField)
user_form = UserForm(session)
widget = user_form.__widget__
assert isinstance(widget.children['user_name'], MyTextField)
def test_formbase_with_field_widget_instance(self):
class UserForm(FormBase):
__entity__ = User
user_name = Field(MyTextField('user_name'))
user_form = UserForm(session)
widget = user_form.__widget__
assert isinstance(widget.children['user_name'], MyTextField)
@raises(ViewBaseError)
def test_formbase_with_field_widget_instance_no_id(self):
class UserForm(FormBase):
__entity__ = User
user_name = Field(MyTextField())
user_form = UserForm(session)
widget = user_form.__widget__
assert isinstance(widget.children['user_name'], MyTextField)
def test_formbase_with_field_widget_and_validator_instance(self):
class UserForm(FormBase):
__entity__ = User
user_name = Field(MyTextField, OpenId)
user_form = UserForm(session)
widget = user_form.__widget__
assert isinstance(widget.children['user_name'], MyTextField)
try:
widget.validate({'user_name':'something'})
except Invalid, e:
assert u'"something" is not a valid OpenId (it is neither an URL nor an XRI)' in e.msg, e.msg
def test__fields__(self):
eq_(sorted_user_columns, sorted(self.base.__fields__))
def test__widget__(self):
rendered = self.base.__widget__()
assert_in_xml("""<tr class="even" id="submit.container" title="" >
<td class="labelcol">
<label id="submit.label" for="submit" class="fieldlabel"></label>
</td>
<td class="fieldcol" >
<input type="submit" class="submitbutton" value="Submit" />
</td>
</tr>""", rendered)
@raises(ViewBaseError)
def test_form_field_with_no_id(self):
class BogusUserForm(FormBase):
__entity__ = User
field = TextField()
bogus = BogusUserForm(session)
def test_entity_with_synonym(self):
class DocumentForm(FormBase):
__entity__ = Document
form = DocumentForm(session)
rendered = form()
assert_in_xml("""<tr class="odd" id="address.container" title="" >
<td class="labelcol">
<label id="address.label" for="address" class="fieldlabel">Address</label>
</td>
<td class="fieldcol" >
<input type="text" id="address" class="textfield" name="address" value="" />
</td>
</tr>""", rendered)
def test_entity_with_dropdown_field_names(self):
class UserFormFieldNames(FormBase):
__entity__ = User
__dropdown_field_names__ = ['group_name']
form = UserFormFieldNames(session)
rendered = form()
assert_in_xml("""<td class="fieldcol" >
<select name="groups" class="propertymultipleselectfield" id="groups" multiple="multiple" size="5">
<option value="1">0</option>
<option value="2">1</option>
<option value="3">2</option>
<option value="4">3</option>
<option value="5">4</option>
</select>
</td>""", rendered)
def test_entity_with_dropdown_field_names2(self):
class UserFormFieldNames(FormBase):
__entity__ = User
__dropdown_field_names__ = {'groups':'group_name'}
form = UserFormFieldNames(session)
rendered = form()
assert_in_xml("""<td class="fieldcol" >
<select name="groups" class="propertymultipleselectfield" id="groups" multiple="multiple" size="5">
<option value="1">0</option>
<option value="2">1</option>
<option value="3">2</option>
<option value="4">3</option>
<option value="5">4</option>
</select>
</td>""", rendered)
def test_entity_with_dropdown_field_names_dict(self):
class UserFormFieldNames(FormBase):
__entity__ = User
__dropdown_field_names__ = {'groups':['group_name']}
form = UserFormFieldNames(session)
rendered = form()
assert_in_xml( """<td class="fieldcol" >
<select name="groups" class="propertymultipleselectfield" id="groups" multiple="multiple" size="5">
<option value="1">0</option>
<option value="2">1</option>
<option value="3">2</option>
<option value="4">3</option>
<option value="5">4</option>
</select>
</td>""", rendered)
def test_require_field(self):
class RegistrationForm(FormBase):
__entity__ = User
__require_fields__ = ['user_name']
form = RegistrationForm(session)
eq_(form.__widget__.children['user_name'].validator.not_empty, True)
class TestAddRecordForm(SproxTest):
def setup(self):
super(TestAddRecordForm, self).setup()
#setup_records(session)
class AddUserForm(AddRecordForm):
__entity__ = User
__limit_fields__ = ['user_name']
self.base = AddUserForm(session)
@raises(Invalid)
def test_validate(self):
self.base.validate(params={'sprox_id':'asdf', 'user_name':'asdf'})
def test_example_form(self):
class AddExampleForm(AddRecordForm):
__entity__ = Example
example_form = AddExampleForm()
#print example_form()
#assert "checkbox" in example_form()
assert "checkbox" in example_form({'boolean':"asdf"})
def test_form_with_base_validator(self):
form_validator = Schema(chained_validators=(FieldsMatch('password',
'verify_password',
messages={'invalidNoMatch':
'Passwords do not match'}),))
class RegistrationForm(AddRecordForm):
__model__ = User
__require_fields__ = ['password', 'user_name', 'email_address']
__omit_fields__ = ['_password', 'groups', 'created', 'user_id', 'town']
__field_order__ = ['user_name', 'email_address', 'display_name', 'password', 'verify_password']
__base_validator__ = form_validator
email_address = TextField
display_name = TextField
verify_password = PasswordField('verify_password')
registration_form = RegistrationForm()
try:
registration_form.validate(params={'password':'blah', 'verify_password':'not_blah'})
except Invalid, exc:
assert 'Passwords do not match' in exc.message
class TestEditableForm(SproxTest):
def setup(self):
super(TestEditableForm, self).setup()
#setup_records(session)
class UserForm(EditableForm):
__entity__ = User
__limit_fields__ = ['user_name']
self.base = UserForm(session)
def test__widget__(self):
rendered = self.base.__widget__()
assert_in_xml("""<tr class="even" id="user_name.container" title="" >
<td class="labelcol">
<label id="user_name.label" for="user_name" class="fieldlabel">User Name</label>
</td>
<td class="fieldcol" >
<input type="text" id="user_name" class="textfield" name="user_name" value="" />
</td>
</tr>""", rendered)
class TestDisabledForm(SproxTest):
def setup(self):
super(TestDisabledForm, self).setup()
#setup_records(session)
class UserForm(DisabledForm):
__entity__ = User
__limit_fields__ = ['user_name']
self.base = UserForm(session)
def test__widget__(self):
rendered = self.base.__widget__()
assert_in_xml( """<tr class="even" id="user_name.container" title="" >
<td class="labelcol">
<label id="user_name.label" for="user_name" class="fieldlabel">User Name</label>
</td>
<td class="fieldcol" >
<input type="text" id="user_name" class="textfield" name="user_name" value="" disabled="disabled" />
</td>
</tr>""", rendered)
|
