unit-test: on import_data zero values shouldn't be converted to None

import_data method converts zero values to None. As a consequence such records
don't pass the required constraint for such fields

issue3136
review779002

trytond/test/__init__.py

@@ -94,8 +94,11 @@ def register():
         MPTT,
         ImportDataBoolean,
         ImportDataInteger,
+        ImportDataIntegerRequired,
         ImportDataFloat,
+        ImportDataFloatRequired,
         ImportDataNumeric,
+        ImportDataNumericRequired,
         ImportDataChar,
         ImportDataText,
         ImportDataSha,

trytond/test/import_data.py

@@ -4,8 +4,10 @@
 from trytond.model import ModelSQL, fields
 
 __all__ = [
-    'ImportDataBoolean', 'ImportDataInteger', 'ImportDataFloat',
-    'ImportDataNumeric', 'ImportDataChar', 'ImportDataText', 'ImportDataSha',
+    'ImportDataBoolean', 'ImportDataInteger', 'ImportDataIntegerRequired',
+    'ImportDataFloat', 'ImportDataFloatRequired',
+    'ImportDataNumeric', 'ImportDataNumericRequired',
+    'ImportDataChar', 'ImportDataText', 'ImportDataSha',
     'ImportDataDate', 'ImportDataDateTime', 'ImportDataSelection',
     'ImportDataMany2OneTarget', 'ImportDataMany2One',
     'ImportDataMany2ManyTarget', 'ImportDataMany2Many',
@@ -27,18 +29,36 @@ class ImportDataInteger(ModelSQL):
     integer = fields.Integer('Integer')
 
 
+class ImportDataIntegerRequired(ModelSQL):
+    "Import Data Integer Required"
+    __name__ = 'test.import_data.integer_required'
+    integer = fields.Integer('Integer', required=True)
+
+
 class ImportDataFloat(ModelSQL):
     "Import Data Float"
     __name__ = 'test.import_data.float'
     float = fields.Float('Float')
 
 
+class ImportDataFloatRequired(ModelSQL):
+    "Import Data Float Required"
+    __name__ = 'test.import_data.float_required'
+    float = fields.Float('Float', required=True)
+
+
 class ImportDataNumeric(ModelSQL):
     "Import Data Numeric"
     __name__ = 'test.import_data.numeric'
     numeric = fields.Numeric('Numeric')
 
 
+class ImportDataNumericRequired(ModelSQL):
+    "Import Data Numeric Required"
+    __name__ = 'test.import_data.numeric_required'
+    numeric = fields.Numeric('Numeric', required=True)
+
+
 class ImportDataChar(ModelSQL):
     "Import Data Char"
     __name__ = 'test.import_data.char'

trytond/tests/test_importdata.py

@@ -17,8 +17,11 @@ class ImportDataTestCase(unittest.TestCase):
         install_module('test')
         self.boolean = POOL.get('test.import_data.boolean')
         self.integer = POOL.get('test.import_data.integer')
+        self.integer_required = POOL.get('test.import_data.integer_required')
         self.float = POOL.get('test.import_data.float')
+        self.float_required = POOL.get('test.import_data.float_required')
         self.numeric = POOL.get('test.import_data.numeric')
+        self.numeric_required = POOL.get('test.import_data.numeric_required')
         self.char = POOL.get('test.import_data.char')
         self.text = POOL.get('test.import_data.text')
         self.sha = POOL.get('test.import_data.sha')
@@ -86,6 +89,41 @@ class ImportDataTestCase(unittest.TestCase):
             self.assertEqual(self.integer.import_data(['integer'],
                 [['foo']])[0], -1)
 
+            self.assertEqual(self.integer.import_data(['integer'],
+                [['0']]), (1, 0, 0, 0))
+
+            transaction.cursor.rollback()
+
+    def test0021integer_required(self):
+        '''
+        Test required integer.
+        '''
+        with Transaction().start(DB_NAME, USER,
+                context=CONTEXT) as transaction:
+            self.assertEqual(self.integer_required.import_data(['integer'],
+                [['1']]), (1, 0, 0, 0))
+
+            self.assertEqual(self.integer_required.import_data(['integer'],
+                [['-1']]), (1, 0, 0, 0))
+
+            self.assertEqual(self.integer_required.import_data(['integer'],
+                [['']])[0], -1)
+
+            self.assertEqual(self.integer_required.import_data(['integer'],
+                [['1'], ['2']]), (2, 0, 0, 0))
+
+            self.assertEqual(self.integer_required.import_data(['integer'],
+                [['1.1']])[0], -1)
+
+            self.assertEqual(self.integer_required.import_data(['integer'],
+                [['-1.1']])[0], -1)
+
+            self.assertEqual(self.integer_required.import_data(['integer'],
+                [['foo']])[0], -1)
+
+            self.assertEqual(self.integer_required.import_data(['integer'],
+                [['0']]), (1, 0, 0, 0))
+
             transaction.cursor.rollback()
 
     def test0030float(self):
@@ -112,6 +150,44 @@ class ImportDataTestCase(unittest.TestCase):
             self.assertEqual(self.float.import_data(['float'],
                 [['foo']])[0], -1)
 
+            self.assertEqual(self.float.import_data(['float'],
+                [['0']]), (1, 0, 0, 0))
+
+            self.assertEqual(self.float.import_data(['float'],
+                [['0.0']]), (1, 0, 0, 0))
+
+            transaction.cursor.rollback()
+
+    def test0031float_required(self):
+        '''
+        Test required float.
+        '''
+        with Transaction().start(DB_NAME, USER,
+                context=CONTEXT) as transaction:
+            self.assertEqual(self.float_required.import_data(['float'],
+                [['1.1']]), (1, 0, 0, 0))
+
+            self.assertEqual(self.float_required.import_data(['float'],
+                [['-1.1']]), (1, 0, 0, 0))
+
+            self.assertEqual(self.float_required.import_data(['float'],
+                [['1']]), (1, 0, 0, 0))
+
+            self.assertEqual(self.float_required.import_data(['float'],
+                [['']])[0], -1)
+
+            self.assertEqual(self.float_required.import_data(['float'],
+                [['1.1'], ['2.2']]), (2, 0, 0, 0))
+
+            self.assertEqual(self.float_required.import_data(['float'],
+                [['foo']])[0], -1)
+
+            self.assertEqual(self.float_required.import_data(['float'],
+                [['0']]), (1, 0, 0, 0))
+
+            self.assertEqual(self.float_required.import_data(['float'],
+                [['0.0']]), (1, 0, 0, 0))
+
             transaction.cursor.rollback()
 
     def test0040numeric(self):
@@ -138,6 +214,44 @@ class ImportDataTestCase(unittest.TestCase):
             self.assertEqual(self.numeric.import_data(['numeric'],
                 [['foo']])[0], -1)
 
+            self.assertEqual(self.numeric.import_data(['numeric'],
+                [['0']]), (1, 0, 0, 0))
+
+            self.assertEqual(self.numeric.import_data(['numeric'],
+                [['0.0']]), (1, 0, 0, 0))
+
+            transaction.cursor.rollback()
+
+    def test0041numeric_required(self):
+        '''
+        Test required numeric.
+        '''
+        with Transaction().start(DB_NAME, USER,
+                context=CONTEXT) as transaction:
+            self.assertEqual(self.numeric_required.import_data(['numeric'],
+                [['1.1']]), (1, 0, 0, 0))
+
+            self.assertEqual(self.numeric_required.import_data(['numeric'],
+                [['-1.1']]), (1, 0, 0, 0))
+
+            self.assertEqual(self.numeric_required.import_data(['numeric'],
+                [['1']]), (1, 0, 0, 0))
+
+            self.assertEqual(self.numeric_required.import_data(['numeric'],
+                [['']])[0], -1)
+
+            self.assertEqual(self.numeric_required.import_data(['numeric'],
+                [['1.1'], ['2.2']]), (2, 0, 0, 0))
+
+            self.assertEqual(self.numeric_required.import_data(['numeric'],
+                [['foo']])[0], -1)
+
+            self.assertEqual(self.numeric_required.import_data(['numeric'],
+                [['0']]), (1, 0, 0, 0))
+
+            self.assertEqual(self.numeric_required.import_data(['numeric'],
+                [['0.0']]), (1, 0, 0, 0))
+
             transaction.cursor.rollback()
 
     def test0050char(self):