def test_records_out_of_stock_event_if_cannot_allocate():
    batch = Batch('batch1', 'SMALL-FORK', 10, eta=today)
    product = Product(sku="SMALL-FORK", batches=[batch])
    product.allocate(OrderLine('order1', 'SMALL-FORK', 10))

    allocation = product.allocate(OrderLine('order2', 'SMALL-FORK', 1))
    assert product.events[-1] == events.OutOfStock(sku="SMALL-FORK")
    assert allocation is None
Example #2
0
def test_raises_out_of_stock_exception_if_cannot_allocate():
    batch = Batch('batch1', 'SMALL-FORK', 10, eta=today)
    line = OrderLine('order1', 'SMALL-FORK', 10)

    prod = Product(line.sku, [batch])
    prod.allocate(line)

    with pytest.raises(OutOfStock, match='SMALL-FORK'):
        prod.allocate(OrderLine('order2', 'SMALL-FORK', 1))
Example #3
0
def test_allocating_to_a_batch_reduces_the_available_quantity():
    batch = Batch("batch-001", "SMALL-TABLE", qty=20, eta=date.today())
    line = OrderLine('order-ref', "SMALL-TABLE", 2)

    batch.allocate(line)

    assert batch.available_quantity == 18
def test_increments_version_number():
    line = OrderLine('oref', "SCANDI-PEN", 10)
    product = Product(sku="SCANDI-PEN",
                      batches=[Batch('b1', "SCANDI-PEN", 100, eta=None)])
    product.version_number = 7
    product.allocate(line)
    assert product.version_number == 8
def deallocate(orderid: str, sku: str, qty: int,
               uow: unit_of_work.AbstractUnitOfWork) -> str:
    line = OrderLine(orderid, sku, qty)
    with uow:
        batches = uow.batches.list()
        if not is_valid_sku(line.sku, batches):
            raise InvalidSku(f'Invalid sku {line.sku}')
        batchref = model.deallocate(line, batches)
        uow.commit()
    return batchref
Example #6
0
def allocate(orderid: str, sku: str, qty: int,
             uow: unit_of_work.AbstractUnitOfWork) -> str:
    line = OrderLine(orderid, sku, qty)
    with uow:
        product = uow.products.get(sku=line.sku)
        if product is None:
            raise InvalidSku(f'Invalid sku {line.sku}')
        batchref = product.allocate(line)
        uow.commit()
    return batchref
def test_outputs_allocated_event():
    batch = Batch("batchref", "RETRO-LAMPSHADE", 100, eta=None)
    line = OrderLine("oref", "RETRO-LAMPSHADE", 10)
    product = Product(sku="RETRO-LAMPSHADE", batches=[batch])
    product.allocate(line)
    expected = events.Allocated(orderid="oref",
                                sku="RETRO-LAMPSHADE",
                                qty=10,
                                batchref=batch.reference)
    assert product.events[-1] == expected
Example #8
0
def allocate(
        cmd: commands.Allocate, uow: unit_of_work.AbstractUnitOfWork
):
    line = OrderLine(cmd.orderid, cmd.sku, cmd.qty)
    with uow:
        product = uow.products.get(sku=line.sku)
        if product is None:
            raise InvalidSku(f'Invalid sku {line.sku}')
        product.allocate(line)
        uow.commit()
Example #9
0
def test_prefers_current_stock_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)
    line = OrderLine("oref", "RETRO-CLOCK", 10)

    prod = Product(line.sku, [in_stock_batch, shipment_batch])
    prod.allocate(line)

    assert in_stock_batch.available_quantity == 90
    assert shipment_batch.available_quantity == 100
def reallocate(orderid: str, sku: str, qty: int, uow: unit_of_work.AbstractUnitOfWork) \
        -> str:
    line = OrderLine(orderid, sku, qty)
    with uow:
        batch = uow.batches.get(sku=line.sku)
        if batch is None:
            raise InvalidSku(f'Invalid sku {line.sku}')
        batch.deallocate(line)
        batches = uow.batches.list()
        batchref = model.allocate(line, batches)
        uow.commit()
    return batchref
Example #11
0
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)
    line = OrderLine("order1", "MINIMALIST-SPOON", 10)

    prod = Product(line.sku, [medium, earliest, latest])
    prod.allocate(line)

    assert earliest.available_quantity == 90
    assert medium.available_quantity == 100
    assert latest.available_quantity == 100
Example #12
0
def test_prefers_current_stock_batches_to_shipments(days_after_today):
    in_stock = Batch('in-stock-batch', 'RETRO-CLOCK', 100, eta=None)
    shipment_batch = Batch('shipment-batch',
                           'RETRO-CLOCK',
                           100,
                           eta=days_after_today(1))
    line = OrderLine('oref', 'RETRO-CLOCK', 10)

    allocate(line, [in_stock, shipment_batch])

    assert in_stock.available_quantity == 90
    assert shipment_batch.available_quantity == 100
Example #13
0
def test_returns_allocated_batch_ref(days_after_today):
    in_stock_batch = Batch('in-stock-batch-ref',
                           'HIGHBROW-POSTER',
                           100,
                           eta=None)
    shipment_batch = Batch('shipment-batch-ref',
                           'HIGHBROW-POSTER',
                           100,
                           eta=days_after_today(1))
    line = OrderLine('oref', 'HIGHBROW-POSTER', 10)
    allocation = allocate(line, [in_stock_batch, shipment_batch])

    assert allocation == in_stock_batch.reference
Example #14
0
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)

    prod = Product(line.sku, [in_stock_batch, shipment_batch])
    allocation = prod.allocate(line)
    assert allocation == in_stock_batch.reference
Example #15
0
def test_prefers_earlier_batches(days_after_today):
    earliest = Batch('speedy-batch', 'MINIMALIST-SPOON', 100, eta=date.today())
    medium = Batch('medium-batch',
                   'MINIMALIST-SPOON',
                   100,
                   eta=days_after_today(1))
    latest = Batch('latest-batch',
                   'MINIMALIST-SPOON',
                   100,
                   eta=days_after_today(2))

    line = OrderLine('order1', 'MINIMALIST-SPOON', 10)

    allocate(line, [medium, earliest, latest])

    assert earliest.available_quantity == 90
    assert medium.available_quantity == 100
    assert latest.available_quantity == 100
Example #16
0
def test_cannot_allocate_if_skus_do_not_match():
    batch = Batch("batch-001", "UNCOMFORTABLE-CHAIR", 100, eta=None)
    different_sku_line = OrderLine("order-123", "EXPENSIVE-TOASTER", 10)
    assert batch.can_allocate(different_sku_line) is False
Example #17
0
def make_batch_and_line(sku, batch_qty, line_qty):
    return (
        Batch("batch-001", sku, batch_qty, eta=date.today()),
        OrderLine("order-123", sku, line_qty)
    )
Example #18
0
def test_raises_out_of_stock_exception_if_cannot_allocate():
    batch = Batch('batch1', 'SMALL-FORK', 10, eta=date.today())
    allocate(OrderLine('order1', 'SMALL-FORK', 10), [batch])

    with pytest.raises(OutOfStock, match='SMALL-FORK'):
        allocate(OrderLine('order2', 'SMALL-FORK', 1), [batch])
Example #19
0
def test_cannot_allocate_if_skus_do_not_match():
    batch = Batch('batch-001', 'NOT-ELEGANT-CHAIR', 100, eta=None)
    different_sku_line = OrderLine('order-123', 'TOSTER', 10)

    assert batch.can_allocate(different_sku_line) is False
Example #20
0
 def _make_batch_and_line(sku, batch_qty, line_qty):
     return (Batch('batch-001', sku, batch_qty,
                   eta=date.today()), OrderLine('order-123', sku, line_qty))