test: add tests for users and data modules

Author: mariajgrimaldi

openedx_authz/tests/api/test_data.py

@@ -0,0 +1,75 @@
+"""Test data for the authorization API."""
+
+from ddt import data, ddt, unpack
+from django.test import TestCase
+
+from openedx_authz.api.data import (
+    ActionData,
+    ContentLibraryData,
+    RoleData,
+    ScopeData,
+    UserData,
+)
+
+
+@ddt
+class TestNamespacedData(TestCase):
+    """Test data for the authorization API."""
+
+    @data(
+        ("instructor", "role@instructor"),
+        ("admin", "role@admin"),
+    )
+    @unpack
+    def test_role_data_namespace(self, input, expected):
+        """Test that RoleData correctly namespaces role names.
+
+        Expected Result:
+            - If input is 'instructor', expected is 'role@instructor'
+            - If input is 'admin', expected is 'role@admin'
+        """
+        role = RoleData(name=input)
+        self.assertEqual(role.role_id, expected)
+
+    @data(
+        ("john_doe", "user@john_doe"),
+        ("jane_smith", "user@jane_smith"),
+    )
+    @unpack
+    def test_user_data_namespace(self, username, expected):
+        """Test that UserData correctly namespaces user IDs.
+
+        Expected Result:
+            - If input is 'john_doe', expected is 'user@john_doe'
+            - If input is 'jane_smith', expected is 'user@jane_smith'
+        """
+        user = UserData(username=username)
+        self.assertEqual(user.subject_id, expected)
+
+    @data(
+        ("read", "act@read"),
+        ("write", "act@write"),
+    )
+    @unpack
+    def test_action_data_namespace(self, action_name, expected):
+        """Test that ActionData correctly namespaces action IDs.
+
+        Expected Result:
+            - If input is 'read', expected is 'act@read'
+            - If input is 'write', expected is 'act@write'
+        """
+        action = ActionData(name=action_name)
+        self.assertEqual(action.action_id, expected)
+
+    @data(
+        ("lib:DemoX:CSPROB", "lib@lib:demox:csprob"),
+    )
+    @unpack
+    def test_scope_content_lib_data_namespace(self, library_id, expected):
+        """Test that ScopeData correctly namespaces scope IDs.
+
+        Expected Result:
+            - If input is 'lib:DemoX:CSPROB', expected is 'lib@lib:DemoX:CSPROB'
+        """
+        scope = ContentLibraryData(library_id=library_id)
+        self.assertEqual(scope.scope_id, expected)

openedx_authz/tests/api/test_users.py

@@ -0,0 +1,172 @@
+"""Test suite for user-role assignment API functions."""
+
+from ddt import data, ddt, unpack
+
+from openedx_authz.api.data import RoleData, ScopeData, UserData
+from openedx_authz.api.users import (
+    assign_role_to_user_in_scope,
+    batch_assign_role_to_users,
+    batch_unassign_role_from_users,
+    get_user_role_assignments,
+    get_user_role_assignments_for_role_in_scope,
+    get_user_role_assignments_in_scope,
+    unassign_role_from_user,
+)
+from openedx_authz.tests.api.test_roles import RolesTestSetupMixin
+
+
+@ddt
+class TestUserRoleAssignments(RolesTestSetupMixin):
+    """Test suite for user-role assignment API functions."""
+
+    @classmethod
+    def _assign_roles_to_users(
+        cls,
+        assignments: list[dict] | None = None,
+    ):
+        """Helper method to assign roles to multiple users.
+
+        This method can be used to assign a role to a single user or multiple users
+        in a specific scope. It can also handle batch assignments.
+
+        Args:
+            assignments (list of dict): List of assignment dictionaries, each containing:
+                - subject (str): ID of the user namespaced (e.g., 'user:john_doe').
+                - role_id (str): Name of the role to assign.
+                - scope (str): Scope in which to assign the role.
+        """
+        if assignments:
+            for assignment in assignments:
+                assign_role_to_user_in_scope(
+                    assignment["subject_name"],
+                    assignment["role_name"],
+                    assignment["scope_name"],
+                )
+
+    @data(
+        ("john", "library_admin", "math_101", False),
+        ("jane", "library_user", "english_101", False),
+        (["mary", "charlie"], "library_collaborator", "science_301", True),
+        (["david", "sarah"], "library_author", "history_201", True),
+    )
+    @unpack
+    def test_assign_role_to_user_in_scope(self, username, role, scope_name, batch):
+        """Test assigning a role to a user in a specific scope.
+
+        Expected result:
+            - The role is successfully assigned to the user in the specified scope.
+        """
+        if batch:
+            batch_assign_role_to_users(
+                users=username, role_name=role, scope=scope_name
+            )
+            for user in username:
+                user_roles = get_user_role_assignments_in_scope(
+                    username=user, scope=scope_name
+                )
+                role_names = {assignment.role.name for assignment in user_roles}
+                self.assertIn(role, role_names)
+        else:
+            assign_role_to_user_in_scope(
+                username=username, role_name=role, scope=scope_name
+            )
+            user_roles = get_user_role_assignments_in_scope(
+                username=username, scope=scope_name
+            )
+            role_names = {assignment.role.name for assignment in user_roles}
+            self.assertIn(role, role_names)
+
+    @data(
+        (["Grace", "Henry"], "library_collaborator", "math_advanced", True),
+        (["Liam", "Maya"], "library_author", "art_101", True),
+        ("Alice", "library_admin", "math_101", False),
+        ("Bob", "library_author", "history_201", False),
+    )
+    @unpack
+    def test_unassign_role_from_user(self, username, role, scope_name, batch):
+        """Test unassigning a role from a user in a specific scope.
+
+        Expected result:
+            - The role is successfully unassigned from the user in the specified scope.
+            - The user no longer has the role in the specified scope.
+        """
+        if batch:
+            batch_unassign_role_from_users(
+                users=username, role_name=role, scope=scope_name
+            )
+            for user in username:
+                user_roles = get_user_role_assignments_in_scope(
+                    username=user, scope=scope_name
+                )
+                role_names = {assignment.role.name for assignment in user_roles}
+                self.assertNotIn(role, role_names)
+        else:
+            unassign_role_from_user(
+                user=username, role_name=role, scope=scope_name
+            )
+            user_roles = get_user_role_assignments_in_scope(
+                username=username, scope=scope_name
+            )
+            role_names = {assignment.role.name for assignment in user_roles}
+            self.assertNotIn(role, role_names)
+
+    @data(
+        ("Eve", {"library_admin", "library_author", "library_user"}),
+        ("Alice", {"library_admin"}),
+        ("Liam", {"library_author"}),
+    )
+    @unpack
+    def test_get_user_role_assignments(self, username, expected_roles):
+        """Test retrieving all role assignments for a user across all scopes.
+
+        Expected result:
+            - All roles assigned to the user across all scopes are correctly retrieved.
+            - Each assigned role is present in the returned role assignments.
+        """
+        role_assignments = get_user_role_assignments(username=username)
+        print(role_assignments)
+
+        assigned_role_names = {assignment.role.name for assignment in role_assignments}
+        self.assertEqual(assigned_role_names, expected_roles)
+
+    @data(
+        ("Alice", "math_101", {"library_admin"}),
+        ("Bob", "history_201", {"library_author"}),
+        ("Eve", "physics_401", {"library_admin"}),
+        ("Grace", "math_advanced", {"library_collaborator"}),
+    )
+    @unpack
+    def test_get_user_role_assignments_in_scope(self, username, scope_name, expected_roles):
+        """Test retrieving role assignments for a user within a specific scope.
+
+        Expected result:
+            - The role assigned to the user in the specified scope is correctly retrieved.
+            - The returned role assignments contain the assigned role.
+        """
+        user_roles = get_user_role_assignments_in_scope(
+            username=username, scope=scope_name
+        )
+
+        role_names = {assignment.role.name for assignment in user_roles}
+        self.assertEqual(role_names, expected_roles)
+
+
+    @data(
+        ("library_admin", "math_101", {"Alice", "Eve"}),
+        ("library_author", "history_201", {"Bob"}),
+        ("library_collaborator", "math_advanced", {"Grace"}),
+    )
+    @unpack
+    def test_get_user_role_assignments_for_role_in_scope(self, role_name, scope_name, expected_users):
+        """Test retrieving all users assigned to a specific role within a specific scope.
+
+        Expected result:
+            - All users assigned to the role in the specified scope are correctly retrieved.
+            - Each assigned user is present in the returned user assignments.
+        """
+        user_assignments = get_user_role_assignments_for_role_in_scope(
+            role_name=role_name, scope=scope_name
+        )
+
+        assigned_usernames = {assignment.subject.username for assignment in user_assignments}
+        self.assertEqual(assigned_usernames, expected_users)