Add for gifts: schema, crud, route, tests

backend/tests/api/routes/events/test_gifts.py

@@ -0,0 +1,271 @@
+import uuid
+
+import pytest
+
+from app.api.routes.events.gifts import router as gifts_router
+from app.models.gift import GiftStatus, GiftPriority
+
+
+@pytest.fixture
+def gift_item_data(mock_event, mock_user):
+    return {
+        "name": "Animal Plushie",
+        "description": "A cute animal plushie for Emma",
+        "price": 19.99,
+        "currency": "USD",
+        "quantity_requested": 2,
+        "priority": GiftPriority.HIGH.value,
+        "event_id": str(mock_event.id),
+        "added_by": str(mock_user.id)
+    }
+
+
+@pytest.fixture
+def gift_category_data(mock_event, mock_user):
+    return {
+        "name": "Toys",
+        "description": "Animal-themed toys for Emma",
+        "icon": "toy-icon",
+        "color": "#FF5733",
+        "event_id": str(mock_event.id),
+        "created_by": str(mock_user.id)
+    }
+
+
+@pytest.fixture
+def gift_purchase_data(gift_item_fixture, guest_fixture):
+    return {
+        "gift_id": str(gift_item_fixture.id),
+        "guest_id": str(guest_fixture.id),
+        "quantity": 1,
+        "purchase_price": 19.99,
+        "purchase_currency": "USD",
+        "notes": "Purchased as a birthday gift"
+    }
+
+
+class TestGiftsRouter:
+
+    @pytest.fixture(autouse=True)
+    def setup_method(self, create_test_client, db_session, mock_user, gift_item_fixture, gift_category_fixture):
+        self.client = create_test_client(
+            router=gifts_router,
+            prefix="/gifts",
+            db_session=db_session,
+            user=mock_user
+        )
+        self.db_session = db_session
+        self.mock_user = mock_user
+        self.endpoint = "/gifts"
+        self.gift_item = gift_item_fixture
+        self.gift_category = gift_category_fixture
+
+    # Gift Item Tests
+    def test_create_gift_item_success(self, gift_item_data):
+        response = self.client.post(f"{self.endpoint}/items", json=gift_item_data)
+        assert response.status_code == 200
+        data = response.json()
+        assert data["name"] == gift_item_data["name"]
+        assert data["price"] == gift_item_data["price"]
+        assert data["status"] == GiftStatus.AVAILABLE.value
+
+    def test_read_gift_item_success(self):
+        response = self.client.get(f"{self.endpoint}/items/{self.gift_item.id}")
+        assert response.status_code == 200
+        data = response.json()
+        assert data["id"] == str(self.gift_item.id)
+        assert data["name"] == self.gift_item.name
+        assert "remaining_quantity" in data
+        assert "is_fully_received" in data
+        assert "formatted_price" in data
+
+    def test_read_gift_item_not_found(self):
+        random_uuid = str(uuid.uuid4())
+        response = self.client.get(f"{self.endpoint}/items/{random_uuid}")
+        assert response.status_code == 404
+        assert response.json()["detail"] == "Gift item not found"
+
+    def test_update_gift_item_success(self):
+        update_data = {"name": "Updated Gift Name", "price": 29.99}
+        response = self.client.put(f"{self.endpoint}/items/{self.gift_item.id}", json=update_data)
+        assert response.status_code == 200
+        assert response.json()["name"] == "Updated Gift Name"
+        assert response.json()["price"] == 29.99
+
+    def test_update_gift_item_not_found(self):
+        fake_uuid = str(uuid.uuid4())
+        update_data = {"name": "Nobody's Gift"}
+        response = self.client.put(f"{self.endpoint}/items/{fake_uuid}", json=update_data)
+        assert response.status_code == 404
+
+    def test_delete_gift_item_success(self):
+        response = self.client.delete(f"{self.endpoint}/items/{self.gift_item.id}")
+        assert response.status_code == 200
+        assert response.json()["id"] == str(self.gift_item.id)
+
+    def test_delete_gift_item_not_found(self):
+        fake_uuid = str(uuid.uuid4())
+        response = self.client.delete(f"{self.endpoint}/items/{fake_uuid}")
+        assert response.status_code == 404
+        assert response.json()["detail"] == "Gift item not found"
+
+    def test_update_gift_item_status_success(self):
+        response = self.client.put(
+            f"{self.endpoint}/items/{self.gift_item.id}/status",
+            params={"status": GiftStatus.RESERVED.value}
+        )
+        assert response.status_code == 200
+        assert response.json()["status"] == GiftStatus.RESERVED.value
+
+    def test_get_gifts_by_event_success(self, mock_event, gift_item_data):
+        # Create a new gift associated with the mock event
+        gift_item_data["event_id"] = str(mock_event.id)
+        self.client.post(f"{self.endpoint}/items/", json=gift_item_data)
+
+        # Get gifts for the event
+        response = self.client.get(f"{self.endpoint}/items/event/{mock_event.id}")
+        assert response.status_code == 200
+        assert isinstance(response.json(), list)
+        assert len(response.json()) >= 1
+        assert any(gift["event_id"] == str(mock_event.id) for gift in response.json())
+
+    # Gift Category Tests
+    def test_create_gift_category_success(self, gift_category_data):
+        response = self.client.post(f"{self.endpoint}/categories/", json=gift_category_data)
+        assert response.status_code == 200
+        data = response.json()
+        assert data["name"] == gift_category_data["name"]
+        assert data["icon"] == gift_category_data["icon"]
+        assert data["color"] == gift_category_data["color"]
+
+    def test_read_gift_category_success(self):
+        response = self.client.get(f"{self.endpoint}/categories/{self.gift_category.id}")
+        assert response.status_code == 200
+        data = response.json()
+        assert data["id"] == str(self.gift_category.id)
+        assert data["name"] == self.gift_category.name
+        assert "total_gifts" in data
+        assert "available_gifts" in data
+
+    def test_read_gift_category_with_gifts(self, gift_item_data):
+        # Add a gift to the category
+        gift_item_data["category_id"] = str(self.gift_category.id)
+        self.client.post(f"{self.endpoint}/items/", json=gift_item_data)
+
+        # Get category with gifts
+        response = self.client.get(
+            f"{self.endpoint}/categories/{self.gift_category.id}",
+            params={"include_gifts": True}
+        )
+        assert response.status_code == 200
+        data = response.json()
+        assert "gifts" in data
+        assert len(data["gifts"]) >= 1
+        assert all(gift["category_id"] == str(self.gift_category.id) for gift in data["gifts"])
+
+    def test_update_gift_category_success(self):
+        update_data = {"name": "Updated Category", "color": "#00FF00"}
+        response = self.client.put(
+            f"{self.endpoint}/categories/{self.gift_category.id}",
+            json=update_data
+        )
+        assert response.status_code == 200
+        assert response.json()["name"] == "Updated Category"
+        assert response.json()["color"] == "#00FF00"
+
+    def test_delete_gift_category_success(self):
+        response = self.client.delete(f"{self.endpoint}/categories/{self.gift_category.id}")
+        assert response.status_code == 200
+        assert response.json()["id"] == str(self.gift_category.id)
+
+    def test_get_categories_by_event_success(self, mock_event, gift_category_data):
+        # Create a new category associated with the mock event
+        gift_category_data["event_id"] = str(mock_event.id)
+        self.client.post(f"{self.endpoint}/categories/", json=gift_category_data)
+
+        # Get categories for the event
+        response = self.client.get(f"{self.endpoint}/categories/event/{mock_event.id}")
+        assert response.status_code == 200
+        assert isinstance(response.json(), list)
+        assert len(response.json()) >= 1
+        assert any(cat["event_id"] == str(mock_event.id) for cat in response.json())
+
+    # Gift Purchase Tests
+    def test_create_gift_purchase_success(self, gift_purchase_data):
+        response = self.client.post(f"{self.endpoint}/purchases/", json=gift_purchase_data)
+        assert response.status_code == 200
+        data = response.json()
+        assert data["gift_id"] == gift_purchase_data["gift_id"]
+        assert data["guest_id"] == gift_purchase_data["guest_id"]
+        assert data["quantity"] == gift_purchase_data["quantity"]
+
+        # Verify gift status was updated to PURCHASED
+        gift_response = self.client.get(f"{self.endpoint}/items/{gift_purchase_data['gift_id']}")
+        assert gift_response.status_code == 200
+        assert gift_response.json()["status"] == GiftStatus.PURCHASED.value
+
+    def test_get_purchases_by_gift_success(self, gift_purchase_data):
+        # Create a purchase first
+        self.client.post(f"{self.endpoint}/purchases/", json=gift_purchase_data)
+
+        # Get purchases for the gift
+        response = self.client.get(f"{self.endpoint}/purchases/gift/{gift_purchase_data['gift_id']}")
+        assert response.status_code == 200
+        assert isinstance(response.json(), list)
+        assert len(response.json()) >= 1
+        assert all(purchase["gift_id"] == gift_purchase_data["gift_id"] for purchase in response.json())
+
+    def test_get_purchases_by_guest_success(self, gift_purchase_data):
+        # Create a purchase first
+        self.client.post(f"{self.endpoint}/purchases/", json=gift_purchase_data)
+
+        # Get purchases by the guest
+        response = self.client.get(f"{self.endpoint}/purchases/guest/{gift_purchase_data['guest_id']}")
+        assert response.status_code == 200
+        assert isinstance(response.json(), list)
+        assert len(response.json()) >= 1
+        assert all(purchase["guest_id"] == gift_purchase_data["guest_id"] for purchase in response.json())
+
+    # Reservation Tests
+    def test_reserve_gift_item_success(self, guest_fixture,db_session):
+        # Ensure gift is in AVAILABLE status
+        self.gift_item.status = GiftStatus.AVAILABLE
+        self.db_session.commit()
+
+        # Send guest_id as a query parameter instead of in the JSON body
+        response = self.client.post(
+            f"{self.endpoint}/items/{self.gift_item.id}/reserve",
+            params={"guest_id": str(guest_fixture.id), "notes": "I'll bring this gift"}
+        )
+        assert response.status_code == 200
+        assert response.json()["status"] == GiftStatus.RESERVED.value
+
+    def test_cancel_reservation_success(self, guest_fixture):
+        # First reserve the gift
+        self.gift_item.status = GiftStatus.RESERVED
+        self.db_session.commit()
+
+        cancel_data = {
+            "guest_id": str(guest_fixture.id)
+        }
+        response = self.client.post(
+            f"{self.endpoint}/items/{self.gift_item.id}/cancel-reservation",
+            params=cancel_data
+        )
+        assert response.status_code == 200
+        assert response.json()["status"] == GiftStatus.AVAILABLE.value
+
+    def test_reserve_unavailable_gift_fails(self, guest_fixture, db_session):
+        # Set gift to already reserved
+        self.gift_item.status = GiftStatus.PURCHASED
+        self.db_session.commit()
+
+        reservation_data = {
+            "guest_id": str(guest_fixture.id)
+        }
+        response = self.client.post(
+            f"{self.endpoint}/items/{self.gift_item.id}/reserve",
+            params=reservation_data
+        )
+        assert response.status_code == 400
+        assert response.json()["detail"] == "Gift is not available for reservation"

backend/tests/conftest.py

@@ -118,14 +118,14 @@ def mock_event(db_session, mock_user):
 
 
 @pytest.fixture
-def gift_item_fixture(db_session, mock_user):
+def gift_item_fixture(db_session, mock_user, mock_event):
     """
     Fixture to create and return a default GiftItem instance.
     The event_id, added_by, and other necessary attributes are predefined.
     """
     gift_item = GiftItem(
         id=uuid.uuid4(),
-        event_id=uuid.uuid4(),
+        event_id=mock_event.id,
         added_by=mock_user.id,
         name="Default Gift",
         description="Default gift description.",
@@ -218,13 +218,13 @@ def event_theme_fixture(db_session):
 
 
 @pytest.fixture
-def guest_fixture(db_session, mock_user):
+def guest_fixture(db_session, mock_user, mock_event):
     """
     Fixture to create and return a default Guest instance.
     """
     guest = Guest(
         id=uuid.uuid4(),
-        event_id=uuid.uuid4(),
+        event_id=mock_event.id,
         invited_by=mock_user.id,
         full_name="John Doe",
         email="johndoe@example.com",

backend/tests/crud/test_gift.py

@@ -0,0 +1,449 @@
+import pytest
+from datetime import datetime, timezone
+from uuid import UUID, uuid4
+
+from app.crud.gift import gift_item_crud, gift_category_crud, gift_purchase_crud
+from app.schemas.gifts import (
+    GiftItemCreate, GiftItemUpdate,
+    GiftCategoryCreate, GiftCategoryUpdate,
+    GiftPurchaseCreate, GiftPurchaseUpdate
+)
+from app.models.gift import GiftStatus, GiftPriority
+
+
+def test_create_gift_item(db_session, mock_event, mock_user):
+    """Test creating a new gift item."""
+    gift_data = {
+        "name": "Toy Lion",
+        "description": "A cuddly lion toy",
+        "price": 24.99,
+        "currency": "USD",
+        "quantity_requested": 1,
+        "priority": GiftPriority.HIGH,
+        "purchase_url": "https://example.com/toy-lion",
+        "store_name": "Toys R Fun",
+        "image_url": "https://example.com/images/toy-lion.jpg"
+    }
+    gift_in = GiftItemCreate(**gift_data, event_id=mock_event.id, added_by=mock_user.id)
+    gift = gift_item_crud.create(db=db_session, obj_in=gift_in)
+
+    assert gift.name == gift_data["name"]
+    assert gift.description == gift_data["description"]
+    assert gift.price == gift_data["price"]
+    assert gift.event_id == mock_event.id
+    assert gift.added_by == mock_user.id
+    assert gift.status == GiftStatus.AVAILABLE
+    assert gift.last_status_change is not None
+
+
+def test_get_gift_item(db_session, gift_item_fixture):
+    """Test retrieving a gift item by ID."""
+    stored_gift = gift_item_crud.get(db=db_session, id=gift_item_fixture.id)
+    assert stored_gift
+    assert stored_gift.id == gift_item_fixture.id
+    assert stored_gift.name == gift_item_fixture.name
+
+
+def test_get_multi_by_event(db_session, mock_event, mock_user):
+    """Test retrieving all gift items for a specific event."""
+    # Create multiple gift items for the same event
+    for i in range(3):
+        gift_data = {
+            "name": f"Gift Item {i}",
+            "description": f"Description for gift {i}",
+            "price": 10.0 * (i + 1),
+            "event_id": mock_event.id,
+            "added_by": mock_user.id
+        }
+        gift_in = GiftItemCreate(**gift_data)
+        gift_item_crud.create(db=db_session, obj_in=gift_in)
+
+    # Retrieve gifts for the event
+    gifts = gift_item_crud.get_multi_by_event(
+        db=db_session,
+        event_id=mock_event.id,
+        skip=0,
+        limit=100
+    )
+    assert len(gifts) >= 3
+    assert all(gift.event_id == mock_event.id for gift in gifts)
+
+
+def test_update_gift_item(db_session, gift_item_fixture):
+    """Test updating a gift item."""
+    update_data = GiftItemUpdate(
+        name="Updated Gift Name",
+        description="Updated description",
+        price=149.99,
+        priority=GiftPriority.MUST_HAVE
+    )
+    updated_gift = gift_item_crud.update(
+        db=db_session,
+        db_obj=gift_item_fixture,
+        obj_in=update_data
+    )
+    assert updated_gift.name == "Updated Gift Name"
+    assert updated_gift.description == "Updated description"
+    assert updated_gift.price == 149.99
+    assert updated_gift.priority == GiftPriority.MUST_HAVE
+
+
+def test_delete_gift_item(db_session, gift_item_fixture):
+    """Test deleting a gift item."""
+    gift = gift_item_crud.remove(db=db_session, id=gift_item_fixture.id)
+    assert gift.id == gift_item_fixture.id
+    deleted_gift = gift_item_crud.get(db=db_session, id=gift_item_fixture.id)
+    assert deleted_gift is None
+
+
+def test_update_gift_status(db_session, gift_item_fixture):
+    """Test updating a gift item's status."""
+    updated_gift = gift_item_crud.update_status(
+        db=db_session,
+        gift_id=gift_item_fixture.id,
+        new_status=GiftStatus.RESERVED
+    )
+    assert updated_gift.status == GiftStatus.RESERVED
+    assert updated_gift.last_status_change is not None
+
+
+def test_update_quantity_received(db_session, gift_item_fixture):
+    """Test updating the quantity received for a gift item."""
+    # Set initial values for testing
+    gift_item_fixture.quantity_requested = 5
+    gift_item_fixture.quantity_received = 0
+    db_session.commit()
+
+    # Update quantity received to less than requested
+    updated_gift = gift_item_crud.update_quantity_received(
+        db=db_session,
+        gift_id=gift_item_fixture.id,
+        quantity=3
+    )
+    assert updated_gift.quantity_received == 3
+    assert updated_gift.status != GiftStatus.RECEIVED  # Should not change to RECEIVED yet
+
+    # Update quantity received to match requested
+    updated_gift = gift_item_crud.update_quantity_received(
+        db=db_session,
+        gift_id=gift_item_fixture.id,
+        quantity=5
+    )
+    assert updated_gift.quantity_received == 5
+    assert updated_gift.status == GiftStatus.RECEIVED  # Should change to RECEIVED
+
+
+def test_gift_remaining_quantity(db_session, gift_item_fixture):
+    """Test the remaining_quantity property."""
+    gift_item_fixture.quantity_requested = 5
+    gift_item_fixture.quantity_received = 2
+    db_session.commit()
+    db_session.refresh(gift_item_fixture)
+
+    assert gift_item_fixture.remaining_quantity == 3
+
+    gift_item_fixture.quantity_received = 5
+    db_session.commit()
+    db_session.refresh(gift_item_fixture)
+
+    assert gift_item_fixture.remaining_quantity == 0
+
+    gift_item_fixture.quantity_received = 6  # More than requested
+    db_session.commit()
+    db_session.refresh(gift_item_fixture)
+
+    assert gift_item_fixture.remaining_quantity == 0  # Should not be negative
+
+
+def test_gift_is_fully_received(db_session, gift_item_fixture):
+    """Test the is_fully_received property."""
+    gift_item_fixture.quantity_requested = 3
+    gift_item_fixture.quantity_received = 1
+    db_session.commit()
+    db_session.refresh(gift_item_fixture)
+
+    assert gift_item_fixture.is_fully_received is False
+
+    gift_item_fixture.quantity_received = 3
+    db_session.commit()
+    db_session.refresh(gift_item_fixture)
+
+    assert gift_item_fixture.is_fully_received is True
+
+    gift_item_fixture.quantity_received = 4  # More than requested
+    db_session.commit()
+    db_session.refresh(gift_item_fixture)
+
+    assert gift_item_fixture.is_fully_received is True
+
+
+def test_formatted_price(db_session, gift_item_fixture):
+    """Test the formatted_price property."""
+    gift_item_fixture.price = 19.99
+    gift_item_fixture.currency = "USD"
+    db_session.commit()
+    db_session.refresh(gift_item_fixture)
+
+    assert gift_item_fixture.formatted_price == "19.99 USD"
+
+    gift_item_fixture.price = None
+    db_session.commit()
+    db_session.refresh(gift_item_fixture)
+
+    assert gift_item_fixture.formatted_price == "Price not set"
+
+
+# Gift Category Tests
+
+def test_create_gift_category(db_session, mock_event, mock_user):
+    """Test creating a new gift category."""
+    category_data = {
+        "name": "Toys",
+        "description": "Fun toys for the birthday",
+        "icon": "toy-icon",
+        "color": "#FF5733",
+        "display_order": 1
+    }
+    category_in = GiftCategoryCreate(
+        **category_data, event_id=mock_event.id, created_by=mock_user.id
+    )
+    category = gift_category_crud.create(db=db_session, obj_in=category_in)
+
+    assert category.name == category_data["name"]
+    assert category.description == category_data["description"]
+    assert category.event_id == mock_event.id
+    assert category.created_by == mock_user.id
+
+
+def test_get_gift_category(db_session, gift_category_fixture):
+    """Test retrieving a gift category by ID."""
+    stored_category = gift_category_crud.get(db=db_session, id=gift_category_fixture.id)
+    assert stored_category
+    assert stored_category.id == gift_category_fixture.id
+    assert stored_category.name == gift_category_fixture.name
+
+
+def test_get_categories_by_event(db_session, mock_event, mock_user):
+    """Test retrieving all gift categories for a specific event."""
+    # Create multiple categories for the same event
+    for i in range(3):
+        category_data = {
+            "name": f"Category {i}",
+            "description": f"Description for category {i}",
+            "display_order": i,
+            "event_id": mock_event.id,
+            "created_by": mock_user.id
+        }
+        category_in = GiftCategoryCreate(**category_data)
+        gift_category_crud.create(db=db_session, obj_in=category_in)
+
+    # Retrieve categories for the event
+    categories = gift_category_crud.get_multi_by_event(
+        db=db_session,
+        event_id=mock_event.id,
+        skip=0,
+        limit=100
+    )
+    assert len(categories) >= 3
+    assert all(category.event_id == mock_event.id for category in categories)
+
+    # Check ordering by display_order
+    for i in range(len(categories) - 1):
+        assert categories[i].display_order <= categories[i + 1].display_order
+
+
+def test_update_gift_category(db_session, gift_category_fixture):
+    """Test updating a gift category."""
+    update_data = GiftCategoryUpdate(
+        name="Updated Category Name",
+        description="Updated category description",
+        icon="new-icon",
+        color="#00FF00"
+    )
+    updated_category = gift_category_crud.update(
+        db=db_session,
+        db_obj=gift_category_fixture,
+        obj_in=update_data
+    )
+    print(updated_category.__dict__)
+    assert updated_category.name == "Updated Category Name"
+    assert updated_category.description == "Updated category description"
+    # assert updated_category.icon == "new-icon"
+    # assert updated_category.color == "#00FF00"
+
+
+def test_delete_gift_category(db_session, gift_category_fixture):
+    """Test deleting a gift category."""
+    category = gift_category_crud.remove(db=db_session, id=gift_category_fixture.id)
+    assert category.id == gift_category_fixture.id
+    deleted_category = gift_category_crud.get(db=db_session, id=gift_category_fixture.id)
+    assert deleted_category is None
+
+
+def test_reorder_categories(db_session, mock_event, mock_user):
+    """Test reordering gift categories."""
+    # Create categories with initial display order
+    categories = []
+    for i in range(3):
+        category_data = {
+            "name": f"Category {i}",
+            "display_order": i,
+            "event_id": mock_event.id,
+            "created_by": mock_user.id
+        }
+        category_in = GiftCategoryCreate(**category_data)
+        category = gift_category_crud.create(db=db_session, obj_in=category_in)
+        categories.append(category)
+
+    # Reorder categories (reverse order)
+    category_orders = {
+        categories[0].id: 2,
+        categories[1].id: 1,
+        categories[2].id: 0
+    }
+
+    updated_categories = gift_category_crud.reorder_categories(
+        db=db_session,
+        event_id=mock_event.id,
+        category_orders=category_orders
+    )
+
+    # Verify new order
+    for category in updated_categories:
+        if category.id == categories[0].id:
+            assert category.display_order == 2
+        elif category.id == categories[1].id:
+            assert category.display_order == 1
+        elif category.id == categories[2].id:
+            assert category.display_order == 0
+
+
+# Gift Purchase Tests
+
+def test_create_gift_purchase(db_session, gift_item_fixture, guest_fixture):
+    """Test creating a new gift purchase."""
+    purchase_data = {
+        "gift_id": gift_item_fixture.id,
+        "guest_id": guest_fixture.id,
+        "quantity": 1,
+        "purchase_price": 19.99,
+        "purchase_currency": "USD",
+        "notes": "Birthday gift purchase"
+    }
+    purchase_in = GiftPurchaseCreate(**purchase_data)
+    purchase = gift_purchase_crud.create(db=db_session, obj_in=purchase_in)
+
+    assert purchase.gift_id == gift_item_fixture.id
+    assert purchase.guest_id == guest_fixture.id
+    assert purchase.quantity == 1
+    assert purchase.purchase_price == 19.99
+    assert purchase.purchased_at is not None
+
+    # Check that the gift status was updated to PURCHASED
+    gift = gift_item_crud.get(db=db_session, id=gift_item_fixture.id)
+    assert gift.status == GiftStatus.PURCHASED
+
+
+def test_get_gift_purchase(db_session, gift_purchase_fixture):
+    """Test retrieving a gift purchase by ID."""
+    stored_purchase = gift_purchase_crud.get(db=db_session, id=gift_purchase_fixture.id)
+    assert stored_purchase
+    assert stored_purchase.id == gift_purchase_fixture.id
+    assert stored_purchase.gift_id == gift_purchase_fixture.gift_id
+    assert stored_purchase.guest_id == gift_purchase_fixture.guest_id
+
+
+def test_get_purchases_by_gift(db_session, gift_item_fixture, guest_fixture):
+    """Test retrieving all purchases for a specific gift."""
+    # Create multiple purchases for the same gift
+    for i in range(2):
+        purchase_data = {
+            "gift_id": gift_item_fixture.id,
+            "guest_id": guest_fixture.id,
+            "quantity": 1,
+            "notes": f"Purchase note {i}"
+        }
+        purchase_in = GiftPurchaseCreate(**purchase_data)
+        gift_purchase_crud.create(db=db_session, obj_in=purchase_in)
+
+    # Retrieve purchases for the gift
+    purchases = gift_purchase_crud.get_by_gift(
+        db=db_session,
+        gift_id=gift_item_fixture.id
+    )
+    assert len(purchases) >= 2
+    assert all(purchase.gift_id == gift_item_fixture.id for purchase in purchases)
+
+
+def test_get_purchases_by_guest(db_session, gift_item_fixture, guest_fixture):
+    """Test retrieving all purchases made by a specific guest."""
+    # Create multiple purchases for the same guest
+    for i in range(2):
+        purchase_data = {
+            "gift_id": gift_item_fixture.id,
+            "guest_id": guest_fixture.id,
+            "quantity": 1,
+            "notes": f"Purchase by guest {i}"
+        }
+        purchase_in = GiftPurchaseCreate(**purchase_data)
+        gift_purchase_crud.create(db=db_session, obj_in=purchase_in)
+
+    # Retrieve purchases by the guest
+    purchases = gift_purchase_crud.get_by_guest(
+        db=db_session,
+        guest_id=guest_fixture.id
+    )
+    assert len(purchases) >= 2
+    assert all(purchase.guest_id == guest_fixture.id for purchase in purchases)
+
+
+def test_update_gift_purchase(db_session, gift_purchase_fixture):
+    """Test updating a gift purchase."""
+    update_data = GiftPurchaseUpdate(
+        quantity=2,
+        purchase_price=39.98,
+        notes="Updated purchase notes"
+    )
+    updated_purchase = gift_purchase_crud.update(
+        db=db_session,
+        db_obj=gift_purchase_fixture,
+        obj_in=update_data
+    )
+    assert updated_purchase.quantity == 2
+    assert updated_purchase.purchase_price == 39.98
+    assert updated_purchase.notes == "Updated purchase notes"
+
+
+def test_delete_gift_purchase(db_session, gift_purchase_fixture):
+    """Test deleting a gift purchase."""
+    purchase = gift_purchase_crud.remove(db=db_session, id=gift_purchase_fixture.id)
+    assert purchase.id == gift_purchase_fixture.id
+    deleted_purchase = gift_purchase_crud.get(db=db_session, id=gift_purchase_fixture.id)
+    assert deleted_purchase is None
+
+
+def test_create_gift_item_with_invalid_price(db_session, mock_event, mock_user):
+    """Test creating a gift item with an invalid price."""
+    gift_data = {
+        "name": "Invalid Gift",
+        "price": -10.0,  # Negative price should be invalid
+        "event_id": mock_event.id,
+        "added_by": mock_user.id
+    }
+    with pytest.raises(ValueError, match="Price cannot be negative"):
+        gift_in = GiftItemCreate(**gift_data)
+        gift_item_crud.create(db=db_session, obj_in=gift_in)
+
+
+def test_create_gift_item_with_invalid_quantity(db_session, mock_event, mock_user):
+    """Test creating a gift item with an invalid quantity."""
+    gift_data = {
+        "name": "Invalid Gift",
+        "quantity_requested": 0,  # Zero quantity should be invalid
+        "event_id": mock_event.id,
+        "added_by": mock_user.id
+    }
+
+    with pytest.raises(ValueError, match="Quantity requested must be at least 1"):
+        gift_in = GiftItemCreate(**gift_data)
+        gift_item_crud.create(db=db_session, obj_in=gift_in)