Added test cases for code coverage

reichie020212 · reichie020212 · commit 7bd8dab49192 · 2024-07-30T10:41:02.000+08:00
diff --git a/spp_area/tests/common.py b/spp_area/tests/common.py
@@ -5,14 +5,22 @@
 
 
 class AreaImportTestMixin(TransactionCase):
+    @staticmethod
+    def get_file_path_1():
+        return f"{os.path.dirname(os.path.abspath(__file__))}/irq_adminboundaries_tabulardata.xlsx"
+
+    @staticmethod
+    def get_file_path_2():
+        return f"{os.path.dirname(os.path.abspath(__file__))}/pse_adminboundaries_tabulardata.xlsx"
+
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
         # Greater than or equal to 400 rows
         xls_file = None
         xls_file_name = None
 
-        file_path = f"{os.path.dirname(os.path.abspath(__file__))}/irq_adminboundaries_tabulardata.xlsx"
+        file_path = cls.get_file_path_1()
         with open(file_path, "rb") as f:
             xls_file_name = f.name
             xls_file = base64.b64encode(f.read())
@@ -29,7 +37,7 @@ def setUpClass(cls):
         xls_file_2 = None
         xls_file_name_2 = None
 
-        file_path_2 = f"{os.path.dirname(os.path.abspath(__file__))}/pse_adminboundaries_tabulardata.xlsx"
+        file_path_2 = cls.get_file_path_2()
         with open(file_path_2, "rb") as f:
             xls_file_name_2 = f.name
             xls_file_2 = base64.b64encode(f.read())
diff --git a/spp_area_gis/tests/__init__.py b/spp_area_gis/tests/__init__.py
@@ -0,0 +1,2 @@
+from . import test_area_import
+from . import test_area_import_raw
diff --git a/spp_area_gis/tests/irq_adminboundaries_tabulardata.xlsx b/spp_area_gis/tests/irq_adminboundaries_tabulardata.xlsx
diff --git a/spp_area_gis/tests/pse_adminboundaries_tabulardata.xlsx b/spp_area_gis/tests/pse_adminboundaries_tabulardata.xlsx
diff --git a/spp_area_gis/tests/test_area_import.py b/spp_area_gis/tests/test_area_import.py
@@ -0,0 +1,36 @@
+import os
+
+from odoo.addons.spp_area.tests.test_area_import import AreaImportTest as AreaImportTestMixin
+
+
+class AreaImportTest(AreaImportTestMixin):
+    @staticmethod
+    def get_file_path_1():
+        return f"{os.path.dirname(os.path.abspath(__file__))}/irq_adminboundaries_tabulardata.xlsx"
+
+    @staticmethod
+    def get_file_path_2():
+        return f"{os.path.dirname(os.path.abspath(__file__))}/pse_adminboundaries_tabulardata.xlsx"
+
+    def test_get_column_indexes(self):
+        columns = {
+            "ADM2_EN": 0,
+            "ADM2_PCODE": 1,
+            "ADM1_EN": 2,
+            "ADM1_PCODE": 3,
+            "ADM0_EN": 4,
+            "ADM0_PCODE": 5,
+            "date": 6,
+            "validOn": 7,
+            "validTo": 8,
+            "AREA_SQKM": 9,
+            "longitude": 10,
+            "latitude": 11,
+        }
+        area_level = 1
+        column_indexes = self.area_import_id_2.get_column_indexes(list(columns.keys()), area_level)
+
+        self.assertIn("latitude_index", column_indexes)
+        self.assertIn("longitude_index", column_indexes)
+        self.assertEqual(column_indexes["latitude_index"], columns["latitude"])
+        self.assertEqual(column_indexes["longitude_index"], columns["longitude"])
diff --git a/spp_area_gis/tests/test_area_import_raw.py b/spp_area_gis/tests/test_area_import_raw.py
@@ -0,0 +1,35 @@
+import os
+
+from odoo.addons.spp_area.tests.test_area_import_raw import AreaImportRawTest as AreaImportRawTestMixin
+
+
+class AreaImportRawTest(AreaImportRawTestMixin):
+    @staticmethod
+    def get_file_path_1():
+        return f"{os.path.dirname(os.path.abspath(__file__))}/irq_adminboundaries_tabulardata.xlsx"
+
+    @staticmethod
+    def get_file_path_2():
+        return f"{os.path.dirname(os.path.abspath(__file__))}/pse_adminboundaries_tabulardata.xlsx"
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.area_import_raw_id.latitude = 13.0
+        cls.area_import_raw_id.longitude = 122.0
+
+    def test_check_errors(self):
+        self.area_import_raw_id.latitude = 91
+        self.area_import_raw_id.longitude = 181
+
+        self.area_import_raw_id.validate_raw_data()
+
+        self.assertEqual(self.area_import_raw_id.state, "Error")
+        self.assertIn("Latitude must be between -90 and 90", self.area_import_raw_id.remarks)
+        self.assertIn("Longitude must be between -180 and 180", self.area_import_raw_id.remarks)
+
+    def test_get_area_vals(self):
+        area_vals = self.area_import_raw_id.get_area_vals()
+
+        self.assertIn("coordinates", area_vals)
+        self.assertEqual(area_vals["coordinates"], '{"type": "Point", "coordinates": [122.0, 13.0]}')
diff --git a/spp_eligibility_sql/tests/__init__.py b/spp_eligibility_sql/tests/__init__.py
@@ -1 +1,3 @@
 from . import test_create_program_wizard
+from . import test_eligibility_manager
+from . import test_program
diff --git a/spp_eligibility_sql/tests/test_create_program_wizard.py b/spp_eligibility_sql/tests/test_create_program_wizard.py
@@ -1,10 +1,17 @@
+from odoo.exceptions import UserError
 from odoo.tests import TransactionCase
 
 
 class TestCreateProgramWiz(TransactionCase):
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
+        cls.group_1 = cls.env["res.partner"].create(
+            {
+                "name": "Group 1",
+                "is_group": True,
+            }
+        )
         cls._program_create_wiz = cls.env["g2p.program.create.wizard"].create(
             {
                 "name": "Test Program 1 [SQL Elibigility]",
@@ -14,6 +21,8 @@ def setUpClass(cls):
                 "cycle_duration": 1,
                 "currency_id": cls.env.company.currency_id.id,
                 "entitlement_kind": "default",
+                "amount_per_cycle": 1.0,
+                "amount_per_individual_in_group": 1.0,
             }
         )
         cls.journal_id = cls._program_create_wiz.create_journal(
@@ -27,3 +36,52 @@ def test_01_check_sql_query_onchange(self):
             "recheck",
             "Correct SQL Query validation state",
         )
+
+    def test_02_test_sql_query(self):
+        self._program_create_wiz.test_sql_query()
+
+        self.assertEqual(self._program_create_wiz.sql_query_valid, "valid")
+        self.assertEqual(
+            self._program_create_wiz.sql_query_valid_message, "The SQL Query is valid but it did not return any record."
+        )
+        self.assertEqual(self._program_create_wiz.sql_record_count, 0)
+        self.assertEqual(self._program_create_wiz.state, "step1")
+
+        self._program_create_wiz.sql_query = "select id from res_partner"
+        self._program_create_wiz.test_sql_query()
+
+        self.assertEqual(self._program_create_wiz.sql_query_valid, "valid")
+        self.assertFalse(self._program_create_wiz.sql_query_valid_message)
+        self.assertEqual(self._program_create_wiz.sql_record_count, 1)
+        self.assertEqual(self._program_create_wiz.state, "step1")
+
+        self._program_create_wiz.target_type = "individual"
+        self._program_create_wiz.test_sql_query()
+
+        self.assertEqual(self._program_create_wiz.sql_query_valid, "valid")
+        self.assertEqual(
+            self._program_create_wiz.sql_query_valid_message, "The SQL Query is valid but it did not return any record."
+        )
+        self.assertEqual(self._program_create_wiz.sql_record_count, 0)
+        self.assertEqual(self._program_create_wiz.state, "step1")
+
+    def test_03_check_required_fields(self):
+        with self.assertRaisesRegex(UserError, "The SQL Query must return 1 or more record."):
+            self._program_create_wiz._check_required_fields()
+
+        with self.assertRaisesRegex(UserError, "The SQL Query must be validated first."):
+            self._program_create_wiz.sql_query_valid = False
+            self._program_create_wiz._check_required_fields()
+
+        with self.assertRaisesRegex(UserError, "A SQL Query is needed for this eligibility criteria type."):
+            self._program_create_wiz.sql_query = False
+            self._program_create_wiz._check_required_fields()
+
+    def test_04_get_eligibility_manager(self):
+        self._program_create_wiz.sql_query = "select id from res_partner"
+        self._program_create_wiz.sql_record_count = 1
+        self.program = self._program_create_wiz.create_program()
+        eligibility_manager = self._program_create_wiz._get_eligibility_manager(self.program["res_id"])
+
+        self.assertIn("eligibility_managers", eligibility_manager)
+        self.assertIn(4, eligibility_manager["eligibility_managers"][0])
diff --git a/spp_eligibility_sql/tests/test_eligibility_manager.py b/spp_eligibility_sql/tests/test_eligibility_manager.py
@@ -0,0 +1,140 @@
+from odoo.exceptions import UserError
+from odoo.tests import TransactionCase
+
+
+class TestSQLBasedEligibilityManager(TransactionCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.partner = cls.env["res.partner"].create({"name": "Test Partner", "is_group": False})
+        cls.program_id = cls.env["g2p.program"].create(
+            {
+                "name": "Test Program",
+                "target_type": "individual",
+            }
+        )
+        cls.membership = cls.env["g2p.program_membership"].create(
+            {
+                "partner_id": cls.partner.id,
+                "program_id": cls.program_id.id,
+                "state": "enrolled",
+            }
+        )
+        cls.sql_manager = cls.env["g2p.program_membership.manager.sql"].create(
+            {
+                "name": "SQL Manager",
+                "program_id": cls.program_id.id,
+            }
+        )
+
+    def test_sql_query_onchange(self):
+        self.sql_manager._sql_query_onchange()
+
+        self.assertEqual(
+            self.sql_manager.sql_query_valid,
+            "recheck",
+        )
+        self.assertFalse(self.sql_manager.sql_query_valid_message)
+        self.assertEqual(self.sql_manager.sql_record_count, 0)
+
+    def test_prepare_eligible_domain(self):
+        domain = self.sql_manager._prepare_eligible_domain(membership=self.program_id.program_membership_ids)
+
+        self.assertEqual(domain, [("id", "in", [self.partner.id]), ("disabled", "=", False), ("is_group", "=", False)])
+
+        self.program_id.target_type = "group"
+        domain = self.sql_manager._prepare_eligible_domain(beneficiaries=self.partner.ids)
+        self.assertEqual(domain, [("id", "in", [self.partner.id]), ("disabled", "=", False), ("is_group", "=", True)])
+
+    def test_generate_sql_query(self):
+        self.sql_manager.sql_query = "select id from res_partner where name = 'Test Partner'"
+        sql_query = self.sql_manager._generate_sql_query()
+
+        self.assertIn(self.sql_manager.sql_query, sql_query)
+        self.assertIn("active AND disabled IS NULL AND NOT is_group", sql_query)
+
+        self.program_id.target_type = "group"
+        self.sql_manager.sql_query = "insert into res_partner (name) values ('Test Partner')"
+        sql_query = self.sql_manager._generate_sql_query()
+
+        self.assertIn("DML ERROR", sql_query)
+        self.assertIn("active AND disabled IS NULL AND is_group", sql_query)
+
+    def test_get_beneficiaries_sql_query(self):
+        with self.assertRaisesRegex(
+            UserError, "The SQL Query is not valid. Be sure to validate this in the Eligibility Manager."
+        ):
+            self.sql_manager._get_beneficiaries_sql_query()
+
+        self.sql_manager.sql_query = "select id from res_partner"
+        self.sql_manager.sql_query_valid = "valid"
+
+        sql_query_result = self.sql_manager._get_beneficiaries_sql_query()
+
+        self.assertIn(self.partner.id, sql_query_result)
+
+    def test_sql_query(self):
+        self.sql_manager.sql_query = "select id from res_partner"
+        self.sql_manager.test_sql_query()
+
+        self.assertEqual(self.sql_manager.sql_query_valid, "valid")
+        self.assertFalse(self.sql_manager.sql_query_valid_message)
+        self.assertEqual(self.sql_manager.sql_record_count, 1)
+
+        self.sql_manager.sql_query = "select id from res_partner where name = 'Wrong Name'"
+        self.sql_manager.test_sql_query()
+
+        self.assertEqual(self.sql_manager.sql_query_valid, "valid")
+        self.assertEqual(
+            self.sql_manager.sql_query_valid_message, "The SQL Query is valid but it did not return any record."
+        )
+        self.assertEqual(self.sql_manager.sql_record_count, 0)
+
+    def test_enroll_eligible_registrants(self):
+        res = self.sql_manager.enroll_eligible_registrants(self.program_id.program_membership_ids)
+
+        self.assertTrue(res)
+        self.assertEqual(res.partner_id, self.partner)
+        self.assertEqual(res.program_id, self.program_id)
+
+    def test_verify_eligibility(self):
+        beneficiaries = self.sql_manager._verify_eligibility(self.program_id.program_membership_ids)
+
+        self.assertIn(self.partner.id, beneficiaries)
+
+    def test_import_eligible_registrants(self):
+        self.env["res.partner"].create({"name": "New Test Partner", "is_group": False})
+
+        self.sql_manager.sql_query = "select id from res_partner"
+        self.sql_manager.sql_query_valid = "valid"
+        ben_count = self.sql_manager.import_eligible_registrants()
+
+        self.assertEqual(ben_count, 1)
+
+    def test_import_registrants_async(self):
+        new_partner = self.env["res.partner"].create({"name": "New Test Partner", "is_group": False})
+        current_count = len(self.env["queue.job"].search([]))
+
+        self.sql_manager._import_registrants_async(new_partner.ids)
+
+        # 2 jobs are created for the import and the verification
+        # - the actual job
+        # - the function after running the actual job
+        self.assertEqual(current_count + 2, len(self.env["queue.job"].search([])))
+
+    def test_mark_import_as_done(self):
+        self.sql_manager.mark_import_as_done()
+
+        self.assertFalse(self.program_id.locked)
+        self.assertFalse(self.program_id.locked_reason)
+
+    def test_import_registrants(self):
+        self.sql_manager.sql_query = "select id from res_partner"
+        self.sql_manager.sql_query_valid = "valid"
+        new_partner = self.env["res.partner"].create({"name": "New Test Partner", "is_group": False})
+
+        self.sql_manager._import_registrants(new_partner.ids, do_count=True)
+
+        self.assertEqual(len(self.program_id.program_membership_ids), 2)
+        self.assertIn(self.partner.id, self.program_id.program_membership_ids.mapped("partner_id").ids)
+        self.assertIn(self.program_id.id, self.program_id.program_membership_ids.mapped("program_id").ids)
diff --git a/spp_eligibility_sql/tests/test_program.py b/spp_eligibility_sql/tests/test_program.py
@@ -0,0 +1,32 @@
+from odoo.exceptions import UserError
+from odoo.tests import TransactionCase
+
+
+class TestProgram(TransactionCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.partner = cls.env["res.partner"].create({"name": "Test Group", "is_registrant": True, "is_group": True})
+
+    def test_create_program_sql_eligibility(self):
+        name = "Test Program 1"
+        sql_query = "select id from res_partner"
+        entitlement_kind = "default"
+        entitlement_vars = {
+            "amount_per_cycle": 1.0,
+            "amount_per_individual_in_group": 1.0,
+            "sql_record_count": 1,
+        }
+        current_count = self.env["g2p.program"].search_count([])
+
+        self.env["g2p.program"].create_program_sql_eligibility(name, sql_query, entitlement_kind, entitlement_vars)
+
+        self.assertEqual(current_count + 1, self.env["g2p.program"].search_count([]))
+
+        with self.assertRaisesRegex(UserError, "The entitlement kind must be specified."):
+            self.env["g2p.program"].create_program_sql_eligibility(name, sql_query, None, entitlement_vars)
+
+        with self.assertRaisesRegex(
+            UserError, "The program name, SQL query, and entitlement dictionary must be provided."
+        ):
+            self.env["g2p.program"].create_program_sql_eligibility(name, None, entitlement_kind, entitlement_vars)

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+from . import test_area_import`
	`2`	`+from . import test_area_import_raw`
Original file line number	Diff line number	Diff line change
`@@ -1 +1,3 @@`
`1`	`1`	`from . import test_create_program_wizard`
	`2`	`+from . import test_eligibility_manager`
	`3`	`+from . import test_program`