test: add tests for 9 modules to reach 90%+ coverage

Add test suites for spp_case_demo (108 tests), spp_grm_case_link (78
tests), spp_grm_programs (42 tests), spp_grm_registry (35 tests),
spp_case_session (29 tests), spp_case_registry (32 tests),
spp_case_entitlements (32 tests), spp_case_graduation (22 tests),
and expand spp_case_programs (6 → 16 tests).

Author: gonzalesedwin1123

spp_case_demo/tests/__init__.py

@@ -0,0 +1,5 @@
+# Part of OpenSPP. See LICENSE file for full copyright and licensing details.
+
+from . import test_case_demo_stories
+from . import test_generate_cases
+from . import test_case_demo_wizard

spp_case_demo/tests/test_case_demo_stories.py

@@ -0,0 +1,197 @@
+# Part of OpenSPP. See LICENSE file for full copyright and licensing details.
+
+"""Tests for case_demo_stories module - pure Python, no Odoo model access needed."""
+
+from odoo.tests import TransactionCase, tagged
+
+from ..models.case_demo_stories import (
+    BACKGROUND_CASES,
+    CASE_DEMO_STORIES,
+    RESERVED_CASE_NAMES,
+    get_all_case_stories,
+    get_background_case_stories,
+    get_case_story_by_id,
+    get_main_case_stories,
+)
+
+
+@tagged("post_install", "-at_install")
+class TestCaseDemoStories(TransactionCase):
+    """Tests for the demo stories data module."""
+
+    def test_case_demo_stories_list_not_empty(self):
+        """The main stories list should have entries."""
+        self.assertTrue(CASE_DEMO_STORIES, "CASE_DEMO_STORIES must not be empty")
+
+    def test_background_cases_list_not_empty(self):
+        """The background cases list should have entries."""
+        self.assertTrue(BACKGROUND_CASES, "BACKGROUND_CASES must not be empty")
+
+    def test_reserved_case_names_not_empty(self):
+        """Reserved names list should have entries."""
+        self.assertTrue(RESERVED_CASE_NAMES, "RESERVED_CASE_NAMES must not be empty")
+
+    def test_each_main_story_has_required_keys(self):
+        """Every main story must have id, case_name, case_profile, and journey."""
+        required_keys = {"id", "case_name", "case_profile", "journey"}
+        for story in CASE_DEMO_STORIES:
+            missing = required_keys - set(story.keys())
+            self.assertFalse(
+                missing,
+                f"Story '{story.get('case_name', '?')}' is missing keys: {missing}",
+            )
+
+    def test_each_story_journey_is_list(self):
+        """Every story's journey must be a list."""
+        for story in get_all_case_stories():
+            self.assertIsInstance(
+                story["journey"],
+                list,
+                f"Journey for '{story.get('case_name', '?')}' must be a list",
+            )
+
+    def test_each_story_case_profile_is_dict(self):
+        """Every story's case_profile must be a dict."""
+        for story in get_all_case_stories():
+            self.assertIsInstance(
+                story["case_profile"],
+                dict,
+                f"case_profile for '{story.get('case_name', '?')}' must be a dict",
+            )
+
+    def test_story_ids_are_unique(self):
+        """All story IDs must be unique."""
+        all_ids = [s["id"] for s in get_all_case_stories()]
+        self.assertEqual(
+            len(all_ids),
+            len(set(all_ids)),
+            "Duplicate story IDs detected",
+        )
+
+    def test_get_main_case_stories_returns_main_list(self):
+        """get_main_case_stories should return CASE_DEMO_STORIES."""
+        result = get_main_case_stories()
+        self.assertEqual(result, CASE_DEMO_STORIES)
+
+    def test_get_background_case_stories_returns_background_list(self):
+        """get_background_case_stories should return BACKGROUND_CASES."""
+        result = get_background_case_stories()
+        self.assertEqual(result, BACKGROUND_CASES)
+
+    def test_get_all_case_stories_combines_both_lists(self):
+        """get_all_case_stories should combine main and background stories."""
+        all_stories = get_all_case_stories()
+        expected_count = len(CASE_DEMO_STORIES) + len(BACKGROUND_CASES)
+        self.assertEqual(len(all_stories), expected_count)
+
+    def test_get_all_case_stories_main_stories_first(self):
+        """Main stories should appear before background stories in the combined list."""
+        all_stories = get_all_case_stories()
+        main_count = len(CASE_DEMO_STORIES)
+        self.assertEqual(all_stories[:main_count], CASE_DEMO_STORIES)
+        self.assertEqual(all_stories[main_count:], BACKGROUND_CASES)
+
+    def test_get_case_story_by_id_found(self):
+        """get_case_story_by_id should return the correct story when it exists."""
+        # Use the first story in main stories as a known ID
+        first_story = CASE_DEMO_STORIES[0]
+        result = get_case_story_by_id(first_story["id"])
+        self.assertEqual(result, first_story)
+
+    def test_get_case_story_by_id_background_story(self):
+        """get_case_story_by_id should also find background case stories."""
+        first_background = BACKGROUND_CASES[0]
+        result = get_case_story_by_id(first_background["id"])
+        self.assertEqual(result, first_background)
+
+    def test_get_case_story_by_id_not_found_returns_none(self):
+        """get_case_story_by_id should return None for an unknown ID."""
+        result = get_case_story_by_id("this_id_does_not_exist_xyz")
+        self.assertIsNone(result)
+
+    def test_santos_family_support_story_exists(self):
+        """The Santos Family Support story must exist by its known ID."""
+        story = get_case_story_by_id("santos_family_support")
+        self.assertIsNotNone(story)
+        self.assertEqual(story["case_name"], "Santos Family Support")
+
+    def test_dela_cruz_emergency_story_exists(self):
+        """The Dela Cruz Emergency story must exist."""
+        story = get_case_story_by_id("dela_cruz_emergency")
+        self.assertIsNotNone(story)
+
+    def test_garcia_elder_care_story_exists(self):
+        """The Garcia Elder Care story must exist."""
+        story = get_case_story_by_id("garcia_elder_care")
+        self.assertIsNotNone(story)
+
+    def test_mendoza_child_protection_story_exists(self):
+        """The Mendoza Child Protection story must exist."""
+        story = get_case_story_by_id("mendoza_child_protection")
+        self.assertIsNotNone(story)
+
+    def test_hassan_resettlement_story_exists(self):
+        """The Hassan Resettlement story must exist."""
+        story = get_case_story_by_id("hassan_resettlement")
+        self.assertIsNotNone(story)
+
+    def test_morales_household_crisis_story_exists(self):
+        """The Morales Household Crisis story must exist."""
+        story = get_case_story_by_id("morales_household_crisis")
+        self.assertIsNotNone(story)
+
+    def test_martinez_disability_support_story_exists(self):
+        """The Martinez Disability Support story must exist."""
+        story = get_case_story_by_id("martinez_disability_support")
+        self.assertIsNotNone(story)
+
+    def test_al_rahman_family_assessment_story_exists(self):
+        """The Al-Rahman Family Assessment story must exist."""
+        story = get_case_story_by_id("al_rahman_family_assessment")
+        self.assertIsNotNone(story)
+
+    def test_said_family_support_story_exists(self):
+        """The Said Family Support story must exist."""
+        story = get_case_story_by_id("said_family_support")
+        self.assertIsNotNone(story)
+
+    def test_story_journey_actions_are_strings(self):
+        """Every journey step must have an action key that is a string."""
+        for story in get_all_case_stories():
+            for step in story["journey"]:
+                self.assertIn("action", step, f"Journey step missing 'action' in story {story['id']}")
+                self.assertIsInstance(step["action"], str)
+
+    def test_story_journey_days_back_non_negative(self):
+        """Journey steps that specify days_back must have a non-negative value."""
+        for story in get_all_case_stories():
+            for step in story["journey"]:
+                if "days_back" in step:
+                    self.assertGreaterEqual(
+                        step["days_back"],
+                        0,
+                        f"days_back must be >= 0 in story '{story['id']}'",
+                    )
+
+    def test_santos_story_has_close_case_action(self):
+        """The Santos story should include a close_case journey step."""
+        story = get_case_story_by_id("santos_family_support")
+        actions = [step["action"] for step in story["journey"]]
+        self.assertIn("close_case", actions)
+
+    def test_background_pending_intake_story(self):
+        """The pending_intake background story must exist."""
+        story = get_case_story_by_id("pending_intake")
+        self.assertIsNotNone(story)
+
+    def test_background_assessment_phase_story(self):
+        """The assessment_phase background story must exist."""
+        story = get_case_story_by_id("assessment_phase")
+        self.assertIsNotNone(story)
+
+    def test_background_closed_unsuccessful_story(self):
+        """The closed_unsuccessful background story must exist and have a close_case step."""
+        story = get_case_story_by_id("closed_unsuccessful")
+        self.assertIsNotNone(story)
+        actions = [step["action"] for step in story["journey"]]
+        self.assertIn("close_case", actions)

spp_case_demo/tests/test_case_demo_wizard.py

@@ -0,0 +1,124 @@
+# Part of OpenSPP. See LICENSE file for full copyright and licensing details.
+
+"""Tests for spp.case.demo.wizard model."""
+
+from odoo.tests import TransactionCase, tagged
+
+
+@tagged("post_install", "-at_install")
+class TestCaseDemoWizard(TransactionCase):
+    """Tests for the spp.case.demo.wizard transient model."""
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+
+        Stage = cls.env["spp.case.stage"]
+        stage_data = [
+            ("Intake", "intake", 10, False),
+            ("Closed", "closure", 60, True),
+        ]
+        for name, phase, sequence, is_closed in stage_data:
+            if not Stage.search([("phase", "=", phase)], limit=1):
+                Stage.create({"name": name, "phase": phase, "sequence": sequence, "is_closed": is_closed})
+
+        CaseType = cls.env["spp.case.type"]
+        if not CaseType.search([("name", "=", "General Support")], limit=1):
+            CaseType.create({"name": "General Support", "code": "GNWZ"})
+
+        # partner_id is required on spp.case; always provide a registrant
+        cls.beneficiary = (
+            cls.env["res.partner"]
+            .with_context(tracking_disable=True)
+            .create({"name": "Wizard Test Beneficiary", "is_registrant": True})
+        )
+
+    def _make_wizard(self, **kwargs):
+        defaults = {
+            "name": "Wizard Test",
+            "number_of_cases": 2,
+            "include_stories": False,
+            "cases_days_back": 30,
+            "link_to_beneficiaries": True,
+            "percentage_with_plans": 0.0,
+            "percentage_with_visits": 0.0,
+            "percentage_with_notes": 0.0,
+            "percentage_closed": 0.0,
+        }
+        defaults.update(kwargs)
+        return self.env["spp.case.demo.wizard"].create(defaults)
+
+    def test_wizard_inherits_generator(self):
+        """spp.case.demo.wizard should inherit spp.case.demo.generator."""
+        wizard = self._make_wizard()
+        # Verify the wizard can access all generator fields
+        self.assertEqual(wizard.number_of_cases, 2)
+        self.assertFalse(wizard.include_stories)
+
+    def test_wizard_generate_cases_returns_action(self):
+        """generate_cases called from wizard should return a valid window action."""
+        wizard = self._make_wizard(number_of_cases=2)
+        result = wizard.generate_cases()
+        self.assertEqual(result["type"], "ir.actions.act_window")
+        self.assertEqual(result["res_model"], "spp.case")
+
+    def test_wizard_create_and_read(self):
+        """Wizard records should be creatable and readable."""
+        wizard = self._make_wizard()
+        self.assertTrue(wizard.id)
+        self.assertEqual(wizard.name, "Wizard Test")
+
+    def test_wizard_model_name(self):
+        """The wizard model name should be spp.case.demo.wizard."""
+        wizard = self._make_wizard()
+        self.assertEqual(wizard._name, "spp.case.demo.wizard")
+
+    def test_wizard_description(self):
+        """The wizard model description should be set."""
+        wizard = self._make_wizard()
+        self.assertTrue(wizard._description)
+
+    def test_wizard_shares_generator_methods(self):
+        """Wizard should have access to all generator methods via inheritance."""
+        wizard = self._make_wizard()
+        # Check that inherited helper methods are accessible
+        self.assertTrue(hasattr(wizard, "generate_cases"))
+        self.assertTrue(hasattr(wizard, "_get_available_beneficiaries"))
+        self.assertTrue(hasattr(wizard, "_get_or_create_case_type"))
+        self.assertTrue(hasattr(wizard, "_get_random_case_type"))
+        self.assertTrue(hasattr(wizard, "_get_random_stage"))
+        self.assertTrue(hasattr(wizard, "_determine_stage_from_journey"))
+        self.assertTrue(hasattr(wizard, "_find_or_create_client"))
+        self.assertTrue(hasattr(wizard, "_get_or_create_service"))
+        self.assertTrue(hasattr(wizard, "_create_random_case"))
+        self.assertTrue(hasattr(wizard, "_add_random_plan"))
+        self.assertTrue(hasattr(wizard, "_add_random_visits"))
+        self.assertTrue(hasattr(wizard, "_add_random_notes"))
+        self.assertTrue(hasattr(wizard, "_close_random_case"))
+        self.assertTrue(hasattr(wizard, "_generate_demo_stories"))
+        self.assertTrue(hasattr(wizard, "_create_case_from_story"))
+        self.assertTrue(hasattr(wizard, "_process_case_journey"))
+
+    def test_wizard_generates_cases_with_stories(self):
+        """Wizard can generate cases including demo stories."""
+        wizard = self._make_wizard(
+            number_of_cases=2,
+            include_stories=True,
+        )
+        result = wizard.generate_cases()
+        self.assertEqual(result["type"], "ir.actions.act_window")
+        case_ids = result["domain"][0][2]
+        self.assertTrue(len(case_ids) >= 1)
+
+    def test_wizard_percentage_fields_accessible(self):
+        """All percentage distribution fields should be accessible on the wizard."""
+        wizard = self._make_wizard(
+            percentage_with_plans=50.0,
+            percentage_with_visits=60.0,
+            percentage_with_notes=70.0,
+            percentage_closed=30.0,
+        )
+        self.assertAlmostEqual(wizard.percentage_with_plans, 50.0)
+        self.assertAlmostEqual(wizard.percentage_with_visits, 60.0)
+        self.assertAlmostEqual(wizard.percentage_with_notes, 70.0)
+        self.assertAlmostEqual(wizard.percentage_closed, 30.0)