예제 #1
0
    def test_terms_copied(self):
        po = create_purchase_order(do_not_save=1)
        po.payment_terms_template = '_Test Payment Term Template'
        po.insert()
        po.submit()
        self.assertTrue(po.get('payment_schedule'))

        pi = make_pi_from_po(po.name)
        pi.insert()
        self.assertTrue(pi.get('payment_schedule'))
예제 #2
0
    def test_make_purchase_invoice(self):
        po = create_purchase_order(do_not_submit=True)

        self.assertRaises(frappe.ValidationError, make_pi_from_po, po.name)

        po.submit()
        pi = make_pi_from_po(po.name)

        self.assertEqual(pi.doctype, "Purchase Invoice")
        self.assertEqual(len(pi.get("items", [])), 1)
예제 #3
0
    def test_terms_are_not_copied_if_automatically_fetch_payment_terms_is_unchecked(
            self):
        po = create_purchase_order(do_not_save=1)
        po.payment_terms_template = "_Test Payment Term Template"
        po.save()
        po.submit()

        frappe.db.set_value("Company", "_Test Company", "payment_terms",
                            "_Test Payment Term Template 1")
        pi = make_pi_from_po(po.name)
        pi.save()

        self.assertEqual(pi.get("payment_terms_template"),
                         "_Test Payment Term Template 1")
        frappe.db.set_value("Company", "_Test Company", "payment_terms", "")
예제 #4
0
    def test_return_against_purchase_order(self):
        po = create_purchase_order()

        pr = make_pr_against_po(po.name, 6)

        po.load_from_db()
        self.assertEqual(po.get("items")[0].received_qty, 6)

        pi2 = make_pi_from_po(po.name)
        pi2.set("update_stock", 1)
        pi2.get("items")[0].qty = 3
        pi2.insert()
        pi2.submit()

        po.load_from_db()
        self.assertEqual(po.get("items")[0].received_qty, 9)

        # Make return purchase receipt, purchase invoice and check quantity
        from erpnext.stock.doctype.purchase_receipt.test_purchase_receipt \
          import make_purchase_receipt as make_purchase_receipt_return
        from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice \
          import make_purchase_invoice as make_purchase_invoice_return

        pr1 = make_purchase_receipt_return(is_return=1,
                                           return_against=pr.name,
                                           qty=-3,
                                           do_not_submit=True)
        pr1.items[0].purchase_order = po.name
        pr1.items[0].purchase_order_item = po.items[0].name
        pr1.submit()

        pi1 = make_purchase_invoice_return(is_return=1,
                                           return_against=pi2.name,
                                           qty=-1,
                                           update_stock=1,
                                           do_not_submit=True)
        pi1.items[0].purchase_order = po.name
        pi1.items[0].po_detail = po.items[0].name
        pi1.submit()

        po.load_from_db()
        self.assertEqual(po.get("items")[0].received_qty, 5)
예제 #5
0
    def test_reserved_qty_subcontract_po(self):
        # Make stock available for raw materials
        make_stock_entry(target="_Test Warehouse - _TC",
                         qty=10,
                         basic_rate=100)
        make_stock_entry(target="_Test Warehouse - _TC",
                         item_code="_Test Item Home Desktop 100",
                         qty=20,
                         basic_rate=100)
        make_stock_entry(target="_Test Warehouse 1 - _TC",
                         item_code="_Test Item",
                         qty=30,
                         basic_rate=100)
        make_stock_entry(target="_Test Warehouse 1 - _TC",
                         item_code="_Test Item Home Desktop 100",
                         qty=30,
                         basic_rate=100)

        bin1 = frappe.db.get_value(
            "Bin",
            filters={
                "warehouse": "_Test Warehouse - _TC",
                "item_code": "_Test Item"
            },
            fieldname=["reserved_qty_for_sub_contract", "projected_qty"],
            as_dict=1)

        # Submit PO
        po = create_purchase_order(item_code="_Test FG Item",
                                   is_subcontracted="Yes")

        bin2 = frappe.db.get_value(
            "Bin",
            filters={
                "warehouse": "_Test Warehouse - _TC",
                "item_code": "_Test Item"
            },
            fieldname=["reserved_qty_for_sub_contract", "projected_qty"],
            as_dict=1)

        self.assertEquals(bin2.reserved_qty_for_sub_contract,
                          bin1.reserved_qty_for_sub_contract + 10)
        self.assertEquals(bin2.projected_qty, bin1.projected_qty - 10)

        # Create stock transfer
        rm_item = [{
            "item_code": "_Test FG Item",
            "rm_item_code": "_Test Item",
            "item_name": "_Test Item",
            "qty": 6,
            "warehouse": "_Test Warehouse - _TC",
            "rate": 100,
            "amount": 600,
            "stock_uom": "Nos"
        }]
        rm_item_string = json.dumps(rm_item)
        se = frappe.get_doc(
            make_subcontract_transfer_entry(po.name, rm_item_string))
        se.to_warehouse = "_Test Warehouse 1 - _TC"
        se.save()
        se.submit()

        bin3 = frappe.db.get_value("Bin",
                                   filters={
                                       "warehouse": "_Test Warehouse - _TC",
                                       "item_code": "_Test Item"
                                   },
                                   fieldname="reserved_qty_for_sub_contract",
                                   as_dict=1)

        self.assertEquals(bin3.reserved_qty_for_sub_contract,
                          bin2.reserved_qty_for_sub_contract - 6)

        # close PO
        po.update_status("Closed")
        bin4 = frappe.db.get_value("Bin",
                                   filters={
                                       "warehouse": "_Test Warehouse - _TC",
                                       "item_code": "_Test Item"
                                   },
                                   fieldname="reserved_qty_for_sub_contract",
                                   as_dict=1)

        self.assertEquals(bin4.reserved_qty_for_sub_contract,
                          bin1.reserved_qty_for_sub_contract)

        # Re-open PO
        po.update_status("Submitted")
        bin5 = frappe.db.get_value("Bin",
                                   filters={
                                       "warehouse": "_Test Warehouse - _TC",
                                       "item_code": "_Test Item"
                                   },
                                   fieldname="reserved_qty_for_sub_contract",
                                   as_dict=1)

        self.assertEquals(bin5.reserved_qty_for_sub_contract,
                          bin2.reserved_qty_for_sub_contract - 6)

        make_stock_entry(target="_Test Warehouse 1 - _TC",
                         item_code="_Test Item",
                         qty=40,
                         basic_rate=100)
        make_stock_entry(target="_Test Warehouse 1 - _TC",
                         item_code="_Test Item Home Desktop 100",
                         qty=40,
                         basic_rate=100)

        # make Purchase Receipt against PO
        pr = make_purchase_receipt(po.name)
        pr.supplier_warehouse = "_Test Warehouse 1 - _TC"
        pr.save()
        pr.submit()

        bin6 = frappe.db.get_value("Bin",
                                   filters={
                                       "warehouse": "_Test Warehouse - _TC",
                                       "item_code": "_Test Item"
                                   },
                                   fieldname="reserved_qty_for_sub_contract",
                                   as_dict=1)

        self.assertEquals(bin6.reserved_qty_for_sub_contract,
                          bin1.reserved_qty_for_sub_contract)

        # Cancel PR
        pr.cancel()
        bin7 = frappe.db.get_value("Bin",
                                   filters={
                                       "warehouse": "_Test Warehouse - _TC",
                                       "item_code": "_Test Item"
                                   },
                                   fieldname="reserved_qty_for_sub_contract",
                                   as_dict=1)

        self.assertEquals(bin7.reserved_qty_for_sub_contract,
                          bin2.reserved_qty_for_sub_contract - 6)

        # Make Purchase Invoice
        pi = make_pi_from_po(po.name)
        pi.update_stock = 1
        pi.supplier_warehouse = "_Test Warehouse 1 - _TC"
        pi.insert()
        pi.submit()
        bin8 = frappe.db.get_value("Bin",
                                   filters={
                                       "warehouse": "_Test Warehouse - _TC",
                                       "item_code": "_Test Item"
                                   },
                                   fieldname="reserved_qty_for_sub_contract",
                                   as_dict=1)

        self.assertEquals(bin8.reserved_qty_for_sub_contract,
                          bin1.reserved_qty_for_sub_contract)

        # Cancel PR
        pi.cancel()
        bin9 = frappe.db.get_value("Bin",
                                   filters={
                                       "warehouse": "_Test Warehouse - _TC",
                                       "item_code": "_Test Item"
                                   },
                                   fieldname="reserved_qty_for_sub_contract",
                                   as_dict=1)

        self.assertEquals(bin9.reserved_qty_for_sub_contract,
                          bin2.reserved_qty_for_sub_contract - 6)

        # Cancel Stock Entry
        se.cancel()
        bin10 = frappe.db.get_value("Bin",
                                    filters={
                                        "warehouse": "_Test Warehouse - _TC",
                                        "item_code": "_Test Item"
                                    },
                                    fieldname="reserved_qty_for_sub_contract",
                                    as_dict=1)

        self.assertEquals(bin10.reserved_qty_for_sub_contract,
                          bin1.reserved_qty_for_sub_contract + 10)

        # Cancel PO
        po.reload()
        po.cancel()
        bin11 = frappe.db.get_value("Bin",
                                    filters={
                                        "warehouse": "_Test Warehouse - _TC",
                                        "item_code": "_Test Item"
                                    },
                                    fieldname="reserved_qty_for_sub_contract",
                                    as_dict=1)

        self.assertEquals(bin11.reserved_qty_for_sub_contract,
                          bin1.reserved_qty_for_sub_contract)