PyOdoo 0.5.6__tar.gz → 0.5.8__tar.gz

{PyOdoo-0.5.6 → PyOdoo-0.5.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyOdoo
-Version: 0.5.6
+Version: 0.5.8
 Summary: API for Odoo
 Home-page: http://www.muflone.com/pyodoo/
 Author: Fabio Castelli
@@ -13,6 +13,7 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Description-Content-Type: text/markdown
 License-File: LICENSE

{PyOdoo-0.5.6 → PyOdoo-0.5.8}/PyOdoo.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyOdoo
-Version: 0.5.6
+Version: 0.5.8
 Summary: API for Odoo
 Home-page: http://www.muflone.com/pyodoo/
 Author: Fabio Castelli
@@ -13,6 +13,7 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Description-Content-Type: text/markdown
 License-File: LICENSE

{PyOdoo-0.5.6 → PyOdoo-0.5.8}/PyOdoo.egg-info/SOURCES.txt

@@ -20,4 +20,5 @@ pyodoo/samples/contacts_async.py
 pyodoo/v12/__init__.py
 pyodoo/v12/api.py
 pyodoo/v12/model.py
+tests/test_compare_types.py
 tests/test_contacts.py

{PyOdoo-0.5.6 → PyOdoo-0.5.8}/pyodoo/compare_type.py

@@ -32,3 +32,13 @@ class CompareType(object):
     NOT_IN = 'not in'
     CONTAINS = 'ilike'
     CONTAINS_NOT = 'not ilike'
+    NOT_CONTAINS = 'not ilike'
+    LIKE = 'like'
+    NOT_LIKE = 'not like'
+    ILIKE = 'ilike'
+    NOT_ILIKE = 'not ilike'
+    RAW_LIKE = '=like'
+    RAW_ILIKE = '=ilike'
+    UNSET_OR_EQUAL = '=?'
+    CHILD_OF = 'child_of'
+    PARENT_OF = 'parent_of'

{PyOdoo-0.5.6 → PyOdoo-0.5.8}/pyodoo/constants.py

@@ -19,7 +19,7 @@
 ##
 
 APP_NAME = 'PyOdoo'
-APP_VERSION = '0.5.6'
+APP_VERSION = '0.5.8'
 APP_DESCRIPTION = 'API for Odoo'
 APP_DOMAIN = 'pyodoo'
 APP_ID = f'{APP_DOMAIN}.muflone.com'

{PyOdoo-0.5.6 → PyOdoo-0.5.8}/pyodoo/samples/contacts.py

@@ -72,6 +72,11 @@ results = model.filter(filters=filters,
                        fields=('id', 'name', 'country_id'))
 print('filter', results)
 
+# Find first record by filters
+results = model.first(filters=filters,
+                      fields=('id', 'name', 'country_id'))
+print('first', results)
+
 # Get all the record
 results = model.all(fields=('id', 'name'),
                     limit=1000)

{PyOdoo-0.5.6 → PyOdoo-0.5.8}/pyodoo/v12/model.py

@@ -315,6 +315,35 @@ class Model(object):
                                           options=options)
         return results
 
+    def first(self,
+              filters: list[Union[BooleanOperator, Filter]],
+              is_active: ActiveStatusChoice = ActiveStatusChoice.NOT_SET,
+              fields: tuple[str, ...] = None,
+              options: dict[str, Any] = None,
+              limit: Optional[int] = None,
+              offset: Optional[int] = None,
+              order: Optional[str] = None) -> Optional[dict[str, Any]]:
+        """
+        Find the first row from a model using some filters
+
+        :param filters: List of filters used for searching the data
+        :param is_active: Additional filter for active field
+        :param fields: Tuple with the fields to include in the response
+        :param options: Dictionary with options to use
+        :param limit: Maximum number of results count
+        :param offset: Starting record number to fetch the data
+        :param order: Ordering clause
+        :return: List of dictionaries with the requested fields
+        """
+        results = self.filter(filters=filters,
+                              is_active=is_active,
+                              fields=fields,
+                              options=options,
+                              limit=limit,
+                              offset=offset,
+                              order=order)
+        return results[0] if results else None
+
     def count(self,
               filters: list[Union[BooleanOperator, Filter]],
               is_active: ActiveStatusChoice = ActiveStatusChoice.NOT_SET,

{PyOdoo-0.5.6 → PyOdoo-0.5.8}/setup.cfg

@@ -17,6 +17,7 @@ classifiers =
 	Programming Language :: Python :: 3
 	Programming Language :: Python :: 3.9
 	Programming Language :: Python :: 3.10
+	Programming Language :: Python :: 3.11
 	Topic :: Software Development :: Libraries :: Python Modules
 
 [options]

PyOdoo-0.5.8/tests/test_compare_types.py

@@ -0,0 +1,393 @@
+##
+#     Project: PyOdoo
+# Description: API for Odoo
+#      Author: Fabio Castelli (Muflone) <muflone@muflone.com>
+#   Copyright: 2021-2023 Fabio Castelli
+#     License: GPL-3+
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+##
+
+import unittest
+
+from pyodoo import CompareType, Filter
+
+import utility
+
+
+class TestCaseCompareTypes(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        """
+        Model object preparation
+        """
+        cls.model = utility.get_model_from_demo(model_name='product.template')
+        cls.model.authenticate()
+
+    def test_01_filter_equal(self) -> None:
+        """
+        Search some rows using filters using compare EQUAL
+        """
+        filters = [Filter(field='name',
+                          compare_type=CompareType.EQUAL,
+                          value='Mozzarella Sandwich')]
+        results = self.model.search(filters=filters)
+        # Check if the results are not None
+        self.assertIsNotNone(results)
+        # Check if the results list has exactly one item
+        self.assertEqual(len(results), 1)
+        # Check if the results list contains the Mozzarella Sandwich
+        self.assertIn(75, results)
+
+    def test_02_filter_not_equal(self) -> None:
+        """
+        Search some rows using filters using compare NOT_EQUAL
+        """
+        filters = [Filter(field='name',
+                          compare_type=CompareType.CONTAINS,
+                          value='Sandwich'),
+                   Filter(field='name',
+                          compare_type=CompareType.NOT_EQUAL,
+                          value='Mozzarella Sandwich')]
+        results = self.model.search(filters=filters)
+        # Check if the results are not None
+        self.assertIsNotNone(results)
+        # Check if the results list has exactly three items
+        self.assertEqual(len(results), 3)
+        # Check if the results list doesn't contain the Mozzarella Sandwich
+        self.assertNotIn(75, results)
+
+    def test_03_filter_greater(self) -> None:
+        """
+        Search some rows using filters using compare GREATER
+        """
+        filters = [Filter(field='name',
+                          compare_type=CompareType.CONTAINS,
+                          value='Sandwich'),
+                   Filter(field='name',
+                          compare_type=CompareType.GREATER,
+                          value='Mozzarella Sandwich')]
+        results = self.model.search(filters=filters)
+        # Check if the results are not None
+        self.assertIsNotNone(results)
+        # Check if the results list has exactly one item
+        self.assertEqual(len(results), 1)
+        # Check if the results list doesn't contain the Mozzarella Sandwich
+        self.assertNotIn(75, results)
+
+    def test_04_filter_greater_equal(self) -> None:
+        """
+        Search some rows using filters using compare GREATER_EQ
+        """
+        filters = [Filter(field='name',
+                          compare_type=CompareType.CONTAINS,
+                          value='Sandwich'),
+                   Filter(field='name',
+                          compare_type=CompareType.GREATER_EQ,
+                          value='Mozzarella Sandwich')]
+        results = self.model.search(filters=filters)
+        # Check if the results are not None
+        self.assertIsNotNone(results)
+        # Check if the results list has exactly two items
+        self.assertEqual(len(results), 2)
+        # Check if the results list contains the Mozzarella Sandwich
+        self.assertIn(75, results)
+
+    def test_05_filter_lower(self) -> None:
+        """
+        Search some rows using filters using compare LOWER
+        """
+        filters = [Filter(field='name',
+                          compare_type=CompareType.CONTAINS,
+                          value='Sandwich'),
+                   Filter(field='name',
+                          compare_type=CompareType.LOWER,
+                          value='Mozzarella Sandwich')]
+        results = self.model.search(filters=filters)
+        # Check if the results are not None
+        self.assertIsNotNone(results)
+        # Check if the results list has exactly two items
+        self.assertEqual(len(results), 2)
+        # Check if the results list doesn't contain the Mozzarella Sandwich
+        self.assertNotIn(75, results)
+
+    def test_06_filter_lower_equal(self) -> None:
+        """
+        Search some rows using filters using compare LOWER_EQ
+        """
+        filters = [Filter(field='name',
+                          compare_type=CompareType.CONTAINS,
+                          value='Sandwich'),
+                   Filter(field='name',
+                          compare_type=CompareType.LOWER_EQ,
+                          value='Mozzarella Sandwich')]
+        results = self.model.search(filters=filters)
+        # Check if the results are not None
+        self.assertIsNotNone(results)
+        # Check if the results list has exactly three items
+        self.assertEqual(len(results), 3)
+        # Check if the results list contains the Mozzarella Sandwich
+        self.assertIn(75, results)
+
+    def test_07_filter_in(self) -> None:
+        """
+        Search some rows using filters using compare IN
+        """
+        filters = [Filter(field='name',
+                          compare_type=CompareType.CONTAINS,
+                          value='Sandwich'),
+                   Filter(field='name',
+                          compare_type=CompareType.IN,
+                          value=('Club Sandwich', 'Mozzarella Sandwich'))]
+        results = self.model.search(filters=filters)
+        # Check if the results are not None
+        self.assertIsNotNone(results)
+        # Check if the results list has exactly two items
+        self.assertEqual(len(results), 2)
+        # Check if the results list contains the Club Sandwich
+        self.assertIn(76, results)
+        # Check if the results list contains the Mozzarella Sandwich
+        self.assertIn(75, results)
+
+    def test_08_filter_not_in(self) -> None:
+        """
+        Search some rows using filters using compare NOT_IN
+        """
+        filters = [Filter(field='name',
+                          compare_type=CompareType.CONTAINS,
+                          value='Sandwich'),
+                   Filter(field='name',
+                          compare_type=CompareType.NOT_IN,
+                          value=('Club Sandwich', 'Mozzarella Sandwich'))]
+        results = self.model.search(filters=filters)
+        # Check if the results are not None
+        self.assertIsNotNone(results)
+        # Check if the results list has exactly two items
+        self.assertEqual(len(results), 2)
+        # Check if the results list doesn't contain the Club Sandwich
+        self.assertNotIn(76, results)
+        # Check if the results list doesn't contain the Mozzarella Sandwich
+        self.assertNotIn(75, results)
+
+    def test_09_filter_contains(self) -> None:
+        """
+        Search some rows using filters using compare CONTAINS
+        """
+        filters = [Filter(field='name',
+                          compare_type=CompareType.CONTAINS,
+                          value='Sandwich')]
+        results = self.model.search(filters=filters)
+        # Check if the results are not None
+        self.assertIsNotNone(results)
+        # Check if the results list has exactly four items
+        self.assertEqual(len(results), 4)
+        # Check if the results list contains the Mozzarella Sandwich
+        self.assertIn(75, results)
+
+    def test_10_filter_contains_not(self) -> None:
+        """
+        Search some rows using filters using compare CONTAINS_NOT
+        """
+        filters = [Filter(field='name',
+                          compare_type=CompareType.CONTAINS,
+                          value='Sandwich'),
+                   Filter(field='name',
+                          compare_type=CompareType.CONTAINS_NOT,
+                          value='mozzarella')]
+        results = self.model.search(filters=filters)
+        # Check if the results are not None
+        self.assertIsNotNone(results)
+        # Check if the results list has exactly three items
+        self.assertEqual(len(results), 3)
+        # Check if the results list doesn't contain the Mozzarella Sandwich
+        self.assertNotIn(75, results)
+
+    def test_11_filter_not_contains(self) -> None:
+        """
+        Search some rows using filters using compare NOT_CONTAINS
+        """
+        filters = [Filter(field='name',
+                          compare_type=CompareType.CONTAINS,
+                          value='Sandwich'),
+                   Filter(field='name',
+                          compare_type=CompareType.NOT_CONTAINS,
+                          value='mozzarella')]
+        results = self.model.search(filters=filters)
+        # Check if the results are not None
+        self.assertIsNotNone(results)
+        # Check if the results list has exactly three items
+        self.assertEqual(len(results), 3)
+        # Check if the results list doesn't contain the Mozzarella Sandwich
+        self.assertNotIn(75, results)
+
+    def test_12_filter_like(self) -> None:
+        """
+        Search some rows using filters using compare LIKE
+        """
+        filters = [Filter(field='name',
+                          compare_type=CompareType.CONTAINS,
+                          value='Sandwich'),
+                   Filter(field='name',
+                          compare_type=CompareType.LIKE,
+                          value='Mozzarella')]
+        results = self.model.search(filters=filters)
+        # Check if the results are not None
+        self.assertIsNotNone(results)
+        # Check if the results list has exactly one item
+        self.assertEqual(len(results), 1)
+        # Check if the results list contains the Mozzarella Sandwich
+        self.assertIn(75, results)
+
+    def test_13_filter_not_like(self) -> None:
+        """
+        Search some rows using filters using compare NOT_LIKE
+        """
+        filters = [Filter(field='name',
+                          compare_type=CompareType.CONTAINS,
+                          value='Sandwich'),
+                   Filter(field='name',
+                          compare_type=CompareType.NOT_LIKE,
+                          value='Mozzarella')]
+        results = self.model.search(filters=filters)
+        # Check if the results are not None
+        self.assertIsNotNone(results)
+        # Check if the results list has exactly three items
+        self.assertEqual(len(results), 3)
+        # Check if the results list doesn't contain the Mozzarella Sandwich
+        self.assertNotIn(75, results)
+
+    def test_14_filter_ilike(self) -> None:
+        """
+        Search some rows using filters using compare ILIKE
+        """
+        filters = [Filter(field='name',
+                          compare_type=CompareType.CONTAINS,
+                          value='Sandwich'),
+                   Filter(field='name',
+                          compare_type=CompareType.ILIKE,
+                          value='mozzarella')]
+        results = self.model.search(filters=filters)
+        # Check if the results are not None
+        self.assertIsNotNone(results)
+        # Check if the results list has exactly one item
+        self.assertEqual(len(results), 1)
+        # Check if the results list contains the Mozzarella Sandwich
+        self.assertIn(75, results)
+
+    def test_15_filter_not_ilike(self) -> None:
+        """
+        Search some rows using filters using compare NOT_ILIKE
+        """
+        filters = [Filter(field='name',
+                          compare_type=CompareType.CONTAINS,
+                          value='Sandwich'),
+                   Filter(field='name',
+                          compare_type=CompareType.NOT_ILIKE,
+                          value='mozzarella')]
+        results = self.model.search(filters=filters)
+        # Check if the results are not None
+        self.assertIsNotNone(results)
+        # Check if the results list has exactly three items
+        self.assertEqual(len(results), 3)
+        # Check if the results list doesn't contain the Mozzarella Sandwich
+        self.assertNotIn(75, results)
+
+    def test_16_filter_raw_like(self) -> None:
+        """
+        Search some rows using filters using compare RAW_LIKE
+        """
+        filters = [Filter(field='name',
+                          compare_type=CompareType.CONTAINS,
+                          value='Sandwich'),
+                   Filter(field='name',
+                          compare_type=CompareType.RAW_LIKE,
+                          value='Mozzarella %')]
+        results = self.model.search(filters=filters)
+        # Check if the results are not None
+        self.assertIsNotNone(results)
+        # Check if the results list has exactly one item
+        self.assertEqual(len(results), 1)
+        # Check if the results list contains the Mozzarella Sandwich
+        self.assertIn(75, results)
+
+    def test_17_filter_raw_ilike(self) -> None:
+        """
+        Search some rows using filters using compare RAW_ILIKE
+        """
+        filters = [Filter(field='name',
+                          compare_type=CompareType.CONTAINS,
+                          value='Sandwich'),
+                   Filter(field='name',
+                          compare_type=CompareType.RAW_ILIKE,
+                          value='mozzarella %')]
+        results = self.model.search(filters=filters)
+        # Check if the results are not None
+        self.assertIsNotNone(results)
+        # Check if the results list has exactly one item
+        self.assertEqual(len(results), 1)
+        # Check if the results list contains the Mozzarella Sandwich
+        self.assertIn(75, results)
+
+    def test_18_filter_unset_or_equal(self) -> None:
+        """
+        Search some rows using filters using compare UNSET_OR_EQUAL
+        """
+        filters = [Filter(field='name',
+                          compare_type=CompareType.CONTAINS,
+                          value='Sandwich'),
+                   Filter(field='uom_id',
+                          compare_type=CompareType.UNSET_OR_EQUAL,
+                          value=1)]
+        results = self.model.search(filters=filters)
+        # Check if the results are not None
+        self.assertIsNotNone(results)
+        # Check if the results list has exactly four items
+        self.assertEqual(len(results), 4)
+        # Check if the results list contains the Mozzarella Sandwich
+        self.assertIn(75, results)
+
+    def test_19_filter_child_of(self) -> None:
+        """
+        Search some rows using filters using compare CHILD_OF
+        """
+        filters = [Filter(field='name',
+                          compare_type=CompareType.CONTAINS,
+                          value='Sandwich'),
+                   Filter(field='categ_id',
+                          compare_type=CompareType.CHILD_OF,
+                          value='PoS')]
+        results = self.model.search(filters=filters)
+        # Check if the results are not None
+        self.assertIsNotNone(results)
+        # Check if the results list has exactly four items
+        self.assertEqual(len(results), 4)
+        # Check if the results list contains the Mozzarella Sandwich
+        self.assertIn(75, results)
+
+    def test_20_filter_parent_of(self) -> None:
+        """
+        Search some rows using filters using compare PARENT_OF
+        """
+        filters = [Filter(field='name',
+                          compare_type=CompareType.CONTAINS,
+                          value='Sandwich'),
+                   Filter(field='categ_id',
+                          compare_type=CompareType.PARENT_OF,
+                          value='Food')]
+        results = self.model.search(filters=filters)
+        # Check if the results are not None
+        self.assertIsNotNone(results)
+        # Check if the results list has exactly four items
+        self.assertEqual(len(results), 4)
+        # Check if the results list contains the Mozzarella Sandwich
+        self.assertIn(75, results)

{PyOdoo-0.5.6 → PyOdoo-0.5.8}/tests/test_contacts.py

@@ -29,6 +29,8 @@ from pyodoo import (ActiveStatusChoice,
 from pyodoo.constants import APP_AUTHOR_EMAIL, APP_NAME, APP_VERSION
 from pyodoo.v12 import Model
 
+import utility
+
 
 class TestCaseContacts(unittest.TestCase):
     @classmethod
@@ -36,24 +38,7 @@ class TestCaseContacts(unittest.TestCase):
         """
         Model object preparation
         """
-        # Get the free public server credentials
-        try:
-            info = xmlrpc.client.ServerProxy(
-                uri='https://demo.odoo.com/start').start()
-        except xmlrpc.client.Fault:
-            # Sometimes the free public server start page is not available
-            # Use a specif instance (this may be very mutable)
-            info = {'host': 'https://demo4.odoo.com',
-                    'database': 'demo_160_1676157153',
-                    'user': 'admin',
-                    'password': 'admin'}
-        cls.model = Model(model_name='res.partner',
-                          endpoint=info['host'],
-                          database=info['database'],
-                          username=info['user'],
-                          password=info['password'],
-                          language='en_US',
-                          authenticate=False)
+        cls.model = utility.get_model_from_demo(model_name='res.partner')
 
     def test_01_authenticate(self) -> None:
         """
@@ -117,7 +102,7 @@ class TestCaseContacts(unittest.TestCase):
         """
         Search some rows using filters
         """
-        # Filters by name and excluding an explicit ID
+        # Filters by active and exclude an explicit name
         filters = [BooleanOperator.AND,
                    Filter(field='active',
                           compare_type=CompareType.EQUAL,
@@ -231,7 +216,7 @@ class TestCaseContacts(unittest.TestCase):
         """
         Find multiple rows using some filters
         """
-        # Filters by name and excluding an explicit ID
+        # Filters by active and exclude an explicit name
         filters = [BooleanOperator.AND,
                    Filter(field='active',
                           compare_type=CompareType.EQUAL,
@@ -252,7 +237,7 @@ class TestCaseContacts(unittest.TestCase):
         """
         Find multiple rows using some filters and order
         """
-        # Filters by name and excluding an explicit ID
+        # Filters by active and exclude an explicit name
         filters = [BooleanOperator.AND,
                    Filter(field='active',
                           compare_type=CompareType.EQUAL,
@@ -270,7 +255,48 @@ class TestCaseContacts(unittest.TestCase):
         # Check if the results list is not empty
         self.assertGreater(len(results), 0)
 
-    def test_14_get(self) -> None:
+    def test_14_first(self) -> None:
+        """
+        Find a single row using some filters
+        """
+        # Filters by active and exclude an explicit name
+        filters = [BooleanOperator.AND,
+                   Filter(field='active',
+                          compare_type=CompareType.EQUAL,
+                          value=False),
+                   BooleanOperator.NOT,
+                   Filter(field='name',
+                          compare_type=CompareType.CONTAINS,
+                          value='OdooBot'),
+                   ]
+        results = self.model.first(filters=filters,
+                                   fields=('id', 'name', 'type', 'street'))
+        # Check if the results type is None or dict
+        self.assertIn(type(results), (None, dict))
+        # Check if the results contains 4 values, for the 4 fields
+        self.assertEqual(len(results), 4)
+
+    def test_15_first_none(self) -> None:
+        """
+        Find a single row which returns None
+        """
+        # Filters by active and exclude an explicit name
+        filters = [BooleanOperator.AND,
+                   Filter(field='active',
+                          compare_type=CompareType.EQUAL,
+                          value=False),
+                   BooleanOperator.NOT,
+                   Filter(field='active',
+                          compare_type=CompareType.EQUAL,
+                          value=True),
+                   ]
+        results = self.model.first(filters=filters,
+                                   fields=('id', 'name', 'type', 'street'),
+                                   offset=1000)
+        # Check if the results type is None
+        self.assertEqual(results, None)
+
+    def test_16_get(self) -> None:
         """
         Get a single row using ID
         """
@@ -290,7 +316,7 @@ class TestCaseContacts(unittest.TestCase):
         self.assertEqual(results['type'], 'contact')
         self.assertGreater(len(results['street']), 0)
 
-    def test_15_get_many(self) -> None:
+    def test_17_get_many(self) -> None:
         """
         Get multiple rows using ID
         """
@@ -308,7 +334,7 @@ class TestCaseContacts(unittest.TestCase):
         self.assertEqual(results[0]['type'], 'contact')
         self.assertGreater(len(results[0]['street']), 0)
 
-    def test_16_create(self) -> None:
+    def test_18_create(self) -> None:
         """
         Create a new row
         """
@@ -319,7 +345,7 @@ class TestCaseContacts(unittest.TestCase):
         # Check if the results is not empty
         self.assertGreater(results, 0)
 
-    def test_17_many_to_many_add(self) -> None:
+    def test_19_many_to_many_add(self) -> None:
         """
         Add a record to a Many-to-Many relationship
         """
@@ -340,7 +366,7 @@ class TestCaseContacts(unittest.TestCase):
         # Check if we have results
         self.assertTrue(results)
 
-    def test_18_many_to_many_create(self) -> None:
+    def test_20_many_to_many_create(self) -> None:
         """
         Create a new record and add it to a Many-to-Many relationship
         """
@@ -358,7 +384,7 @@ class TestCaseContacts(unittest.TestCase):
         # Check if we have results
         self.assertTrue(results)
 
-    def test_19_many_to_many_update(self) -> None:
+    def test_21_many_to_many_update(self) -> None:
         """
         Update an existing record from a Many-to-Many relationship
         """
@@ -390,7 +416,7 @@ class TestCaseContacts(unittest.TestCase):
         # Check if we have results
         self.assertTrue(results)
 
-    def test_20_many_to_many_delete(self) -> None:
+    def test_22_many_to_many_delete(self) -> None:
         """
         Delete an existing child record from a Many-to-Many relationship
         and delete the record itself
@@ -430,7 +456,7 @@ class TestCaseContacts(unittest.TestCase):
                 # We catched a different error, re-raise it
                 raise error
 
-    def test_21_many_to_many_remove(self) -> None:
+    def test_23_many_to_many_remove(self) -> None:
         """
         Remove an existing child record from a Many-to-Many relationship
         """
@@ -460,7 +486,7 @@ class TestCaseContacts(unittest.TestCase):
         # Check if we have results
         self.assertTrue(results)
 
-    def test_22_many_to_many_clear(self) -> None:
+    def test_24_many_to_many_clear(self) -> None:
         """
         Clear any existing children records from a Many-to-Many relationship
         """
@@ -476,7 +502,7 @@ class TestCaseContacts(unittest.TestCase):
         # Check if we have results
         self.assertTrue(results)
 
-    def test_23_many_to_many_replace(self) -> None:
+    def test_25_many_to_many_replace(self) -> None:
         """
         Replace any existing children records from a Many-to-Many relationship
         """
@@ -503,7 +529,7 @@ class TestCaseContacts(unittest.TestCase):
         # Check if we have results
         self.assertTrue(results)
 
-    def test_24_update(self) -> None:
+    def test_26_update(self) -> None:
         """
         Update the newly created rows
         """
@@ -532,7 +558,7 @@ class TestCaseContacts(unittest.TestCase):
             # Check the field street
             self.assertEqual(results_updated['street'], 'TEST TEST TEST')
 
-    def test_25_update_many(self) -> None:
+    def test_27_update_many(self) -> None:
         """
         Update all the newly created rows at once
         """
@@ -547,7 +573,7 @@ class TestCaseContacts(unittest.TestCase):
         self.model.update(entity_id=results,
                           values={'street': 'TEST TEST TEST 2'})
 
-    def test_26_count(self) -> None:
+    def test_28_count(self) -> None:
         """
         Count the newly created rows.
         """
@@ -559,7 +585,7 @@ class TestCaseContacts(unittest.TestCase):
         self.assertIsNotNone(results)
         self.assertGreater(results, 0)
 
-    def test_27_get_model_data_reference(self) -> None:
+    def test_29_get_model_data_reference(self) -> None:
         """
         Get a reference row from ir.model.data
         """
@@ -571,7 +597,7 @@ class TestCaseContacts(unittest.TestCase):
         self.assertIsInstance(results, dict)
         self.assertGreater(results['res_id'], 0)
 
-    def test_28_get_message_subtype_id_activity(self) -> None:
+    def test_30_get_message_subtype_id_activity(self) -> None:
         """
         Get a Message subtype ID
         """
@@ -582,7 +608,7 @@ class TestCaseContacts(unittest.TestCase):
         self.assertIsInstance(results, int)
         self.assertGreater(results, 0)
 
-    def test_29_get_message_subtype_id_comment(self) -> None:
+    def test_31_get_message_subtype_id_comment(self) -> None:
         """
         Get a Message subtype ID
         """
@@ -593,7 +619,7 @@ class TestCaseContacts(unittest.TestCase):
         self.assertIsInstance(results, int)
         self.assertGreater(results, 0)
 
-    def test_30_get_message_subtype_id_note(self) -> None:
+    def test_32_get_message_subtype_id_note(self) -> None:
         """
         Get a Message subtype ID
         """
@@ -604,7 +630,7 @@ class TestCaseContacts(unittest.TestCase):
         self.assertIsInstance(results, int)
         self.assertGreater(results, 0)
 
-    def test_31_post_message_activity(self) -> None:
+    def test_33_post_message_activity(self) -> None:
         """
         Post a new message as activity
         """
@@ -623,7 +649,7 @@ class TestCaseContacts(unittest.TestCase):
         self.assertIsNotNone(entity_id)
         self.assertGreater(entity_id, 0)
 
-    def test_32_post_message_comment(self) -> None:
+    def test_34_post_message_comment(self) -> None:
         """
         Post a new message as comment
         """
@@ -642,7 +668,7 @@ class TestCaseContacts(unittest.TestCase):
         self.assertIsNotNone(entity_id)
         self.assertGreater(entity_id, 0)
 
-    def test_33_post_message_note(self) -> None:
+    def test_35_post_message_note(self) -> None:
         """
         Post a new message as note
         """
@@ -661,7 +687,7 @@ class TestCaseContacts(unittest.TestCase):
         self.assertIsNotNone(entity_id)
         self.assertGreater(entity_id, 0)
 
-    def test_34_delete(self) -> None:
+    def test_36_delete(self) -> None:
         """
         Delete the newly created rows.
         This test may be skipped in the case there's an active PoS session
@@ -694,7 +720,7 @@ class TestCaseContacts(unittest.TestCase):
                     # We catched a different error, re-raise it
                     raise error
 
-    def test_35_delete_many(self) -> None:
+    def test_37_delete_many(self) -> None:
         """
         Delete the newly created rows.
         This test may be skipped in the case there's an active PoS session
@@ -720,7 +746,7 @@ class TestCaseContacts(unittest.TestCase):
                 # We catched a different error, re-raise it
                 raise error
 
-    def test_36_language(self) -> None:
+    def test_38_language(self) -> None:
         """
         Get the current default language, change and restore it
         """
@@ -737,7 +763,7 @@ class TestCaseContacts(unittest.TestCase):
         results = self.model.language
         self.assertEqual(results, original_language)
 
-    def test_37_get_fields(self) -> None:
+    def test_39_get_fields(self) -> None:
         """
         Get the model fields
         """
@@ -745,7 +771,7 @@ class TestCaseContacts(unittest.TestCase):
         # Check if we have results
         self.assertIsNotNone(results)
 
-    def test_38_get_fields_attributes(self) -> None:
+    def test_40_get_fields_attributes(self) -> None:
         """
         Get the model fields
         """
@@ -758,7 +784,7 @@ class TestCaseContacts(unittest.TestCase):
         self.assertIn('string', field_name)
         self.assertIn('type', field_name)
 
-    def test_39_get_model(self) -> None:
+    def test_41_get_model(self) -> None:
         """
         Get a new Model object
         """