예제 #1
0
    def test_picklist_with_partial_bundles(self):
        # from test_records.json
        warehouse = "_Test Warehouse - _TC"

        quantities = [5, 2]
        bundle, components = create_product_bundle(quantities,
                                                   warehouse=warehouse)

        so = make_sales_order(item_code=bundle, qty=4, rate=42)

        pl = create_pick_list(so.name)
        for loc in pl.locations:
            loc.picked_qty = loc.qty / 2

        pl.save().submit()
        so.reload()
        self.assertEqual(so.per_picked, 50)

        # deliver half qty
        dn = create_delivery_note(pl.name).submit()
        self.assertEqual(dn.items[0].rate, 42)
        so.reload()
        self.assertEqual(so.per_delivered, 50)

        pl = create_pick_list(so.name)
        pl.save().submit()
        so.reload()
        self.assertEqual(so.per_picked, 100)

        # deliver remaining
        dn = create_delivery_note(pl.name).submit()
        self.assertEqual(dn.items[0].rate, 42)
        so.reload()
        self.assertEqual(so.per_delivered, 100)
예제 #2
0
    def test_picklist_with_bundles(self):
        warehouse = "_Test Warehouse - _TC"

        quantities = [5, 2]
        bundle, components = create_product_bundle(quantities,
                                                   warehouse=warehouse)
        bundle_items = dict(zip(components, quantities))

        so = make_sales_order(item_code=bundle, qty=3, rate=42)

        pl = create_pick_list(so.name)
        pl.save()
        self.assertEqual(len(pl.locations), 2)
        for item in pl.locations:
            self.assertEqual(item.stock_qty, bundle_items[item.item_code] * 3)

        # check picking status on sales order
        pl.submit()
        so.reload()
        self.assertEqual(so.per_picked, 100)

        # deliver
        dn = create_delivery_note(pl.name).submit()
        self.assertEqual(dn.items[0].rate, 42)
        self.assertEqual(dn.packed_items[0].warehouse, warehouse)
        so.reload()
        self.assertEqual(so.per_delivered, 100)
예제 #3
0
    def test_pick_list_for_items_with_multiple_UOM(self):
        purchase_receipt = make_purchase_receipt(item_code="_Test Item",
                                                 qty=10)
        purchase_receipt.submit()

        sales_order = frappe.get_doc({
            'doctype':
            'Sales Order',
            'customer':
            '_Test Customer',
            'company':
            '_Test Company',
            'items': [{
                'item_code': '_Test Item',
                'qty': 1,
                'conversion_factor': 5,
                'delivery_date': frappe.utils.today()
            }, {
                'item_code': '_Test Item',
                'qty': 1,
                'conversion_factor': 1,
                'delivery_date': frappe.utils.today()
            }],
        }).insert()
        sales_order.submit()

        pick_list = frappe.get_doc({
            'doctype':
            'Pick List',
            'company':
            '_Test Company',
            'customer':
            '_Test Customer',
            'items_based_on':
            'Sales Order',
            'locations': [{
                'item_code': '_Test Item',
                'qty': 1,
                'stock_qty': 5,
                'conversion_factor': 5,
                'sales_order': sales_order.name,
                'sales_order_item': sales_order.items[0].name,
            }, {
                'item_code': '_Test Item',
                'qty': 1,
                'stock_qty': 1,
                'conversion_factor': 1,
                'sales_order': sales_order.name,
                'sales_order_item': sales_order.items[1].name,
            }]
        })
        pick_list.set_item_locations()
        pick_list.submit()

        delivery_note = create_delivery_note(pick_list.name)

        self.assertEqual(pick_list.locations[0].qty,
                         delivery_note.items[0].qty)
        self.assertEqual(pick_list.locations[1].qty,
                         delivery_note.items[1].qty)
        self.assertEqual(sales_order.items[0].conversion_factor,
                         delivery_note.items[0].conversion_factor)

        pick_list.cancel()
        sales_order.cancel()
        purchase_receipt.cancel()
예제 #4
0
    def test_multiple_dn_creation(self):
        sales_order_1 = frappe.get_doc({
            "doctype":
            "Sales Order",
            "customer":
            "_Test Customer",
            "company":
            "_Test Company",
            "items": [{
                "item_code": "_Test Item",
                "qty": 1,
                "conversion_factor": 1,
                "delivery_date": frappe.utils.today(),
            }],
        }).insert()
        sales_order_1.submit()
        sales_order_2 = frappe.get_doc({
            "doctype":
            "Sales Order",
            "customer":
            "_Test Customer 1",
            "company":
            "_Test Company",
            "items": [
                {
                    "item_code": "_Test Item 2",
                    "qty": 1,
                    "conversion_factor": 1,
                    "delivery_date": frappe.utils.today(),
                },
            ],
        }).insert()
        sales_order_2.submit()
        pick_list = frappe.get_doc({
            "doctype":
            "Pick List",
            "company":
            "_Test Company",
            "items_based_on":
            "Sales Order",
            "purpose":
            "Delivery",
            "picker":
            "P001",
            "locations": [
                {
                    "item_code": "_Test Item ",
                    "qty": 1,
                    "stock_qty": 1,
                    "conversion_factor": 1,
                    "sales_order": sales_order_1.name,
                    "sales_order_item": sales_order_1.items[0].name,
                },
                {
                    "item_code": "_Test Item 2",
                    "qty": 1,
                    "stock_qty": 1,
                    "conversion_factor": 1,
                    "sales_order": sales_order_2.name,
                    "sales_order_item": sales_order_2.items[0].name,
                },
            ],
        })
        pick_list.set_item_locations()
        pick_list.submit()
        create_delivery_note(pick_list.name)
        for dn in frappe.get_all(
                "Delivery Note",
                filters={
                    "pick_list": pick_list.name,
                    "customer": "_Test Customer"
                },
                fields={"name"},
        ):
            for dn_item in frappe.get_doc("Delivery Note",
                                          dn.name).get("items"):
                self.assertEqual(dn_item.item_code, "_Test Item")
                self.assertEqual(dn_item.against_sales_order,
                                 sales_order_1.name)
                self.assertEqual(dn_item.pick_list_item,
                                 pick_list.locations[dn_item.idx - 1].name)

        for dn in frappe.get_all(
                "Delivery Note",
                filters={
                    "pick_list": pick_list.name,
                    "customer": "_Test Customer 1"
                },
                fields={"name"},
        ):
            for dn_item in frappe.get_doc("Delivery Note",
                                          dn.name).get("items"):
                self.assertEqual(dn_item.item_code, "_Test Item 2")
                self.assertEqual(dn_item.against_sales_order,
                                 sales_order_2.name)
        # test DN creation without so
        pick_list_1 = frappe.get_doc({
            "doctype":
            "Pick List",
            "company":
            "_Test Company",
            "purpose":
            "Delivery",
            "picker":
            "P001",
            "locations": [
                {
                    "item_code": "_Test Item ",
                    "qty": 1,
                    "stock_qty": 1,
                    "conversion_factor": 1,
                },
                {
                    "item_code": "_Test Item 2",
                    "qty": 2,
                    "stock_qty": 2,
                    "conversion_factor": 1,
                },
            ],
        })
        pick_list_1.set_item_locations()
        pick_list_1.submit()
        create_delivery_note(pick_list_1.name)
        for dn in frappe.get_all("Delivery Note",
                                 filters={"pick_list": pick_list_1.name},
                                 fields={"name"}):
            for dn_item in frappe.get_doc("Delivery Note",
                                          dn.name).get("items"):
                if dn_item.item_code == "_Test Item":
                    self.assertEqual(dn_item.qty, 1)
                if dn_item.item_code == "_Test Item 2":
                    self.assertEqual(dn_item.qty, 2)
예제 #5
0
    def test_pick_list_for_items_with_multiple_UOM(self):
        item_code = make_item().name
        purchase_receipt = make_purchase_receipt(item_code=item_code, qty=10)
        purchase_receipt.submit()

        sales_order = frappe.get_doc({
            "doctype":
            "Sales Order",
            "customer":
            "_Test Customer",
            "company":
            "_Test Company",
            "items": [
                {
                    "item_code": item_code,
                    "qty": 1,
                    "conversion_factor": 5,
                    "stock_qty": 5,
                    "delivery_date": frappe.utils.today(),
                    "warehouse": "_Test Warehouse - _TC",
                },
                {
                    "item_code": item_code,
                    "qty": 1,
                    "conversion_factor": 1,
                    "delivery_date": frappe.utils.today(),
                    "warehouse": "_Test Warehouse - _TC",
                },
            ],
        }).insert()
        sales_order.submit()

        pick_list = frappe.get_doc({
            "doctype":
            "Pick List",
            "company":
            "_Test Company",
            "customer":
            "_Test Customer",
            "items_based_on":
            "Sales Order",
            "purpose":
            "Delivery",
            "locations": [
                {
                    "item_code": item_code,
                    "qty": 2,
                    "stock_qty": 1,
                    "conversion_factor": 0.5,
                    "sales_order": sales_order.name,
                    "sales_order_item": sales_order.items[0].name,
                },
                {
                    "item_code": item_code,
                    "qty": 1,
                    "stock_qty": 1,
                    "conversion_factor": 1,
                    "sales_order": sales_order.name,
                    "sales_order_item": sales_order.items[1].name,
                },
            ],
        })
        pick_list.set_item_locations()
        pick_list.submit()

        delivery_note = create_delivery_note(pick_list.name)

        self.assertEqual(pick_list.locations[0].qty,
                         delivery_note.items[0].qty)
        self.assertEqual(pick_list.locations[1].qty,
                         delivery_note.items[1].qty)
        self.assertEqual(sales_order.items[0].conversion_factor,
                         delivery_note.items[0].conversion_factor)

        pick_list.cancel()
        sales_order.cancel()
        purchase_receipt.cancel()