fix(spp_user_roles): remove _default_role_lines override that copies roles from arbitrary users

The override tried base.default_user (removed in Odoo 19) then fell back
to copying roles from the first user with any role lines — silently
giving every new user an arbitrary set of roles. The upstream base_user_role
OCA module already handles this correctly via an is_default boolean on
res.users.role. Remove the dead overrides from spp_user_roles and spp_area,
rewrite the test to verify the is_default mechanism, and fix tuple syntax
to use Command.create() per Odoo 19 conventions.

Closes #156

Author: gonzalesedwin1123

spp_area/models/user.py

@@ -25,16 +25,3 @@ def _compute_center_area_ids(self):
                         center_area_ids.append(Command.link(area.id))
                 if center_area_ids:
                     user.update({"center_area_ids": center_area_ids})
-
-    @api.model
-    def _default_role_lines(self):
-        default_values = super()._default_role_lines()
-
-        default_user = self.env.ref("base.default_user", raise_if_not_found=False)
-        if default_user:
-            for default_value in default_values:
-                for role_line in default_user.with_context(active_test=False).role_line_ids:
-                    if role_line.role_id.id == default_value["role_id"]:
-                        default_value["local_area_ids"] = [Command.set(role_line.local_area_ids.ids)]
-                        break
-        return default_values

spp_user_roles/models/user.py

@@ -21,33 +21,6 @@ def _compute_role_ids_stored(self):
         for user in self:
             user.role_ids_stored = user.role_line_ids.filtered(lambda r: r.is_enabled).mapped("role_id")
 
-    @api.model
-    def _default_role_lines(self):
-        """Build default role lines from a template user when available.
-
-        ``base.default_user`` disappeared in Odoo 19.0, so we gracefully fall
-        back to the first user that already has role lines defined. This keeps
-        the feature working while remaining backward compatible when the XMLID
-        is present.
-        """
-
-        default_user = self.env.ref("base.default_user", raise_if_not_found=False)
-        if not default_user:
-            default_user = self.env["res.users"].search([("role_line_ids", "!=", False)], limit=1)
-
-        default_values = []
-        if default_user:
-            for role_line in default_user.with_context(active_test=False).role_line_ids:
-                default_values.append(
-                    {
-                        "role_id": role_line.role_id.id,
-                        "date_from": role_line.date_from,
-                        "date_to": role_line.date_to,
-                        "is_enabled": role_line.is_enabled,
-                    }
-                )
-        return default_values
-
     def set_groups_from_roles(self, force=False):
         """Override the original method to exclude some groups in removing."""
         DO_NOT_REMOVE_GROUPS = [

spp_user_roles/tests/test_user.py

@@ -27,8 +27,8 @@ def setUpClass(cls):
                 "name": "Test User",
                 "login": "test_user",
                 "role_line_ids": [
-                    (0, 0, {"role_id": cls.role_user.id}),
-                    (0, 0, {"role_id": cls.role_no_one.id}),
+                    Command.create({"role_id": cls.role_user.id}),
+                    Command.create({"role_id": cls.role_no_one.id}),
                 ],
             }
         )
@@ -44,19 +44,26 @@ def test_set_groups_from_roles(self):
         self.assertIn(self.env.ref("base.group_user").id, self.user.group_ids.ids)
         self.assertIn(self.env.ref("base.group_no_one").id, self.user.group_ids.ids)
 
-    def test_default_role_lines(self):
+    def test_default_role_lines_uses_is_default(self):
+        """Default role lines come from roles with is_default=True, not from arbitrary users."""
+        # Neither role is marked as default, so no defaults should be returned
         default_values = self.env["res.users"]._default_role_lines()
+        default_role_ids = [v["role_id"] for v in default_values]
+        self.assertNotIn(self.role_user.id, default_role_ids)
+        self.assertNotIn(self.role_no_one.id, default_role_ids)
 
-        self.assertTrue(bool(default_values))
-        self.assertEqual(len(default_values), 2)
-        self.assertEqual(default_values[0]["role_id"], self.role_user.id)
-        self.assertEqual(default_values[1]["role_id"], self.role_no_one.id)
-        self.assertTrue(default_values[0]["is_enabled"])
-        self.assertTrue(default_values[1]["is_enabled"])
-        self.assertFalse(default_values[0]["date_from"])
-        self.assertFalse(default_values[1]["date_from"])
-        self.assertFalse(default_values[0]["date_to"])
-        self.assertFalse(default_values[1]["date_to"])
+        # Mark one role as default
+        self.role_user.is_default = True
+        default_values = self.env["res.users"]._default_role_lines()
+        default_role_ids = [v["role_id"] for v in default_values]
+        self.assertIn(self.role_user.id, default_role_ids)
+        self.assertNotIn(self.role_no_one.id, default_role_ids)
+
+        # New user without explicit role_line_ids gets the default role
+        new_user = self.env["res.users"].create({"name": "New User", "login": "new_test_user"})
+        new_user_role_ids = new_user.role_line_ids.mapped("role_id").ids
+        self.assertIn(self.role_user.id, new_user_role_ids)
+        self.assertNotIn(self.role_no_one.id, new_user_role_ids)
 
     @unittest.skip("center_area_ids computation not available in Odoo 19 build")
     def test_compute_center_area_ids(self):