1 # copyright 2003-2010 LOGILAB S.A. (Paris, FRANCE), all rights reserved.

     2 # contact http://www.logilab.fr/ -- mailto:contact@logilab.fr

     3 #

     4 # This file is part of CubicWeb.

     5 #

     6 # CubicWeb is free software: you can redistribute it and/or modify it under the

     7 # terms of the GNU Lesser General Public License as published by the Free

     8 # Software Foundation, either version 2.1 of the License, or (at your option)

     9 # any later version.

    10 #

    11 # CubicWeb is distributed in the hope that it will be useful, but WITHOUT

    12 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

    13 # FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more

    14 # details.

    15 #

    16 # You should have received a copy of the GNU Lesser General Public License along

    17 # with CubicWeb.  If not, see <http://www.gnu.org/licenses/>.

    18 """unittests for cw.web.formfields"""

    19 

    20 from logilab.common.testlib import TestCase, unittest_main, mock_object as mock

    21 

    22 from yams.constraints import StaticVocabularyConstraint, SizeConstraint

    23 

    24 import cubicweb

    25 from cubicweb.devtools import TestServerConfiguration

    26 from cubicweb.devtools.testlib import CubicWebTC

    27 from cubicweb.web.formwidgets import PasswordInput, TextArea, Select, Radio

    28 from cubicweb.web.formfields import *

    29 from cubicweb.web.views.forms import EntityFieldsForm, FieldsForm

    30 

    31 from cubes.file.entities import File

    32 

    33 def setUpModule(*args):

    34     global schema

    35     config = TestServerConfiguration('data', apphome=GuessFieldTC.datadir)

    36     config.bootstrap_cubes()

    37     schema = config.load_schema()

    38 

    39 class GuessFieldTC(CubicWebTC):

    40 

    41     def test_state_fields(self):

    42         with self.admin_access.web_request() as req:

    43             title_field = guess_field(schema['State'], schema['name'], req=req)

    44             self.assertIsInstance(title_field, StringField)

    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 

    53         with self.admin_access.web_request() as req:

    54             description_field = guess_field(schema['State'], schema['description'], req=req)

    55             self.assertIsInstance(description_field, RichTextField)

    56             self.assertEqual(description_field.required, False)

    57             self.assertEqual(description_field.format_field, None)

    58 

    59         # description_format_field = guess_field(schema['State'], schema['description_format'])

    60         # self.assertEqual(description_format_field, None)

    61 

    62         with self.admin_access.web_request() as req:

    63             description_format_field = guess_field(schema['State'], schema['description_format'],

    64                                                    req=req)

    65             self.assertEqual(description_format_field.internationalizable, True)

    66             self.assertEqual(description_format_field.sort, True)

    67 

    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):

    74         with self.admin_access.web_request() as req:

    75             upassword_field = guess_field(schema['CWUser'], schema['upassword'], req=req)

    76             self.assertIsInstance(upassword_field, StringField)

    77             self.assertIsInstance(upassword_field.widget, PasswordInput)

    78             self.assertEqual(upassword_field.required, True)

    79 

    80         with self.admin_access.web_request() as req:

    81             last_login_time_field = guess_field(schema['CWUser'], schema['last_login_time'], req=req)

    82             self.assertIsInstance(last_login_time_field, DateTimeField)

    83             self.assertEqual(last_login_time_field.required, False)

    84 

    85         with self.admin_access.web_request() as req:

    86             in_group_field = guess_field(schema['CWUser'], schema['in_group'], req=req)

    87             self.assertIsInstance(in_group_field, RelationField)

    88             self.assertEqual(in_group_field.required, True)

    89             self.assertEqual(in_group_field.role, 'subject')

    90             self.assertEqual(in_group_field.help, 'groups grant permissions to the user')

    91 

    92         with self.admin_access.web_request() as req:

    93             owned_by_field = guess_field(schema['CWUser'], schema['owned_by'], 'object', req=req)

    94             self.assertIsInstance(owned_by_field, RelationField)

    95             self.assertEqual(owned_by_field.required, False)

    96             self.assertEqual(owned_by_field.role, 'object')

    97 

    98 

    99     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:

   108             data_field = guess_field(schema['File'], schema['data'], req=req)

   109             self.assertIsInstance(data_field, FileField)

   110             self.assertEqual(data_field.required, True)

   111             self.assertIsInstance(data_field.format_field, StringField)

   112             self.assertIsInstance(data_field.encoding_field, StringField)

   113             self.assertIsInstance(data_field.name_field, StringField)

   114 

   115     def test_constraints_priority(self):

   116         with self.admin_access.web_request() as req:

   117             salesterm_field = guess_field(schema['Salesterm'], schema['reason'], req=req)

   118             constraints = schema['reason'].rdef('Salesterm', 'String').constraints

   119             self.assertEqual([c.__class__ for c in constraints],

   120                               [SizeConstraint, StaticVocabularyConstraint])

   121             self.assertIsInstance(salesterm_field, StringField)

   122             self.assertIsInstance(salesterm_field.widget, Select)

   123 

   124 

   125     def test_bool_field_base(self):

   126         with self.admin_access.web_request() as req:

   127             field = guess_field(schema['CWAttribute'], schema['indexed'], req=req)

   128             self.assertIsInstance(field, BooleanField)

   129             self.assertEqual(field.required, False)

   130             self.assertIsInstance(field.widget, Radio)

   131             self.assertEqual(field.vocabulary(mock(_cw=mock(_=cubicweb._))),

   132                               [(u'yes', '1'), (u'no', '')])

   133 

   134     def test_bool_field_explicit_choices(self):

   135         with self.admin_access.web_request() as req:

   136             field = guess_field(schema['CWAttribute'], schema['indexed'],

   137                                 choices=[(u'maybe', '1'), (u'no', '')], req=req)

   138             self.assertIsInstance(field.widget, Radio)

   139             self.assertEqual(field.vocabulary(mock(req=mock(_=cubicweb._))),

   140                               [(u'maybe', '1'), (u'no', '')])

   141 

   142 

   143 class MoreFieldsTC(CubicWebTC):

   144     def test_rtf_format_field(self):

   145         with self.admin_access.web_request() as req:

   146             req.use_fckeditor = lambda: False

   147             e = self.vreg['etypes'].etype_class('State')(req)

   148             form = EntityFieldsForm(req, entity=e)

   149             description_field = guess_field(schema['State'], schema['description'])

   150             description_format_field = description_field.get_format_field(form)

   151             self.assertEqual(description_format_field.internationalizable, True)

   152             self.assertEqual(description_format_field.sort, True)

   153             # unlike below, initial is bound to form.form_field_format

   154             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"')

   156             req.cnx.commit()

   157             self.assertEqual(description_format_field.value(form), 'text/rest')

   158 

   159 

   160     def test_property_key_field(self):

   161         from cubicweb.web.views.cwproperties import PropertyKeyField

   162         with self.admin_access.web_request() as req:

   163             field = PropertyKeyField(name='test')

   164             e = self.vreg['etypes'].etype_class('CWProperty')(req)

   165             renderer = self.vreg['formrenderers'].select('base', req)

   166             form = EntityFieldsForm(req, entity=e)

   167             form.formvalues = {}

   168             field.render(form, renderer)

   169 

   170 

   171 class CompoundFieldTC(CubicWebTC):

   172 

   173     def test_multipart(self):

   174         """Ensures that compound forms have needs_multipart set if their

   175         children require it"""

   176         class AForm(FieldsForm):

   177             comp = CompoundField([IntField(), StringField()])

   178         with self.admin_access.web_request() as req:

   179             aform = AForm(req, None)

   180             self.assertFalse(aform.needs_multipart)

   181         class MForm(FieldsForm):

   182             comp = CompoundField([IntField(), FileField()])

   183         with self.admin_access.web_request() as req:

   184             mform = MForm(req, None)

   185             self.assertTrue(mform.needs_multipart)

   186 

   187 

   188 class UtilsTC(TestCase):

   189     def test_vocab_sort(self):

   190         self.assertEqual(vocab_sort([('Z', 1), ('A', 2),

   191                                       ('Group 1', None), ('Y', 3), ('B', 4),

   192                                       ('Group 2', None), ('X', 5), ('C', 6)]),

   193                           [('A', 2), ('Z', 1),

   194                            ('Group 1', None), ('B', 4), ('Y', 3),

   195                            ('Group 2', None), ('C', 6), ('X', 5)]

   196                           )

   197 

   198 if __name__ == '__main__':

   199     unittest_main()