4 :copyright: 2001-2009 LOGILAB S.A. (Paris, FRANCE), license is LGPL v2. |
4 :copyright: 2001-2009 LOGILAB S.A. (Paris, FRANCE), license is LGPL v2. |
5 :contact: http://www.logilab.fr/ -- mailto:contact@logilab.fr |
5 :contact: http://www.logilab.fr/ -- mailto:contact@logilab.fr |
6 :license: GNU Lesser General Public License, v2.1 - http://www.gnu.org/licenses |
6 :license: GNU Lesser General Public License, v2.1 - http://www.gnu.org/licenses |
7 """ |
7 """ |
8 |
8 |
9 from logilab.common.testlib import TestCase, unittest_main |
9 from logilab.common.testlib import TestCase, unittest_main, mock_object as mock |
10 |
10 |
11 from yams.constraints import StaticVocabularyConstraint, SizeConstraint |
11 from yams.constraints import StaticVocabularyConstraint, SizeConstraint |
12 |
12 |
13 from cubicweb.devtools import TestServerConfiguration |
13 from cubicweb.devtools import TestServerConfiguration |
14 from cubicweb.devtools.testlib import EnvBasedTC |
14 from cubicweb.devtools.testlib import EnvBasedTC |
15 from cubicweb.web.formwidgets import PasswordInput, TextArea, Select |
15 from cubicweb.web.formwidgets import PasswordInput, TextArea, Select, Radio |
16 from cubicweb.web.formfields import * |
16 from cubicweb.web.formfields import * |
17 from cubicweb.web.views.forms import EntityFieldsForm |
17 from cubicweb.web.views.forms import EntityFieldsForm |
18 |
18 |
19 from cubes.file.entities import File |
19 from cubes.file.entities import File |
20 |
20 |
21 config = TestServerConfiguration('data') |
21 config = TestServerConfiguration('data') |
22 config.bootstrap_cubes() |
22 config.bootstrap_cubes() |
23 schema = config.load_schema() |
23 schema = config.load_schema() |
24 state_schema = schema['State'] |
|
25 cwuser_schema = schema['CWUser'] |
|
26 file_schema = schema['File'] |
|
27 salesterm_schema = schema['Salesterm'] |
|
28 |
24 |
29 class GuessFieldTC(TestCase): |
25 class GuessFieldTC(TestCase): |
30 |
26 |
31 def test_state_fields(self): |
27 def test_state_fields(self): |
32 title_field = guess_field(state_schema, schema['name']) |
28 title_field = guess_field(schema['State'], schema['name']) |
33 self.assertIsInstance(title_field, StringField) |
29 self.assertIsInstance(title_field, StringField) |
34 self.assertEquals(title_field.required, True) |
30 self.assertEquals(title_field.required, True) |
35 |
31 |
36 # synopsis_field = guess_field(state_schema, schema['synopsis']) |
32 # synopsis_field = guess_field(schema['State'], schema['synopsis']) |
37 # self.assertIsInstance(synopsis_field, StringField) |
33 # self.assertIsInstance(synopsis_field, StringField) |
38 # self.assertIsInstance(synopsis_field.widget, TextArea) |
34 # self.assertIsInstance(synopsis_field.widget, TextArea) |
39 # self.assertEquals(synopsis_field.required, False) |
35 # self.assertEquals(synopsis_field.required, False) |
40 # self.assertEquals(synopsis_field.help, 'an abstract for this state') |
36 # self.assertEquals(synopsis_field.help, 'an abstract for this state') |
41 |
37 |
42 description_field = guess_field(state_schema, schema['description']) |
38 description_field = guess_field(schema['State'], schema['description']) |
43 self.assertIsInstance(description_field, RichTextField) |
39 self.assertIsInstance(description_field, RichTextField) |
44 self.assertEquals(description_field.required, False) |
40 self.assertEquals(description_field.required, False) |
45 self.assertEquals(description_field.format_field, None) |
41 self.assertEquals(description_field.format_field, None) |
46 |
42 |
47 description_format_field = guess_field(state_schema, schema['description_format']) |
43 description_format_field = guess_field(schema['State'], schema['description_format']) |
48 self.assertEquals(description_format_field, None) |
44 self.assertEquals(description_format_field, None) |
49 |
45 |
50 description_format_field = guess_field(state_schema, schema['description_format'], skip_meta_attr=False) |
46 description_format_field = guess_field(schema['State'], schema['description_format'], skip_meta_attr=False) |
51 self.assertEquals(description_format_field.internationalizable, True) |
47 self.assertEquals(description_format_field.internationalizable, True) |
52 self.assertEquals(description_format_field.sort, True) |
48 self.assertEquals(description_format_field.sort, True) |
53 self.assertEquals(description_format_field.initial(None), 'text/rest') |
49 self.assertEquals(description_format_field.initial(None), 'text/rest') |
54 |
50 |
55 |
51 # wikiid_field = guess_field(schema['State'], schema['wikiid']) |
56 # wikiid_field = guess_field(state_schema, schema['wikiid']) |
|
57 # self.assertIsInstance(wikiid_field, StringField) |
52 # self.assertIsInstance(wikiid_field, StringField) |
58 # self.assertEquals(wikiid_field.required, False) |
53 # self.assertEquals(wikiid_field.required, False) |
59 |
54 |
60 |
55 |
61 def test_cwuser_fields(self): |
56 def test_cwuser_fields(self): |
62 upassword_field = guess_field(cwuser_schema, schema['upassword']) |
57 upassword_field = guess_field(schema['CWUser'], schema['upassword']) |
63 self.assertIsInstance(upassword_field, StringField) |
58 self.assertIsInstance(upassword_field, StringField) |
64 self.assertIsInstance(upassword_field.widget, PasswordInput) |
59 self.assertIsInstance(upassword_field.widget, PasswordInput) |
65 self.assertEquals(upassword_field.required, True) |
60 self.assertEquals(upassword_field.required, True) |
66 |
61 |
67 last_login_time_field = guess_field(cwuser_schema, schema['last_login_time']) |
62 last_login_time_field = guess_field(schema['CWUser'], schema['last_login_time']) |
68 self.assertIsInstance(last_login_time_field, DateTimeField) |
63 self.assertIsInstance(last_login_time_field, DateTimeField) |
69 self.assertEquals(last_login_time_field.required, False) |
64 self.assertEquals(last_login_time_field.required, False) |
70 |
65 |
71 in_group_field = guess_field(cwuser_schema, schema['in_group']) |
66 in_group_field = guess_field(schema['CWUser'], schema['in_group']) |
72 self.assertIsInstance(in_group_field, RelationField) |
67 self.assertIsInstance(in_group_field, RelationField) |
73 self.assertEquals(in_group_field.required, True) |
68 self.assertEquals(in_group_field.required, True) |
74 self.assertEquals(in_group_field.role, 'subject') |
69 self.assertEquals(in_group_field.role, 'subject') |
75 self.assertEquals(in_group_field.help, 'groups grant permissions to the user') |
70 self.assertEquals(in_group_field.help, 'groups grant permissions to the user') |
76 |
71 |
77 owned_by_field = guess_field(cwuser_schema, schema['owned_by'], 'object') |
72 owned_by_field = guess_field(schema['CWUser'], schema['owned_by'], 'object') |
78 self.assertIsInstance(owned_by_field, RelationField) |
73 self.assertIsInstance(owned_by_field, RelationField) |
79 self.assertEquals(owned_by_field.required, False) |
74 self.assertEquals(owned_by_field.required, False) |
80 self.assertEquals(owned_by_field.role, 'object') |
75 self.assertEquals(owned_by_field.role, 'object') |
81 |
76 |
82 |
77 |
83 def test_file_fields(self): |
78 def test_file_fields(self): |
84 data_format_field = guess_field(file_schema, schema['data_format']) |
79 data_format_field = guess_field(schema['File'], schema['data_format']) |
85 self.assertEquals(data_format_field, None) |
80 self.assertEquals(data_format_field, None) |
86 data_encoding_field = guess_field(file_schema, schema['data_encoding']) |
81 data_encoding_field = guess_field(schema['File'], schema['data_encoding']) |
87 self.assertEquals(data_encoding_field, None) |
82 self.assertEquals(data_encoding_field, None) |
88 |
83 |
89 data_field = guess_field(file_schema, schema['data']) |
84 data_field = guess_field(schema['File'], schema['data']) |
90 self.assertIsInstance(data_field, FileField) |
85 self.assertIsInstance(data_field, FileField) |
91 self.assertEquals(data_field.required, True) |
86 self.assertEquals(data_field.required, True) |
92 self.assertIsInstance(data_field.format_field, StringField) |
87 self.assertIsInstance(data_field.format_field, StringField) |
93 self.assertIsInstance(data_field.encoding_field, StringField) |
88 self.assertIsInstance(data_field.encoding_field, StringField) |
94 |
89 |
95 def test_constraints_priority(self): |
90 def test_constraints_priority(self): |
96 salesterm_field = guess_field(salesterm_schema, schema['reason']) |
91 salesterm_field = guess_field(schema['Salesterm'], schema['reason']) |
97 constraints = schema['reason'].rproperty('Salesterm', 'String', 'constraints') |
92 constraints = schema['reason'].rproperty('Salesterm', 'String', 'constraints') |
98 self.assertEquals([c.__class__ for c in constraints], |
93 self.assertEquals([c.__class__ for c in constraints], |
99 [SizeConstraint, StaticVocabularyConstraint]) |
94 [SizeConstraint, StaticVocabularyConstraint]) |
100 self.assertIsInstance(salesterm_field.widget, Select) |
95 self.assertIsInstance(salesterm_field.widget, Select) |
|
96 |
|
97 |
|
98 def test_bool_field_base(self): |
|
99 field = guess_field(schema['CWAttribute'], schema['indexed']) |
|
100 self.assertIsInstance(field, BooleanField) |
|
101 self.assertEquals(field.required, False) |
|
102 self.assertEquals(field.initial(None), None) |
|
103 self.assertIsInstance(field.widget, Radio) |
|
104 self.assertEquals(field.vocabulary(mock(req=mock(_=unicode))), |
|
105 [(u'yes', '1'), (u'no', '')]) |
|
106 |
|
107 def test_bool_field_explicit_choices(self): |
|
108 field = guess_field(schema['CWAttribute'], schema['indexed'], |
|
109 choices=[(u'maybe', '1'), (u'no', '')]) |
|
110 self.assertIsInstance(field.widget, Radio) |
|
111 self.assertEquals(field.vocabulary(mock(req=mock(_=unicode))), |
|
112 [(u'maybe', '1'), (u'no', '')]) |
|
113 |
101 |
114 |
102 class MoreFieldsTC(EnvBasedTC): |
115 class MoreFieldsTC(EnvBasedTC): |
103 def test_rtf_format_field(self): |
116 def test_rtf_format_field(self): |
104 req = self.request() |
117 req = self.request() |
105 req.use_fckeditor = lambda: False |
118 req.use_fckeditor = lambda: False |
106 e = self.etype_instance('State') |
119 e = self.etype_instance('State') |
107 form = EntityFieldsForm(req, entity=e) |
120 form = EntityFieldsForm(req, entity=e) |
108 description_field = guess_field(state_schema, schema['description']) |
121 description_field = guess_field(schema['State'], schema['description']) |
109 description_format_field = description_field.get_format_field(form) |
122 description_format_field = description_field.get_format_field(form) |
110 self.assertEquals(description_format_field.internationalizable, True) |
123 self.assertEquals(description_format_field.internationalizable, True) |
111 self.assertEquals(description_format_field.sort, True) |
124 self.assertEquals(description_format_field.sort, True) |
112 # unlike below, initial is bound to form.form_field_format |
125 # unlike below, initial is bound to form.form_field_format |
113 self.assertEquals(description_format_field.initial(form), 'text/html') |
126 self.assertEquals(description_format_field.initial(form), 'text/html') |