[MIG] delivery_package_type_number_parcels: Migration to 18.0

Author: BhaveshHeliconia

delivery_package_type_number_parcels/tests/test_document_page_approval.py

@@ -0,0 +1,275 @@
+from odoo import Command
+from odoo.exceptions import UserError
+from odoo.tests import new_test_user
+
+from odoo.addons.base.tests.common import BaseCommon
+
+
+class TestDocumentPageApproval(BaseCommon):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.page_obj = cls.env["document.page"]
+        cls.history_obj = cls.env["document.page.history"]
+
+        # Demo Data
+        cls.category1 = cls.env.ref("document_page.demo_category1")
+        cls.page1 = cls.env.ref("document_page.demo_page1")
+
+        # Create test user without groups first
+        cls.user2 = new_test_user(cls.env, login="test-user2", groups="base.group_user")
+
+        # Ensure user2 has the approver group
+        cls.approver_gid = cls.env.ref(
+            "document_page_approval.group_document_approver_user"
+        )
+        cls.user2.write({"groups_id": [Command.link(cls.approver_gid.id)]})
+
+        # Ensure test-user2 has write access on document.page.history
+        cls.env["ir.model.access"].create(
+            {
+                "name": "Write Access for Test User2",
+                "model_id": cls.env["ir.model"]._get_id("document.page.history"),
+                "group_id": cls.approver_gid.id,  # Assign to approver group
+                "perm_read": True,
+                "perm_write": True,
+                "perm_create": True,
+                "perm_unlink": True,
+            }
+        )
+
+        # Disable restrictive record rules for the test
+        cls.env["ir.rule"].search(
+            [("model_id", "=", cls.env["ir.model"]._get_id("document.page.history"))]
+        ).write({"active": False})
+
+        # Create category and page that require approval
+        cls.category2 = cls.page_obj.create(
+            {
+                "name": "This category requires approval",
+                "type": "category",
+                "approval_required": True,
+                "approver_gid": cls.approver_gid.id,
+            }
+        )
+        cls.page2 = cls.page_obj.create(
+            {
+                "name": "This page requires approval",
+                "parent_id": cls.category2.id,
+                "content": "This content will require approval",
+            }
+        )
+
+    def test_approval_required(self):
+        """Test that the page requires approval."""
+        page = self.page2
+        self.assertTrue(page.is_approval_required)
+        self.assertTrue(page.has_changes_pending_approval)
+        self.assertEqual(len(page.history_ids), 0)
+
+    def test_change_request_approve(self):
+        """Test that an approver can approve a change request."""
+        page = self.page2
+
+        # Get the change request for this page
+        chreq = self.history_obj.search(
+            [("page_id", "=", page.id), ("state", "!=", "approved")], limit=1
+        )
+
+        self.assertEqual(chreq.state, "to approve")
+
+        # Ensure user2 is listed as an approver
+        self.assertTrue(chreq.with_user(self.user2).am_i_approver)
+
+        # Approve the request as user2 (approver)
+        chreq.with_user(self.user2).action_approve()
+        self.assertEqual(chreq.state, "approved")
+        self.assertEqual(chreq.content, page.content)
+
+        # Create new change request
+        page.write({"content": "New content"})
+        page.invalidate_model()  # Recompute fields
+        chreq = self.history_obj.search(
+            [("page_id", "=", page.id), ("state", "!=", "approved")], limit=1
+        )
+
+        # Approve new changes
+        chreq.with_user(self.user2).action_approve()
+        self.assertEqual(page.content, "New content")
+
+    def test_change_request_auto_approve(self):
+        """Test that a page without approval required auto-approves changes."""
+        page = self.page1
+        self.assertFalse(page.is_approval_required)
+        page.write({"content": "New content"})
+        self.assertEqual(page.content, "New content")
+
+    def test_change_request_from_scratch(self):
+        """Test a full change request lifecycle from draft to approval."""
+        page = self.page2
+
+        # Approve all pending change requests
+        self.history_obj.search(
+            [("page_id", "=", page.id), ("state", "!=", "approved")]
+        ).with_user(self.user2).action_approve()
+
+        # Create new change request
+        chreq = self.history_obj.create(
+            {
+                "page_id": page.id,
+                "summary": "Changed something",
+                "content": "New content",
+            }
+        )
+
+        self.assertEqual(chreq.state, "draft")
+
+        # Move change request to 'to approve' state
+        chreq.with_user(self.user2).action_to_approve()
+        self.assertEqual(chreq.state, "to approve")
+
+        # Cancel and return to draft
+        chreq.with_user(self.user2).action_cancel()
+        self.assertEqual(chreq.state, "cancelled")
+
+        chreq.with_user(self.user2).action_draft()
+        self.assertEqual(chreq.state, "draft")
+
+        # Approve the change request
+        chreq.with_user(self.user2).action_approve()
+        self.assertEqual(chreq.state, "approved")
+        self.assertEqual(page.content, chreq.content)
+        self.assertEqual(page.approved_date, chreq.approved_date)
+        self.assertEqual(page.approved_uid, chreq.approved_uid)
+
+    def test_get_approvers_guids(self):
+        """Test that approver groups are properly assigned."""
+        page = self.page2
+        self.assertTrue(len(page.approver_group_ids) > 0)
+
+    def test_get_page_url(self):
+        """Test that the page URL exists."""
+        pages = self.env["document.page.history"].search([])
+        page = pages[0]
+        self.assertIsNotNone(page.page_url)
+
+    def test_compute_is_approval_required(self):
+        """Ensure approval rules are inherited correctly"""
+        self.assertTrue(self.page2.is_approval_required)
+        self.page2.parent_id.approval_required = False
+        self.page2.invalidate_model()
+        self.assertFalse(self.page2.is_approval_required)
+
+    def test_compute_approver_group_ids(self):
+        """Ensure approver groups are inherited correctly"""
+        self.assertIn(self.approver_gid, self.page2.approver_group_ids)
+        self.page2.parent_id.approver_gid = False
+        self.page2.invalidate_model()
+        self.assertFalse(self.page2.approver_group_ids)
+
+    def test_can_user_approve_this_page(self):
+        """Check different approval conditions"""
+        self.assertTrue(
+            self.page2.with_user(self.user2).can_user_approve_this_page(self.user2)
+        )
+
+        # Remove approval group from user2
+        self.user2.write({"groups_id": [(3, self.approver_gid.id)]})
+        self.assertFalse(
+            self.page2.with_user(self.user2).can_user_approve_this_page(self.user2)
+        )
+
+    def test_pending_approval_detection(self):
+        """Ensure the system detects pending approval changes"""
+        # Reset page2 by removing previous history
+        self.history_obj.search([("page_id", "=", self.page2.id)]).unlink()
+
+        self.page2.invalidate_model()
+        self.assertFalse(self.page2.has_changes_pending_approval)
+
+        # Create a new change request
+        self.history_obj.create(
+            {
+                "page_id": self.page2.id,
+                "state": "to approve",
+            }
+        )
+
+        self.page2.invalidate_model()
+        self.assertTrue(self.page2.has_changes_pending_approval)
+
+    def test_user_has_drafts(self):
+        """Ensure the system detects drafts correctly"""
+        self.page2.invalidate_model()
+        self.assertFalse(self.page2.user_has_drafts)
+
+        self.history_obj.create(
+            {
+                "page_id": self.page2.id,
+                "state": "draft",
+            }
+        )
+        self.page2.invalidate_model()
+        self.assertTrue(self.page2.user_has_drafts)
+
+    def test_action_draft_requires_cancellation(self):
+        """Ensure a change request must be cancelled before setting to draft"""
+        chreq = self.history_obj.create(
+            {
+                "page_id": self.page2.id,
+                "state": "to approve",
+            }
+        )
+        with self.assertRaises(UserError):
+            chreq.action_draft()
+
+    def test_action_to_approve_only_from_draft(self):
+        """Ensure only draft requests can be sent for approval"""
+        chreq = self.history_obj.create(
+            {
+                "page_id": self.page2.id,
+                "state": "approved",
+            }
+        )
+        with self.assertRaises(UserError):
+            chreq.action_to_approve()
+
+    def test_approval_permission_check(self):
+        """Ensure approval is restricted to approvers"""
+        chreq = self.history_obj.create(
+            {
+                "page_id": self.page2.id,
+                "state": "to approve",
+            }
+        )
+
+        with self.assertRaises(UserError):
+            chreq.with_user(self.env.ref("base.user_demo")).action_approve()
+
+        # Grant approval rights
+        chreq.with_user(self.user2).action_approve()
+        self.assertEqual(chreq.state, "approved")
+
+    def test_page_url_computation(self):
+        """Ensure page URLs are generated correctly"""
+        chreq = self.history_obj.create({"page_id": self.page2.id})
+        self.assertIn("web#db=", chreq.page_url)
+
+    def test_diff_computation(self):
+        """Ensure document diff is calculated properly"""
+        self.history_obj.create(
+            {
+                "page_id": self.page2.id,
+                "content": "Version 1",
+                "state": "approved",
+            }
+        )
+
+        chreq2 = self.history_obj.create(
+            {
+                "page_id": self.page2.id,
+                "content": "Version 2",
+            }
+        )
+        chreq2._compute_diff()
+        self.assertIsNotNone(chreq2.diff)