38 class GuessFieldTC(TestCase): |
36 class GuessFieldTC(TestCase): |
39 |
37 |
40 def test_state_fields(self): |
38 def test_state_fields(self): |
41 title_field = guess_field(schema['State'], schema['name']) |
39 title_field = guess_field(schema['State'], schema['name']) |
42 self.assertIsInstance(title_field, StringField) |
40 self.assertIsInstance(title_field, StringField) |
43 self.assertEquals(title_field.required, True) |
41 self.assertEqual(title_field.required, True) |
44 |
42 |
45 # synopsis_field = guess_field(schema['State'], schema['synopsis']) |
43 # synopsis_field = guess_field(schema['State'], schema['synopsis']) |
46 # self.assertIsInstance(synopsis_field, StringField) |
44 # self.assertIsInstance(synopsis_field, StringField) |
47 # self.assertIsInstance(synopsis_field.widget, TextArea) |
45 # self.assertIsInstance(synopsis_field.widget, TextArea) |
48 # self.assertEquals(synopsis_field.required, False) |
46 # self.assertEqual(synopsis_field.required, False) |
49 # self.assertEquals(synopsis_field.help, 'an abstract for this state') |
47 # self.assertEqual(synopsis_field.help, 'an abstract for this state') |
50 |
48 |
51 description_field = guess_field(schema['State'], schema['description']) |
49 description_field = guess_field(schema['State'], schema['description']) |
52 self.assertIsInstance(description_field, RichTextField) |
50 self.assertIsInstance(description_field, RichTextField) |
53 self.assertEquals(description_field.required, False) |
51 self.assertEqual(description_field.required, False) |
54 self.assertEquals(description_field.format_field, None) |
52 self.assertEqual(description_field.format_field, None) |
|
53 |
|
54 # description_format_field = guess_field(schema['State'], schema['description_format']) |
|
55 # self.assertEqual(description_format_field, None) |
55 |
56 |
56 description_format_field = guess_field(schema['State'], schema['description_format']) |
57 description_format_field = guess_field(schema['State'], schema['description_format']) |
57 self.assertEquals(description_format_field, None) |
58 self.assertEqual(description_format_field.internationalizable, True) |
58 |
59 self.assertEqual(description_format_field.sort, True) |
59 description_format_field = guess_field(schema['State'], schema['description_format'], skip_meta_attr=False) |
|
60 self.assertEquals(description_format_field.internationalizable, True) |
|
61 self.assertEquals(description_format_field.sort, True) |
|
62 |
60 |
63 # wikiid_field = guess_field(schema['State'], schema['wikiid']) |
61 # wikiid_field = guess_field(schema['State'], schema['wikiid']) |
64 # self.assertIsInstance(wikiid_field, StringField) |
62 # self.assertIsInstance(wikiid_field, StringField) |
65 # self.assertEquals(wikiid_field.required, False) |
63 # self.assertEqual(wikiid_field.required, False) |
66 |
64 |
67 |
65 |
68 def test_cwuser_fields(self): |
66 def test_cwuser_fields(self): |
69 upassword_field = guess_field(schema['CWUser'], schema['upassword']) |
67 upassword_field = guess_field(schema['CWUser'], schema['upassword']) |
70 self.assertIsInstance(upassword_field, StringField) |
68 self.assertIsInstance(upassword_field, StringField) |
71 self.assertIsInstance(upassword_field.widget, PasswordInput) |
69 self.assertIsInstance(upassword_field.widget, PasswordInput) |
72 self.assertEquals(upassword_field.required, True) |
70 self.assertEqual(upassword_field.required, True) |
73 |
71 |
74 last_login_time_field = guess_field(schema['CWUser'], schema['last_login_time']) |
72 last_login_time_field = guess_field(schema['CWUser'], schema['last_login_time']) |
75 self.assertIsInstance(last_login_time_field, DateTimeField) |
73 self.assertIsInstance(last_login_time_field, DateTimeField) |
76 self.assertEquals(last_login_time_field.required, False) |
74 self.assertEqual(last_login_time_field.required, False) |
77 |
75 |
78 in_group_field = guess_field(schema['CWUser'], schema['in_group']) |
76 in_group_field = guess_field(schema['CWUser'], schema['in_group']) |
79 self.assertIsInstance(in_group_field, RelationField) |
77 self.assertIsInstance(in_group_field, RelationField) |
80 self.assertEquals(in_group_field.required, True) |
78 self.assertEqual(in_group_field.required, True) |
81 self.assertEquals(in_group_field.role, 'subject') |
79 self.assertEqual(in_group_field.role, 'subject') |
82 self.assertEquals(in_group_field.help, 'groups grant permissions to the user') |
80 self.assertEqual(in_group_field.help, 'groups grant permissions to the user') |
83 |
81 |
84 owned_by_field = guess_field(schema['CWUser'], schema['owned_by'], 'object') |
82 owned_by_field = guess_field(schema['CWUser'], schema['owned_by'], 'object') |
85 self.assertIsInstance(owned_by_field, RelationField) |
83 self.assertIsInstance(owned_by_field, RelationField) |
86 self.assertEquals(owned_by_field.required, False) |
84 self.assertEqual(owned_by_field.required, False) |
87 self.assertEquals(owned_by_field.role, 'object') |
85 self.assertEqual(owned_by_field.role, 'object') |
88 |
86 |
89 |
87 |
90 def test_file_fields(self): |
88 def test_file_fields(self): |
91 data_format_field = guess_field(schema['File'], schema['data_format']) |
89 # data_format_field = guess_field(schema['File'], schema['data_format']) |
92 self.assertEquals(data_format_field, None) |
90 # self.assertEqual(data_format_field, None) |
93 data_encoding_field = guess_field(schema['File'], schema['data_encoding']) |
91 # data_encoding_field = guess_field(schema['File'], schema['data_encoding']) |
94 self.assertEquals(data_encoding_field, None) |
92 # self.assertEqual(data_encoding_field, None) |
95 data_name_field = guess_field(schema['File'], schema['data_name']) |
93 # data_name_field = guess_field(schema['File'], schema['data_name']) |
96 self.assertEquals(data_name_field, None) |
94 # self.assertEqual(data_name_field, None) |
97 |
95 |
98 data_field = guess_field(schema['File'], schema['data']) |
96 data_field = guess_field(schema['File'], schema['data']) |
99 self.assertIsInstance(data_field, FileField) |
97 self.assertIsInstance(data_field, FileField) |
100 self.assertEquals(data_field.required, True) |
98 self.assertEqual(data_field.required, True) |
101 self.assertIsInstance(data_field.format_field, StringField) |
99 self.assertIsInstance(data_field.format_field, StringField) |
102 self.assertIsInstance(data_field.encoding_field, StringField) |
100 self.assertIsInstance(data_field.encoding_field, StringField) |
103 self.assertIsInstance(data_field.name_field, StringField) |
101 self.assertIsInstance(data_field.name_field, StringField) |
104 |
102 |
105 def test_constraints_priority(self): |
103 def test_constraints_priority(self): |
106 salesterm_field = guess_field(schema['Salesterm'], schema['reason']) |
104 salesterm_field = guess_field(schema['Salesterm'], schema['reason']) |
107 constraints = schema['reason'].rdef('Salesterm', 'String').constraints |
105 constraints = schema['reason'].rdef('Salesterm', 'String').constraints |
108 self.assertEquals([c.__class__ for c in constraints], |
106 self.assertEqual([c.__class__ for c in constraints], |
109 [SizeConstraint, StaticVocabularyConstraint]) |
107 [SizeConstraint, StaticVocabularyConstraint]) |
110 self.assertIsInstance(salesterm_field, StringField) |
108 self.assertIsInstance(salesterm_field, StringField) |
111 self.assertIsInstance(salesterm_field.widget, Select) |
109 self.assertIsInstance(salesterm_field.widget, Select) |
112 |
110 |
113 |
111 |
114 def test_bool_field_base(self): |
112 def test_bool_field_base(self): |
115 field = guess_field(schema['CWAttribute'], schema['indexed']) |
113 field = guess_field(schema['CWAttribute'], schema['indexed']) |
116 self.assertIsInstance(field, BooleanField) |
114 self.assertIsInstance(field, BooleanField) |
117 self.assertEquals(field.required, False) |
115 self.assertEqual(field.required, False) |
118 self.assertIsInstance(field.widget, Radio) |
116 self.assertIsInstance(field.widget, Radio) |
119 self.assertEquals(field.vocabulary(mock(_cw=mock(_=unicode))), |
117 self.assertEqual(field.vocabulary(mock(_cw=mock(_=unicode))), |
120 [(u'yes', '1'), (u'no', '')]) |
118 [(u'yes', '1'), (u'no', '')]) |
121 |
119 |
122 def test_bool_field_explicit_choices(self): |
120 def test_bool_field_explicit_choices(self): |
123 field = guess_field(schema['CWAttribute'], schema['indexed'], |
121 field = guess_field(schema['CWAttribute'], schema['indexed'], |
124 choices=[(u'maybe', '1'), (u'no', '')]) |
122 choices=[(u'maybe', '1'), (u'no', '')]) |
125 self.assertIsInstance(field.widget, Radio) |
123 self.assertIsInstance(field.widget, Radio) |
126 self.assertEquals(field.vocabulary(mock(req=mock(_=unicode))), |
124 self.assertEqual(field.vocabulary(mock(req=mock(_=unicode))), |
127 [(u'maybe', '1'), (u'no', '')]) |
125 [(u'maybe', '1'), (u'no', '')]) |
128 |
126 |
129 |
127 |
130 class MoreFieldsTC(CubicWebTC): |
128 class MoreFieldsTC(CubicWebTC): |
131 def test_rtf_format_field(self): |
129 def test_rtf_format_field(self): |
133 req.use_fckeditor = lambda: False |
131 req.use_fckeditor = lambda: False |
134 e = self.vreg['etypes'].etype_class('State')(req) |
132 e = self.vreg['etypes'].etype_class('State')(req) |
135 form = EntityFieldsForm(req, entity=e) |
133 form = EntityFieldsForm(req, entity=e) |
136 description_field = guess_field(schema['State'], schema['description']) |
134 description_field = guess_field(schema['State'], schema['description']) |
137 description_format_field = description_field.get_format_field(form) |
135 description_format_field = description_field.get_format_field(form) |
138 self.assertEquals(description_format_field.internationalizable, True) |
136 self.assertEqual(description_format_field.internationalizable, True) |
139 self.assertEquals(description_format_field.sort, True) |
137 self.assertEqual(description_format_field.sort, True) |
140 # unlike below, initial is bound to form.form_field_format |
138 # unlike below, initial is bound to form.form_field_format |
141 self.assertEquals(description_format_field.value(form), 'text/html') |
139 self.assertEqual(description_format_field.value(form), 'text/html') |
142 self.execute('INSERT CWProperty X: X pkey "ui.default-text-format", X value "text/rest", X for_user U WHERE U login "admin"') |
140 self.execute('INSERT CWProperty X: X pkey "ui.default-text-format", X value "text/rest", X for_user U WHERE U login "admin"') |
143 self.commit() |
141 self.commit() |
144 self.assertEquals(description_format_field.value(form), 'text/rest') |
142 self.assertEqual(description_format_field.value(form), 'text/rest') |
145 |
143 |
146 |
144 |
147 class UtilsTC(TestCase): |
145 class UtilsTC(TestCase): |
148 def test_vocab_sort(self): |
146 def test_vocab_sort(self): |
149 self.assertEquals(vocab_sort([('Z', 1), ('A', 2), |
147 self.assertEqual(vocab_sort([('Z', 1), ('A', 2), |
150 ('Group 1', None), ('Y', 3), ('B', 4), |
148 ('Group 1', None), ('Y', 3), ('B', 4), |
151 ('Group 2', None), ('X', 5), ('C', 6)]), |
149 ('Group 2', None), ('X', 5), ('C', 6)]), |
152 [('A', 2), ('Z', 1), |
150 [('A', 2), ('Z', 1), |
153 ('Group 1', None), ('B', 4), ('Y', 3), |
151 ('Group 1', None), ('B', 4), ('Y', 3), |
154 ('Group 2', None), ('C', 6), ('X', 5)] |
152 ('Group 2', None), ('C', 6), ('X', 5)] |