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
