add catalog listing delete endpoint

Author: pgorecki

src/api/main.py

@@ -1,12 +1,14 @@
 import time
 
 from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
 
 import api.routers.catalog
 from api.models import CurrentUser
 from api.routers import catalog, iam
 from config.api_config import ApiConfig
 from config.container import Container
+from seedwork.domain.exceptions import DomainException, EntityNotFoundException
 from seedwork.infrastructure.logging import LoggerFactory, logger
 from seedwork.infrastructure.request_context import request_context
 
@@ -26,6 +28,24 @@
 logger.info("using db engine %s" % str(container.engine()))
 
 
+@app.exception_handler(DomainException)
+async def unicorn_exception_handler(request: Request, exc: DomainException):
+    return JSONResponse(
+        status_code=500,
+        content={"message": f"Oops! {exc.name} did something. There goes a rainbow..."},
+    )
+
+
+@app.exception_handler(EntityNotFoundException)
+async def unicorn_exception_handler(request: Request, exc: EntityNotFoundException):
+    return JSONResponse(
+        status_code=404,
+        content={
+            "message": f"Entity {exc.entity_id} not found in {exc.repository.__class__.__name__}"
+        },
+    )
+
+
 @app.middleware("http")
 async def add_request_context(request: Request, call_next):
     start_time = time.time()

src/api/routers/catalog.py

@@ -4,8 +4,9 @@
 from api.shared import dependency
 from config.container import Container, inject
 from modules.catalog import CatalogModule
-from modules.catalog.application.command.create_listing_draft import (
+from modules.catalog.application.command import (
     CreateListingDraftCommand,
+    DeleteListingDraftCommand,
 )
 from modules.catalog.application.query.get_all_listings import GetAllListings
 from modules.catalog.application.query.get_listing_details import GetListingDetails
@@ -69,7 +70,19 @@ async def create_listing(
         return query_result.payload
 
 
-#
-#     # TODO: for now we return just the id, but in the future we should return
-#     # a representation of a newly created listing resource
-#     return {"id": result.id}
+@router.delete(
+    "/catalog/{listing_id}", tags=["catalog"], status_code=204, response_model=None
+)
+@inject
+async def delete_listing(
+    listing_id,
+    module: CatalogModule = dependency(Container.catalog_module),
+):
+    """
+    Delete listing
+    """
+    command = DeleteListingDraftCommand(
+        listing_id=listing_id,
+    )
+    with module.unit_of_work():
+        module.execute_command(command)

src/api/tests/test_catalog.py

@@ -1,7 +1,7 @@
 import pytest
 
 from modules.catalog.application.command import CreateListingDraftCommand
-from seedwork.domain.value_objects import Money
+from seedwork.domain.value_objects import UUID, Money
 
 
 @pytest.mark.integration
@@ -18,7 +18,10 @@ def test_catalog_list_with_one_item(api, api_client):
     with catalog_module.unit_of_work():
         command_result = catalog_module.execute_command(
             CreateListingDraftCommand(
-                title="Foo", description="Bar", ask_price=Money(10), seller_id="abcd"
+                title="Foo",
+                description="Bar",
+                ask_price=Money(10),
+                seller_id=UUID("00000000000000000000000000000002"),
             )
         )
 
@@ -49,12 +52,18 @@ def test_catalog_list_with_two_items(api, api_client):
     with catalog_module.unit_of_work():
         catalog_module.execute_command(
             CreateListingDraftCommand(
-                title="Foo #1", description="Bar", ask_price=Money(10), seller_id="abcd"
+                title="Foo #1",
+                description="Bar",
+                ask_price=Money(10),
+                seller_id=UUID("00000000000000000000000000000002"),
             )
         )
         catalog_module.execute_command(
             CreateListingDraftCommand(
-                title="Foo #2", description="Bar", ask_price=Money(10), seller_id="abcd"
+                title="Foo #2",
+                description="Bar",
+                ask_price=Money(10),
+                seller_id=UUID("00000000000000000000000000000002"),
             )
         )
 
@@ -65,3 +74,28 @@ def test_catalog_list_with_two_items(api, api_client):
     assert response.status_code == 200
     response_data = response.json()["data"]
     assert len(response_data) == 2
+
+
+@pytest.mark.integration
+def test_catalog_delete_draft(api, api_client):
+    catalog_module = api.container.catalog_module()
+    with catalog_module.unit_of_work():
+        result = catalog_module.execute_command(
+            CreateListingDraftCommand(
+                title="Foo to be deleted",
+                description="Bar",
+                ask_price=Money(10),
+                seller_id=UUID("00000000000000000000000000000002"),
+            )
+        )
+
+    response = api_client.delete(f"/catalog/{result.entity_id}")
+
+    assert response.status_code == 204
+
+
+@pytest.mark.integration
+def test_catalog_delete_non_existing_draft_returns_404(api, api_client):
+    listing_id = UUID("00000000000000000000000000000001")
+    response = api_client.delete(f"/catalog/{listing_id}")
+    assert response.status_code == 404

src/conftest.py

@@ -16,6 +16,7 @@ def engine():
     with engine.begin() as connection:
         Base.metadata.drop_all(connection)
         Base.metadata.create_all(connection)
+        print("---- engine ready ----")
         return engine
 
 

src/modules/catalog/__init__.py

@@ -1,5 +1,6 @@
 from modules.catalog.application.command import (
     CreateListingDraftCommand,
+    DeleteListingDraftCommand,
     PublishListingCommand,
     UpdateListingDraftCommand,
 )
@@ -19,6 +20,7 @@ class CatalogModule(BusinessModule):
     supported_commands = (
         CreateListingDraftCommand,
         UpdateListingDraftCommand,
+        DeleteListingDraftCommand,
         PublishListingCommand,
     )
     supported_queries = (GetAllListings, GetListingDetails, GetListingsOfSeller)

src/modules/catalog/application/command/__init__.py

@@ -1,3 +1,4 @@
 from .create_listing_draft import CreateListingDraftCommand
+from .delete_listing_draft import DeleteListingDraftCommand
 from .publish_listing import PublishListingCommand
 from .update_listing_draft import UpdateListingDraftCommand

src/modules/catalog/application/command/delete_listing_draft.py

@@ -0,0 +1,27 @@
+from dataclasses import dataclass
+
+from modules.catalog.domain.entities import Listing
+from modules.catalog.domain.events import ListingDraftDeletedEvent
+from modules.catalog.domain.repositories import ListingRepository
+from seedwork.application.command_handlers import CommandResult
+from seedwork.application.commands import Command
+from seedwork.application.decorators import command_handler
+from seedwork.domain.value_objects import UUID
+
+
+@dataclass
+class DeleteListingDraftCommand(Command):
+    """A command for updating a listing"""
+
+    listing_id: UUID
+
+
+@command_handler
+def delete_listing_draft(
+    command: DeleteListingDraftCommand, repository: ListingRepository
+) -> CommandResult:
+    listing: Listing = repository.get_by_id(command.listing_id)
+    repository.remove(listing)
+    return CommandResult.success(
+        entity_id=listing.id, events=[ListingDraftDeletedEvent(listing_id=listing.id)]
+    )

src/modules/catalog/domain/events.py

@@ -10,5 +10,9 @@ class ListingDraftUpdatedEvent(DomainEvent):
     listing_id: UUID
 
 
+class ListingDraftDeletedEvent(DomainEvent):
+    listing_id: UUID
+
+
 class ListingPublishedEvent(DomainEvent):
     listing_id: UUID

src/modules/catalog/tests/application/test_delete_listing_draft.py

@@ -0,0 +1,62 @@
+import pytest
+
+from modules.catalog.application.command.delete_listing_draft import (
+    DeleteListingDraftCommand,
+    delete_listing_draft,
+)
+from modules.catalog.domain.entities import Listing
+from modules.catalog.domain.events import ListingDraftDeletedEvent
+from modules.catalog.infrastructure.listing_repository import (
+    PostgresJsonListingRepository,
+)
+from seedwork.domain.value_objects import UUID, Money
+from seedwork.infrastructure.repository import InMemoryRepository
+
+
+@pytest.mark.unit
+def test_delete_listing_draft():
+    # arrange
+    repository = InMemoryRepository()
+    listing = Listing(
+        id=Listing.next_id(),
+        title="Tiny dragon",
+        description="Tiny dragon for sale",
+        ask_price=Money(1),
+        seller_id=UUID.v4(),
+    )
+    repository.add(listing)
+
+    command = DeleteListingDraftCommand(
+        listing_id=listing.id,
+    )
+
+    # act
+    result = delete_listing_draft(command, repository)
+
+    # assert
+    assert result.is_success()
+    assert result.entity_id == listing.id
+    assert result.events == [ListingDraftDeletedEvent(listing_id=listing.id)]
+
+
+@pytest.mark.integration
+def test_delete_listing_draft_removes_from_database(db_session):
+    repository = PostgresJsonListingRepository(db_session=db_session)
+    listing = Listing(
+        id=Listing.next_id(),
+        title="Tiny dragon",
+        description="Tiny dragon for sale",
+        ask_price=Money(1),
+        seller_id=UUID.v4(),
+    )
+    repository.add(listing)
+
+    command = DeleteListingDraftCommand(
+        listing_id=listing.id,
+    )
+
+    # act
+    delete_listing_draft(command, repository)
+
+    # assert
+    assert repository.count() == 0

src/seedwork/application/exceptions.py

@@ -1,6 +1,2 @@
 class ApplicationException(Exception):
     pass
-
-
-class EntityNotFoundException(Exception):
-    pass