conference-room-booking-system/backend/tests/routers/test_bookings.py

"""Unit tests for the backend.routers.bookings module."""

from datetime import datetime
from typing import Any
from unittest.mock import ANY
from unittest.mock import AsyncMock
from unittest.mock import MagicMock
from unittest.mock import patch

import pytest
from fastapi.testclient import TestClient
from sqlalchemy.exc import NoResultFound
from sqlalchemy.exc import SQLAlchemyError

from backend.models import Booking
from backend.models import Room
from backend.services.bookings import BookingList


@pytest.mark.asyncio
@pytest.mark.parametrize("mock_logger", ["backend.routers.bookings"], indirect=True)
async def test_get_bookings_for_room_success(
    client: TestClient, sample_bookings: BookingList, mock_logger: MagicMock
) -> None:
    """Test successful retrieval of all bookings for a room via GET /bookings/room/{room_id}.

    Verifies that the endpoint returns the expected list of bookings with a 200 status.
    """
    room_id = 1
    with patch(
        "backend.routers.bookings.get_bookings_for_room", new=AsyncMock()
    ) as mock_get_bookings:
        mock_get_bookings.return_value = sample_bookings

        response = client.get(f"/bookings/room/{room_id}")

        assert response.status_code == 200
        assert response.json() == [
            {
                "id": 1,
                "room_id": 1,
                "start_time": "2025-08-25T10:00:00",
                "end_time": "2025-08-25T11:00:00",
            },
            {
                "id": 2,
                "room_id": 1,
                "start_time": "2025-08-25T12:00:00",
                "end_time": "2025-08-25T13:00:00",
            },
        ]
        mock_get_bookings.assert_called_once_with(ANY, room_id)


@pytest.mark.asyncio
@pytest.mark.parametrize("mock_logger", ["backend.routers.bookings"], indirect=True)
async def test_get_bookings_for_room_empty(
    client: TestClient, mock_logger: MagicMock
) -> None:
    """Test retrieval of bookings when none exist for a room via GET /bookings/room/{room_id}.

    Verifies that the endpoint returns an empty list with a 200 status.
    """
    room_id = 1
    with patch(
        "backend.routers.bookings.get_bookings_for_room", new=AsyncMock()
    ) as mock_get_bookings:
        mock_get_bookings.return_value = []

        response = client.get(f"/bookings/room/{room_id}")

        assert response.status_code == 200
        assert response.json() == []
        mock_get_bookings.assert_called_once_with(ANY, room_id)


@pytest.mark.asyncio
@pytest.mark.parametrize("mock_logger", ["backend.routers.bookings"], indirect=True)
async def test_get_bookings_for_room_database_error(
    client: TestClient, mock_logger: MagicMock
) -> None:
    """Test handling of database errors in GET /bookings/room/{room_id}.

    Verifies that the endpoint returns a 500 status on database failure.
    """
    room_id = 1
    with patch(
        "backend.routers.bookings.get_bookings_for_room", new=AsyncMock()
    ) as mock_get_bookings:
        mock_get_bookings.side_effect = SQLAlchemyError()

        response = client.get(f"/bookings/room/{room_id}")

        assert response.status_code == 500
        assert "detail" in response.json()
        mock_get_bookings.assert_called_once_with(ANY, room_id)


@pytest.mark.asyncio
@pytest.mark.parametrize("mock_logger", ["backend.routers.bookings"], indirect=True)
async def test_get_booking_success(
    client: TestClient, sample_room: Room, mock_logger: MagicMock
) -> None:
    """Test successful retrieval of a booking by ID via GET /bookings/{booking_id}.

    Verifies that the endpoint returns the correct booking with a 200 status.
    """
    booking_id = 1
    booking = Booking(
        room_id=1,
        start_time=datetime.fromisoformat("2025-08-25T10:00:00"),
        end_time=datetime.fromisoformat("2025-08-25T11:00:00"),
    )
    booking.id = booking_id
    booking.room = sample_room  # Attach room relationship
    with patch(
        "backend.routers.bookings.get_booking", new=AsyncMock()
    ) as mock_get_booking:
        mock_get_booking.return_value = booking

        response = client.get(f"/bookings/{booking_id}")

        assert response.status_code == 200
        assert response.json() == {
            "id": booking_id,
            "room_id": 1,
            "start_time": "2025-08-25T10:00:00",
            "end_time": "2025-08-25T11:00:00",
        }
        mock_get_booking.assert_called_once_with(ANY, booking_id)


@pytest.mark.asyncio
@pytest.mark.parametrize("mock_logger", ["backend.routers.bookings"], indirect=True)
async def test_get_booking_not_found(
    client: TestClient, mock_logger: MagicMock
) -> None:
    """Test handling of non-existent booking in GET /bookings/{booking_id}.

    Verifies that the endpoint returns a 404 status when the booking is not found.
    """
    booking_id = 999
    with patch(
        "backend.routers.bookings.get_booking", new=AsyncMock()
    ) as mock_get_booking:
        mock_get_booking.side_effect = NoResultFound()

        response = client.get(f"/bookings/{booking_id}")

        assert response.status_code == 404
        assert "detail" in response.json()
        mock_get_booking.assert_called_once_with(ANY, booking_id)


@pytest.mark.asyncio
@pytest.mark.parametrize("mock_logger", ["backend.routers.bookings"], indirect=True)
async def test_get_booking_database_error(
    client: TestClient, mock_logger: MagicMock
) -> None:
    """Test handling of database errors in GET /bookings/{booking_id}.

    Verifies that the endpoint returns a 500 status on database failure.
    """
    booking_id = 1
    with patch(
        "backend.routers.bookings.get_booking", new=AsyncMock()
    ) as mock_get_booking:
        mock_get_booking.side_effect = SQLAlchemyError()

        response = client.get(f"/bookings/{booking_id}")

        assert response.status_code == 500
        assert "detail" in response.json()
        mock_get_booking.assert_called_once_with(ANY, booking_id)


@pytest.mark.asyncio
@pytest.mark.parametrize("mock_logger", ["backend.routers.bookings"], indirect=True)
async def test_create_booking_success(
    client: TestClient, sample_room: Room, mock_logger: MagicMock
) -> None:
    """Test successful creation of a new booking via POST /bookings/.

    Verifies that the endpoint returns the created booking with a 201 status.
    """
    booking_data: dict[str, Any] = {
        "room_id": 1,
        "start_time": "2025-08-25T10:00:00",
        "end_time": "2025-08-25T11:00:00",
    }
    created_booking = Booking(**booking_data)
    created_booking.id = 3
    created_booking.room = sample_room  # Attach room relationship
    with patch(
        "backend.routers.bookings.new_booking", new=AsyncMock()
    ) as mock_new_booking:
        mock_new_booking.return_value = created_booking

        response = client.post("/bookings/", json=booking_data)

        assert response.status_code == 201
        assert response.json() == {
            "id": 3,
            "room_id": 1,
            "start_time": "2025-08-25T10:00:00",
            "end_time": "2025-08-25T11:00:00",
        }
        mock_new_booking.assert_called_once()


@pytest.mark.asyncio
@pytest.mark.parametrize("mock_logger", ["backend.routers.bookings"], indirect=True)
async def test_create_booking_database_error(
    client: TestClient, mock_logger: MagicMock
) -> None:
    """Test handling of database errors in POST /bookings/.

    Verifies that the endpoint returns a 400 status on database failure.
    """
    booking_data: dict[str, Any] = {
        "room_id": 1,
        "start_time": "2025-08-25T10:00:00",
        "end_time": "2025-08-25T11:00:00",
    }
    with patch(
        "backend.routers.bookings.new_booking", new=AsyncMock()
    ) as mock_new_booking:
        mock_new_booking.side_effect = SQLAlchemyError()

        response = client.post("/bookings/", json=booking_data)

        assert response.status_code == 500
        assert "detail" in response.json()
        mock_new_booking.assert_called_once()


@pytest.mark.asyncio
@pytest.mark.parametrize("mock_logger", ["backend.routers.bookings"], indirect=True)
async def test_update_booking_success(
    client: TestClient, sample_room: Room, mock_logger: MagicMock
) -> None:
    """Test successful update of a booking via PUT /bookings/{booking_id}.

    Verifies that the endpoint returns the updated booking with a 200 status.
    """
    booking_id = 1
    update_data: dict[str, Any] = {
        "room_id": 2,
        "start_time": "2025-08-25T14:00:00",
        "end_time": "2025-08-25T15:00:00",
    }
    updated_booking = Booking(**update_data)
    updated_booking.id = booking_id
    updated_booking.room = sample_room  # Attach room relationship
    with patch(
        "backend.routers.bookings.update_booking", new=AsyncMock()
    ) as mock_update_booking:
        mock_update_booking.return_value = updated_booking

        response = client.put(f"/bookings/{booking_id}", json=update_data)

        assert response.status_code == 200
        assert response.json() == {
            "id": booking_id,
            "room_id": 2,
            "start_time": "2025-08-25T14:00:00",
            "end_time": "2025-08-25T15:00:00",
        }
        update_data["start_time"] = datetime.fromisoformat(update_data["start_time"])
        update_data["end_time"] = datetime.fromisoformat(update_data["end_time"])
        mock_update_booking.assert_called_once_with(ANY, booking_id, **update_data)


@pytest.mark.asyncio
@pytest.mark.parametrize("mock_logger", ["backend.routers.bookings"], indirect=True)
async def test_update_booking_not_found(
    client: TestClient, mock_logger: MagicMock
) -> None:
    """Test handling of non-existent booking in PUT /bookings/{booking_id}.

    Verifies that the endpoint returns a 404 status when the booking is not found.
    """
    booking_id = 999
    update_data: dict[str, Any] = {
        "room_id": 2,
        "start_time": "2025-08-25T14:00:00",
        "end_time": "2025-08-25T15:00:00",
    }
    with patch(
        "backend.routers.bookings.update_booking", new=AsyncMock()
    ) as mock_update_booking:
        mock_update_booking.side_effect = NoResultFound()

        response = client.put(f"/bookings/{booking_id}", json=update_data)

        assert response.status_code == 404
        assert "detail" in response.json()
        update_data["start_time"] = datetime.fromisoformat(update_data["start_time"])
        update_data["end_time"] = datetime.fromisoformat(update_data["end_time"])
        mock_update_booking.assert_called_once_with(ANY, booking_id, **update_data)


@pytest.mark.asyncio
@pytest.mark.parametrize("mock_logger", ["backend.routers.bookings"], indirect=True)
async def test_update_booking_database_error(
    client: TestClient, mock_logger: MagicMock
) -> None:
    """Test handling of database errors in PUT /bookings/{booking_id}.

    Verifies that the endpoint returns a 500 status on database failure.
    """
    booking_id = 1
    update_data: dict[str, Any] = {
        "room_id": 2,
        "start_time": "2025-08-25T14:00:00",
        "end_time": "2025-08-25T15:00:00",
    }
    with patch(
        "backend.routers.bookings.update_booking", new=AsyncMock()
    ) as mock_update_booking:
        mock_update_booking.side_effect = SQLAlchemyError()

        response = client.put(f"/bookings/{booking_id}", json=update_data)

        assert response.status_code == 500
        assert "detail" in response.json()
        update_data["start_time"] = datetime.fromisoformat(update_data["start_time"])
        update_data["end_time"] = datetime.fromisoformat(update_data["end_time"])
        mock_update_booking.assert_called_once_with(ANY, booking_id, **update_data)


@pytest.mark.asyncio
@pytest.mark.parametrize("mock_logger", ["backend.routers.bookings"], indirect=True)
async def test_delete_booking_success(
    client: TestClient, mock_logger: MagicMock
) -> None:
    """Test successful deletion of a booking via DELETE /bookings/{booking_id}.

    Verifies that the endpoint returns a 204 status on successful deletion.
    """
    booking_id = 1
    with patch(
        "backend.routers.bookings.delete_booking", new=AsyncMock()
    ) as mock_delete_booking:
        response = client.delete(f"/bookings/{booking_id}")

        assert response.status_code == 204
        assert response.text == ""
        mock_delete_booking.assert_called_once_with(ANY, booking_id)


@pytest.mark.asyncio
@pytest.mark.parametrize("mock_logger", ["backend.routers.bookings"], indirect=True)
async def test_delete_booking_not_found(
    client: TestClient, mock_logger: MagicMock
) -> None:
    """Test handling of non-existent booking in DELETE /bookings/{booking_id}.

    Verifies that the endpoint returns a 404 status when the booking is not found.
    """
    booking_id = 999
    with patch(
        "backend.routers.bookings.delete_booking", new=AsyncMock()
    ) as mock_delete_booking:
        mock_delete_booking.side_effect = NoResultFound()

        response = client.delete(f"/bookings/{booking_id}")

        assert response.status_code == 404
        assert "detail" in response.json()
        mock_delete_booking.assert_called_once_with(ANY, booking_id)


@pytest.mark.asyncio
@pytest.mark.parametrize("mock_logger", ["backend.routers.bookings"], indirect=True)
async def test_delete_booking_database_error(
    client: TestClient, mock_logger: MagicMock
) -> None:
    """Test handling of database errors in DELETE /bookings/{booking_id}.

    Verifies that the endpoint returns a 500 status on database failure.
    """
    booking_id = 1
    with patch(
        "backend.routers.bookings.delete_booking", new=AsyncMock()
    ) as mock_delete_booking:
        mock_delete_booking.side_effect = SQLAlchemyError()

        response = client.delete(f"/bookings/{booking_id}")

        assert response.status_code == 500
        assert "detail" in response.json()
        mock_delete_booking.assert_called_once_with(ANY, booking_id)