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

hjwp · hjwp · commit d77ebf38d52c · 2019-11-20T21:10:23.000Z
diff --git a/src/allocation/model.py b/src/allocation/model.py
@@ -8,15 +8,21 @@ 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/orm.py b/src/allocation/orm.py
@@ -17,11 +17,17 @@
     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,10 +42,13 @@
 
 def start_mappers():
     lines_mapper = mapper(model.OrderLine, order_lines)
-    mapper(model.Batch, batches, properties={
+    batches_mapper = mapper(model.Batch, batches, properties={
         '_allocations': relationship(
             lines_mapper,
             secondary=allocations,
             collection_class=set,
         )
     })
+    mapper(model.Product, products, properties={
+        'batches': relationship(batches_mapper)
+    })
diff --git a/src/allocation/repository.py b/src/allocation/repository.py
@@ -1,15 +1,14 @@
 import abc
 from allocation import model
 
-
 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
 
 
@@ -19,11 +18,8 @@ class SqlAlchemyRepository(AbstractRepository):
     def __init__(self, session):
         self.session = session
 
-    def add(self, batch):
-        self.session.add(batch)
-
-    def get(self, reference):
-        return self.session.query(model.Batch).filter_by(reference=reference).one()
+    def add(self, product):
+        self.session.add(product)
 
-    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/services.py b/src/allocation/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/unit_of_work.py b/src/allocation/unit_of_work.py
@@ -1,7 +1,6 @@
 # pylint: disable=attribute-defined-outside-init
 from __future__ import annotations
 import abc
-from typing import Callable
 from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker
 from sqlalchemy.orm.session import Session
@@ -11,7 +10,7 @@
 
 
 class AbstractUnitOfWork(abc.ABC):
-    batches: repository.AbstractRepository
+    products: repository.AbstractRepository
 
     def __enter__(self) -> AbstractUnitOfWork:
         return self
@@ -40,7 +39,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
@@ -3,6 +3,10 @@
 from allocation import unit_of_work
 
 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)',
@@ -29,9 +33,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,17 +1,18 @@
 from datetime import date, timedelta
 import pytest
-from allocation.model import allocate, OrderLine, Batch, OutOfStock
+from allocation.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
@@ -21,9 +22,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
@@ -34,13 +36,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
