alpinebits_python/tests/test_xml_builders.py

"""Tests for XML builder helpers."""

import pytest
from xml.etree import ElementTree as ET

from tests.helpers.xml_builders import (
    ReservationXMLBuilder,
    MultiReservationXMLBuilder,
    RoomReservationBuilder,
)


class TestRoomReservationBuilder:
    """Test RoomReservationBuilder functionality."""

    def test_basic_room_without_revenue(self):
        """Test creating a basic room reservation without revenue."""
        builder = RoomReservationBuilder(
            arrival="2025-12-01",
            departure="2025-12-03",
            room_type="DZV",
            room_number="101",
        )

        elem = builder.build()

        assert elem.tag == "roomReservation"
        assert elem.get("arrival") == "2025-12-01"
        assert elem.get("departure") == "2025-12-03"
        assert elem.get("roomType") == "DZV"
        assert elem.get("roomNumber") == "101"

        # Check daily sales - should have 3 entries (12-01, 12-02, 12-03)
        daily_sales = elem.find("dailySales")
        assert daily_sales is not None
        daily_sale_elements = daily_sales.findall("dailySale")
        assert len(daily_sale_elements) == 3

        # First two should have no revenue attributes
        assert daily_sale_elements[0].get("revenueTotal") is None
        assert daily_sale_elements[0].get("revenueLogis") is None

    def test_room_with_revenue(self):
        """Test creating a room with revenue per day."""
        builder = RoomReservationBuilder(
            arrival="2025-12-01",
            departure="2025-12-03",
            room_type="DZV",
            room_number="101",
            revenue_logis_per_day=150.0,
        )

        elem = builder.build()
        daily_sales = elem.find("dailySales")
        daily_sale_elements = daily_sales.findall("dailySale")

        # Should have 3 entries total
        assert len(daily_sale_elements) == 3

        # First two days should have revenue
        assert daily_sale_elements[0].get("revenueTotal") == "150.0"
        assert daily_sale_elements[0].get("revenueLogis") == "150.0"
        assert daily_sale_elements[1].get("revenueTotal") == "150.0"
        assert daily_sale_elements[1].get("revenueLogis") == "150.0"

        # Departure day should have no revenue
        assert daily_sale_elements[2].get("revenueTotal") is None
        assert daily_sale_elements[2].get("revenueLogis") is None

    def test_room_with_children_and_infants(self):
        """Test room with children and infants attributes."""
        builder = RoomReservationBuilder(
            arrival="2025-12-01",
            departure="2025-12-02",
            adults=2,
            children=1,
            infants=1,
        )

        elem = builder.build()
        assert elem.get("adults") == "2"
        assert elem.get("children") == "1"
        assert elem.get("infants") == "1"


class TestReservationXMLBuilder:
    """Test ReservationXMLBuilder functionality."""

    def test_basic_reservation(self):
        """Test creating a basic reservation with one room."""
        builder = ReservationXMLBuilder(
            hotel_id="39054_001",
            reservation_id="12345",
            reservation_number="RES-001",
            reservation_date="2025-11-14",
        )
        builder.set_guest(
            guest_id="1001",
            first_name="John",
            last_name="Doe",
            email="john@example.com",
        )
        builder.add_room(
            arrival="2025-12-01",
            departure="2025-12-05",
            revenue_logis_per_day=150.0,
        )

        xml_string = builder.build_xml()

        # Parse and verify structure
        root = ET.fromstring(xml_string)
        assert root.tag == "reservations"

        reservation = root.find("reservation")
        assert reservation is not None
        assert reservation.get("hotelID") == "39054_001"
        assert reservation.get("id") == "12345"
        assert reservation.get("number") == "RES-001"

        guest = reservation.find("guest")
        assert guest is not None
        assert guest.get("firstName") == "John"
        assert guest.get("lastName") == "Doe"
        assert guest.get("email") == "john@example.com"

        room_reservations = reservation.find("roomReservations")
        assert room_reservations is not None
        rooms = room_reservations.findall("roomReservation")
        assert len(rooms) == 1

    def test_reservation_with_multiple_rooms(self):
        """Test reservation with multiple rooms."""
        builder = ReservationXMLBuilder(
            hotel_id="39054_001",
            reservation_id="12345",
            reservation_number="RES-001",
            reservation_date="2025-11-14",
        )
        builder.set_guest(
            guest_id="1001",
            first_name="John",
            last_name="Doe",
            email="john@example.com",
        )
        builder.add_room(
            arrival="2025-12-01",
            departure="2025-12-05",
            room_number="101",
            revenue_logis_per_day=150.0,
        )
        builder.add_room(
            arrival="2025-12-01",
            departure="2025-12-05",
            room_number="102",
            revenue_logis_per_day=200.0,
        )

        xml_string = builder.build_xml()
        root = ET.fromstring(xml_string)

        reservation = root.find("reservation")
        room_reservations = reservation.find("roomReservations")
        rooms = room_reservations.findall("roomReservation")

        assert len(rooms) == 2
        assert rooms[0].get("roomNumber") == "101"
        assert rooms[1].get("roomNumber") == "102"

    def test_reservation_with_advertising_data(self):
        """Test reservation with advertising campaign data."""
        builder = ReservationXMLBuilder(
            hotel_id="39054_001",
            reservation_id="12345",
            reservation_number="RES-001",
            reservation_date="2025-11-14",
            advertising_medium="99TALES",
            advertising_partner="google",
            advertising_campagne="EAIaIQobChMI...",
        )
        builder.set_guest(
            guest_id="1001",
            first_name="John",
            last_name="Doe",
            email="john@example.com",
        )
        builder.add_room(
            arrival="2025-12-01",
            departure="2025-12-05",
        )

        xml_string = builder.build_xml()
        root = ET.fromstring(xml_string)

        reservation = root.find("reservation")
        assert reservation.get("advertisingMedium") == "99TALES"
        assert reservation.get("advertisingPartner") == "google"
        assert reservation.get("advertisingCampagne") == "EAIaIQobChMI..."


class TestMultiReservationXMLBuilder:
    """Test MultiReservationXMLBuilder functionality."""

    def test_multiple_reservations(self):
        """Test creating XML with multiple reservations."""
        multi_builder = MultiReservationXMLBuilder()

        # Add first reservation
        res1 = ReservationXMLBuilder(
            hotel_id="39054_001",
            reservation_id="12345",
            reservation_number="RES-001",
            reservation_date="2025-11-14",
        )
        res1.set_guest(
            guest_id="1001",
            first_name="John",
            last_name="Doe",
            email="john@example.com",
        )
        res1.add_room(
            arrival="2025-12-01",
            departure="2025-12-03",
            revenue_logis_per_day=150.0,
        )
        multi_builder.add_reservation(res1)

        # Add second reservation
        res2 = ReservationXMLBuilder(
            hotel_id="39054_001",
            reservation_id="12346",
            reservation_number="RES-002",
            reservation_date="2025-11-15",
        )
        res2.set_guest(
            guest_id="1002",
            first_name="Jane",
            last_name="Smith",
            email="jane@example.com",
        )
        res2.add_room(
            arrival="2025-12-10",
            departure="2025-12-12",
            revenue_logis_per_day=200.0,
        )
        multi_builder.add_reservation(res2)

        xml_string = multi_builder.build_xml()
        root = ET.fromstring(xml_string)

        assert root.tag == "reservations"
        reservations = root.findall("reservation")
        assert len(reservations) == 2
        assert reservations[0].get("id") == "12345"
        assert reservations[1].get("id") == "12346"


class TestConvenienceFeatures:
    """Test convenience features for common test scenarios."""

    def test_simple_one_liner_reservation(self):
        """Test creating a simple reservation in a fluent style."""
        xml = (
            ReservationXMLBuilder(
                hotel_id="39054_001",
                reservation_id="12345",
                reservation_number="RES-001",
                reservation_date="2025-11-14",
            )
            .set_guest(
                guest_id="1001",
                first_name="John",
                last_name="Doe",
                email="john@example.com",
            )
            .add_room(
                arrival="2025-12-01",
                departure="2025-12-05",
                revenue_logis_per_day=160.0,
            )
            .build_xml()
        )

        assert '<?xml version="1.0" ?>' in xml
        assert 'hotelID="39054_001"' in xml
        assert 'revenueLogis="160.0"' in xml

    def test_revenue_calculation_for_multi_day_stay(self):
        """Test that daily sales are correctly generated for multi-day stays."""
        builder = ReservationXMLBuilder(
            hotel_id="39054_001",
            reservation_id="12345",
            reservation_number="RES-001",
            reservation_date="2025-11-14",
        )
        builder.set_guest(
            guest_id="1001",
            first_name="John",
            last_name="Doe",
            email="john@example.com",
        )
        # 7-day stay (June 25 - July 2, 7 nights)
        builder.add_room(
            arrival="2026-06-25",
            departure="2026-07-02",
            revenue_logis_per_day=160.0,
        )

        elem = builder.build()
        room_reservations = elem.find("roomReservations")
        room = room_reservations.find("roomReservation")
        daily_sales = room.find("dailySales")
        daily_sale_elements = daily_sales.findall("dailySale")

        # Should have 8 daily sale entries (7 nights + departure day)
        assert len(daily_sale_elements) == 8

        # First 7 should have revenue
        for i in range(7):
            assert daily_sale_elements[i].get("revenueLogis") == "160.0"

        # Departure day should not have revenue
        assert daily_sale_elements[7].get("revenueLogis") is None


if __name__ == "__main__":
    pytest.main([__file__, "-v"])