style(spp_registry): apply ruff fixes and formatting to test suite

Replace blind `assertRaises(Exception)` with the actual `UserError`
raised by `phone_validation.phone_format`, drop unused imports, and
apply ruff format to the new test files so pre-commit passes on CI.

Author: kneckinator

spp_registry/tests/common.py

@@ -20,19 +20,11 @@ def setUpClass(cls):
         cls.Membership = cls.env["spp.group.membership"]
         cls.VocabCode = cls.env["spp.vocabulary.code"]
 
-        cls.head_code = cls.VocabCode.sudo().get_code(
-            "urn:openspp:vocab:group-membership-type", "head"
-        )
+        cls.head_code = cls.VocabCode.sudo().get_code("urn:openspp:vocab:group-membership-type", "head")
 
-        cls.group = cls.Partner.create(
-            {"name": "Test Household", "is_registrant": True, "is_group": True}
-        )
-        cls.individual_a = cls.Partner.create(
-            {"name": "Alice", "is_registrant": True, "is_group": False}
-        )
-        cls.individual_b = cls.Partner.create(
-            {"name": "Bob", "is_registrant": True, "is_group": False}
-        )
+        cls.group = cls.Partner.create({"name": "Test Household", "is_registrant": True, "is_group": True})
+        cls.individual_a = cls.Partner.create({"name": "Alice", "is_registrant": True, "is_group": False})
+        cls.individual_b = cls.Partner.create({"name": "Bob", "is_registrant": True, "is_group": False})
 
     @classmethod
     def _make_user(cls, login, group_xmlids):

spp_registry/tests/test_constraints.py

@@ -158,32 +158,24 @@ def setUpClass(cls):
         cls.IDType = cls.env["spp.id.type"]
 
     def test_valid_uri_accepted(self):
-        rec = self.IDType.create(
-            {"name": "PSA National ID", "namespace_uri": "urn:gov:ph:psa:national-id"}
-        )
+        rec = self.IDType.create({"name": "PSA National ID", "namespace_uri": "urn:gov:ph:psa:national-id"})
         self.assertEqual(rec.namespace_uri, "urn:gov:ph:psa:national-id")
 
     def test_create_lowercases_namespace(self):
         """create() override should normalise to lowercase + trim whitespace."""
-        rec = self.IDType.create(
-            {"name": "Mixed Case Type", "namespace_uri": "  URN:GOV:PH:Mixed  "}
-        )
+        rec = self.IDType.create({"name": "Mixed Case Type", "namespace_uri": "  URN:GOV:PH:Mixed  "})
         self.assertEqual(rec.namespace_uri, "urn:gov:ph:mixed")
 
     def test_write_lowercases_namespace(self):
         """write() override should normalise to lowercase + trim whitespace."""
-        rec = self.IDType.create(
-            {"name": "Writable Type", "namespace_uri": "urn:gov:ph:initial"}
-        )
+        rec = self.IDType.create({"name": "Writable Type", "namespace_uri": "urn:gov:ph:initial"})
         rec.write({"namespace_uri": "  URN:GOV:PH:UPDATED  "})
         self.assertEqual(rec.namespace_uri, "urn:gov:ph:updated")
 
     def test_invalid_scheme_rejected(self):
         """Non-``urn:`` URIs violate the ADR-007 pattern."""
         with self.assertRaises(ValidationError):
-            self.IDType.create(
-                {"name": "Bad Scheme", "namespace_uri": "http://example.org/id"}
-            )
+            self.IDType.create({"name": "Bad Scheme", "namespace_uri": "http://example.org/id"})
 
     def test_missing_type_component_rejected(self):
         """``urn:<namespace>`` without the trailing ``:<type>`` is rejected."""
@@ -193,9 +185,7 @@ def test_missing_type_component_rejected(self):
     def test_disallowed_characters_rejected(self):
         """The pattern only permits [a-z0-9._-] in each segment."""
         with self.assertRaises(ValidationError):
-            self.IDType.create(
-                {"name": "Spaces", "namespace_uri": "urn:gov:ph:national id"}
-            )
+            self.IDType.create({"name": "Spaces", "namespace_uri": "urn:gov:ph:national id"})
 
     def test_empty_namespace_is_allowed(self):
         """Empty / falsy namespace_uri short-circuits validation (see code)."""
@@ -204,9 +194,7 @@ def test_empty_namespace_is_allowed(self):
 
     def test_duplicate_namespace_uri_rejected(self):
         """The ``_unique_namespace_uri`` SQL constraint must fire."""
-        self.IDType.create(
-            {"name": "First", "namespace_uri": "urn:gov:ph:psa:national-id"}
-        )
+        self.IDType.create({"name": "First", "namespace_uri": "urn:gov:ph:psa:national-id"})
         # TODO: assert IntegrityError via with self.assertRaises + flush().
         # SQL constraints raise on flush, not on the ORM call, so the
         # idiomatic Odoo pattern is ``with mute_logger(...): self.env.flush_all()``.

spp_registry/tests/test_group_aggregation.py

@@ -36,9 +36,6 @@
     way to ``spp.vocabulary.code``. So callers must pass display strings.
 """
 
-from datetime import datetime, timedelta
-
-from odoo import fields
 from odoo.tests import tagged
 
 from .common import RegistryCommon
@@ -49,17 +46,11 @@ class AggregationCommon(RegistryCommon):
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
-        cls.individual_c = cls.Partner.create(
-            {"name": "Carol", "is_registrant": True, "is_group": False}
-        )
-        cls.individual_d = cls.Partner.create(
-            {"name": "Dave", "is_registrant": True, "is_group": False}
-        )
+        cls.individual_c = cls.Partner.create({"name": "Carol", "is_registrant": True, "is_group": False})
+        cls.individual_d = cls.Partner.create({"name": "Dave", "is_registrant": True, "is_group": False})
 
         # Second group so multi-group queries can be tested.
-        cls.group_b = cls.Partner.create(
-            {"name": "Second Household", "is_registrant": True, "is_group": True}
-        )
+        cls.group_b = cls.Partner.create({"name": "Second Household", "is_registrant": True, "is_group": True})
 
         # Synthesize a non-head membership-type code so we can filter
         # by relationship_kinds without head-uniqueness collisions.
@@ -81,9 +72,7 @@ def _add_member(self, group, individual, type_codes=()):
             {
                 "group": group.id,
                 "individual": individual.id,
-                "membership_type_ids": [(6, 0, [c.id for c in type_codes])]
-                if type_codes
-                else False,
+                "membership_type_ids": [(6, 0, [c.id for c in type_codes])] if type_codes else False,
             }
         )
 
@@ -146,10 +135,7 @@ def test_disabled_individual_excluded(self):
         ``_query_members_aggregate`` from ``expression.expression()`` to
         the ``Domain`` API (the deprecation warning's own suggestion).
         Then drop these skips."""
-        self.skipTest(
-            "BROKEN: deprecated expression.expression() yields empty "
-            "filter SQL on Odoo 19 — see docstring"
-        )
+        self.skipTest("BROKEN: deprecated expression.expression() yields empty filter SQL on Odoo 19 — see docstring")
 
     def test_ended_membership_excluded(self):
         """Same Odoo-19 ``expression.expression()`` deprecation bug as
@@ -186,26 +172,20 @@ class TestCountIndividualsKindFilter(AggregationCommon):
     def test_filter_by_head_display_matches_only_head_members(self):
         self._add_member(self.group, self.individual_a, type_codes=[self.head_code])
         self._add_member(self.group, self.individual_b, type_codes=[self.member_code])
-        result = self._to_dict(
-            self.group.count_individuals(relationship_kinds=["Head"])
-        )
+        result = self._to_dict(self.group.count_individuals(relationship_kinds=["Head"]))
         self.assertEqual(result.get(self.group.id), 1)
 
     def test_filter_by_multiple_displays(self):
         self._add_member(self.group, self.individual_a, type_codes=[self.head_code])
         self._add_member(self.group, self.individual_b, type_codes=[self.member_code])
-        result = self._to_dict(
-            self.group.count_individuals(relationship_kinds=["Head", "Member"])
-        )
+        result = self._to_dict(self.group.count_individuals(relationship_kinds=["Head", "Member"]))
         self.assertEqual(result.get(self.group.id), 2)
 
     def test_filter_with_no_matches_returns_no_row(self):
         """No memberships with the requested kind → group falls out of
         the GROUP BY entirely."""
         self._add_member(self.group, self.individual_a, type_codes=[self.head_code])
-        result = self._to_dict(
-            self.group.count_individuals(relationship_kinds=["Member"])
-        )
+        result = self._to_dict(self.group.count_individuals(relationship_kinds=["Member"]))
         self.assertNotIn(self.group.id, result)
 
     def test_lowercase_code_does_not_match(self):
@@ -215,9 +195,7 @@ def test_lowercase_code_does_not_match(self):
 
         Pin the surprise; document until the impl is harmonized."""
         self._add_member(self.group, self.individual_a, type_codes=[self.head_code])
-        result = self._to_dict(
-            self.group.count_individuals(relationship_kinds=["head"])
-        )
+        result = self._to_dict(self.group.count_individuals(relationship_kinds=["head"]))
         self.assertNotIn(self.group.id, result)
 
 
@@ -229,16 +207,12 @@ class TestCountIndividualsDomainFilter(AggregationCommon):
     def test_filter_by_individual_name(self):
         self._add_member(self.group, self.individual_a)  # "Alice"
         self._add_member(self.group, self.individual_b)  # "Bob"
-        result = self._to_dict(
-            self.group.count_individuals(domain=[("name", "=", "Alice")])
-        )
+        result = self._to_dict(self.group.count_individuals(domain=[("name", "=", "Alice")]))
         self.assertEqual(result.get(self.group.id), 1)
 
     def test_filter_with_no_matching_individuals(self):
         self._add_member(self.group, self.individual_a)
-        result = self._to_dict(
-            self.group.count_individuals(domain=[("name", "=", "Nobody")])
-        )
+        result = self._to_dict(self.group.count_individuals(domain=[("name", "=", "Nobody")]))
         self.assertNotIn(self.group.id, result)
 
     def test_compound_domain(self):
@@ -247,9 +221,7 @@ def test_compound_domain(self):
         self._add_member(self.group, self.individual_b)  # Bob, individual
         # All individuals match is_registrant=True; restrict to "Alice".
         result = self._to_dict(
-            self.group.count_individuals(
-                domain=[("is_registrant", "=", True), ("name", "=", "Alice")]
-            )
+            self.group.count_individuals(domain=[("is_registrant", "=", True), ("name", "=", "Alice")])
         )
         self.assertEqual(result.get(self.group.id), 1)
 
@@ -259,9 +231,7 @@ def test_kind_and_domain_combined(self):
         self._add_member(self.group, self.individual_b, type_codes=[self.member_code])
         # Only Bob is a "Member" AND named "Bob" → expect 1.
         result = self._to_dict(
-            self.group.count_individuals(
-                relationship_kinds=["Member"], domain=[("name", "=", "Bob")]
-            )
+            self.group.count_individuals(relationship_kinds=["Member"], domain=[("name", "=", "Bob")])
         )
         self.assertEqual(result.get(self.group.id), 1)
 
@@ -297,11 +267,7 @@ def test_kind_domain_with_translated_name_leaf(self):
         op, val)`` for the vocab query. Pin that the translation is the
         contract — pass a ``name`` leaf and observe display filtering."""
         self._add_member(self.group, self.individual_a, type_codes=[self.head_code])
-        result = dict(
-            self.group._query_members_aggregate(
-                membership_kind_domain=[("name", "in", ["Head"])]
-            )
-        )
+        result = dict(self.group._query_members_aggregate(membership_kind_domain=[("name", "in", ["Head"])]))
         self.assertEqual(result.get(self.group.id), 1)
 
 
@@ -339,9 +305,7 @@ def test_no_records_is_noop(self):
         # Pass only individuals; ``.filtered(lambda a: a.is_group)`` yields
         # empty. Method should silently return.
         individuals = self.individual_a | self.individual_b
-        individuals.compute_count_and_set_indicator(
-            field_name="never_set", kinds=None, domain=None
-        )
+        individuals.compute_count_and_set_indicator(field_name="never_set", kinds=None, domain=None)
 
 
 @tagged("post_install", "-at_install")
@@ -353,9 +317,7 @@ class TestUpdateComputeFields(AggregationCommon):
     def test_filters_to_groups_only_no_raise(self):
         """Non-group records are filtered out by the first line."""
         individuals = self.individual_a | self.individual_b
-        self.env["res.partner"]._update_compute_fields(
-            individuals, field_name="never_set", kinds=None, domain=None
-        )
+        self.env["res.partner"]._update_compute_fields(individuals, field_name="never_set", kinds=None, domain=None)
 
     def test_happy_path_requires_host_module_field(self):
         # TODO: same as TestComputeCountAndSetIndicator — needs an integer

spp_registry/tests/test_individual_name.py

@@ -132,9 +132,7 @@ def test_create_sets_name_from_parts(self):
 
     def test_create_respects_explicit_name_when_no_parts(self):
         """No name parts in vals → ``name`` is NOT overwritten."""
-        rec = self.Partner.create(
-            {"is_registrant": True, "name": "Explicit Name"}
-        )
+        rec = self.Partner.create({"is_registrant": True, "name": "Explicit Name"})
         self.assertEqual(rec.name, "Explicit Name")
 
     def test_create_does_not_format_for_groups(self):
@@ -151,9 +149,7 @@ def test_create_does_not_format_for_groups(self):
         self.assertEqual(rec.name, "Test Household")
 
     def test_create_with_only_addl(self):
-        rec = self.Partner.create(
-            {"is_registrant": True, "addl_name": "Marie"}
-        )
+        rec = self.Partner.create({"is_registrant": True, "addl_name": "Marie"})
         self.assertEqual(rec.name, "MARIE")
 
 
@@ -199,9 +195,7 @@ def test_skip_name_format_context_bypasses_reformat(self):
         super() without recursion. Anyone passing the context explicitly
         gets the same opt-out.
         """
-        self.rec.with_context(skip_name_format=True).write(
-            {"family_name": "Smith"}
-        )
+        self.rec.with_context(skip_name_format=True).write({"family_name": "Smith"})
         # family_name updated but name unchanged.
         self.assertEqual(self.rec.family_name, "Smith")
         self.assertEqual(self.rec.name, "DOE, JANE")

spp_registry/tests/test_membership_constraints.py

@@ -21,7 +21,7 @@
 
 from odoo import fields
 from odoo.exceptions import ValidationError
-from odoo.tests import Form, tagged
+from odoo.tests import tagged
 
 from .common import RegistryCommon
 
@@ -57,45 +57,27 @@ class TestCheckGroupMembers(MembershipCommon):
     """``_check_group_members`` — no duplicate individuals in a group."""
 
     def test_same_individual_twice_in_same_group_rejected(self):
-        self.Membership.create(
-            {"group": self.group.id, "individual": self.individual_a.id}
-        )
+        self.Membership.create({"group": self.group.id, "individual": self.individual_a.id})
         with self.assertRaises(ValidationError):
-            self.Membership.create(
-                {"group": self.group.id, "individual": self.individual_a.id}
-            )
+            self.Membership.create({"group": self.group.id, "individual": self.individual_a.id})
 
     def test_different_individuals_in_same_group_allowed(self):
-        self.Membership.create(
-            {"group": self.group.id, "individual": self.individual_a.id}
-        )
-        rec = self.Membership.create(
-            {"group": self.group.id, "individual": self.individual_b.id}
-        )
+        self.Membership.create({"group": self.group.id, "individual": self.individual_a.id})
+        rec = self.Membership.create({"group": self.group.id, "individual": self.individual_b.id})
         self.assertTrue(rec.id)
 
     def test_same_individual_in_different_groups_allowed(self):
         """Cross-group memberships for the same person are fine."""
-        other_group = self.Partner.create(
-            {"name": "Second Household", "is_registrant": True, "is_group": True}
-        )
-        self.Membership.create(
-            {"group": self.group.id, "individual": self.individual_a.id}
-        )
-        rec = self.Membership.create(
-            {"group": other_group.id, "individual": self.individual_a.id}
-        )
+        other_group = self.Partner.create({"name": "Second Household", "is_registrant": True, "is_group": True})
+        self.Membership.create({"group": self.group.id, "individual": self.individual_a.id})
+        rec = self.Membership.create({"group": other_group.id, "individual": self.individual_a.id})
         self.assertTrue(rec.id)
 
     def test_write_into_duplicate_individual_rejected(self):
         """Reassigning a membership to an already-present individual trips
         the constraint via the write path."""
-        self.Membership.create(
-            {"group": self.group.id, "individual": self.individual_a.id}
-        )
-        existing = self.Membership.create(
-            {"group": self.group.id, "individual": self.individual_b.id}
-        )
+        self.Membership.create({"group": self.group.id, "individual": self.individual_a.id})
+        existing = self.Membership.create({"group": self.group.id, "individual": self.individual_b.id})
         with self.assertRaises(ValidationError):
             existing.write({"individual": self.individual_a.id})
 
@@ -239,9 +221,7 @@ class TestComputeStatus(MembershipCommon):
     ``ended_date``."""
 
     def test_active_when_no_end_date(self):
-        rec = self.Membership.create(
-            {"group": self.group.id, "individual": self.individual_a.id}
-        )
+        rec = self.Membership.create({"group": self.group.id, "individual": self.individual_a.id})
         self.assertEqual(rec.status, "active")
 
     def test_active_when_end_date_in_future(self):
@@ -292,9 +272,7 @@ class TestComputeIsEnded(MembershipCommon):
     """``_compute_is_ended`` — boolean shadow of ``status``."""
 
     def test_false_when_no_end_date(self):
-        rec = self.Membership.create(
-            {"group": self.group.id, "individual": self.individual_a.id}
-        )
+        rec = self.Membership.create({"group": self.group.id, "individual": self.individual_a.id})
         self.assertFalse(rec.is_ended)
 
     def test_false_when_end_date_in_future(self):
@@ -363,9 +341,7 @@ class TestMembershipDisplayName(MembershipCommon):
     """``_compute_display_name`` — uses the group's name."""
 
     def test_display_name_is_group_name(self):
-        rec = self.Membership.create(
-            {"group": self.group.id, "individual": self.individual_a.id}
-        )
+        rec = self.Membership.create({"group": self.group.id, "individual": self.individual_a.id})
         self.assertEqual(rec.display_name, self.group.name)
 
     def test_display_name_falls_back_when_no_group(self):