# /mnt/e/genesis-system/core/rwl/guard/integration_test.py

import unittest
from unittest.mock import MagicMock
from genesis_system.core.rwl.guard.integration import enforce_rwl, integrate_all_entrypoints
from genesis_system.core.rwl.guard.guard import RWLGuard  # Assuming guard.py
from genesis_system.core.rwl.guard.guard import MockRWLGuard # Assuming MockRWLGuard for testing

class TestRWLIntegration(unittest.TestCase):

    def test_enforce_rwl_allowed(self):
        """Test that enforce_rwl allows execution when RWLGuard allows access."""
        mock_guard = MockRWLGuard(allow=True)  # Always allows access
        @enforce_rwl(mock_guard)
        def my_func():
            return "Function executed"

        result = my_func()
        self.assertEqual(result, "Function executed")

    def test_enforce_rwl_denied(self):
        """Test that enforce_rwl blocks execution when RWLGuard denies access."""
        mock_guard = MockRWLGuard(allow=False)  # Always denies access

        @enforce_rwl(mock_guard)
        def my_func():
            return "Function executed"

        result = my_func()
        self.assertEqual(result, "Access Denied") # Ensure result is what handle_denial returns

    def test_enforce_rwl_exception(self):
        """Test that exceptions during enforcement are properly raised."""
        mock_guard = MagicMock(spec=RWLGuard) # Mock RWLGuard instead of using the implementation.
        mock_guard.is_allowed.side_effect = Exception("Test exception")

        @enforce_rwl(mock_guard)
        def my_func():
            return "Function executed"

        with self.assertRaises(Exception) as context:
            my_func()
        self.assertEqual(str(context.exception), "Test exception")

    def test_integrate_all_entrypoints(self):
        """Test the integrate_all_entrypoints function."""
        mock_guard = MockRWLGuard(allow=True)  # Always allows access
        def entrypoint1(): return "Entrypoint 1"
        def entrypoint2(): return "Entrypoint 2"

        integrate_all_entrypoints(mock_guard, [entrypoint1, entrypoint2])

        # After integration, entrypoint1 and entrypoint2 should be decorated
        self.assertEqual(entrypoint1(), "Entrypoint 1")
        self.assertEqual(entrypoint2(), "Entrypoint 2")

        # Test with a denying guard
        mock_guard_deny = MockRWLGuard(allow=False)

        def entrypoint3(): return "Entrypoint 3"
        integrate_all_entrypoints(mock_guard_deny, [entrypoint3])

        self.assertEqual(entrypoint3(), "Access Denied")

if __name__ == '__main__':
    unittest.main()