def test_repack_with_change_in_valuation(self): set_perpetual_inventory() make_stock_entry(item_code="_Test Item", target="_Test Warehouse - _TC", qty=50, incoming_rate=100) repack = frappe.copy_doc(test_records[3]) repack.posting_date = nowdate() repack.posting_time = nowtime() repack.additional_operating_cost = 1000.0 repack.insert() repack.submit() stock_in_hand_account = frappe.db.get_value("Account", {"account_type": "Warehouse", "warehouse": repack.get("items")[1].t_warehouse}) rm_stock_value_diff = abs(frappe.db.get_value("Stock Ledger Entry", {"voucher_type": "Stock Entry", "voucher_no": repack.name, "item_code": "_Test Item"}, "stock_value_difference")) fg_stock_value_diff = abs(frappe.db.get_value("Stock Ledger Entry", {"voucher_type": "Stock Entry", "voucher_no": repack.name, "item_code": "_Test Item Home Desktop 100"}, "stock_value_difference")) stock_value_diff = flt(fg_stock_value_diff - rm_stock_value_diff, 2) self.check_gl_entries("Stock Entry", repack.name, sorted([ [stock_in_hand_account, stock_value_diff, 0.0], ["Stock Adjustment - _TC", 0.0, stock_value_diff], ]) ) set_perpetual_inventory(0)
def test_production_order(self): from erpnext.manufacturing.doctype.production_order.production_order \ import make_stock_entry as _make_stock_entry bom_no, bom_operation_cost = frappe.db.get_value("BOM", {"item": "_Test FG Item 2", "is_default": 1, "docstatus": 1}, ["name", "operating_cost"]) production_order = frappe.new_doc("Production Order") production_order.update({ "company": "_Test Company", "fg_warehouse": "_Test Warehouse 1 - _TC", "production_item": "_Test FG Item 2", "bom_no": bom_no, "qty": 1.0, "stock_uom": "_Test UOM", "wip_warehouse": "_Test Warehouse - _TC", "additional_operating_cost": 1000 }) production_order.insert() production_order.submit() make_stock_entry(item_code="_Test Item", target="_Test Warehouse - _TC", qty=50, basic_rate=100) stock_entry = _make_stock_entry(production_order.name, "Manufacture", 1) rm_cost = 0 for d in stock_entry.get("items"): if d.s_warehouse: rm_cost += flt(d.amount) fg_cost = filter(lambda x: x.item_code=="_Test FG Item 2", stock_entry.get("items"))[0].amount self.assertEqual(fg_cost, flt(rm_cost + bom_operation_cost + production_order.additional_operating_cost, 2))
def test_scrap_material_qty(self): prod_order = make_prod_order_test_record(planned_start_date=now(), qty=2) # add raw materials to stores test_stock_entry.make_stock_entry(item_code="_Test Item", target="Stores - _TC", qty=10, basic_rate=5000.0) test_stock_entry.make_stock_entry( item_code="_Test Item Home Desktop 100", target="Stores - _TC", qty=10, basic_rate=1000.0 ) s = frappe.get_doc(make_stock_entry(prod_order.name, "Material Transfer for Manufacture", 2)) for d in s.get("items"): d.s_warehouse = "Stores - _TC" s.insert() s.submit() s = frappe.get_doc(make_stock_entry(prod_order.name, "Manufacture", 2)) s.insert() s.submit() prod_order_details = frappe.db.get_value( "Production Order", prod_order.name, ["scrap_warehouse", "qty", "produced_qty", "bom_no"], as_dict=1 ) scrap_item_details = get_scrap_item_details(prod_order_details.bom_no) self.assertEqual(prod_order_details.produced_qty, 2) for item in s.items: if item.bom_no and item.item_code in scrap_item_details: self.assertEqual(prod_order_details.scrap_warehouse, item.t_warehouse) self.assertEqual(flt(prod_order_details.qty) * flt(scrap_item_details[item.item_code]), item.qty)
def test_reserved_qty_for_production_on_stock_entry(self): test_stock_entry.make_stock_entry(item_code="_Test Item", target= self.warehouse, qty=100, basic_rate=100) test_stock_entry.make_stock_entry(item_code="_Test Item Home Desktop 100", target= self.warehouse, qty=100, basic_rate=100) self.test_reserved_qty_for_production_submit() s = frappe.get_doc(make_stock_entry(self.pro_order.name, "Material Transfer for Manufacture", 2)) s.submit() bin1_on_start_production = get_bin(self.item, self.warehouse) # reserved_qty_for_producion updated self.assertEqual(cint(self.bin1_at_start.reserved_qty_for_production), cint(bin1_on_start_production.reserved_qty_for_production)) # projected qty will now be 2 less (becuase of item movement) self.assertEqual(cint(self.bin1_at_start.projected_qty), cint(bin1_on_start_production.projected_qty) + 2) s = frappe.get_doc(make_stock_entry(self.pro_order.name, "Manufacture", 2)) bin1_on_end_production = get_bin(self.item, self.warehouse) # no change in reserved / projected self.assertEqual(cint(bin1_on_end_production.reserved_qty_for_production), cint(bin1_on_start_production.reserved_qty_for_production)) self.assertEqual(cint(bin1_on_end_production.projected_qty), cint(bin1_on_end_production.projected_qty))
def _test_delivery_note_return(self, item_code, delivered_qty, returned_qty): from erpnext.stock.doctype.delivery_note.test_delivery_note import create_delivery_note from erpnext.stock.doctype.delivery_note.delivery_note import make_sales_invoice make_stock_entry(item_code="_Test Item", target="_Test Warehouse - _TC", qty=50, incoming_rate=100) actual_qty_0 = get_qty_after_transaction() # make a delivery note based on this invoice dn = create_delivery_note(item_code="_Test Item", warehouse="_Test Warehouse - _TC", qty=delivered_qty) actual_qty_1 = get_qty_after_transaction() self.assertEquals(actual_qty_0 - delivered_qty, actual_qty_1) si = make_sales_invoice(dn.name) si.insert() si.submit() # insert and submit stock entry for sales return se = make_stock_entry(item_code="_Test Item", target="_Test Warehouse - _TC", qty=returned_qty, purpose="Sales Return", delivery_note_no=dn.name) actual_qty_2 = get_qty_after_transaction() self.assertEquals(actual_qty_1 + returned_qty, actual_qty_2) return se
def check_planned_qty(self): set_perpetual_inventory(0) planned0 = frappe.db.get_value("Bin", {"item_code": "_Test FG Item", "warehouse": "_Test Warehouse 1 - _TC"}, "planned_qty") or 0 pro_doc = frappe.copy_doc(test_records[0]) pro_doc.insert() pro_doc.submit() # add raw materials to stores test_stock_entry.make_stock_entry("_Test Item", None, "Stores - _TC", 100, 100) test_stock_entry.make_stock_entry("_Test Item Home Desktop 100", None, "Stores - _TC", 100, 100) # from stores to wip s = frappe.get_doc(make_stock_entry(pro_doc.name, "Material Transfer", 4)) for d in s.get("mtn_details"): d.s_warehouse = "Stores - _TC" s.fiscal_year = "_Test Fiscal Year 2013" s.posting_date = "2013-01-02" s.insert() s.submit() # from wip to fg s = frappe.get_doc(make_stock_entry(pro_doc.name, "Manufacture", 4)) s.fiscal_year = "_Test Fiscal Year 2013" s.posting_date = "2013-01-03" s.insert() s.submit() self.assertEqual(frappe.db.get_value("Production Order", pro_doc.name, "produced_qty"), 4) planned1 = frappe.db.get_value("Bin", {"item_code": "_Test FG Item", "warehouse": "_Test Warehouse 1 - _TC"}, "planned_qty") self.assertEqual(planned1 - planned0, 6) return pro_doc
def test_material_issue_gl_entry(self): set_perpetual_inventory() make_stock_entry(item_code="_Test Item", target="_Test Warehouse - _TC", qty=50, basic_rate=100) mi = make_stock_entry(item_code="_Test Item", source="_Test Warehouse - _TC", qty=40) self.check_stock_ledger_entries("Stock Entry", mi.name, [["_Test Item", "_Test Warehouse - _TC", -40.0]]) stock_in_hand_account = frappe.db.get_value("Account", {"account_type": "Warehouse", "warehouse": "_Test Warehouse - _TC"}) stock_value_diff = abs(frappe.db.get_value("Stock Ledger Entry", {"voucher_type": "Stock Entry", "voucher_no": mi.name}, "stock_value_difference")) self.check_gl_entries("Stock Entry", mi.name, sorted([ [stock_in_hand_account, 0.0, stock_value_diff], ["Stock Adjustment - _TC", stock_value_diff, 0.0] ]) ) mi.cancel() self.assertFalse(frappe.db.sql("""select name from `tabStock Ledger Entry` where voucher_type='Stock Entry' and voucher_no=%s""", mi.name)) self.assertFalse(frappe.db.sql("""select name from `tabGL Entry` where voucher_type='Stock Entry' and voucher_no=%s""", mi.name))
def test_repack_no_change_in_valuation(self): set_perpetual_inventory(0) make_stock_entry(item_code="_Test Item", target="_Test Warehouse - _TC", qty=50, basic_rate=100) make_stock_entry( item_code="_Test Item Home Desktop 100", target="_Test Warehouse - _TC", qty=50, basic_rate=100 ) repack = frappe.copy_doc(test_records[3]) repack.posting_date = nowdate() repack.posting_time = nowtime() repack.insert() repack.submit() self.check_stock_ledger_entries( "Stock Entry", repack.name, [ ["_Test Item", "_Test Warehouse - _TC", -50.0], ["_Test Item Home Desktop 100", "_Test Warehouse - _TC", 1], ], ) gl_entries = frappe.db.sql( """select account, debit, credit from `tabGL Entry` where voucher_type='Stock Entry' and voucher_no=%s order by account desc""", repack.name, as_dict=1, ) self.assertFalse(gl_entries) set_perpetual_inventory(0)
def test_fifo(self): frappe.db.set_value("Stock Settings", None, "allow_negative_stock", 1) item_code = "_Test Item 2" warehouse = "_Test Warehouse - _TC" create_stock_reconciliation(item_code="_Test Item 2", warehouse="_Test Warehouse - _TC", qty=0, rate=100) make_stock_entry(item_code=item_code, target=warehouse, qty=1, basic_rate=10) sle = get_sle(item_code=item_code, warehouse=warehouse)[0] self.assertEqual([[1, 10]], eval(sle.stock_queue)) # negative qty make_stock_entry(item_code=item_code, source=warehouse, qty=2, basic_rate=10) sle = get_sle(item_code=item_code, warehouse=warehouse)[0] self.assertEqual([[-1, 10]], eval(sle.stock_queue)) # further negative make_stock_entry(item_code=item_code, source=warehouse, qty=1) sle = get_sle(item_code=item_code, warehouse=warehouse)[0] self.assertEqual([[-2, 10]], eval(sle.stock_queue)) # move stock to positive make_stock_entry(item_code=item_code, target=warehouse, qty=3, basic_rate=20) sle = get_sle(item_code=item_code, warehouse=warehouse)[0] self.assertEqual([[1, 20]], eval(sle.stock_queue)) # incoming entry with diff rate make_stock_entry(item_code=item_code, target=warehouse, qty=1, basic_rate=30) sle = get_sle(item_code=item_code, warehouse=warehouse)[0] self.assertEqual([[1, 20], [1, 30]], eval(sle.stock_queue)) frappe.db.set_default("allow_negative_stock", 0)
def _test_sales_invoice_return(self, item_code, delivered_qty, returned_qty): from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice si = create_sales_invoice(item_code=item_code, qty=delivered_qty) se = make_stock_entry( item_code="_Test Item", target="_Test Warehouse - _TC", qty=returned_qty, purpose="Sales Return", sales_invoice_no=si.name, do_not_save=True, ) self.assertRaises(NotUpdateStockError, se.insert) make_stock_entry(item_code="_Test Item", target="_Test Warehouse - _TC", qty=200, incoming_rate=100) # check currency available qty in bin actual_qty_0 = get_qty_after_transaction() # insert a pos invoice with update stock si = create_sales_invoice(update_stock=1, item_code=item_code, qty=5) # check available bin qty after invoice submission actual_qty_1 = get_qty_after_transaction() self.assertEquals(actual_qty_0 - delivered_qty, actual_qty_1) # check if item is validated se = make_stock_entry( item_code="_Test Item Home Desktop 200", target="_Test Warehouse - _TC", qty=returned_qty, purpose="Sales Return", sales_invoice_no=si.name, do_not_save=True, ) self.assertRaises(frappe.DoesNotExistError, se.insert) # try again se = make_stock_entry( item_code="_Test Item", target="_Test Warehouse - _TC", qty=returned_qty, purpose="Sales Return", sales_invoice_no=si.name, ) # check if available qty is increased actual_qty_2 = get_qty_after_transaction() self.assertEquals(actual_qty_1 + returned_qty, actual_qty_2) return se
def validate_operations(production_order_id, purpose, qty=None): from erpnext.manufacturing.doctype.production_order.production_order import make_stock_entry production_order = frappe.get_doc("Production Order", production_order_id) bom = frappe.get_doc("BOM", production_order.bom_no) if not bom.with_operations or purpose == "Material Transfer": return make_stock_entry(production_order_id, purpose, qty=None) ops = frappe.db.sql("""select status from `tabProduction Operations` where p_order=%s""", production_order_id, as_dict=1) for d in ops: if d.status != "Complete": frappe.throw(_("Please Complete all Production Operations of this Order")) return make_stock_entry(production_order_id, purpose, qty=None)
def test_repack_with_additional_costs(self): set_perpetual_inventory() make_stock_entry(item_code="_Test Item", target="_Test Warehouse - _TC", qty=50, basic_rate=100) repack = frappe.copy_doc(test_records[3]) repack.posting_date = nowdate() repack.posting_time = nowtime() repack.set( "additional_costs", [ {"description": "Actual Oerating Cost", "amount": 1000}, {"description": "additional operating costs", "amount": 200}, ], ) repack.insert() repack.submit() stock_in_hand_account = frappe.db.get_value( "Account", {"account_type": "Warehouse", "warehouse": repack.get("items")[1].t_warehouse} ) rm_stock_value_diff = abs( frappe.db.get_value( "Stock Ledger Entry", {"voucher_type": "Stock Entry", "voucher_no": repack.name, "item_code": "_Test Item"}, "stock_value_difference", ) ) fg_stock_value_diff = abs( frappe.db.get_value( "Stock Ledger Entry", {"voucher_type": "Stock Entry", "voucher_no": repack.name, "item_code": "_Test Item Home Desktop 100"}, "stock_value_difference", ) ) stock_value_diff = flt(fg_stock_value_diff - rm_stock_value_diff, 2) self.assertEqual(stock_value_diff, 1200) self.check_gl_entries( "Stock Entry", repack.name, sorted([[stock_in_hand_account, 1200, 0.0], ["Expenses Included In Valuation - _TC", 0.0, 1200.0]]), ) set_perpetual_inventory(0)
def _test_delivery_note_return_against_sales_order(self, item_code, delivered_qty, returned_qty): from erpnext.selling.doctype.sales_order.sales_order import make_sales_invoice actual_qty_0 = get_qty_after_transaction() so = make_sales_order(qty=50) dn = create_dn_against_so(so.name, delivered_qty) actual_qty_1 = get_qty_after_transaction() self.assertEquals(actual_qty_0 - delivered_qty, actual_qty_1) si = make_sales_invoice(so.name) si.insert() si.submit() # insert and submit stock entry for sales return se = make_stock_entry(item_code="_Test Item", target="_Test Warehouse - _TC", qty=returned_qty, purpose="Sales Return", delivery_note_no=dn.name) actual_qty_2 = get_qty_after_transaction() self.assertEquals(actual_qty_1 + returned_qty, actual_qty_2) return se
def test_purchase_receipt_return(self): actual_qty_0 = get_qty_after_transaction() # submit purchase receipt pr = make_purchase_receipt(item_code="_Test Item", warehouse="_Test Warehouse - _TC", qty=5) actual_qty_1 = get_qty_after_transaction() self.assertEquals(actual_qty_0 + 5, actual_qty_1) pi_doc = make_purchase_invoice(pr.name) pi = frappe.get_doc(pi_doc) pi.posting_date = pr.posting_date pi.credit_to = "_Test Payable - _TC" for d in pi.get("items"): d.expense_account = "_Test Account Cost for Goods Sold - _TC" d.cost_center = "_Test Cost Center - _TC" for d in pi.get("taxes"): d.cost_center = "_Test Cost Center - _TC" pi.insert() pi.submit() # submit purchase return se = make_stock_entry(item_code="_Test Item", source="_Test Warehouse - _TC", qty=5, purpose="Purchase Return", purchase_receipt_no=pr.name) actual_qty_2 = get_qty_after_transaction() self.assertEquals(actual_qty_1 - 5, actual_qty_2) return se, pr.name
def test_variant_production_order(self): bom_no = frappe.db.get_value("BOM", { "item": "_Test Variant Item", "is_default": 1, "docstatus": 1 }) production_order = frappe.new_doc("Production Order") production_order.update({ "company": "_Test Company", "fg_warehouse": "_Test Warehouse 1 - _TC", "production_item": "_Test Variant Item-S", "bom_no": bom_no, "qty": 1.0, "stock_uom": "_Test UOM", "wip_warehouse": "_Test Warehouse - _TC" }) production_order.insert() production_order.submit() from erpnext.manufacturing.doctype.production_order.production_order import make_stock_entry stock_entry = frappe.get_doc( make_stock_entry(production_order.name, "Manufacture", 1)) stock_entry.insert() self.assertTrue( "_Test Variant Item-S" in [d.item_code for d in stock_entry.items])
def test_same_serial_nos_in_repack_or_manufacture_entries(self): s1 = make_serialized_item(target_warehouse="_Test Warehouse - _TC") serial_nos = s1.get("items")[0].serial_no s2 = make_stock_entry( item_code="_Test Serialized Item With Series", source="_Test Warehouse - _TC", qty=2, basic_rate=100, purpose="Repack", serial_no=serial_nos, do_not_save=True, ) s2.append( "items", { "item_code": "_Test Serialized Item", "t_warehouse": "_Test Warehouse - _TC", "qty": 2, "basic_rate": 120, "expense_account": "Stock Adjustment - _TC", "conversion_factor": 1.0, "cost_center": "_Test Cost Center - _TC", "serial_no": serial_nos, }, ) s2.submit() s2.cancel()
def test_material_receipt_gl_entry(self): set_perpetual_inventory() mr = make_stock_entry(item_code="_Test Item", target="_Test Warehouse - _TC", qty=50, basic_rate=100) stock_in_hand_account = frappe.db.get_value("Account", {"account_type": "Warehouse", "warehouse": mr.get("items")[0].t_warehouse}) self.check_stock_ledger_entries("Stock Entry", mr.name, [["_Test Item", "_Test Warehouse - _TC", 50.0]]) self.check_gl_entries("Stock Entry", mr.name, sorted([ [stock_in_hand_account, 5000.0, 0.0], ["Stock Adjustment - _TC", 0.0, 5000.0] ]) ) mr.cancel() self.assertFalse(frappe.db.sql("""select * from `tabStock Ledger Entry` where voucher_type='Stock Entry' and voucher_no=%s""", mr.name)) self.assertFalse(frappe.db.sql("""select * from `tabGL Entry` where voucher_type='Stock Entry' and voucher_no=%s""", mr.name))
def test_purchase_receipt_return(self): actual_qty_0 = get_qty_after_transaction() # submit purchase receipt pr = make_purchase_receipt(item_code="_Test Item", warehouse="_Test Warehouse - _TC", qty=5) actual_qty_1 = get_qty_after_transaction() self.assertEquals(actual_qty_0 + 5, actual_qty_1) pi_doc = make_purchase_invoice(pr.name) pi = frappe.get_doc(pi_doc) pi.posting_date = pr.posting_date pi.credit_to = "_Test Payable - _TC" for d in pi.get("items"): d.expense_account = "_Test Account Cost for Goods Sold - _TC" d.cost_center = "_Test Cost Center - _TC" for d in pi.get("taxes"): d.cost_center = "_Test Cost Center - _TC" pi.insert() pi.submit() # submit purchase return se = make_stock_entry(item_code="_Test Item", source="_Test Warehouse - _TC", qty=5, purpose="Purchase Return", purchase_receipt_no=pr.name) actual_qty_2 = get_qty_after_transaction() self.assertEquals(actual_qty_1 - 5, actual_qty_2) return se, pr.name
def _test_delivery_note_return_against_sales_order(self, item_code, delivered_qty, returned_qty): from erpnext.selling.doctype.sales_order.sales_order import make_sales_invoice actual_qty_0 = get_qty_after_transaction() so = make_sales_order(qty=50) dn = create_dn_against_so(so.name, delivered_qty) actual_qty_1 = get_qty_after_transaction() self.assertEquals(actual_qty_0 - delivered_qty, actual_qty_1) si = make_sales_invoice(so.name) si.insert() si.submit() # insert and submit stock entry for sales return se = make_stock_entry( item_code="_Test Item", target="_Test Warehouse - _TC", qty=returned_qty, purpose="Sales Return", delivery_note_no=dn.name, ) actual_qty_2 = get_qty_after_transaction() self.assertEquals(actual_qty_1 + returned_qty, actual_qty_2) return se
def _test_purchase_return_return_against_purchase_order(self): actual_qty_0 = get_qty_after_transaction() from erpnext.buying.doctype.purchase_order.test_purchase_order import ( test_records as purchase_order_test_records, ) from erpnext.buying.doctype.purchase_order.purchase_order import make_purchase_receipt, make_purchase_invoice # submit purchase receipt po = frappe.copy_doc(purchase_order_test_records[0]) po.transaction_date = nowdate() po.is_subcontracted = None po.get("items")[0].item_code = "_Test Item" po.get("items")[0].rate = 50 po.insert() po.submit() pr_doc = make_purchase_receipt(po.name) pr = frappe.get_doc(pr_doc) pr.posting_date = po.transaction_date pr.insert() pr.submit() actual_qty_1 = get_qty_after_transaction() self.assertEquals(actual_qty_0 + 10, actual_qty_1) pi_doc = make_purchase_invoice(po.name) pi = frappe.get_doc(pi_doc) pi.posting_date = pr.posting_date pi.credit_to = "_Test Payable - _TC" for d in pi.get("items"): d.expense_account = "_Test Account Cost for Goods Sold - _TC" d.cost_center = "_Test Cost Center - _TC" for d in pi.get("taxes"): d.cost_center = "_Test Cost Center - _TC" pi.run_method("calculate_taxes_and_totals") pi.bill_no = "NA" pi.insert() pi.submit() # submit purchase return se = make_stock_entry( item_code="_Test Item", source="_Test Warehouse - _TC", qty=5, purpose="Purchase Return", purchase_receipt_no=pr.name, ) actual_qty_2 = get_qty_after_transaction() self.assertEquals(actual_qty_1 - 5, actual_qty_2) return se, pr.name
def test_material_transfer_gl_entry(self): set_perpetual_inventory() create_stock_reconciliation(qty=100, rate=100) mtn = make_stock_entry(item_code="_Test Item", source="_Test Warehouse - _TC", target="_Test Warehouse 1 - _TC", qty=45) self.check_stock_ledger_entries("Stock Entry", mtn.name, [["_Test Item", "_Test Warehouse - _TC", -45.0], ["_Test Item", "_Test Warehouse 1 - _TC", 45.0]]) stock_in_hand_account = frappe.db.get_value("Account", {"account_type": "Warehouse", "warehouse": mtn.get("items")[0].s_warehouse}) fixed_asset_account = frappe.db.get_value("Account", {"account_type": "Warehouse", "warehouse": mtn.get("items")[0].t_warehouse}) stock_value_diff = abs(frappe.db.get_value("Stock Ledger Entry", {"voucher_type": "Stock Entry", "voucher_no": mtn.name, "warehouse": "_Test Warehouse - _TC"}, "stock_value_difference")) self.check_gl_entries("Stock Entry", mtn.name, sorted([ [stock_in_hand_account, 0.0, stock_value_diff], [fixed_asset_account, stock_value_diff, 0.0], ]) ) mtn.cancel() self.assertFalse(frappe.db.sql("""select * from `tabStock Ledger Entry` where voucher_type='Stock Entry' and voucher_no=%s""", mtn.name)) self.assertFalse(frappe.db.sql("""select * from `tabGL Entry` where voucher_type='Stock Entry' and voucher_no=%s""", mtn.name))
def _test_purchase_return_return_against_purchase_order(self): actual_qty_0 = get_qty_after_transaction() from erpnext.buying.doctype.purchase_order.test_purchase_order \ import test_records as purchase_order_test_records from erpnext.buying.doctype.purchase_order.purchase_order import \ make_purchase_receipt, make_purchase_invoice # submit purchase receipt po = frappe.copy_doc(purchase_order_test_records[0]) po.transaction_date = nowdate() po.is_subcontracted = None po.get("items")[0].item_code = "_Test Item" po.get("items")[0].rate = 50 po.insert() po.submit() pr_doc = make_purchase_receipt(po.name) pr = frappe.get_doc(pr_doc) pr.posting_date = po.transaction_date pr.insert() pr.submit() actual_qty_1 = get_qty_after_transaction() self.assertEquals(actual_qty_0 + 10, actual_qty_1) pi_doc = make_purchase_invoice(po.name) pi = frappe.get_doc(pi_doc) pi.posting_date = pr.posting_date pi.credit_to = "_Test Payable - _TC" for d in pi.get("items"): d.expense_account = "_Test Account Cost for Goods Sold - _TC" d.cost_center = "_Test Cost Center - _TC" for d in pi.get("taxes"): d.cost_center = "_Test Cost Center - _TC" pi.run_method("calculate_taxes_and_totals") pi.bill_no = "NA" pi.insert() pi.submit() # submit purchase return se = make_stock_entry(item_code="_Test Item", source="_Test Warehouse - _TC", qty=5, purpose="Purchase Return", purchase_receipt_no=pr.name) actual_qty_2 = get_qty_after_transaction() self.assertEquals(actual_qty_1 - 5, actual_qty_2) return se, pr.name
def check_planned_qty(self): set_perpetual_inventory(0) planned0 = ( frappe.db.get_value( "Bin", {"item_code": "_Test FG Item", "warehouse": "_Test Warehouse 1 - _TC"}, "planned_qty" ) or 0 ) pro_order = make_prod_order_test_record() planned1 = frappe.db.get_value( "Bin", {"item_code": "_Test FG Item", "warehouse": "_Test Warehouse 1 - _TC"}, "planned_qty" ) self.assertEqual(planned1, planned0 + 10) # add raw materials to stores test_stock_entry.make_stock_entry(item_code="_Test Item", target="Stores - _TC", qty=100, basic_rate=100) test_stock_entry.make_stock_entry( item_code="_Test Item Home Desktop 100", target="Stores - _TC", qty=100, basic_rate=100 ) # from stores to wip s = frappe.get_doc(make_stock_entry(pro_order.name, "Material Transfer for Manufacture", 4)) for d in s.get("items"): d.s_warehouse = "Stores - _TC" s.insert() s.submit() # from wip to fg s = frappe.get_doc(make_stock_entry(pro_order.name, "Manufacture", 4)) s.insert() s.submit() self.assertEqual(frappe.db.get_value("Production Order", pro_order.name, "produced_qty"), 4) planned2 = frappe.db.get_value( "Bin", {"item_code": "_Test FG Item", "warehouse": "_Test Warehouse 1 - _TC"}, "planned_qty" ) self.assertEqual(planned2, planned0 + 6) return pro_order
def test_over_stock_return(self): from erpnext.stock.doctype.stock_entry.stock_entry import StockOverReturnError # out of 10, 5 gets returned prev_se, pr_docname = self.test_purchase_receipt_return() se = make_stock_entry(item_code="_Test Item", source="_Test Warehouse - _TC", qty=6, purpose="Purchase Return", purchase_receipt_no=pr_docname, do_not_save=True) self.assertRaises(StockOverReturnError, se.insert)
def test_over_production(self): from erpnext.manufacturing.doctype.production_order.production_order import StockOverProductionError pro_doc = self.test_planned_qty() test_stock_entry.make_stock_entry("_Test Item", None, "_Test Warehouse - _TC", 100, 100) test_stock_entry.make_stock_entry("_Test Item Home Desktop 100", None, "_Test Warehouse - _TC", 100, 100) s = frappe.get_doc(make_stock_entry(pro_doc.name, "Manufacture", 7)) s.insert() self.assertRaises(StockOverProductionError, s.submit)
def test_production_order(self): bom_no, bom_operation_cost = frappe.db.get_value( "BOM", {"item": "_Test FG Item 2", "is_default": 1, "docstatus": 1}, ["name", "operating_cost"] ) production_order = frappe.new_doc("Production Order") production_order.update( { "company": "_Test Company", "fg_warehouse": "_Test Warehouse 1 - _TC", "production_item": "_Test FG Item 2", "bom_no": bom_no, "qty": 1.0, "stock_uom": "_Test UOM", "wip_warehouse": "_Test Warehouse - _TC", } ) production_order.insert() production_order.submit() make_stock_entry(item_code="_Test Item", target="_Test Warehouse - _TC", qty=50, incoming_rate=100) stock_entry = frappe.new_doc("Stock Entry") stock_entry.update( { "purpose": "Manufacture", "production_order": production_order.name, "bom_no": bom_no, "fg_completed_qty": "1", "additional_operating_cost": 1000, } ) stock_entry.get_items() rm_cost = 0 for d in stock_entry.get("items"): if d.s_warehouse: rm_cost += flt(d.amount) fg_cost = filter(lambda x: x.item_code == "_Test FG Item 2", stock_entry.get("items"))[0].amount self.assertEqual(fg_cost, flt(rm_cost + bom_operation_cost + stock_entry.additional_operating_cost, 2))
def test_over_production(self): from erpnext.manufacturing.doctype.production_order.production_order import StockOverProductionError pro_doc = self.check_planned_qty() test_stock_entry.make_stock_entry(item_code="_Test Item", target="_Test Warehouse - _TC", qty=100, incoming_rate=100) test_stock_entry.make_stock_entry(item_code="_Test Item Home Desktop 100", target="_Test Warehouse - _TC", qty=100, incoming_rate=100) s = frappe.get_doc(make_stock_entry(pro_doc.name, "Manufacture", 7)) s.fiscal_year = "_Test Fiscal Year 2013" s.posting_date = "2013-01-04" s.insert() self.assertRaises(StockOverProductionError, s.submit)
def _test_delivery_note_return(self, item_code, delivered_qty, returned_qty): from erpnext.stock.doctype.delivery_note.test_delivery_note import create_delivery_note from erpnext.stock.doctype.delivery_note.delivery_note import make_sales_invoice make_stock_entry(item_code="_Test Item", target="_Test Warehouse - _TC", qty=50, incoming_rate=100) actual_qty_0 = get_qty_after_transaction() # make a delivery note based on this invoice dn = create_delivery_note(item_code="_Test Item", warehouse="_Test Warehouse - _TC", qty=delivered_qty) actual_qty_1 = get_qty_after_transaction() self.assertEquals(actual_qty_0 - delivered_qty, actual_qty_1) si = make_sales_invoice(dn.name) si.insert() si.submit() # insert and submit stock entry for sales return se = make_stock_entry(item_code="_Test Item", target="_Test Warehouse - _TC", qty=returned_qty, purpose="Sales Return", delivery_note_no=dn.name) actual_qty_2 = get_qty_after_transaction() self.assertEquals(actual_qty_1 + returned_qty, actual_qty_2) return se
def make_stock_entry_from_pro(pro_id, purpose, current_date): from erpnext.manufacturing.doctype.production_order.production_order import make_stock_entry from erpnext.stock.stock_ledger import NegativeStockError from erpnext.stock.doctype.stock_entry.stock_entry import IncorrectValuationRateError, \ DuplicateEntryForProductionOrderError, OperationsNotCompleteError try: st = frappe.get_doc(make_stock_entry(pro_id, purpose)) st.posting_date = current_date st.fiscal_year = cstr(current_date.year) for d in st.get("items"): d.cost_center = "Main - " + settings.company_abbr st.insert() frappe.db.commit() st.submit() frappe.db.commit() except (NegativeStockError, IncorrectValuationRateError, DuplicateEntryForProductionOrderError, OperationsNotCompleteError): frappe.db.rollback()
def make_stock_entry_from_pro(pro_id, purpose, current_date): from erpnext.manufacturing.doctype.production_order.production_order import make_stock_entry from erpnext.stock.stock_ledger import NegativeStockError from erpnext.stock.doctype.stock_entry.stock_entry import IncorrectValuationRateError, DuplicateEntryForProductionOrderError try: st = frappe.get_doc(make_stock_entry(pro_id, purpose)) st.posting_date = current_date st.fiscal_year = cstr(current_date.year) for d in st.get("mtn_details"): d.expense_account = "Stock Adjustment - " + company_abbr d.cost_center = "Main - " + company_abbr st.insert() frappe.db.commit() st.submit() frappe.db.commit() except NegativeStockError: pass except IncorrectValuationRateError: pass except DuplicateEntryForProductionOrderError: pass
def test_variant_production_order(self): bom_no = frappe.db.get_value("BOM", {"item": "_Test Variant Item", "is_default": 1, "docstatus": 1}) production_order = frappe.new_doc("Production Order") production_order.update({ "company": "_Test Company", "fg_warehouse": "_Test Warehouse 1 - _TC", "production_item": "_Test Variant Item-S", "bom_no": bom_no, "qty": 1.0, "stock_uom": "_Test UOM", "wip_warehouse": "_Test Warehouse - _TC" }) production_order.insert() production_order.submit() from erpnext.manufacturing.doctype.production_order.production_order import make_stock_entry stock_entry = frappe.get_doc(make_stock_entry(production_order.name, "Manufacture", 1)) stock_entry.insert() self.assertTrue("_Test Variant Item-S" in [d.item_code for d in stock_entry.items])
def make_stock_entry_from_pro(pro_id, purpose, current_date): from erpnext.manufacturing.doctype.production_order.production_order import make_stock_entry from erpnext.stock.stock_ledger import NegativeStockError from erpnext.stock.doctype.stock_entry.stock_entry import IncorrectValuationRateError, DuplicateEntryForProductionOrderError try: st = frappe.get_doc(make_stock_entry(pro_id, purpose)) st.posting_date = current_date st.fiscal_year = cstr(current_date.year) for d in st.get("mtn_details"): d.expense_account = "库存调整 - " + company_abbr d.cost_center = "主要的 - " + company_abbr st.insert() frappe.db.commit() st.submit() frappe.db.commit() except NegativeStockError: pass except IncorrectValuationRateError: pass except DuplicateEntryForProductionOrderError: pass