Ejemplo n.º 1
0
    def test_invoice_delivery(self):
        delivery = DeliveryFactory.build()
        delivery.add_item("PROD001", 1, "ORD001")
        delivery.add_item("PROD002", 3, "ORD001")
        delivery.add_item("PROD001", 2, "ORD002")
        delivery.add_item("PROD002", 4, "ORD002")
        delivery.adjust_deliver_quantity("PROD001", 1, "ORD001")
        delivery.adjust_deliver_quantity("PROD002", 3, "ORD001")
        delivery.adjust_deliver_quantity("PROD001", 2, "ORD002")
        delivery.adjust_deliver_quantity("PROD002", 4, "ORD002")

        service = InvoicingService(self.customer_repository, self.invoice_repository, self.order_repository,
                                   self.inventory_repository, self.tax_repository)

        invoices = service.invoice_delivery(delivery)

        self.assertEquals(2, len(invoices), "Exactly 2 invoices should have been created")

        inv_ord001 = [inv for inv in invoices if inv.order_id == "ORD001"][0]
        self.assertEquals("INV001", inv_ord001.invoice_id, "Wrong Invoice ID assigned")
        self.assertEquals("CUST-PO001", inv_ord001.customer_reference, "Incorrect customer reference")
        self.assertEquals(2, len(inv_ord001.line_items), "Invoice should only contain 2 line items")
        self.assertEquals(132.00, inv_ord001.total_amount(), "Invoice total is incorrect")
        self.assertFalse(inv_ord001.finalised, "Invoice should not yet be finalised")

        inv_ord002 = [inv for inv in invoices if inv.order_id == "ORD002"][0]
        self.assertEquals("INV002", inv_ord002.invoice_id, "Wrong Invoice ID assigned")
        self.assertEquals("CUST-PO002", inv_ord002.customer_reference, "Incorrect customer reference")
        self.assertEquals(2, len(inv_ord002.line_items), "Invoice should only contain 2 line items")
        self.assertEquals(242.00, inv_ord002.total_amount(), "Invoice total is incorrect")
        self.assertFalse(inv_ord002.finalised, "Invoice should not yet be finalised")
Ejemplo n.º 2
0
    def test_invoice_descriptor_nonexistent_commitment(self):
        service = InvoicingService(self.customer_repository, self.invoice_repository, self.order_repository,
                                   self.inventory_repository, self.tax_repository)

        # Order descriptor has a product with no corresponding commitment
        self.order_descriptors["ORD001"].append({"sku": "PROD003", "quantity": 10})

        service._invoice_order("ORD001", self.order_descriptors["ORD001"])
Ejemplo n.º 3
0
    def test_invoice_descriptor_commitment_quantity_mismatch(self):
        service = InvoicingService(self.customer_repository, self.invoice_repository, self.order_repository,
                                   self.inventory_repository, self.tax_repository)

        # Order descriptor has a commitment for wrong quantity
        self.order_descriptors["ORD001"] = [{"sku": "PROD001", "quantity": 10}]

        service._invoice_order("ORD001", self.order_descriptors["ORD001"])
Ejemplo n.º 4
0
    def test_invoice_descriptor_nonexistent_sku(self):
        service = InvoicingService(self.customer_repository, self.invoice_repository, self.order_repository,
                                   self.inventory_repository, self.tax_repository)

        self.order_descriptors["ORD001"][0]["sku"] = "PRODFAKE"
        service._invoice_order("ORD001", descriptors=self.order_descriptors["ORD001"])

        self.assertTrue(call("PRODFAKE") in self.inventory_repository.find.call_args_list, "SKU was not queried for")
Ejemplo n.º 5
0
    def test_invoice_order(self):
        service = InvoicingService(self.customer_repository, self.invoice_repository, self.order_repository,
                                   self.inventory_repository, self.tax_repository)

        invoice = service.invoice_order("ORD001")

        self.assertEquals("INV001", invoice.invoice_id, "Wrong Invoice ID assigned")
        self.assertEquals("CUST-PO001", invoice.customer_reference, "Incorrect customer reference")
        self.assertEquals(2, len(invoice.line_items), "Invoice should only contain 2 line items")
        self.assertEquals(132.00, invoice.total_amount(), "Invoice total is incorrect")
        self.assertFalse(invoice.finalised, "Invoice should not yet be finalised")
Ejemplo n.º 6
0
    def test_invoice_nonexistent_customer(self):
        customer_repository = Mock()
        customer_repository.find = Mock(return_value=None)

        self.orders["ORD00X"].is_acknowledged = Mock(return_value=True)

        service = InvoicingService(customer_repository, None, self.order_repository, None, None)
        service._invoice_order("ORD00X")

        self.assertTrue(call("Fake Customer") in self.customer_repository.find.call_args_list,
                        "Fake Customer was not queried for")
Ejemplo n.º 7
0
    def test_invoice_order_fulfill_commitment_fails(self):
        service = InvoicingService(self.customer_repository, self.invoice_repository, self.order_repository,
                                   self.inventory_repository, self.tax_repository)

        invoice = service.invoice_order("ORD003")
Ejemplo n.º 8
0
    def test_invoice_unacknowledged_orders(self):
        service = InvoicingService(self.customer_repository, self.invoice_repository, self.order_repository,
                                   self.inventory_repository, self.tax_repository)

        service._invoice_order("ORD00X")
Ejemplo n.º 9
0
    def test_invoice_order_no_such_order_id(self):
        service = InvoicingService(self.customer_repository, None, self.order_repository, None, None)

        service._invoice_order("ORDER-NONEXISTENT")
Ejemplo n.º 10
0
 def test_invalid_order_descriptor(self):
     service = InvoicingService(self.customer_repository, self.invoice_repository, self.order_repository,
                                self.inventory_repository, self.tax_repository)
     service._invoice_order("ORD001", [{"bad": None, "keys": None}])