fix(spp_programs): handle state=None in enroll eligible async dispatch

The "Enroll Eligible" button calls enroll_eligible_registrants() with no
argument, so state defaults to None. When the program has at least
MIN_ROW_JOB_QUEUE (200) beneficiaries, the async path runs and called
tuple(states) on None, raising TypeError.

Mirror get_beneficiaries semantics: when states is None/empty, omit the
"state IN %s" filter from the SQL where-clause so all states are
considered. Add a regression test that covers state=None.

Author: gonzalesedwin1123

spp_programs/models/managers/program_manager.py

@@ -188,11 +188,20 @@ def _enroll_eligible_registrants_async(self, states, members_count):
         if isinstance(states, str):
             states = [states]
 
+        # Mirror get_beneficiaries: when states is None/empty, no state filter is
+        # applied (i.e. all states). Otherwise restrict to the given states.
+        if states:
+            where_clause = "program_id = %s AND state IN %s"
+            params = (program.id, tuple(states))
+        else:
+            where_clause = "program_id = %s"
+            params = (program.id,)
+
         id_ranges = compute_id_ranges(
             self.env.cr,
             "spp_program_membership",
-            "program_id = %s AND state IN %s",
-            (program.id, tuple(states)),
+            where_clause,
+            params,
             self.MAX_ROW_JOB_QUEUE,
         )
 

spp_programs/tests/test_keyset_pagination.py

@@ -497,3 +497,51 @@ def test_enroll_eligible_async_handles_string_state(self):
             # Verify the states param was converted from string to tuple
             call_params = mock_ranges.call_args[0][3]
             self.assertIsInstance(call_params[1], tuple)
+
+    def test_enroll_eligible_async_handles_none_state(self):
+        """_enroll_eligible_registrants_async must handle state=None.
+
+        The UI "Enroll Eligible" button calls enroll_eligible_registrants() with no
+        argument. When the program has >= MIN_ROW_JOB_QUEUE beneficiaries, the async
+        path runs with state=None — it must not crash on `tuple(None)`.
+        """
+        partners = self.env["res.partner"].create(
+            [{"name": f"Registrant {i}", "is_registrant": True} for i in range(5)]
+        )
+        self.env["spp.program.membership"].create(
+            [
+                {
+                    "partner_id": p.id,
+                    "program_id": self.program.id,
+                    "state": "draft",
+                }
+                for p in partners
+            ]
+        )
+
+        manager = self.env["spp.program.manager.default"].create(
+            {
+                "name": "Test Manager",
+                "program_id": self.program.id,
+            }
+        )
+
+        with patch(
+            "odoo.addons.spp_programs.models.managers.program_manager.compute_id_ranges",
+            return_value=[(1, 5)],
+        ) as mock_ranges:
+            with patch.object(type(manager), "delayable", return_value=manager):
+                try:
+                    manager._enroll_eligible_registrants_async(None, 5)
+                except TypeError as e:
+                    self.fail(f"async dispatch must accept state=None, got TypeError: {e}")
+                except Exception:  # pylint: disable=except-pass
+                    pass
+
+            mock_ranges.assert_called_once()
+            # When states is None, the where clause must omit "state IN %s" and
+            # params must contain only the program id (no states tuple).
+            where_clause = mock_ranges.call_args[0][2]
+            call_params = mock_ranges.call_args[0][3]
+            self.assertNotIn("state IN", where_clause)
+            self.assertEqual(call_params, (self.program.id,))