[FIX] models: exists() should not consider record with id 0 as existing

[odoo/odoo.git] / openerp / addons / base / tests / test_orm.py

diff --git a/openerp/addons/base/tests/test_orm.py b/openerp/addons/base/tests/test_orm.py
index 9683874..0c877a4 100644 (file)
--- a/openerp/addons/base/tests/test_orm.py
+++ b/openerp/addons/base/tests/test_orm.py
@@ -24,7 +24,7 @@ class TestORM(common.TransactionCase):
         employee_gid = self.ref('base.group_user')
         self.uid2 = self.users.create(cr, uid, {'name': 'test user', 'login': 'test', 'groups_id': [4,employee_gid]})
 
-    @mute_logger('openerp.osv.orm')
+    @mute_logger('openerp.models')
     def testAccessDeletedRecords(self):
         """ Verify that accessing deleted records works as expected """
         cr, uid, uid2, p1, p2 = self.cr, self.uid, self.uid2, self.p1, self.p2
@@ -45,7 +45,7 @@ class TestORM(common.TransactionCase):
         with self.assertRaises(Exception):
             self.partner.write(cr, uid, [p1], {'name': 'foo'})
 
-    @mute_logger('openerp.osv.orm')
+    @mute_logger('openerp.models')
     def testAccessFilteredRecords(self):
         """ Verify that accessing filtered records works as expected for non-admin user """
         cr, uid, uid2, p1, p2 = self.cr, self.uid, self.uid2, self.p1, self.p2
@@ -77,7 +77,17 @@ class TestORM(common.TransactionCase):
         with self.assertRaises(Exception):
             self.partner.unlink(cr, uid2, [p1,p2])
 
-    @mute_logger('openerp.osv.orm')
+    def test_multi_read(self):
+        record_id = self.partner.create(self.cr, UID, {'name': 'MyPartner1'})
+        records = self.partner.read(self.cr, UID, [record_id])
+        self.assertIsInstance(records, list)
+
+    def test_one_read(self):
+        record_id = self.partner.create(self.cr, UID, {'name': 'MyPartner1'})
+        record = self.partner.read(self.cr, UID, record_id)
+        self.assertIsInstance(record, dict)
+
+    @mute_logger('openerp.models')
     def test_search_read(self):
         # simple search_read
         self.partner.create(self.cr, UID, {'name': 'MyPartner1'})
@@ -101,6 +111,18 @@ class TestORM(common.TransactionCase):
         found = self.partner.search_read(self.cr, UID, [['name', '=', 'Does not exists']], ['name'])
         self.assertEqual(len(found), 0)
 
+    def test_exists(self):
+        partner = self.partner.browse(self.cr, UID, [])
+
+        # check that records obtained from search exist
+        recs = partner.search([])
+        self.assertTrue(recs)
+        self.assertEqual(recs.exists(), recs)
+
+        # check that there is no record with id 0
+        recs = partner.browse([0])
+        self.assertFalse(recs.exists())
+
     def test_groupby_date(self):
         partners = dict(
             A='2012-11-19',
@@ -141,6 +163,10 @@ class TestORM(common.TransactionCase):
         self.assertEqual(len(read_group('month')), len(partners_by_month))
         self.assertEqual(len(read_group('year')), len(partners_by_year))
 
+        rg = self.partner.read_group(self.cr, self.uid, [('id', 'in', all_partners)], 
+                        ['date'], ['date:month', 'date:day'], lazy=False)
+        self.assertEqual(len(rg), len(all_partners))
+
 
 class TestInherits(common.TransactionCase):
     """ test the behavior of the orm for models that use _inherits;
@@ -152,6 +178,12 @@ class TestInherits(common.TransactionCase):
         self.partner = self.registry('res.partner')
         self.user = self.registry('res.users')
 
+    def test_default(self):
+        """ `default_get` cannot return a dictionary or a new id """
+        defaults = self.user.default_get(self.cr, UID, ['partner_id'])
+        if 'partner_id' in defaults:
+            self.assertIsInstance(defaults['partner_id'], (bool, int, long))
+
     def test_create(self):
         """ creating a user should automatically create a new partner """
         partners_before = self.partner.search(self.cr, UID, [])
@@ -173,7 +205,7 @@ class TestInherits(common.TransactionCase):
         self.assertEqual(foo.name, 'Foo')
         self.assertEqual(foo.partner_id.id, par_id)
 
-    @mute_logger('openerp.osv.orm')
+    @mute_logger('openerp.models')
     def test_read(self):
         """ inherited fields should be read without any indirection """
         foo_id = self.user.create(self.cr, UID, {'name': 'Foo', 'login': 'foo', 'password': 'foo'})
@@ -185,13 +217,15 @@ class TestInherits(common.TransactionCase):
         foo = self.user.browse(self.cr, UID, foo_id)
         self.assertEqual(foo.name, foo.partner_id.name)
 
-    @mute_logger('openerp.osv.orm')
+    @mute_logger('openerp.models')
     def test_copy(self):
         """ copying a user should automatically copy its partner, too """
         foo_id = self.user.create(self.cr, UID, {'name': 'Foo', 'login': 'foo', 'password': 'foo'})
         foo_before, = self.user.read(self.cr, UID, [foo_id])
+        del foo_before['__last_update']
         bar_id = self.user.copy(self.cr, UID, foo_id, {'login': 'bar', 'password': 'bar'})
         foo_after, = self.user.read(self.cr, UID, [foo_id])
+        del foo_after['__last_update']
 
         self.assertEqual(foo_before, foo_after)
 
@@ -200,16 +234,19 @@ class TestInherits(common.TransactionCase):
         self.assertNotEqual(foo.id, bar.id)
         self.assertNotEqual(foo.partner_id.id, bar.partner_id.id)
 
-    @mute_logger('openerp.osv.orm')
+    @mute_logger('openerp.models')
     def test_copy_with_ancestor(self):
         """ copying a user with 'parent_id' in defaults should not duplicate the partner """
-        foo_id = self.user.create(self.cr, UID, {'name': 'Foo', 'login': 'foo', 'password': 'foo'})
+        foo_id = self.user.create(self.cr, UID, {'name': 'Foo', 'login': 'foo', 'password': 'foo',
+                                                 'login_date': '2016-01-01', 'signature': 'XXX'})
         par_id = self.partner.create(self.cr, UID, {'name': 'Bar'})
 
         foo_before, = self.user.read(self.cr, UID, [foo_id])
+        del foo_before['__last_update']
         partners_before = self.partner.search(self.cr, UID, [])
         bar_id = self.user.copy(self.cr, UID, foo_id, {'partner_id': par_id, 'login': 'bar'})
         foo_after, = self.user.read(self.cr, UID, [foo_id])
+        del foo_after['__last_update']
         partners_after = self.partner.search(self.cr, UID, [])
 
         self.assertEqual(foo_before, foo_after)
@@ -219,8 +256,9 @@ class TestInherits(common.TransactionCase):
         self.assertNotEqual(foo.id, bar.id)
         self.assertEqual(bar.partner_id.id, par_id)
         self.assertEqual(bar.login, 'bar', "login is given from copy parameters")
-        self.assertEqual(bar.password, foo.password, "password is given from original record")
+        self.assertFalse(bar.login_date, "login_date should not be copied from original record")
         self.assertEqual(bar.name, 'Bar', "name is given from specific partner")
+        self.assertEqual(bar.signature, foo.signature, "signature should be copied")