fix tests

Author: pgorecki

src/modules/bidding/domain/entities.py

@@ -1,18 +1,16 @@
 from dataclasses import dataclass, field
-from datetime import date, datetime, timedelta
+from datetime import datetime, timedelta
 from typing import List, Optional
-from collections.abc import Sequence
 from modules.bidding.domain.value_objects import Bid, Bidder, Seller
 from modules.bidding.domain.rules import (
     PlacedBidMustBeGreaterThanCurrentWinningBid,
     BidCanBeRetracted,
     ListingCanBeCancelled,
 )
 from seedwork.domain.entities import AggregateRoot
-from seedwork.domain.events import DomainEvent
 from seedwork.domain.exceptions import DomainException
 from seedwork.domain.events import DomainEvent
-from seedwork.domain.value_objects import UUID, Money
+from seedwork.domain.value_objects import Money
 
 
 class BidderIsNotBiddingListing(DomainException):
@@ -51,7 +49,7 @@ def __post_init__(self) -> None:
         self.current_price = self.initial_price
 
     # public commands
-    def place_bid(self, bid: Bid) -> Sequence[DomainEvent]:
+    def place_bid(self, bid: Bid) -> List[DomainEvent]:
         """Public method"""
         self.check_rule(
             PlacedBidMustBeGreaterThanCurrentWinningBid(
@@ -66,7 +64,7 @@ def place_bid(self, bid: Bid) -> Sequence[DomainEvent]:
 
         return [BidPlacedEvent(listing_id=self.id, bidder=bid.bidder, price=bid.price)]
 
-    def retract_bid_of(self, bidder: Bidder) -> Sequence[DomainEvent]:
+    def retract_bid_of(self, bidder: Bidder) -> List[DomainEvent]:
         """Public method"""
         bid = self.get_bid_of(bidder)
         self.check_rule(
@@ -76,7 +74,7 @@ def retract_bid_of(self, bidder: Bidder) -> Sequence[DomainEvent]:
         self._remove_bid_of(bidder=bidder)
         return [BidRetractedEvent(listing_id=self.id, bidder_id=bidder.uuid)]
 
-    def cancel_listing(self) -> Sequence[DomainEvent]:
+    def cancel_listing(self) -> List[DomainEvent]:
         self.check_rule(
             ListingCanBeCancelled(
                 time_left_in_listing=self.time_left_in_listing,
@@ -86,7 +84,7 @@ def cancel_listing(self) -> Sequence[DomainEvent]:
         self.ends_at = datetime.utcnow()
         return [ListingCancelledEvent(listing_id=self.id)]
 
-    def end_bidding(self) -> Sequence[DomainEvent]:
+    def end_bidding(self) -> List[DomainEvent]:
         raise NotImplementedError()
         return []
 

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

@@ -3,6 +3,7 @@
 from seedwork.application.command_handlers import CommandResult
 from seedwork.application.decorators import command_handler
 from modules.catalog.domain.entities import Listing
+from modules.catalog.domain.events import ListingDraftCreatedEvent
 from modules.catalog.domain.repositories import ListingRepository
 
 
@@ -19,10 +20,6 @@ class CreateListingDraftCommand(Command):
 def create_listing_draft(
     command: CreateListingDraftCommand, repository: ListingRepository
 ) -> CommandResult:
-    listing = Listing(id=repository.next_id(), **command.dict())
-    try:
-        repository.insert(listing)
-    except Exception as e:
-        return CommandResult.failed(message="Failed to create listing", exception=e)
-
-    return CommandResult.ok(result=listing.id)
+    listing = Listing(id=Listing.next_id(), **command.dict())
+    repository.insert(listing)
+    return CommandResult.ok(result=listing.id, events=[ListingDraftCreatedEvent(listing_id=listing.id)])

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

@@ -1,8 +1,9 @@
 from seedwork.application.commands import Command
 from seedwork.domain.value_objects import UUID
-from modules.catalog.domain.repositories import ListingRepository, SellerRepository
 from seedwork.application.command_handlers import CommandResult
 from seedwork.application.decorators import command_handler
+from modules.catalog.domain.entities import Listing, Seller
+from modules.catalog.domain.repositories import ListingRepository, SellerRepository
 
 
 class PublishListingCommand(Command):
@@ -18,12 +19,12 @@ def publish_listing(
     listing_repository: ListingRepository,
     seller_repository: SellerRepository,
 ):
-    listing = listing_repository.get_by_id(command.listing_id)
-    seller = seller_repository.get_by_id(command.seller_id)
+    listing: Listing = listing_repository.get_by_id(command.listing_id)
+    seller: Seller = seller_repository.get_by_id(command.seller_id)
 
-    seller.publish_listing(listing)
+    events = seller.publish_listing(listing)
 
     # TODO: for now we need to manually persist the changes, but it should be handled automatically using "Unit of Work"
     listing_repository.update(listing)
 
-    return CommandResult.ok()
+    return CommandResult.ok(events=events)

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

@@ -1,8 +1,9 @@
 from seedwork.application.commands import Command
-from seedwork.domain.value_objects import Money, UUID
-from modules.catalog.domain.repositories import ListingRepository
 from seedwork.application.command_handlers import CommandResult
 from seedwork.application.decorators import command_handler
+from seedwork.domain.value_objects import Money, UUID
+from modules.catalog.domain.entities import Listing
+from modules.catalog.domain.repositories import ListingRepository
 
 
 class UpdateListingDraftCommand(Command):
@@ -19,13 +20,9 @@ class UpdateListingDraftCommand(Command):
 def update_listing_draft(
     command: UpdateListingDraftCommand, repository: ListingRepository
 ) -> CommandResult:
-    listing = repository.get_by_id(command.listing_id)
-    listing.change_main_attributes(
+    listing: Listing = repository.get_by_id(command.listing_id)
+    events = listing.change_main_attributes(
         title=command.title, description=command.description, price=command.price
     )
-    try:
-        repository.update(listing)
-    except:
-        return CommandResult.error("Failed to update listing")
-
-    return CommandResult.ok()
+    repository.update(listing)
+    return CommandResult.ok(events=events)

src/modules/catalog/domain/entities.py

@@ -1,35 +1,41 @@
 from dataclasses import dataclass
-from datetime import date
-from typing import Any
-from seedwork.domain.entities import Entity
+from typing import List
+from seedwork.domain.entities import AggregateRoot
 from seedwork.domain.value_objects import Money, UUID
+from modules.catalog.domain.events import ListingDraftUpdatedEvent, ListingPublishedEvent, DomainEvent
 from modules.catalog.domain.rules import ListingPriceMustBeGreaterThanZero
 from .value_objects import ListingStatus
 
 
-class Listing(Entity):
+@dataclass
+class Listing(AggregateRoot):
     title: str
     description: str
     price: Money
     seller_id: UUID
     status = ListingStatus.DRAFT
 
-    def change_main_attributes(self, title: str, description: str, price: Money):
+    def change_main_attributes(self, title: str, description: str, price: Money) -> List[DomainEvent]:
         self.title = title
         self.description = description
         self.price = price
 
-    def publish(self):
-        self.status = ListingStatus.PUBLISHED
+        return [ListingDraftUpdatedEvent(listing_id=self.id)]
 
+    def publish(self) -> List[DomainEvent]:
+        self.check_rule(ListingPriceMustBeGreaterThanZero(price=self.price))
+        self.status = ListingStatus.PUBLISHED
+        return [ListingPublishedEvent(listing_id=self.id)]
 
-class Seller(Entity):
+@dataclass
+class Seller(AggregateRoot):
     id: UUID
     is_new: bool = True
     currently_published_listings_count: int = 0
 
-    def publish_listing(self, listing):
+    def publish_listing(self, listing) -> List[DomainEvent]:
         self.check_rule(ListingPriceMustBeGreaterThanZero(price=listing.price))
         # self.check_rule(ListingMustBeInDraftState(listing.status))
         # self.check_rule(SellerMustBeEligibleForAddingNextListing(self))
-        listing.publish()
+        return listing.publish()
+

src/modules/catalog/domain/events.py

@@ -3,6 +3,13 @@
 from seedwork.domain.value_objects import UUID
 
 
-@dataclass
 class ListingDraftCreatedEvent(DomainEvent):
     listing_id: UUID
+
+
+class ListingDraftUpdatedEvent(DomainEvent):
+    listing_id: UUID
+
+
+class ListingPublishedEvent(DomainEvent):
+    listing_id: UUID

src/modules/catalog/infrastructure/test_listing_repository.py

@@ -14,12 +14,12 @@ def test_listing_repo_is_empty(db_session):
 
 
 def test_listing_persistence(db_session):
-    original = Listing(title="red dragon", description="", price=1, seller_id=UUID.v4())
-    repo = PostgresJsonListingRepository(db_session=db_session)
+    original = Listing(id=Listing.next_id(), title="red dragon", description="", price=1, seller_id=UUID.v4())
+    repository = PostgresJsonListingRepository(db_session=db_session)
 
-    repo.insert(original)
+    repository.insert(original)
     db_session.commit()
 
-    persisted = repo.get_by_id(original.id)
+    persisted = repository.get_by_id(original.id)
 
     assert original == persisted

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

@@ -14,31 +14,32 @@
 from modules.catalog.domain.entities import Listing, Seller
 from modules.catalog.domain.value_objects import ListingStatus
 from seedwork.infrastructure.repository import InMemoryRepository
-from seedwork.domain.value_objects import UUID
+from seedwork.domain.value_objects import UUID, Money
 
 
 def test_create_listing_draft():
     # arrange
     command = CreateListingDraftCommand(
-        title="foo", description="bar", price=1, seller_id=UUID.v4()
+        title="foo", description="bar", price=Money(1), seller_id=Seller.next_id()
     )
     repository = InMemoryRepository()
 
     # act
     result = create_listing_draft(command, repository)
-
+    
     # assert
-    assert repository.get_by_id(result.id).title == "foo"
+    assert repository.get_by_id(result.result).title == "foo"
     assert result.has_errors() is False
 
 
 def test_update_listing_draft():
     # arrange
     repository = InMemoryRepository()
     listing = Listing(
+        id=Listing.next_id(),
         title="Tiny dragon",
         description="Tiny dragon for sale",
-        price=1,
+        price=Money(1),
         seller_id=UUID.v4(),
     )
     repository.insert(listing)
@@ -60,16 +61,16 @@ def test_update_listing_draft():
 
 def test_publish_listing():
     # arrange
-    seller_id = UUID.v4()
     seller_repository = InMemoryRepository()
-    seller = Seller()
+    seller = Seller(id=Seller.next_id())
     seller_repository.insert(seller)
 
     listing_repository = InMemoryRepository()
     listing = Listing(
+        id=Listing.next_id(),
         title="Tiny dragon",
         description="Tiny dragon for sale",
-        price=1,
+        price=Money(1),
         seller_id=seller.id,
     )
     listing_repository.insert(listing)
@@ -85,6 +86,8 @@ def test_publish_listing():
         listing_repository=listing_repository,
         seller_repository=seller_repository,
     )
+    
+    print(result)
 
     # assert
     assert result.is_ok()
@@ -93,16 +96,16 @@ def test_publish_listing():
 
 def test_publish_listing_and_break_business_rule():
     # arrange
-    seller_id = UUID.v4()
     seller_repository = InMemoryRepository()
-    seller = Seller()
+    seller = Seller(id=Seller.next_id())
     seller_repository.insert(seller)
 
     listing_repository = InMemoryRepository()
     listing = Listing(
+        id=Listing.next_id(),
         title="Tiny dragon",
         description="Tiny dragon for sale",
-        price=0,  # this will break the rule
+        price=Money(0),  # this will break the rule
         seller_id=seller.id,
     )
     listing_repository.insert(listing)

src/modules/catalog/tests/domain/test_entities.py

@@ -1,15 +1,17 @@
 import pytest
+from seedwork.domain.exceptions import BusinessRuleValidationException
+from seedwork.domain.value_objects import Money
 from modules.catalog.domain.entities import Seller, Listing
 from modules.catalog.domain.value_objects import ListingStatus
-from seedwork.domain.exceptions import BusinessRuleValidationException
 
 
 def test_seller_publishes_listing_happy_path():
-    seller = Seller()
+    seller = Seller(id=Seller.next_id())
     listing = Listing(
+        id=Listing.next_id(),
         title="Tiny dragon",
         description="Tiny dragon for sale",
-        price=1,
+        price=Money(1),
         seller_id=seller.id,
     )
 
@@ -19,11 +21,12 @@ def test_seller_publishes_listing_happy_path():
 
 
 def test_seller_fails_to_publish_listing_with_zero_price():
-    seller = Seller()
+    seller = Seller(id=Seller.next_id())
     listing = Listing(
+        id=Listing.next_id(),
         title="Tiny dragon",
         description="Tiny dragon for sale",
-        price=0,
+        price=Money(0),
         seller_id=seller.id,
     )
 

src/modules/catalog/tests/domain/test_rules.py

@@ -1,11 +1,12 @@
+from seedwork.domain.value_objects import Money
 from modules.catalog.domain.rules import ListingPriceMustBeGreaterThanZero
 
 
 def test_AuctionItemPriceMustBeGreaterThanZero_rule():
-    rule = ListingPriceMustBeGreaterThanZero(price=1)
+    rule = ListingPriceMustBeGreaterThanZero(price=Money(1))
     assert not rule.is_broken()
 
 
 def test_AuctionItemPriceMustBeGreaterThanZero_rule_is_broken():
-    rule = ListingPriceMustBeGreaterThanZero(price=0)
+    rule = ListingPriceMustBeGreaterThanZero(price=Money(0))
     assert rule.is_broken()