"""Unit tests for AuthService and ACL enforcement.""" import pytest from datetime import UTC, datetime, timedelta from src.auth.auth_service import AuthService, Session, UserProjectAccess, UserProfile from src.domain.models import Role class TestAuthService: """Test AuthService functionality.""" @pytest.fixture def auth_service(self): """Create a test AuthService instance.""" return AuthService(session_ttl_minutes=120) @pytest.fixture def setup_users(self, auth_service): """Setup test users with project access.""" auth_service.register_user_project_access( "admin_user", {"kenya-2024": Role.admin, "nairobi-2023": Role.admin}, ) auth_service.register_user_project_access( "validator1", {"kenya-2024": Role.validator, "nairobi-2023": Role.validator}, ) auth_service.register_user_project_access( "validator2", {"kenya-2024": Role.validator}, ) auth_service.register_user_project_access( "inactive_user", {"kenya-2024": Role.validator}, ) auth_service.set_user_active("inactive_user", False) def test_login_success(self, auth_service, setup_users): """Test successful login.""" session = auth_service.login("admin_user") assert session is not None assert session.username == "admin_user" assert session.role == Role.admin assert len(session.authorized_projects) == 2 assert "kenya-2024" in session.authorized_projects assert "nairobi-2023" in session.authorized_projects def test_login_nonexistent_user(self, auth_service): """Test login with nonexistent user.""" session = auth_service.login("nonexistent") assert session is None def test_login_inactive_user(self, auth_service, setup_users): """Test login with inactive user.""" session = auth_service.login("inactive_user") assert session is None def test_validator_role_assigned_correctly(self, auth_service, setup_users): """Test validator role is assigned when user has only validator projects.""" session = auth_service.login("validator1") assert session is not None assert session.role == Role.validator def test_admin_role_takes_precedence(self, auth_service, setup_users): """Test admin role takes precedence over validator.""" session = auth_service.login("admin_user") assert session is not None assert session.username == "admin_user" assert session.role == Role.admin def test_session_expiration(self, auth_service, setup_users): """Test that expired sessions are handled.""" # Create a service with very short TTL short_ttl_service = AuthService(session_ttl_minutes=0) short_ttl_service.register_user_project_access( "test_user", {"project-1": Role.validator}, ) session = short_ttl_service.login("test_user") assert session is not None # Manually set expiration to past session.expires_at = datetime.now(UTC) - timedelta(seconds=1) # Try to retrieve expired session retrieved = short_ttl_service.get_session(session.session_id) assert retrieved is None def test_get_session_updates_activity(self, auth_service, setup_users): """Test that retrieving a session updates its last_activity.""" session = auth_service.login("validator1") original_activity = session.last_activity # Wait a moment (in real tests, would mock datetime) import time time.sleep(0.1) # Retrieve session retrieved = auth_service.get_session(session.session_id) assert retrieved is not None assert retrieved.last_activity >= original_activity def test_logout_invalidates_session(self, auth_service, setup_users): """Test that logout removes a session.""" session = auth_service.login("validator1") session_id = session.session_id # Verify session exists assert auth_service.get_session(session_id) is not None # Logout auth_service.logout(session_id) # Verify session is gone assert auth_service.get_session(session_id) is None def test_is_user_authorized_for_project(self, auth_service, setup_users): """Test project authorization check.""" assert auth_service.is_user_authorized_for_project("admin_user", "kenya-2024") assert auth_service.is_user_authorized_for_project("admin_user", "nairobi-2023") assert auth_service.is_user_authorized_for_project("validator1", "kenya-2024") assert not auth_service.is_user_authorized_for_project("validator2", "nairobi-2023") def test_is_user_authorized_inactive(self, auth_service, setup_users): """Test that inactive users are not authorized.""" assert not auth_service.is_user_authorized_for_project("inactive_user", "kenya-2024") def test_get_user_role_for_project(self, auth_service, setup_users): """Test retrieving user's role for a specific project.""" admin_role = auth_service.get_user_role_for_project("admin_user", "kenya-2024") assert admin_role == Role.admin validator_role = auth_service.get_user_role_for_project( "validator1", "kenya-2024" ) assert validator_role == Role.validator no_access = auth_service.get_user_role_for_project("validator2", "nairobi-2023") assert no_access is None def test_list_user_projects(self, auth_service, setup_users): """Test listing projects a user has access to.""" admin_projects = auth_service.list_user_projects("admin_user") assert len(admin_projects) == 2 assert "kenya-2024" in admin_projects assert "nairobi-2023" in admin_projects validator2_projects = auth_service.list_user_projects("validator2") assert len(validator2_projects) == 1 assert "kenya-2024" in validator2_projects def test_list_projects_for_inactive_user(self, auth_service, setup_users): """Test that inactive users have no accessible projects.""" projects = auth_service.list_user_projects("inactive_user") assert len(projects) == 0 def test_cleanup_expired_sessions(self, auth_service, setup_users): """Test cleanup of expired sessions.""" session1 = auth_service.login("admin_user") session2 = auth_service.login("validator1") # Expire session1 session1.expires_at = datetime.now(UTC) - timedelta(seconds=1) # Cleanup auth_service.cleanup_expired_sessions() # session1 should be gone assert auth_service.get_session(session1.session_id) is None # session2 should still be there assert auth_service.get_session(session2.session_id) is not None def test_set_user_active(self, auth_service, setup_users): """Test disabling and enabling users.""" # User is initially inactive assert not auth_service.is_user_authorized_for_project("inactive_user", "kenya-2024") # Reactivate auth_service.set_user_active("inactive_user", True) assert auth_service.is_user_authorized_for_project("inactive_user", "kenya-2024") # Deactivate again auth_service.set_user_active("inactive_user", False) assert not auth_service.is_user_authorized_for_project("inactive_user", "kenya-2024") def test_set_user_inactive_revokes_existing_sessions(self, auth_service): auth_service.register_user_project_access("active_user", {"project-1": Role.validator}) session = auth_service.login("active_user") assert session is not None auth_service.set_user_active("active_user", False) assert auth_service.get_session(session.session_id) is None def test_login_with_verified_hf_identity_uses_oauth_identity_without_whoami(self): service = AuthService() session, message = service.login_with_verified_hf_identity( username="oauth_user", token="oauth_access_token", email="oauth_user@example.org", ) assert session is not None assert session.username == "oauth_user" assert session.authentication_method == "oauth" assert "Welcome, oauth_user" in message assert service.get_hf_token_for_user("oauth_user") == "oauth_access_token" assert service.get_known_email_for_user("oauth_user") == "oauth_user@example.org" def test_register_user_project_access_update(self, auth_service): """Test updating user's project access.""" auth_service.register_user_project_access( "user1", {"project-1": Role.validator} ) projects = auth_service.list_user_projects("user1") assert projects == ["project-1"] # Update to add more projects auth_service.register_user_project_access( "user1", {"project-1": Role.validator, "project-2": Role.admin}, ) projects = auth_service.list_user_projects("user1") assert len(projects) == 2 assert auth_service.get_user_role_for_project("user1", "project-2") == Role.admin def test_upsert_user_project_role_creates_and_updates_user(self, auth_service): auth_service.upsert_user_project_role("new_user", "project-1", Role.validator) assert auth_service.get_user_role_for_project("new_user", "project-1") == Role.validator auth_service.upsert_user_project_role("new_user", "project-1", Role.admin) assert auth_service.get_user_role_for_project("new_user", "project-1") == Role.admin def test_remove_user_project_role(self, auth_service): auth_service.register_user_project_access("temp_user", {"project-1": Role.validator}) removed = auth_service.remove_user_project_role("temp_user", "project-1") assert removed is True assert auth_service.get_user_role_for_project("temp_user", "project-1") is None removed_again = auth_service.remove_user_project_role("temp_user", "project-1") assert removed_again is False def test_remove_user_project_role_clears_matching_pending_invite(self, auth_service): auth_service.register_user_project_access("temp_user", {"project-1": Role.validator}) ok, _ = auth_service.create_project_invite( project_slug="project-1", role=Role.validator, invited_by="owner", username="temp_user", ) assert ok is True removed = auth_service.remove_user_project_role("temp_user", "project-1") assert removed is True assert auth_service.list_pending_invites("temp_user") == [] def test_remove_user_project_role_refreshes_active_session(self, auth_service): auth_service.register_user_project_access("temp_user", {"project-1": Role.validator, "project-2": Role.validator}) session = auth_service.login("temp_user") assert session is not None assert "project-1" in session.authorized_projects removed = auth_service.remove_user_project_role("temp_user", "project-1") assert removed is True refreshed = auth_service.get_session(session.session_id) assert refreshed is not None assert "project-1" not in refreshed.authorized_projects assert "project-2" in refreshed.authorized_projects def test_list_usernames_honors_active_filter(self, auth_service): auth_service.register_user_project_access("active_user", {"project-1": Role.validator}) auth_service.register_user_project_access("inactive_user", {"project-1": Role.validator}) auth_service.set_user_active("inactive_user", False) active_only = auth_service.list_usernames() with_inactive = auth_service.list_usernames(include_inactive=True) assert "active_user" in active_only assert "inactive_user" not in active_only assert "inactive_user" in with_inactive def test_session_isolation_between_users(self, auth_service, setup_users): """Test that sessions are isolated between users.""" session_admin = auth_service.login("admin_user") session_validator = auth_service.login("validator1") assert session_admin.session_id != session_validator.session_id assert session_admin.username != session_validator.username assert session_admin.role != session_validator.role # Sessions should remain independent auth_service.logout(session_admin.session_id) assert auth_service.get_session(session_validator.session_id) is not None def test_invite_accept_flow_grants_access(self, auth_service): auth_service.register_user_project_access("owner", {"proj-1": Role.admin}) ok, _ = auth_service.create_project_invite( project_slug="proj-1", username="validator_new", role=Role.validator, invited_by="owner", ) assert ok is True pending = auth_service.list_pending_invites("validator_new") assert len(pending) == 1 assert pending[0].project_slug == "proj-1" accepted, _ = auth_service.accept_project_invite("validator_new", "proj-1") assert accepted is True assert auth_service.get_user_role_for_project("validator_new", "proj-1") == Role.validator assert auth_service.list_pending_invites("validator_new") == [] def test_invited_user_can_login_before_accepting(self, auth_service): ok, _ = auth_service.create_project_invite( username="pending_user", project_slug="proj-1", role=Role.validator, invited_by="owner", ) assert ok is True session = auth_service.login_internal("pending_user") assert session is not None assert session.username == "pending_user" assert session.authorized_projects == [] def test_email_only_invite_is_visible_and_accepts_for_known_email(self, auth_service): ok, _ = auth_service.create_project_invite( project_slug="proj-email", role=Role.validator, invited_by="owner", invitee_email="invitee@example.org", ) assert ok is True auth_service._user_profiles["invitee_user"] = UserProfile( username="invitee_user", hf_email="invitee@example.org", ) pending = auth_service.list_pending_invites("invitee_user") assert len(pending) == 1 assert pending[0].project_slug == "proj-email" accepted, _ = auth_service.accept_project_invite("invitee_user", "proj-email") assert accepted is True assert auth_service.get_user_role_for_project("invitee_user", "proj-email") == Role.validator assert auth_service.list_pending_invites("invitee_user") == [] def test_reject_invite_removes_pending(self, auth_service): ok, _ = auth_service.create_project_invite( username="pending_user", project_slug="proj-1", role=Role.validator, invited_by="owner", ) assert ok is True rejected, _ = auth_service.reject_project_invite("pending_user", "proj-1") assert rejected is True assert auth_service.list_pending_invites("pending_user") == [] def test_accept_all_project_invites(self, auth_service): ok1, _ = auth_service.create_project_invite( username="pending_user", project_slug="proj-1", role=Role.validator, invited_by="owner", ) ok2, _ = auth_service.create_project_invite( project_slug="proj-2", role=Role.admin, username="pending_user", invited_by="owner", ) assert ok1 and ok2 accepted, failed, _ = auth_service.accept_all_project_invites("pending_user") assert accepted == 2 assert failed == 0 assert auth_service.get_user_role_for_project("pending_user", "proj-1") == Role.validator assert auth_service.get_user_role_for_project("pending_user", "proj-2") == Role.admin def test_revoke_project_invite(self, auth_service): ok, _ = auth_service.create_project_invite( username="pending_user", project_slug="proj-1", role=Role.validator, invited_by="owner", ) assert ok is True revoked, _ = auth_service.revoke_project_invite("pending_user", "proj-1") assert revoked is True assert auth_service.list_pending_invites("pending_user") == [] def test_expired_invite_is_pruned(self): service = AuthService(session_ttl_minutes=120, invite_ttl_hours=1) ok, _ = service.create_project_invite( username="pending_user", project_slug="proj-1", role=Role.validator, invited_by="owner", ) assert ok is True invite = service.list_pending_invites("pending_user")[0] invite.expires_at = datetime.now(UTC) - timedelta(seconds=1) assert service.list_pending_invites("pending_user") == [] def test_remove_project_from_all_users_updates_acl_and_session(self, auth_service): auth_service.register_user_project_access( "admin_user", {"proj-a": Role.admin, "proj-b": Role.admin}, ) auth_service.register_user_project_access( "validator_user", {"proj-a": Role.validator}, ) admin_session = auth_service.login("admin_user") validator_session = auth_service.login("validator_user") removed = auth_service.remove_project_from_all_users("proj-a") assert removed == 2 assert auth_service.get_user_role_for_project("admin_user", "proj-a") is None assert auth_service.get_user_role_for_project("validator_user", "proj-a") is None assert auth_service.get_user_role_for_project("admin_user", "proj-b") == Role.admin assert admin_session is not None and "proj-a" not in admin_session.authorized_projects assert validator_session is not None and "proj-a" not in validator_session.authorized_projects def test_revoke_all_invites_for_project(self, auth_service): auth_service.create_project_invite(project_slug="proj-a", role=Role.validator, invited_by="owner", username="u1") auth_service.create_project_invite(project_slug="proj-a", role=Role.validator, invited_by="owner", username="u2") auth_service.create_project_invite(project_slug="proj-b", role=Role.validator, invited_by="owner", username="u3") revoked = auth_service.revoke_all_invites_for_project("proj-a") assert revoked == 2 assert auth_service.list_pending_invites("u1") == [] assert auth_service.list_pending_invites("u2") == [] assert len(auth_service.list_pending_invites("u3")) == 1 class TestUserProjectAccess: """Test UserProjectAccess model.""" def test_user_project_access_creation(self): """Test creating user project access.""" access = UserProjectAccess( username="test_user", project_slugs={"proj-1": Role.admin, "proj-2": Role.validator}, ) assert access.username == "test_user" assert len(access.project_slugs) == 2 assert access.is_active is True def test_user_project_access_deactivation(self): """Test deactivating user.""" access = UserProjectAccess( username="test_user", project_slugs={"proj-1": Role.validator}, ) assert access.is_active is True access.is_active = False assert access.is_active is False class TestSessionModel: """Test Session model.""" def test_session_creation(self): """Test creating a session.""" now = datetime.now(UTC) session = Session( session_id="test-session-123", username="test_user", role=Role.validator, authorized_projects=["proj-1", "proj-2"], created_at=now, last_activity=now, expires_at=now + timedelta(hours=2), ) assert session.session_id == "test-session-123" assert session.username == "test_user" assert session.role == Role.validator assert len(session.authorized_projects) == 2 def test_session_expiration_check(self): """Test session expiration detection.""" now = datetime.now(UTC) # Not expired session = Session( session_id="test", username="user", role=Role.validator, authorized_projects=[], created_at=now, last_activity=now, expires_at=now + timedelta(hours=1), ) assert not session.is_expired() # Expired session.expires_at = now - timedelta(seconds=1) assert session.is_expired() def test_session_activity_update(self): """Test updating session activity.""" now = datetime.now(UTC) session = Session( session_id="test", username="user", role=Role.validator, authorized_projects=[], created_at=now, last_activity=now, expires_at=now + timedelta(minutes=120), ) original_activity = session.last_activity # Update activity with 30-minute TTL import time time.sleep(0.1) session.update_activity(ttl_minutes=30) assert session.last_activity >= original_activity # The new expiration should be approximately 30 minutes from now expected_expires = datetime.now(UTC) + timedelta(minutes=30) # Allow 5 seconds of variance due to timing assert abs((session.expires_at - expected_expires).total_seconds()) < 5