start on a Product model with an allocate fn [product_aggregate]

hjwp · hjwp · commit aa4bad7de824 · 2024-03-01T15:01:34.000Z
diff --git a/src/allocation/adapters/orm.py b/src/allocation/adapters/orm.py
@@ -15,12 +15,19 @@
     Column("orderid", String(255)),
 )
 
+products = Table(
+    "products",
+    metadata,
+    Column("sku", String(255), primary_key=True),
+    # Column('version_number', Integer, nullable=False, default=0),
+)
+
 batches = Table(
     "batches",
     metadata,
     Column("id", Integer, primary_key=True, autoincrement=True),
     Column("reference", String(255)),
-    Column("sku", String(255)),
+    Column("sku", ForeignKey("products.sku")),
     Column("_purchased_quantity", Integer, nullable=False),
     Column("eta", Date, nullable=True),
 )
@@ -36,7 +43,7 @@
 
 def start_mappers():
     lines_mapper = mapper(model.OrderLine, order_lines)
-    mapper(
+    batches_mapper = mapper(
         model.Batch,
         batches,
         properties={
@@ -47,3 +54,6 @@ def start_mappers():
             )
         },
     )
+    mapper(
+        model.Product, products, properties={"batches": relationship(batches_mapper)}
+    )
diff --git a/src/allocation/adapters/repository.py b/src/allocation/adapters/repository.py
@@ -4,23 +4,20 @@
 
 class AbstractRepository(abc.ABC):
     @abc.abstractmethod
-    def add(self, batch: model.Batch):
+    def add(self, product: model.Product):
         raise NotImplementedError
 
     @abc.abstractmethod
-    def get(self, reference) -> model.Batch:
+    def get(self, sku) -> model.Product:
         raise NotImplementedError
 
 
 class SqlAlchemyRepository(AbstractRepository):
     def __init__(self, session):
         self.session = session
 
-    def add(self, batch):
-        self.session.add(batch)
+    def add(self, product):
+        self.session.add(product)
 
-    def get(self, reference):
-        return self.session.query(model.Batch).filter_by(reference=reference).one()
-
-    def list(self):
-        return self.session.query(model.Batch).all()
+    def get(self, sku):
+        return self.session.query(model.Product).filter_by(sku=sku).first()
diff --git a/src/allocation/domain/model.py b/src/allocation/domain/model.py
@@ -8,13 +8,18 @@ class OutOfStock(Exception):
     pass
 
 
-def allocate(line: OrderLine, batches: List[Batch]) -> str:
-    try:
-        batch = next(b for b in sorted(batches) if b.can_allocate(line))
-        batch.allocate(line)
-        return batch.reference
-    except StopIteration:
-        raise OutOfStock(f"Out of stock for sku {line.sku}")
+class Product:
+    def __init__(self, sku: str, batches: List[Batch]):
+        self.sku = sku
+        self.batches = batches
+
+    def allocate(self, line: OrderLine) -> str:
+        try:
+            batch = next(b for b in sorted(self.batches) if b.can_allocate(line))
+            batch.allocate(line)
+            return batch.reference
+        except StopIteration:
+            raise OutOfStock(f"Out of stock for sku {line.sku}")
 
 
 @dataclass(unsafe_hash=True)
diff --git a/src/allocation/service_layer/services.py b/src/allocation/service_layer/services.py
@@ -11,16 +11,16 @@ class InvalidSku(Exception):
     pass
 
 
-def is_valid_sku(sku, batches):
-    return sku in {b.sku for b in batches}
-
-
 def add_batch(
     ref: str, sku: str, qty: int, eta: Optional[date],
     uow: unit_of_work.AbstractUnitOfWork,
 ):
     with uow:
-        uow.batches.add(model.Batch(ref, sku, qty, eta))
+        product = uow.products.get(sku=sku)
+        if product is None:
+            product = model.Product(sku, batches=[])
+            uow.products.add(product)
+        product.batches.append(model.Batch(ref, sku, qty, eta))
         uow.commit()
 
 
@@ -30,9 +30,9 @@ def allocate(
 ) -> str:
     line = OrderLine(orderid, sku, qty)
     with uow:
-        batches = uow.batches.list()
-        if not is_valid_sku(line.sku, batches):
+        product = uow.products.get(sku=line.sku)
+        if product is None:
             raise InvalidSku(f"Invalid sku {line.sku}")
-        batchref = model.allocate(line, batches)
+        batchref = product.allocate(line)
         uow.commit()
     return batchref
diff --git a/src/allocation/service_layer/unit_of_work.py b/src/allocation/service_layer/unit_of_work.py
@@ -10,7 +10,7 @@
 
 
 class AbstractUnitOfWork(abc.ABC):
-    batches: repository.AbstractRepository
+    products: repository.AbstractRepository
 
     def __enter__(self) -> AbstractUnitOfWork:
         return self
@@ -40,7 +40,7 @@ def __init__(self, session_factory=DEFAULT_SESSION_FACTORY):
 
     def __enter__(self):
         self.session = self.session_factory()  # type: Session
-        self.batches = repository.SqlAlchemyRepository(self.session)
+        self.products = repository.SqlAlchemyRepository(self.session)
         return super().__enter__()
 
     def __exit__(self, *args):
diff --git a/tests/integration/test_orm.py b/tests/integration/test_orm.py
diff --git a/tests/integration/test_repository.py b/tests/integration/test_repository.py
diff --git a/tests/integration/test_uow.py b/tests/integration/test_uow.py
@@ -4,6 +4,10 @@
 
 
 def insert_batch(session, ref, sku, qty, eta):
+    session.execute(
+        "INSERT INTO products (sku) VALUES (:sku)",
+        dict(sku=sku),
+    )
     session.execute(
         "INSERT INTO batches (reference, sku, _purchased_quantity, eta)"
         " VALUES (:ref, :sku, :qty, :eta)",
@@ -31,9 +35,9 @@ def test_uow_can_retrieve_a_batch_and_allocate_to_it(session_factory):
 
     uow = unit_of_work.SqlAlchemyUnitOfWork(session_factory)
     with uow:
-        batch = uow.batches.get(reference="batch1")
+        product = uow.products.get(sku="HIPSTER-WORKBENCH")
         line = model.OrderLine("o1", "HIPSTER-WORKBENCH", 10)
-        batch.allocate(line)
+        product.allocate(line)
         uow.commit()
 
     batchref = get_allocated_batch_ref(session, "o1", "HIPSTER-WORKBENCH")
diff --git a/tests/unit/test_product.py b/tests/unit/test_product.py
@@ -1,18 +1,19 @@
 from datetime import date, timedelta
 import pytest
-from allocation.domain.model import allocate, OrderLine, Batch, OutOfStock
+from allocation.domain.model import Product, OrderLine, Batch, OutOfStock
 
 today = date.today()
 tomorrow = today + timedelta(days=1)
 later = tomorrow + timedelta(days=10)
 
 
-def test_prefers_current_stock_batches_to_shipments():
+def test_prefers_warehouse_batches_to_shipments():
     in_stock_batch = Batch("in-stock-batch", "RETRO-CLOCK", 100, eta=None)
     shipment_batch = Batch("shipment-batch", "RETRO-CLOCK", 100, eta=tomorrow)
+    product = Product(sku="RETRO-CLOCK", batches=[in_stock_batch, shipment_batch])
     line = OrderLine("oref", "RETRO-CLOCK", 10)
 
-    allocate(line, [in_stock_batch, shipment_batch])
+    product.allocate(line)
 
     assert in_stock_batch.available_quantity == 90
     assert shipment_batch.available_quantity == 100
@@ -22,9 +23,10 @@ def test_prefers_earlier_batches():
     earliest = Batch("speedy-batch", "MINIMALIST-SPOON", 100, eta=today)
     medium = Batch("normal-batch", "MINIMALIST-SPOON", 100, eta=tomorrow)
     latest = Batch("slow-batch", "MINIMALIST-SPOON", 100, eta=later)
+    product = Product(sku="MINIMALIST-SPOON", batches=[medium, earliest, latest])
     line = OrderLine("order1", "MINIMALIST-SPOON", 10)
 
-    allocate(line, [medium, earliest, latest])
+    product.allocate(line)
 
     assert earliest.available_quantity == 90
     assert medium.available_quantity == 100
@@ -35,13 +37,15 @@ def test_returns_allocated_batch_ref():
     in_stock_batch = Batch("in-stock-batch-ref", "HIGHBROW-POSTER", 100, eta=None)
     shipment_batch = Batch("shipment-batch-ref", "HIGHBROW-POSTER", 100, eta=tomorrow)
     line = OrderLine("oref", "HIGHBROW-POSTER", 10)
-    allocation = allocate(line, [in_stock_batch, shipment_batch])
+    product = Product(sku="HIGHBROW-POSTER", batches=[in_stock_batch, shipment_batch])
+    allocation = product.allocate(line)
     assert allocation == in_stock_batch.reference
 
 
 def test_raises_out_of_stock_exception_if_cannot_allocate():
     batch = Batch("batch1", "SMALL-FORK", 10, eta=today)
-    allocate(OrderLine("order1", "SMALL-FORK", 10), [batch])
+    product = Product(sku="SMALL-FORK", batches=[batch])
+    product.allocate(OrderLine("order1", "SMALL-FORK", 10))
 
     with pytest.raises(OutOfStock, match="SMALL-FORK"):
-        allocate(OrderLine("order2", "SMALL-FORK", 1), [batch])
+        product.allocate(OrderLine("order2", "SMALL-FORK", 1))
diff --git a/tests/unit/test_services.py b/tests/unit/test_services.py
