eventspace/backend/tests/models/test_event_manager.py

# tests/models/test_event_manager.py

import uuid
from datetime import datetime, timezone
from app.models.event_manager import EventManager, EventManagerRole, init_event_owner


def test_create_event_manager(db_session, mock_user):
    # Arrange
    event_id = uuid.uuid4()
    assigner_id = uuid.uuid4()

    new_event_manager = EventManager(
        id=uuid.uuid4(),
        user_id=mock_user.id,
        event_id=event_id,
        assigned_by=assigner_id,
        role=EventManagerRole.ADMIN,
        can_edit=True,
        can_invite=True,
        can_manage_gifts=True,
        can_send_updates=True,
        can_view_analytics=True,
    )

    db_session.add(new_event_manager)

    # Act
    db_session.commit()
    created_event_manager = db_session.query(EventManager).filter_by(user_id=mock_user.id, event_id=event_id).first()

    # Assert
    assert created_event_manager is not None
    assert created_event_manager.role == EventManagerRole.ADMIN
    assert created_event_manager.can_edit is True
    assert created_event_manager.can_invite is True
    assert created_event_manager.assigned_by == assigner_id
    assert created_event_manager.assigned_at is not None


def test_update_event_manager(db_session, mock_user):
    # Arrange
    event_id = uuid.uuid4()
    event_manager = EventManager(
        id=uuid.uuid4(),
        user_id=mock_user.id,
        event_id=event_id,
        assigned_by=mock_user.id,
        role=EventManagerRole.MODERATOR,
        can_edit=False,
        can_invite=True,
        can_manage_gifts=True,
        can_send_updates=False,
        can_view_analytics=True,
    )
    db_session.add(event_manager)
    db_session.commit()

    # Act
    event_manager.role = EventManagerRole.ADMIN
    event_manager.can_send_updates = True
    db_session.commit()

    updated_event_manager = db_session.query(EventManager).filter_by(user_id=mock_user.id).first()

    # Assert
    assert updated_event_manager.role == EventManagerRole.ADMIN
    assert updated_event_manager.can_send_updates is True
    assert updated_event_manager.can_edit == False  # Remains unchanged unless explicitly updated.


def test_delete_event_manager(db_session, mock_user):
    # Arrange
    event_id = uuid.uuid4()
    event_manager = EventManager(
        id=uuid.uuid4(),
        user_id=mock_user.id,
        event_id=event_id,
        assigned_by=mock_user.id,
        role=EventManagerRole.VIEWER,
    )
    db_session.add(event_manager)
    db_session.commit()

    # Act
    db_session.delete(event_manager)
    db_session.commit()

    deleted_event_manager = db_session.query(EventManager).filter_by(user_id=mock_user.id, event_id=event_id).first()

    # Assert
    assert deleted_event_manager is None


def test_event_manager_unique_constraint(db_session, mock_user):
    # Arrange
    event_id = uuid.uuid4()
    event_manager1 = EventManager(
        id=uuid.uuid4(),
        user_id=mock_user.id,
        event_id=event_id,
        assigned_by=mock_user.id,
        role=EventManagerRole.VIEWER,
    )
    db_session.add(event_manager1)
    db_session.commit()

    # Act & Assert
    event_manager2 = EventManager(
        id=uuid.uuid4(),
        user_id=mock_user.id,
        event_id=event_id,  # Same user-event pair
        assigned_by=mock_user.id,
        role=EventManagerRole.ADMIN,
    )
    db_session.add(event_manager2)
    try:
        db_session.commit()
        assert False, "Expected an IntegrityError due to the unique constraint on user_id and event_id."
    except Exception:
        db_session.rollback()


def test_event_manager_permission_check(db_session, mock_user):
    # Arrange
    event_manager = EventManager(
        id=uuid.uuid4(),
        user_id=mock_user.id,
        event_id=uuid.uuid4(),
        assigned_by=mock_user.id,
        role=EventManagerRole.MODERATOR,
        can_edit=False,
    )

    db_session.add(event_manager)
    db_session.commit()

    # Act & Assert
    assert event_manager.has_permission("can_invite") is True
    assert event_manager.has_permission("can_manage_gifts") is True
    assert event_manager.has_permission("can_edit") is False  # Explicitly set to False


def test_event_manager_role_permissions():
    # Test various roles and their default permissions
    owner = EventManager(role=EventManagerRole.OWNER)
    admin = EventManager(role=EventManagerRole.ADMIN)
    moderator = EventManager(role=EventManagerRole.MODERATOR)
    viewer = EventManager(role=EventManagerRole.VIEWER)

    # Act & Assert
    assert owner.permissions["can_edit"]
    assert owner.permissions["can_manage_managers"]
    assert not admin.permissions["can_manage_managers"]

    assert moderator.permissions["can_manage_gifts"]
    assert not viewer.permissions["can_manage_gifts"]


def test_init_event_owner():
    # Arrange
    user_id = uuid.uuid4()
    event_id = uuid.uuid4()

    # Act
    event_owner = init_event_owner(user_id, event_id)

    # Assert
    assert event_owner.role == EventManagerRole.OWNER
    assert event_owner.can_edit is True
    assert event_owner.can_invite is True
    assert event_owner.can_manage_gifts is True
    assert event_owner.user_id == user_id
    assert event_owner.event_id == event_id
    assert event_owner.assigned_by == user_id


def test_event_manager_string_representation():
    # Arrange
    event_manager = EventManager(
        id=uuid.uuid4(),
        user_id=uuid.uuid4(),
        event_id=uuid.uuid4(),
        role=EventManagerRole.ADMIN,
    )

    # Act
    representation = repr(event_manager)

    # Assert
    assert representation.startswith("<EventManager user_id=")
    assert "role=admin" in representation