Factorize the required test

issue2587
review370001

trytond/model/modelstorage.py

@@ -1058,6 +1058,14 @@ class ModelStorage(Model):
                                         'domain_validation_record',
                                         error_args=self._get_error_args(
                                             field_name))
+
+                def required_test(value, field_name):
+                    if (isinstance(value,
+                                (BrowseRecordNull, type(None), type(False),
+                                    BrowseRecordList))
+                            and not value):
+                        self.raise_user_error('required_validation_record',
+                            error_args=self._get_error_args(field_name))
                 # validate states required
                 if field.states and 'required' in field.states:
                     if is_pyson(field.states['required']):
@@ -1071,28 +1079,16 @@ class ModelStorage(Model):
                             env['context'] = Transaction().context
                             env['active_id'] = record.id
                             required = PYSONDecoder(env).decode(pyson_required)
-                            if required and record[field_name] is None:
-                                self.raise_user_error(
-                                        'required_validation_record',
-                                        error_args=self._get_error_args(
-                                            field_name))
+                            if required:
+                                required_test(record[field_name], field_name)
                     else:
                         if field.states['required']:
                             for record in records:
-                                if not record[field_name]:
-                                    self.raise_user_error(
-                                            'required_validation_record',
-                                            error_args=self._get_error_args(
-                                                field_name))
+                                required_test(record[field_name], field_name)
                 # validate required
                 if field.required:
                     for record in records:
-                        if (isinstance(record[field_name], (BrowseRecordNull,
-                                        type(None), type(False)))
-                                and not record[field_name]):
-                            self.raise_user_error(
-                                'required_validation_record',
-                                error_args=self._get_error_args(field_name))
+                        required_test(record[field_name], field_name)
                 # validate size
                 if hasattr(field, 'size') and field.size:
                     for record in records:

trytond/test/test.py

@@ -492,6 +492,27 @@ class One2ManyTarget(ModelSQL):
 One2ManyTarget()
 
 
+class One2ManyRequired(ModelSQL):
+    'One2Many Required'
+    _name = 'test.one2many_required'
+    _description = __doc__
+    name = fields.Char('Name', required=True)
+    targets = fields.One2Many('test.one2many_required.target', 'origin',
+        'Targets', required=True)
+
+One2ManyRequired()
+
+
+class One2ManyRequiredTarget(ModelSQL):
+    'One2Many Required Target'
+    _name = 'test.one2many_required.target'
+    _description = __doc__
+    name = fields.Char('Name', required=True)
+    origin = fields.Many2One('test.one2many_required', 'Origin')
+
+One2ManyRequiredTarget()
+
+
 class One2ManyReference(ModelSQL):
     'One2Many Reference Relation'
     _name = 'test.one2many_reference'
@@ -546,6 +567,37 @@ class Many2ManyRelation(ModelSQL):
 Many2ManyRelation()
 
 
+class Many2ManyRequired(ModelSQL):
+    'Many2Many Required'
+    _name = 'test.many2many_required'
+    _description = __doc__
+    name = fields.Char('Name', required=True)
+    targets = fields.Many2Many('test.many2many.relation', 'origin', 'target',
+        'Targets', required=True)
+
+Many2ManyRequired()
+
+
+class Many2ManyRequiredTarget(ModelSQL):
+    'Many2Many Required Target'
+    _name = 'test.many2many_required.target'
+    _description = __doc__
+    name = fields.Char('Name', required=True)
+
+
+Many2ManyRequiredTarget()
+
+
+class Many2ManyRequiredRelation(ModelSQL):
+    'Many2Many Required Relation'
+    _name = 'test.many2many_required.relation'
+    _description = __doc__
+    origin = fields.Many2One('test.many2many', 'Origin')
+    target = fields.Many2One('test.many2many.target', 'Target')
+
+Many2ManyRequiredRelation()
+
+
 class Many2ManyReference(ModelSQL):
     'Many2Many Reference'
     _name = 'test.many2many_reference'

trytond/tests/test_fields.py

@@ -78,12 +78,14 @@ class FieldsTestCase(unittest.TestCase):
 
         self.one2many = POOL.get('test.one2many')
         self.one2many_target = POOL.get('test.one2many.target')
+        self.one2many_required = POOL.get('test.one2many_required')
         self.one2many_reference = POOL.get('test.one2many_reference')
         self.one2many_reference_target = POOL.get(
             'test.one2many_reference.target')
 
         self.many2many = POOL.get('test.many2many')
         self.many2many_target = POOL.get('test.many2many.target')
+        self.many2many_required = POOL.get('test.many2many_required')
         self.many2many_reference = POOL.get('test.many2many_reference')
         self.many2many_reference_target = POOL.get(
             'test.many2many_reference.target')
@@ -2627,6 +2629,23 @@ class FieldsTestCase(unittest.TestCase):
 
                 transaction.cursor.rollback()
 
+            self.assertRaises(Exception, self.one2many_required.create, {
+                    'name': 'origin3',
+                    })
+            transaction.cursor.rollback()
+
+            origin3_id = self.one2many_required.create({
+                    'name': 'origin3',
+                    'targets': [
+                        ('create', {
+                                'name': 'target3',
+                                }),
+                        ],
+                    })
+            self.assert_(origin3_id)
+
+            transaction.cursor.rollback()
+
     def test0130many2many(self):
         '''
         Test Many2Many.
@@ -2786,6 +2805,23 @@ class FieldsTestCase(unittest.TestCase):
 
                 transaction.cursor.rollback()
 
+            self.assertRaises(Exception, self.many2many_required.create, {
+                    'name': 'origin3',
+                    })
+            transaction.cursor.rollback()
+
+            origin3_id = self.many2many_required.create({
+                    'name': 'origin3',
+                    'targets': [
+                        ('create', {
+                                'name': 'target3',
+                                }),
+                        ],
+                    })
+            self.assert_(origin3_id)
+
+            transaction.cursor.rollback()
+
     def test0140property(self):
         '''
         Test Property with supported field types.