22 from yams.constraints import StaticVocabularyConstraint, SizeConstraint |
22 from yams.constraints import StaticVocabularyConstraint, SizeConstraint |
23 |
23 |
24 import cubicweb |
24 import cubicweb |
25 from cubicweb.devtools import TestServerConfiguration |
25 from cubicweb.devtools import TestServerConfiguration |
26 from cubicweb.devtools.testlib import CubicWebTC |
26 from cubicweb.devtools.testlib import CubicWebTC |
27 from cubicweb.web.formwidgets import PasswordInput, TextArea, Select, Radio |
27 from cubicweb.web.formwidgets import PasswordInput, Select, Radio |
28 from cubicweb.web.formfields import * |
28 from cubicweb.web.formfields import * |
29 from cubicweb.web.views.forms import EntityFieldsForm, FieldsForm |
29 from cubicweb.web.views.forms import EntityFieldsForm, FieldsForm |
30 |
30 |
31 from cubes.file.entities import File |
|
32 |
31 |
33 def setUpModule(*args): |
32 def setUpModule(*args): |
34 global schema |
33 global schema |
35 config = TestServerConfiguration('data', apphome=GuessFieldTC.datadir) |
34 config = TestServerConfiguration('data', apphome=GuessFieldTC.datadir) |
36 config.bootstrap_cubes() |
35 config.bootstrap_cubes() |
37 schema = config.load_schema() |
36 schema = config.load_schema() |
|
37 |
38 |
38 |
39 class GuessFieldTC(CubicWebTC): |
39 class GuessFieldTC(CubicWebTC): |
40 |
40 |
41 def test_state_fields(self): |
41 def test_state_fields(self): |
42 with self.admin_access.web_request() as req: |
42 with self.admin_access.web_request() as req: |
43 title_field = guess_field(schema['State'], schema['name'], req=req) |
43 title_field = guess_field(schema['State'], schema['name'], req=req) |
44 self.assertIsInstance(title_field, StringField) |
44 self.assertIsInstance(title_field, StringField) |
45 self.assertEqual(title_field.required, True) |
45 self.assertEqual(title_field.required, True) |
46 |
|
47 # synopsis_field = guess_field(schema['State'], schema['synopsis']) |
|
48 # self.assertIsInstance(synopsis_field, StringField) |
|
49 # self.assertIsInstance(synopsis_field.widget, TextArea) |
|
50 # self.assertEqual(synopsis_field.required, False) |
|
51 # self.assertEqual(synopsis_field.help, 'an abstract for this state') |
|
52 |
46 |
53 with self.admin_access.web_request() as req: |
47 with self.admin_access.web_request() as req: |
54 description_field = guess_field(schema['State'], schema['description'], req=req) |
48 description_field = guess_field(schema['State'], schema['description'], req=req) |
55 self.assertIsInstance(description_field, RichTextField) |
49 self.assertIsInstance(description_field, RichTextField) |
56 self.assertEqual(description_field.required, False) |
50 self.assertEqual(description_field.required, False) |
63 description_format_field = guess_field(schema['State'], schema['description_format'], |
57 description_format_field = guess_field(schema['State'], schema['description_format'], |
64 req=req) |
58 req=req) |
65 self.assertEqual(description_format_field.internationalizable, True) |
59 self.assertEqual(description_format_field.internationalizable, True) |
66 self.assertEqual(description_format_field.sort, True) |
60 self.assertEqual(description_format_field.sort, True) |
67 |
61 |
68 # wikiid_field = guess_field(schema['State'], schema['wikiid']) |
|
69 # self.assertIsInstance(wikiid_field, StringField) |
|
70 # self.assertEqual(wikiid_field.required, False) |
|
71 |
|
72 |
|
73 def test_cwuser_fields(self): |
62 def test_cwuser_fields(self): |
74 with self.admin_access.web_request() as req: |
63 with self.admin_access.web_request() as req: |
75 upassword_field = guess_field(schema['CWUser'], schema['upassword'], req=req) |
64 upassword_field = guess_field(schema['CWUser'], schema['upassword'], req=req) |
76 self.assertIsInstance(upassword_field, StringField) |
65 self.assertIsInstance(upassword_field, StringField) |
77 self.assertIsInstance(upassword_field.widget, PasswordInput) |
66 self.assertIsInstance(upassword_field.widget, PasswordInput) |
78 self.assertEqual(upassword_field.required, True) |
67 self.assertEqual(upassword_field.required, True) |
79 |
68 |
80 with self.admin_access.web_request() as req: |
69 with self.admin_access.web_request() as req: |
81 last_login_time_field = guess_field(schema['CWUser'], schema['last_login_time'], req=req) |
70 last_login_time_field = guess_field(schema['CWUser'], schema['last_login_time'], |
|
71 req=req) |
82 self.assertIsInstance(last_login_time_field, DateTimeField) |
72 self.assertIsInstance(last_login_time_field, DateTimeField) |
83 self.assertEqual(last_login_time_field.required, False) |
73 self.assertEqual(last_login_time_field.required, False) |
84 |
74 |
85 with self.admin_access.web_request() as req: |
75 with self.admin_access.web_request() as req: |
86 in_group_field = guess_field(schema['CWUser'], schema['in_group'], req=req) |
76 in_group_field = guess_field(schema['CWUser'], schema['in_group'], req=req) |
93 owned_by_field = guess_field(schema['CWUser'], schema['owned_by'], 'object', req=req) |
83 owned_by_field = guess_field(schema['CWUser'], schema['owned_by'], 'object', req=req) |
94 self.assertIsInstance(owned_by_field, RelationField) |
84 self.assertIsInstance(owned_by_field, RelationField) |
95 self.assertEqual(owned_by_field.required, False) |
85 self.assertEqual(owned_by_field.required, False) |
96 self.assertEqual(owned_by_field.role, 'object') |
86 self.assertEqual(owned_by_field.role, 'object') |
97 |
87 |
98 |
|
99 def test_file_fields(self): |
88 def test_file_fields(self): |
100 # data_format_field = guess_field(schema['File'], schema['data_format']) |
|
101 # self.assertEqual(data_format_field, None) |
|
102 # data_encoding_field = guess_field(schema['File'], schema['data_encoding']) |
|
103 # self.assertEqual(data_encoding_field, None) |
|
104 # data_name_field = guess_field(schema['File'], schema['data_name']) |
|
105 # self.assertEqual(data_name_field, None) |
|
106 |
|
107 with self.admin_access.web_request() as req: |
89 with self.admin_access.web_request() as req: |
108 data_field = guess_field(schema['File'], schema['data'], req=req) |
90 data_field = guess_field(schema['File'], schema['data'], req=req) |
109 self.assertIsInstance(data_field, FileField) |
91 self.assertIsInstance(data_field, FileField) |
110 self.assertEqual(data_field.required, True) |
92 self.assertEqual(data_field.required, True) |
111 self.assertIsInstance(data_field.format_field, StringField) |
93 self.assertIsInstance(data_field.format_field, StringField) |
115 def test_constraints_priority(self): |
97 def test_constraints_priority(self): |
116 with self.admin_access.web_request() as req: |
98 with self.admin_access.web_request() as req: |
117 salesterm_field = guess_field(schema['Salesterm'], schema['reason'], req=req) |
99 salesterm_field = guess_field(schema['Salesterm'], schema['reason'], req=req) |
118 constraints = schema['reason'].rdef('Salesterm', 'String').constraints |
100 constraints = schema['reason'].rdef('Salesterm', 'String').constraints |
119 self.assertEqual([c.__class__ for c in constraints], |
101 self.assertEqual([c.__class__ for c in constraints], |
120 [SizeConstraint, StaticVocabularyConstraint]) |
102 [SizeConstraint, StaticVocabularyConstraint]) |
121 self.assertIsInstance(salesterm_field, StringField) |
103 self.assertIsInstance(salesterm_field, StringField) |
122 self.assertIsInstance(salesterm_field.widget, Select) |
104 self.assertIsInstance(salesterm_field.widget, Select) |
123 |
|
124 |
105 |
125 def test_bool_field_base(self): |
106 def test_bool_field_base(self): |
126 with self.admin_access.web_request() as req: |
107 with self.admin_access.web_request() as req: |
127 field = guess_field(schema['CWAttribute'], schema['indexed'], req=req) |
108 field = guess_field(schema['CWAttribute'], schema['indexed'], req=req) |
128 self.assertIsInstance(field, BooleanField) |
109 self.assertIsInstance(field, BooleanField) |
129 self.assertEqual(field.required, False) |
110 self.assertEqual(field.required, False) |
130 self.assertIsInstance(field.widget, Radio) |
111 self.assertIsInstance(field.widget, Radio) |
131 self.assertEqual(field.vocabulary(mock(_cw=mock(_=cubicweb._))), |
112 self.assertEqual(field.vocabulary(mock(_cw=mock(_=cubicweb._))), |
132 [(u'yes', '1'), (u'no', '')]) |
113 [(u'yes', '1'), (u'no', '')]) |
133 |
114 |
134 def test_bool_field_explicit_choices(self): |
115 def test_bool_field_explicit_choices(self): |
135 with self.admin_access.web_request() as req: |
116 with self.admin_access.web_request() as req: |
136 field = guess_field(schema['CWAttribute'], schema['indexed'], |
117 field = guess_field(schema['CWAttribute'], schema['indexed'], |
137 choices=[(u'maybe', '1'), (u'no', '')], req=req) |
118 choices=[(u'maybe', '1'), (u'no', '')], req=req) |
138 self.assertIsInstance(field.widget, Radio) |
119 self.assertIsInstance(field.widget, Radio) |
139 self.assertEqual(field.vocabulary(mock(req=mock(_=cubicweb._))), |
120 self.assertEqual(field.vocabulary(mock(req=mock(_=cubicweb._))), |
140 [(u'maybe', '1'), (u'no', '')]) |
121 [(u'maybe', '1'), (u'no', '')]) |
141 |
122 |
142 |
123 |
143 class MoreFieldsTC(CubicWebTC): |
124 class MoreFieldsTC(CubicWebTC): |
144 def test_rtf_format_field(self): |
125 def test_rtf_format_field(self): |
145 with self.admin_access.web_request() as req: |
126 with self.admin_access.web_request() as req: |
150 description_format_field = description_field.get_format_field(form) |
131 description_format_field = description_field.get_format_field(form) |
151 self.assertEqual(description_format_field.internationalizable, True) |
132 self.assertEqual(description_format_field.internationalizable, True) |
152 self.assertEqual(description_format_field.sort, True) |
133 self.assertEqual(description_format_field.sort, True) |
153 # unlike below, initial is bound to form.form_field_format |
134 # unlike below, initial is bound to form.form_field_format |
154 self.assertEqual(description_format_field.value(form), 'text/plain') |
135 self.assertEqual(description_format_field.value(form), 'text/plain') |
155 req.cnx.execute('INSERT CWProperty X: X pkey "ui.default-text-format", X value "text/rest", X for_user U WHERE U login "admin"') |
136 req.cnx.create_entity('CWProperty', pkey=u"ui.default-text-format", value=u"text/rest", |
|
137 for_user=req.user.eid) |
156 req.cnx.commit() |
138 req.cnx.commit() |
157 self.assertEqual(description_format_field.value(form), 'text/rest') |
139 self.assertEqual(description_format_field.value(form), 'text/rest') |
158 |
|
159 |
140 |
160 def test_property_key_field(self): |
141 def test_property_key_field(self): |
161 from cubicweb.web.views.cwproperties import PropertyKeyField |
142 from cubicweb.web.views.cwproperties import PropertyKeyField |
162 with self.admin_access.web_request() as req: |
143 with self.admin_access.web_request() as req: |
163 field = PropertyKeyField(name='test') |
144 field = PropertyKeyField(name='test') |
169 |
150 |
170 |
151 |
171 class CompoundFieldTC(CubicWebTC): |
152 class CompoundFieldTC(CubicWebTC): |
172 |
153 |
173 def test_multipart(self): |
154 def test_multipart(self): |
174 """Ensures that compound forms have needs_multipart set if their |
155 """Ensures that compound forms have needs_multipart set if their children require it""" |
175 children require it""" |
|
176 class AForm(FieldsForm): |
156 class AForm(FieldsForm): |
177 comp = CompoundField([IntField(), StringField()]) |
157 comp = CompoundField([IntField(), StringField()]) |
|
158 |
178 with self.admin_access.web_request() as req: |
159 with self.admin_access.web_request() as req: |
179 aform = AForm(req, None) |
160 aform = AForm(req, None) |
180 self.assertFalse(aform.needs_multipart) |
161 self.assertFalse(aform.needs_multipart) |
|
162 |
181 class MForm(FieldsForm): |
163 class MForm(FieldsForm): |
182 comp = CompoundField([IntField(), FileField()]) |
164 comp = CompoundField([IntField(), FileField()]) |
|
165 |
183 with self.admin_access.web_request() as req: |
166 with self.admin_access.web_request() as req: |
184 mform = MForm(req, None) |
167 mform = MForm(req, None) |
185 self.assertTrue(mform.needs_multipart) |
168 self.assertTrue(mform.needs_multipart) |
186 |
169 |
187 |
170 |
188 class UtilsTC(TestCase): |
171 class UtilsTC(TestCase): |
189 def test_vocab_sort(self): |
172 def test_vocab_sort(self): |
190 self.assertEqual(vocab_sort([('Z', 1), ('A', 2), |
173 self.assertEqual(vocab_sort([('Z', 1), ('A', 2), |
191 ('Group 1', None), ('Y', 3), ('B', 4), |
174 ('Group 1', None), ('Y', 3), ('B', 4), |
192 ('Group 2', None), ('X', 5), ('C', 6)]), |
175 ('Group 2', None), ('X', 5), ('C', 6)]), |
193 [('A', 2), ('Z', 1), |
176 [('A', 2), ('Z', 1), |
194 ('Group 1', None), ('B', 4), ('Y', 3), |
177 ('Group 1', None), ('B', 4), ('Y', 3), |
195 ('Group 2', None), ('C', 6), ('X', 5)] |
178 ('Group 2', None), ('C', 6), ('X', 5)]) |
196 ) |
179 |
197 |
180 |
198 if __name__ == '__main__': |
181 if __name__ == '__main__': |
199 unittest_main() |
182 unittest_main() |