test(spp_branding_kit): add comprehensive test coverage

- Add tests for post_init_hook and uninstall_hook functions
- Add tests for OpenSPPHome controller (debug mode restrictions)
- Add tests for OpenSPPBrandingController routes (about, version, telemetry)
- Add tests for IrHttp.session_info customization
- Add tests for IrModuleModule helper methods (filter, count)
- Add tests for ResUsers email signature and account URL
- Add edge case tests for modules with no license
- Add tests for various paid license format variations

This improves test coverage from 68% to target coverage levels

Author: jeremi

spp_branding_kit/tests/__init__.py

@@ -2,3 +2,6 @@
 # ABOUTME: Import test cases for spp_branding_kit module
 
 from . import test_hide_paid_apps
+from . import test_init_hooks
+from . import test_controllers
+from . import test_models

spp_branding_kit/tests/test_controllers.py

@@ -0,0 +1,263 @@
+# ABOUTME: Unit tests for the controllers in spp_branding_kit
+# ABOUTME: Tests OpenSPPHome and OpenSPPBrandingController
+
+import json
+from unittest.mock import MagicMock, patch
+
+from odoo.tests import TransactionCase, tagged
+
+
+@tagged("post_install", "-at_install")
+class TestOpenSPPHome(TransactionCase):
+    def setUp(self):
+        super().setUp()
+        self.IrConfigParam = self.env["ir.config_parameter"].sudo()
+
+    def test_web_client_removes_debug_for_non_admin(self):
+        """Test that debug mode is removed for non-admin users"""
+        from ..controllers.main import OpenSPPHome
+
+        # Set debug_admin_only to True
+        self.IrConfigParam.set_param("openspp.debug_admin_only", "True")
+
+        # Create a non-admin user
+        non_admin_user = self.env["res.users"].create(
+            {
+                "name": "Test Non-Admin",
+                "login": "test_non_admin",
+                "email": "[email protected]",
+            }
+        )
+
+        # Mock request
+        with patch("spp_branding_kit.controllers.main.request") as mock_request:
+            mock_request.env = self.env.sudo(non_admin_user)
+            mock_request.session.uid = non_admin_user.id
+            mock_request.env.user = non_admin_user
+            mock_request.redirect = MagicMock(return_value="redirect_response")
+
+            controller = OpenSPPHome()
+
+            # Mock super().web_client
+            with patch.object(OpenSPPHome.__bases__[0], "web_client", return_value="web_client_response"):
+                # Test with debug=True for non-admin
+                result = controller.web_client(debug=True)
+
+                # Should redirect without debug
+                mock_request.redirect.assert_called_once_with("/web", 303)
+                self.assertEqual(result, "redirect_response")
+
+    def test_web_client_allows_debug_for_admin(self):
+        """Test that debug mode is allowed for admin users"""
+        from ..controllers.main import OpenSPPHome
+
+        # Set debug_admin_only to True
+        self.IrConfigParam.set_param("openspp.debug_admin_only", "True")
+
+        # Use admin user
+        admin_user = self.env.ref("base.user_admin")
+
+        # Mock request
+        with patch("spp_branding_kit.controllers.main.request") as mock_request:
+            mock_request.env = self.env.sudo(admin_user)
+            mock_request.session.uid = admin_user.id
+            mock_request.env.user = admin_user
+
+            controller = OpenSPPHome()
+
+            # Mock super().web_client
+            with patch.object(OpenSPPHome.__bases__[0], "web_client", return_value="web_client_response") as mock_super:
+                # Test with debug=True for admin
+                result = controller.web_client(debug=True)
+
+                # Should call super with debug parameter
+                mock_super.assert_called_once_with(debug=True)
+                self.assertEqual(result, "web_client_response")
+
+    def test_web_client_allows_debug_when_disabled(self):
+        """Test that debug mode is allowed for all when debug_admin_only is False"""
+        from ..controllers.main import OpenSPPHome
+
+        # Set debug_admin_only to False
+        self.IrConfigParam.set_param("openspp.debug_admin_only", "False")
+
+        # Create a non-admin user
+        non_admin_user = self.env["res.users"].create(
+            {
+                "name": "Test User",
+                "login": "test_user",
+                "email": "[email protected]",
+            }
+        )
+
+        # Mock request
+        with patch("spp_branding_kit.controllers.main.request") as mock_request:
+            mock_request.env = self.env.sudo(non_admin_user)
+            mock_request.session.uid = non_admin_user.id
+            mock_request.env.user = non_admin_user
+
+            controller = OpenSPPHome()
+
+            # Mock super().web_client
+            with patch.object(OpenSPPHome.__bases__[0], "web_client", return_value="web_client_response") as mock_super:
+                # Test with debug=True for non-admin
+                result = controller.web_client(debug=True)
+
+                # Should call super with debug parameter
+                mock_super.assert_called_once_with(debug=True)
+                self.assertEqual(result, "web_client_response")
+
+    def test_web_client_without_debug(self):
+        """Test web_client without debug parameter"""
+        from ..controllers.main import OpenSPPHome
+
+        controller = OpenSPPHome()
+
+        # Mock super().web_client
+        with patch.object(OpenSPPHome.__bases__[0], "web_client", return_value="web_client_response") as mock_super:
+            # Test without debug parameter
+            result = controller.web_client()
+
+            # Should call super without modifications
+            mock_super.assert_called_once_with()
+            self.assertEqual(result, "web_client_response")
+
+
+@tagged("post_install", "-at_install")
+class TestOpenSPPBrandingController(TransactionCase):
+    def setUp(self):
+        super().setUp()
+        self.IrConfigParam = self.env["ir.config_parameter"].sudo()
+
+    def test_openspp_about_route(self):
+        """Test the /openspp/about route"""
+        from ..controllers.main import OpenSPPBrandingController
+
+        # Set custom configuration
+        self.IrConfigParam.set_param("openspp.system_name", "Test System")
+        self.IrConfigParam.set_param("openspp.documentation_url", "https://test-docs.org")
+        self.IrConfigParam.set_param("openspp.support_url", "https://test-support.org")
+
+        # Mock request
+        with patch("spp_branding_kit.controllers.main.request") as mock_request:
+            mock_request.env = self.env
+
+            controller = OpenSPPBrandingController()
+            result = controller.openspp_about()
+
+            # Parse the JSON response
+            data = json.loads(result)
+
+            self.assertEqual(data["title"], "About OpenSPP")
+            self.assertEqual(data["version"], "1.0.0")
+            self.assertEqual(data["system_name"], "Test System")
+            self.assertEqual(data["documentation_url"], "https://test-docs.org")
+            self.assertEqual(data["support_url"], "https://test-support.org")
+
+    def test_openspp_about_route_with_defaults(self):
+        """Test the /openspp/about route with default values"""
+        from ..controllers.main import OpenSPPBrandingController
+
+        # Clear any existing parameters
+        self.IrConfigParam.search([("key", "=like", "openspp.%")]).unlink()
+
+        # Mock request
+        with patch("spp_branding_kit.controllers.main.request") as mock_request:
+            mock_request.env = self.env
+
+            controller = OpenSPPBrandingController()
+            result = controller.openspp_about()
+
+            # Parse the JSON response
+            data = json.loads(result)
+
+            self.assertEqual(data["title"], "About OpenSPP")
+            self.assertEqual(data["version"], "1.0.0")
+            self.assertEqual(data["system_name"], "OpenSPP Platform")
+            self.assertEqual(data["documentation_url"], "https://docs.openspp.org")
+            self.assertEqual(data["support_url"], "https://openspp.org")
+
+    def test_version_info_route(self):
+        """Test the /web/webclient/version_info route"""
+        from ..controllers.main import OpenSPPBrandingController
+
+        # Set custom system name
+        self.IrConfigParam.set_param("openspp.system_name", "Custom OpenSPP")
+
+        # Mock request
+        with patch("spp_branding_kit.controllers.main.request") as mock_request:
+            mock_request.env = self.env
+
+            controller = OpenSPPBrandingController()
+            result = controller.version_info()
+
+            self.assertEqual(result["server_version"], "Custom OpenSPP")
+            self.assertEqual(result["server_serie"], "1.0")
+            self.assertEqual(result["protocol_version"], 1)
+
+    def test_publisher_warranty_telemetry_enabled(self):
+        """Test publisher warranty route when telemetry is enabled"""
+        from ..controllers.main import OpenSPPBrandingController
+
+        # Enable telemetry
+        self.IrConfigParam.set_param("openspp.telemetry_enabled", "True")
+        self.IrConfigParam.set_param("openspp.telemetry_endpoint", "https://custom-telemetry.org")
+
+        # Mock request
+        with patch("spp_branding_kit.controllers.main.request") as mock_request:
+            mock_request.env = self.env
+
+            controller = OpenSPPBrandingController()
+            result = controller.publisher_warranty()
+
+            # Parse the JSON response
+            data = json.loads(result)
+
+            self.assertEqual(data["status"], "redirected")
+            self.assertEqual(data["endpoint"], "https://custom-telemetry.org")
+            self.assertEqual(data["message"], "Telemetry redirected to OpenSPP")
+
+    def test_publisher_warranty_telemetry_disabled(self):
+        """Test publisher warranty route when telemetry is disabled"""
+        from ..controllers.main import OpenSPPBrandingController
+
+        # Disable telemetry
+        self.IrConfigParam.set_param("openspp.telemetry_enabled", "False")
+
+        # Mock request
+        with patch("spp_branding_kit.controllers.main.request") as mock_request:
+            mock_request.env = self.env
+
+            controller = OpenSPPBrandingController()
+            result = controller.publisher_warranty()
+
+            # Parse the JSON response
+            data = json.loads(result)
+
+            self.assertEqual(data["status"], "disabled")
+            self.assertEqual(data["message"], "Telemetry disabled")
+
+    def test_publisher_warranty_with_default_endpoint(self):
+        """Test publisher warranty route with default telemetry endpoint"""
+        from ..controllers.main import OpenSPPBrandingController
+
+        # Enable telemetry but don't set custom endpoint
+        self.IrConfigParam.set_param("openspp.telemetry_enabled", "True")
+        # Clear telemetry endpoint if exists
+        param = self.IrConfigParam.search([("key", "=", "openspp.telemetry_endpoint")])
+        if param:
+            param.unlink()
+
+        # Mock request
+        with patch("spp_branding_kit.controllers.main.request") as mock_request:
+            mock_request.env = self.env
+
+            controller = OpenSPPBrandingController()
+            result = controller.publisher_warranty()
+
+            # Parse the JSON response
+            data = json.loads(result)
+
+            self.assertEqual(data["status"], "redirected")
+            self.assertEqual(data["endpoint"], "https://telemetry.openspp.org")
+            self.assertEqual(data["message"], "Telemetry redirected to OpenSPP")

spp_branding_kit/tests/test_hide_paid_apps.py

@@ -118,3 +118,64 @@ def test_search_methods_respect_setting(self):
             if r.get("license") and (r["license"].startswith("OEEL") or r["license"].startswith("OPL"))
         ]
         self.assertFalse(paid_in_web, "web_search_read should filter paid apps")
+
+    def test_edge_cases_with_none_license(self):
+        """Test handling of modules with None or empty license"""
+        # Create module with no license
+        no_license_module = self.Module.create(
+            {
+                "name": "test_no_license",
+                "shortdesc": "Test No License",
+                "state": "installed",
+                "license": False,  # No license
+                "application": True,
+            }
+        )
+
+        # Enable hiding paid apps
+        self.IrConfigParam.set_param("openspp.hide_paid_apps", True)
+
+        # Search for modules in Apps context
+        modules = self.Module.with_context(apps_menu=True).search([])
+
+        # Module with no license should be visible
+        self.assertIn(no_license_module, modules, "Modules with no license should be visible")
+
+    def test_paid_license_variations(self):
+        """Test that different variations of paid licenses are filtered"""
+        # Create modules with various paid license formats
+        oeel_variations = [
+            self.Module.create(
+                {
+                    "name": f"test_oeel_{i}",
+                    "shortdesc": f"Test OEEL {i}",
+                    "state": "installed",
+                    "license": license,
+                    "application": True,
+                }
+            )
+            for i, license in enumerate(["OEEL-1", "OEEL-2", "OEEL", "OEEL-1.0"])
+        ]
+
+        opl_variations = [
+            self.Module.create(
+                {
+                    "name": f"test_opl_{i}",
+                    "shortdesc": f"Test OPL {i}",
+                    "state": "installed",
+                    "license": license,
+                    "application": True,
+                }
+            )
+            for i, license in enumerate(["OPL-1", "OPL-2", "OPL", "OPL-1.0"])
+        ]
+
+        # Enable hiding paid apps
+        self.IrConfigParam.set_param("openspp.hide_paid_apps", True)
+
+        # Search for modules in Apps context
+        modules = self.Module.with_context(apps_menu=True).search([])
+
+        # All paid license variations should be hidden
+        for module in oeel_variations + opl_variations:
+            self.assertNotIn(module, modules, f"Module with license {module.license} should be hidden")