def test_allow_negative_for_batch(self):
from erpnext.stock.doctype.stock_entry.test_stock_entry import make_stock_entry
item_code = "Stock-Reco-batch-Item-5"
warehouse = "_Test Warehouse for Stock Reco5 - _TC"
create_warehouse("_Test Warehouse for Stock Reco5", {"is_group": 0,
"parent_warehouse": "_Test Warehouse Group - _TC", "company": "_Test Company"})
batch_item_doc = create_item(item_code, is_stock_item=1)
if not batch_item_doc.has_batch_no:
frappe.db.set_value("Item", item_code, {
"has_batch_no": 1,
"create_new_batch": 1,
"batch_number_series": "Test-C.####"
})
ste1=make_stock_entry(posting_date="2020-10-07", posting_time="02:00", item_code=item_code,
target=warehouse, qty=2, basic_rate=100)
batch_no = ste1.items[0].batch_no
ste2=make_stock_entry(posting_date="2020-10-09", posting_time="02:00", item_code=item_code,
source=warehouse, qty=2, basic_rate=100, batch_no=batch_no)
sr = create_stock_reconciliation(item_code=item_code,
warehouse = warehouse, batch_no=batch_no, rate=200)
for doc in [sr, ste2, ste1]:
doc.cancel()
frappe.delete_doc(doc.doctype, doc.name)
def test_raise_extra_transfer_materials(self):
from erpnext.stock.doctype.warehouse.test_warehouse import create_warehouse
warehouse = "_Test Warehouse FG 1 - _TC"
if not frappe.db.exists('Warehouse', warehouse):
create_warehouse("_Test Warehouse FG 1")
outward_entry = make_stock_entry(item_code="_Test Item",
purpose="Send to Warehouse",
source="_Test Warehouse - _TC",
target="_Test Warehouse 1 - _TC",
qty=50,
basic_rate=100)
inward_entry1 = make_stock_in_entry(outward_entry.name)
inward_entry1.items[0].t_warehouse = warehouse
inward_entry1.items[0].qty = 25
inward_entry1.submit()
inward_entry2 = make_stock_in_entry(outward_entry.name)
inward_entry2.items[0].t_warehouse = warehouse
inward_entry2.items[0].qty = 35
self.assertRaises(ExtraMaterialReceived, inward_entry2.submit)
print(inward_entry2.name)
def test_get_items(self):
create_warehouse(
"_Test Warehouse Group 1", {
"is_group": 1,
"company": "_Test Company",
"parent_warehouse": "All Warehouses - _TC"
})
create_warehouse(
"_Test Warehouse Ledger 1", {
"is_group": 0,
"parent_warehouse": "_Test Warehouse Group 1 - _TC",
"company": "_Test Company"
})
create_item("_Test Stock Reco Item",
is_stock_item=1,
valuation_rate=100,
warehouse="_Test Warehouse Ledger 1 - _TC",
opening_stock=100)
items = get_items("_Test Warehouse Group 1 - _TC", nowdate(),
nowtime(), "_Test Company")
self.assertEqual(
["_Test Stock Reco Item", "_Test Warehouse Ledger 1 - _TC", 100],
[items[0]["item_code"], items[0]["warehouse"], items[0]["qty"]])
def test_goods_in_transit(self):
from erpnext.stock.doctype.warehouse.test_warehouse import create_warehouse
warehouse = "_Test Warehouse FG 1 - _TC"
if not frappe.db.exists('Warehouse', warehouse):
create_warehouse("_Test Warehouse FG 1")
outward_entry = make_stock_entry(item_code="_Test Item",
purpose="Send to Warehouse",
source="_Test Warehouse - _TC",
target="_Test Warehouse 1 - _TC",
qty=50,
basic_rate=100)
inward_entry1 = make_stock_in_entry(outward_entry.name)
inward_entry1.items[0].t_warehouse = warehouse
inward_entry1.items[0].qty = 25
inward_entry1.submit()
doc = frappe.get_doc('Stock Entry', outward_entry.name)
self.assertEqual(doc.per_transferred, 50)
inward_entry2 = make_stock_in_entry(outward_entry.name)
inward_entry2.items[0].t_warehouse = warehouse
inward_entry2.items[0].qty = 25
inward_entry2.submit()
doc = frappe.get_doc('Stock Entry', outward_entry.name)
self.assertEqual(doc.per_transferred, 100)
def create_batch_or_serial_no_items():
create_warehouse("_Test Warehouse for Stock Reco1", {
"is_group": 0,
"parent_warehouse": "_Test Warehouse Group - _TC"
})
create_warehouse("_Test Warehouse for Stock Reco2", {
"is_group": 0,
"parent_warehouse": "_Test Warehouse Group - _TC"
})
serial_item_doc = create_item("Stock-Reco-Serial-Item-1", is_stock_item=1)
if not serial_item_doc.has_serial_no:
serial_item_doc.has_serial_no = 1
serial_item_doc.serial_no_series = "SRSI.####"
serial_item_doc.save(ignore_permissions=True)
serial_item_doc = create_item("Stock-Reco-Serial-Item-2", is_stock_item=1)
if not serial_item_doc.has_serial_no:
serial_item_doc.has_serial_no = 1
serial_item_doc.serial_no_series = "SRSII.####"
serial_item_doc.save(ignore_permissions=True)
batch_item_doc = create_item("Stock-Reco-batch-Item-1", is_stock_item=1)
if not batch_item_doc.has_batch_no:
batch_item_doc.has_batch_no = 1
batch_item_doc.create_new_batch = 1
serial_item_doc.batch_number_series = "BASR.#####"
batch_item_doc.save(ignore_permissions=True)
def make_item(item_code, properties=None):
if frappe.db.exists("Item", item_code):
return frappe.get_doc("Item", item_code)
item = frappe.get_doc({
"doctype": "Item",
"item_code": item_code,
"item_name": item_code,
"description": item_code,
"is_sales_item": 1,
"item_group": "Products"
})
if properties:
item.update(properties)
if item.is_stock_item:
warehouse = "_Test Warehouse - _TC"
for item_default in [
doc for doc in item.get("item_defaults")
if not doc.default_warehouse
]:
item_default.default_warehouse = warehouse
item_default.company = "_Test Company"
if not frappe.db.exists('Warehouse', warehouse):
create_warehouse(warehouse)
item.insert()
return item
def test_retain_sample(self):
from erpnext.stock.doctype.warehouse.test_warehouse import create_warehouse
from erpnext.stock.doctype.batch.batch import get_batch_qty
create_warehouse("Test Warehouse for Sample Retention")
frappe.db.set_value("Stock Settings", None, "sample_retention_warehouse", "Test Warehouse for Sample Retention - _TC")
test_item_code = "Retain Sample Item"
if not frappe.db.exists('Item', test_item_code):
item = frappe.new_doc("Item")
item.item_code = test_item_code
item.item_name = "Retain Sample Item"
item.description = "Retain Sample Item"
item.item_group = "All Item Groups"
item.is_stock_item = 1
item.has_batch_no = 1
item.create_new_batch = 1
item.retain_sample = 1
item.sample_quantity = 4
item.save()
receipt_entry = frappe.new_doc("Stock Entry")
receipt_entry.company = "_Test Company"
receipt_entry.purpose = "Material Receipt"
receipt_entry.append("items", {
"item_code": test_item_code,
"t_warehouse": "_Test Warehouse - _TC",
"qty": 40,
"basic_rate": 12,
"cost_center": "_Test Cost Center - _TC",
"sample_quantity": 4
})
receipt_entry.set_stock_entry_type()
receipt_entry.insert()
receipt_entry.submit()
retention_data = move_sample_to_retention_warehouse(receipt_entry.company, receipt_entry.get("items"))
retention_entry = frappe.new_doc("Stock Entry")
retention_entry.company = retention_data.company
retention_entry.purpose = retention_data.purpose
retention_entry.append("items", {
"item_code": test_item_code,
"t_warehouse": "Test Warehouse for Sample Retention - _TC",
"s_warehouse": "_Test Warehouse - _TC",
"qty": 4,
"basic_rate": 12,
"cost_center": "_Test Cost Center - _TC",
"batch_no": receipt_entry.get("items")[0].batch_no
})
retention_entry.set_stock_entry_type()
retention_entry.insert()
retention_entry.submit()
qty_in_usable_warehouse = get_batch_qty(receipt_entry.get("items")[0].batch_no, "_Test Warehouse - _TC", "_Test Item")
qty_in_retention_warehouse = get_batch_qty(receipt_entry.get("items")[0].batch_no, "Test Warehouse for Sample Retention - _TC", "_Test Item")
self.assertEqual(qty_in_usable_warehouse, 36)
self.assertEqual(qty_in_retention_warehouse, 4)
def test_get_items(self):
create_warehouse("_Test Warehouse Group 1", {"is_group": 1})
create_warehouse("_Test Warehouse Ledger 1", {"is_group": 0, "parent_warehouse": "_Test Warehouse Group 1 - _TC"})
make_item("_Test Stock Reco Item", {"default_warehouse": "_Test Warehouse Ledger 1 - _TC",
"is_stock_item": 1, "opening_stock": 100, "valuation_rate": 100})
items = get_items("_Test Warehouse Group 1 - _TC", nowdate(), nowtime())
self.assertEqual(["_Test Stock Reco Item", "_Test Warehouse Ledger 1 - _TC", 100],
[items[0]["item_code"], items[0]["warehouse"], items[0]["qty"]])
def test_retain_sample(self):
from erpnext.stock.doctype.warehouse.test_warehouse import create_warehouse
from erpnext.stock.doctype.batch.batch import get_batch_qty
create_warehouse("Test Warehouse for Sample Retention")
frappe.db.set_value("Stock Settings", None, "sample_retention_warehouse", "Test Warehouse for Sample Retention - _TC")
item = frappe.new_doc("Item")
item.item_code = "Retain Sample Item"
item.item_name = "Retain Sample Item"
item.description = "Retain Sample Item"
item.item_group = "All Item Groups"
item.is_stock_item = 1
item.has_batch_no = 1
item.create_new_batch = 1
item.retain_sample = 1
item.sample_quantity = 4
item.save()
receipt_entry = frappe.new_doc("Stock Entry")
receipt_entry.company = "_Test Company"
receipt_entry.purpose = "Material Receipt"
receipt_entry.append("items", {
"item_code": item.item_code,
"t_warehouse": "_Test Warehouse - _TC",
"qty": 40,
"basic_rate": 12,
"cost_center": "_Test Cost Center - _TC",
"sample_quantity": 4
})
receipt_entry.insert()
receipt_entry.submit()
retention_data = move_sample_to_retention_warehouse(receipt_entry.company, receipt_entry.get("items"))
retention_entry = frappe.new_doc("Stock Entry")
retention_entry.company = retention_data.company
retention_entry.purpose = retention_data.purpose
retention_entry.append("items", {
"item_code": item.item_code,
"t_warehouse": "Test Warehouse for Sample Retention - _TC",
"s_warehouse": "_Test Warehouse - _TC",
"qty": 4,
"basic_rate": 12,
"cost_center": "_Test Cost Center - _TC",
"batch_no": receipt_entry.get("items")[0].batch_no
})
retention_entry.insert()
retention_entry.submit()
qty_in_usable_warehouse = get_batch_qty(receipt_entry.get("items")[0].batch_no, "_Test Warehouse - _TC", "_Test Item")
qty_in_retention_warehouse = get_batch_qty(receipt_entry.get("items")[0].batch_no, "Test Warehouse for Sample Retention - _TC", "_Test Item")
self.assertEquals(qty_in_usable_warehouse, 36)
self.assertEquals(qty_in_retention_warehouse, 4)
def test_get_items(self):
create_warehouse("_Test Warehouse Group 1", {"is_group": 1})
create_warehouse("_Test Warehouse Ledger 1",
{"is_group": 0, "parent_warehouse": "_Test Warehouse Group 1 - _TC"})
create_item("_Test Stock Reco Item", is_stock_item=1, valuation_rate=100,
warehouse="_Test Warehouse Ledger 1 - _TC", opening_stock=100)
items = get_items("_Test Warehouse Group 1 - _TC", nowdate(), nowtime(), "_Test Company")
self.assertEqual(["_Test Stock Reco Item", "_Test Warehouse Ledger 1 - _TC", 100],
[items[0]["item_code"], items[0]["warehouse"], items[0]["qty"]])
def test_stock_transfer_from_purchase_receipt_with_valuation(self):
create_warehouse(
"_Test Warehouse for Valuation",
company="_Test Company with perpetual inventory",
properties={"account": '_Test Account Stock In Hand - TCP1'})
pr1 = make_purchase_receipt(
warehouse='_Test Warehouse for Valuation - TCP1',
company="_Test Company with perpetual inventory")
pr = make_purchase_receipt(
company="_Test Company with perpetual inventory",
warehouse="Stores - TCP1",
do_not_save=1)
pr.items[0].from_warehouse = '_Test Warehouse for Valuation - TCP1'
pr.supplier_warehouse = ''
pr.append(
'taxes', {
'charge_type': 'On Net Total',
'account_head': '_Test Account Shipping Charges - TCP1',
'category': 'Valuation and Total',
'cost_center': 'Main - TCP1',
'description': 'Test',
'rate': 9
})
pr.submit()
gl_entries = get_gl_entries('Purchase Receipt', pr.name)
sl_entries = get_sl_entries('Purchase Receipt', pr.name)
expected_gle = [['Stock In Hand - TCP1', 272.5, 0.0],
['_Test Account Stock In Hand - TCP1', 0.0, 250.0],
['_Test Account Shipping Charges - TCP1', 0.0, 22.5]]
expected_sle = {
'_Test Warehouse for Valuation - TCP1': -5,
'Stores - TCP1': 5
}
for sle in sl_entries:
self.assertEqual(expected_sle[sle.warehouse], sle.actual_qty)
for i, gle in enumerate(gl_entries):
self.assertEqual(gle.account, expected_gle[i][0])
self.assertEqual(gle.debit, expected_gle[i][1])
self.assertEqual(gle.credit, expected_gle[i][2])
pr.cancel()
pr1.cancel()
def test_stock_reco_for_same_item_with_multiple_batches(self):
from erpnext.stock.doctype.stock_entry.test_stock_entry import make_stock_entry
set_perpetual_inventory()
item_code = "Stock-Reco-batch-Item-2"
warehouse = "_Test Warehouse for Stock Reco3 - _TC"
create_warehouse("_Test Warehouse for Stock Reco3", {"is_group": 0,
"parent_warehouse": "_Test Warehouse Group - _TC", "company": "_Test Company"})
batch_item_doc = create_item(item_code, is_stock_item=1)
if not batch_item_doc.has_batch_no:
frappe.db.set_value("Item", item_code, {
"has_batch_no": 1,
"create_new_batch": 1,
"batch_number_series": "Test-C.####"
})
# inward entries with different batch and valuation rate
ste1=make_stock_entry(posting_date="2012-12-15", posting_time="02:00", item_code=item_code,
target=warehouse, qty=6, basic_rate=700)
ste2=make_stock_entry(posting_date="2012-12-16", posting_time="02:00", item_code=item_code,
target=warehouse, qty=3, basic_rate=200)
ste3=make_stock_entry(posting_date="2012-12-17", posting_time="02:00", item_code=item_code,
target=warehouse, qty=2, basic_rate=500)
ste4=make_stock_entry(posting_date="2012-12-17", posting_time="02:00", item_code=item_code,
target=warehouse, qty=4, basic_rate=100)
batchwise_item_details = {}
for stock_doc in [ste1, ste2, ste3, ste4]:
self.assertEqual(item_code, stock_doc.items[0].item_code)
batchwise_item_details[stock_doc.items[0].batch_no] = [stock_doc.items[0].qty, 0.01]
stock_balance = frappe.get_all("Stock Ledger Entry",
filters = {"item_code": item_code, "warehouse": warehouse},
fields=["sum(stock_value_difference)"], as_list=1)
self.assertEqual(flt(stock_balance[0][0]), 6200.00)
sr = create_stock_reconciliation(item_code=item_code,
warehouse = warehouse, batch_details = batchwise_item_details)
stock_balance = frappe.get_all("Stock Ledger Entry",
filters = {"item_code": item_code, "warehouse": warehouse},
fields=["sum(stock_value_difference)"], as_list=1)
self.assertEqual(flt(stock_balance[0][0]), 0.15)
for doc in [sr, ste1, ste2, ste3, ste4]:
doc.cancel()
frappe.delete_doc(doc.doctype, doc.name)
def test_resered_qty_for_partial_completion(self):
item = "_Test Item"
warehouse = create_warehouse("Test Warehouse for reserved_qty - _TC")
bin1_at_start = get_bin(item, warehouse)
# reset to correct value
bin1_at_start.update_reserved_qty_for_production()
wo_order = make_wo_order_test_record(item="_Test FG Item", qty=2,
source_warehouse=warehouse, skip_transfer=1)
bin1_on_submit = get_bin(item, warehouse)
# reserved qty for production is updated
self.assertEqual(cint(bin1_at_start.reserved_qty_for_production) + 2,
cint(bin1_on_submit.reserved_qty_for_production))
test_stock_entry.make_stock_entry(item_code="_Test Item",
target=warehouse, qty=100, basic_rate=100)
test_stock_entry.make_stock_entry(item_code="_Test Item Home Desktop 100",
target=warehouse, qty=100, basic_rate=100)
s = frappe.get_doc(make_stock_entry(wo_order.name, "Manufacture", 1))
s.submit()
bin1_at_completion = get_bin(item, warehouse)
self.assertEqual(cint(bin1_at_completion.reserved_qty_for_production),
cint(bin1_on_submit.reserved_qty_for_production) - 1)
def test_valuation_rate_missing_on_make_stock_entry(self):
item_name = 'Test Valuation Rate Missing'
rm_item = '_Test raw material item'
make_item(item_name, {
"is_stock_item": 1,
"include_item_in_manufacturing": 1,
})
make_item('_Test raw material item', {
"is_stock_item": 1,
"include_item_in_manufacturing": 1,
})
if not frappe.db.get_value('BOM', {'item': item_name}):
make_bom(item=item_name, raw_materials=[rm_item], rm_qty=1)
company = "_Test Company with perpetual inventory"
source_warehouse = create_warehouse(
"Test Valuation Rate Missing Warehouse", company=company)
wo = make_wo_order_test_record(item=item_name,
qty=1,
source_warehouse=source_warehouse,
company=company)
self.assertRaises(frappe.ValidationError, make_stock_entry, wo.name,
'Material Transfer for Manufacture')
def test_inter_company_transfer(self):
se = make_serialized_item(target_warehouse="_Test Warehouse - _TC")
serial_nos = get_serial_nos(se.get("items")[0].serial_no)
dn = create_delivery_note(
item_code="_Test Serialized Item With Series",
qty=1,
serial_no=serial_nos[0])
serial_no = frappe.get_doc("Serial No", serial_nos[0])
# check Serial No details after delivery
self.assertEqual(serial_no.status, "Delivered")
self.assertEqual(serial_no.warehouse, None)
self.assertEqual(serial_no.company, "_Test Company")
self.assertEqual(serial_no.delivery_document_type, "Delivery Note")
self.assertEqual(serial_no.delivery_document_no, dn.name)
wh = create_warehouse("_Test Warehouse", company="_Test Company 1")
pr = make_purchase_receipt(
item_code="_Test Serialized Item With Series",
qty=1,
serial_no=serial_nos[0],
company="_Test Company 1",
warehouse=wh)
serial_no.reload()
# check Serial No details after purchase in second company
self.assertEqual(serial_no.status, "Active")
self.assertEqual(serial_no.warehouse, wh)
self.assertEqual(serial_no.company, "_Test Company 1")
self.assertEqual(serial_no.purchase_document_type, "Purchase Receipt")
self.assertEqual(serial_no.purchase_document_no, pr.name)
def test_get_items(self):
from erpnext.stock.doctype.stock_entry.test_stock_entry import make_stock_entry
create_warehouse("_Test Warehouse Group", {"is_group": 0})
create_warehouse("_Test Warehouse Ledger 1",
{"is_group": 0, "parent_warehouse": "_Test Warehouse Group - _TC"})
create_item("_Test Stock Reco Item", is_stock_item=1, valuation_rate=100,
warehouse="_Test Warehouse Ledger 1 - _TC", create_new_batch=1, has_batch_no=1)
make_stock_entry(posting_date="2012-12-15", posting_time="02:00", item_code="_Test Stock Reco Item",
target="_Test Warehouse Ledger 1 - _TC", qty=100, basic_rate=100, purpose="Material Receipt")
items = get_items("_Test Warehouse Group - _TC", nowdate(), nowtime(), "_Test Company")
self.assertEqual(["_Test Stock Reco Item", "_Test Warehouse Ledger 1 - _TC", 100],
[items[0]["item_code"], items[0]["warehouse"], items[0]["qty"]])
def test_get_items(self):
create_warehouse("_Test Warehouse Group 1", {"is_group": 1})
create_warehouse("_Test Warehouse Ledger 1", {
"is_group": 0,
"parent_warehouse": "_Test Warehouse Group 1 - _TC"
})
make_item(
"_Test Stock Reco Item", {
"default_warehouse": "_Test Warehouse Ledger 1 - _TC",
"is_stock_item": 1,
"opening_stock": 100,
"valuation_rate": 100
})
items = get_items("_Test Warehouse Group 1 - _TC", nowdate(),
nowtime())
self.assertEqual(
["_Test Stock Reco Item", "_Test Warehouse Ledger 1 - _TC", 100],
[items[0]["item_code"], items[0]["warehouse"], items[0]["qty"]])
def setUp(self):
if not frappe.db.exists("Item", "_Rice"):
make_item("_Rice", {
'is_stock_item': 1,
'has_batch_no' : 1,
'create_new_batch': 1,
'stock_uom': 'Kg'
})
if not frappe.db.exists("Warehouse", {"warehouse_name": "Rack 1"}):
create_warehouse("Rack 1")
if not frappe.db.exists("Warehouse", {"warehouse_name": "Rack 2"}):
create_warehouse("Rack 2")
self.warehouse_1 = frappe.db.get_value("Warehouse", {"warehouse_name": "Rack 1"})
self.warehouse_2 = frappe.db.get_value("Warehouse", {"warehouse_name": "Rack 2"})
if not frappe.db.exists("UOM", "Bag"):
new_uom = frappe.new_doc("UOM")
new_uom.uom_name = "Bag"
new_uom.save()
def test_inter_company_transfer(self):
se = make_serialized_item(target_warehouse="_Test Warehouse - _TC")
serial_nos = get_serial_nos(se.get("items")[0].serial_no)
create_delivery_note(item_code="_Test Serialized Item With Series", qty=1, serial_no=serial_nos[0])
wh = create_warehouse("_Test Warehouse", company="_Test Company 1")
make_purchase_receipt(item_code="_Test Serialized Item With Series", qty=1, serial_no=serial_nos[0],
company="_Test Company 1", warehouse=wh)
serial_no = frappe.db.get_value("Serial No", serial_nos[0], ["warehouse", "company"], as_dict=1)
self.assertEqual(serial_no.warehouse, wh)
self.assertEqual(serial_no.company, "_Test Company 1")
def generate_expected_data(self):
if not frappe.db.exists("Company", "_Test Procurement Company"):
frappe.get_doc(
dict(
doctype="Company",
company_name="_Test Procurement Company",
abbr="_TPC",
default_currency="INR",
country="Pakistan",
)).insert()
warehouse = create_warehouse("_Test Procurement Warehouse",
company="_Test Procurement Company")
mr = make_material_request(company="_Test Procurement Company",
warehouse=warehouse,
cost_center="Main - _TPC")
po = make_purchase_order(mr.name)
po.supplier = "_Test Supplier"
po.get("items")[0].cost_center = "Main - _TPC"
po.submit()
pr = make_purchase_receipt(po.name)
pr.get("items")[0].cost_center = "Main - _TPC"
pr.submit()
date_obj = datetime.date(datetime.now())
po.load_from_db()
expected_data = {
"material_request_date": date_obj,
"cost_center": "Main - _TPC",
"project": None,
"requesting_site": "_Test Procurement Warehouse - _TPC",
"requestor": "Administrator",
"material_request_no": mr.name,
"item_code": "_Test Item",
"quantity": 10.0,
"unit_of_measurement": "_Test UOM",
"status": "To Bill",
"purchase_order_date": date_obj,
"purchase_order": po.name,
"supplier": "_Test Supplier",
"estimated_cost": 0.0,
"actual_cost": 0.0,
"purchase_order_amt": po.net_total,
"purchase_order_amt_in_company_currency": po.base_net_total,
"expected_delivery_date": date_obj,
"actual_delivery_date": date_obj,
}
return expected_data
def test_inter_company_transfer(self):
se = make_serialized_item(target_warehouse="_Test Warehouse - _TC")
serial_nos = get_serial_nos(se.get("items")[0].serial_no)
create_delivery_note(
item_code="_Test Serialized Item With Series", qty=1, serial_no=serial_nos[0])
wh = create_warehouse("_Test Warehouse", company="_Test Company 1")
make_purchase_receipt(item_code="_Test Serialized Item With Series", qty=1, serial_no=serial_nos[0],
company="_Test Company 1", warehouse=wh)
serial_no = frappe.db.get_value("Serial No", serial_nos[0], [
"warehouse", "company"], as_dict=1)
self.assertEqual(serial_no.warehouse, wh)
self.assertEqual(serial_no.company, "_Test Company 1")
def make_wo_order_test_record(**args):
args = frappe._dict(args)
if args.company and args.company != "_Test Company":
warehouse_map = {
"fg_warehouse": "_Test FG Warehouse",
"wip_warehouse": "_Test WIP Warehouse"
}
for attr, wh_name in warehouse_map.items():
if not args.get(attr):
args[attr] = create_warehouse(wh_name, company=args.company)
wo_order = frappe.new_doc("Work Order")
wo_order.production_item = args.production_item or args.item or args.item_code or "_Test FG Item"
wo_order.bom_no = args.bom_no or frappe.db.get_value(
"BOM", {
"item": wo_order.production_item,
"is_active": 1,
"is_default": 1
})
wo_order.qty = args.qty or 10
wo_order.wip_warehouse = args.wip_warehouse or "_Test Warehouse - _TC"
wo_order.fg_warehouse = args.fg_warehouse or "_Test Warehouse 1 - _TC"
wo_order.scrap_warehouse = args.fg_warehouse or "_Test Scrap Warehouse - _TC"
wo_order.company = args.company or "_Test Company"
wo_order.stock_uom = args.stock_uom or "_Test UOM"
wo_order.use_multi_level_bom = 0
wo_order.skip_transfer = args.skip_transfer or 0
wo_order.get_items_and_operations_from_bom()
wo_order.sales_order = args.sales_order or None
wo_order.planned_start_date = args.planned_start_date or now()
wo_order.transfer_material_against = args.transfer_material_against or "Work Order"
if args.source_warehouse:
for item in wo_order.get("required_items"):
item.source_warehouse = args.source_warehouse
if not args.do_not_save:
wo_order.insert()
if not args.do_not_submit:
wo_order.submit()
return wo_order
def test_make_stock_entry_for_customer_provided_item(self):
finished_item = 'Test Item for Make Stock Entry 1'
make_item(finished_item, {
"include_item_in_manufacturing": 1,
"is_stock_item": 1
})
customer_provided_item = 'CUST-0987'
make_item(
customer_provided_item, {
'is_purchase_item': 0,
'is_customer_provided_item': 1,
"is_stock_item": 1,
"include_item_in_manufacturing": 1,
'customer': '_Test Customer'
})
if not frappe.db.exists('BOM', {'item': finished_item}):
make_bom(item=finished_item,
raw_materials=[customer_provided_item],
rm_qty=1)
company = "_Test Company with perpetual inventory"
customer_warehouse = create_warehouse(
"Test Customer Provided Warehouse", company=company)
wo = make_wo_order_test_record(item=finished_item,
qty=1,
source_warehouse=customer_warehouse,
company=company)
ste = frappe.get_doc(
make_stock_entry(wo.name,
purpose='Material Transfer for Manufacture'))
ste.insert()
self.assertEqual(len(ste.items), 1)
for item in ste.items:
self.assertEqual(item.allow_zero_valuation_rate, 1)
self.assertEqual(item.valuation_rate, 0)
def initialize_records_for_future_negative_sle_test( item_code, batch_no, warehouses, opening_qty, posting_date ): from erpnext.stock.doctype.batch.test_batch import TestBatch, make_new_batch from erpnext.stock.doctype.stock_reconciliation.test_stock_reconciliation import ( create_stock_reconciliation, ) from erpnext.stock.doctype.warehouse.test_warehouse import create_warehouse TestBatch.make_batch_item(item_code) make_new_batch(item_code=item_code, batch_id=batch_no) warehouse_names = [create_warehouse(w) for w in warehouses] create_stock_reconciliation( purpose="Opening Stock", posting_date=posting_date, posting_time="20:00:20", item_code=item_code, warehouse=warehouse_names[0], valuation_rate=100, qty=opening_qty, batch_no=batch_no, ) return warehouse_names
def test_inter_company_transfer_intermediate_cancellation(self):
"""
Receive into and Deliver Serial No from one company.
Then Receive into and Deliver from second company.
Try to cancel intermediate receipts/deliveries to test if it is blocked.
"""
se = make_serialized_item(target_warehouse="_Test Warehouse - _TC")
serial_nos = get_serial_nos(se.get("items")[0].serial_no)
sn_doc = frappe.get_doc("Serial No", serial_nos[0])
# check Serial No details after purchase in first company
self.assertEqual(sn_doc.status, "Active")
self.assertEqual(sn_doc.company, "_Test Company")
self.assertEqual(sn_doc.warehouse, "_Test Warehouse - _TC")
self.assertEqual(sn_doc.purchase_document_no, se.name)
dn = create_delivery_note(
item_code="_Test Serialized Item With Series",
qty=1,
serial_no=serial_nos[0])
sn_doc.reload()
# check Serial No details after delivery from **first** company
self.assertEqual(sn_doc.status, "Delivered")
self.assertEqual(sn_doc.company, "_Test Company")
self.assertEqual(sn_doc.warehouse, None)
self.assertEqual(sn_doc.delivery_document_no, dn.name)
# try cancelling the first Serial No Receipt, even though it is delivered
# block cancellation is Serial No is out of the warehouse
self.assertRaises(frappe.ValidationError, se.cancel)
# receive serial no in second company
wh = create_warehouse("_Test Warehouse", company="_Test Company 1")
pr = make_purchase_receipt(
item_code="_Test Serialized Item With Series",
qty=1,
serial_no=serial_nos[0],
company="_Test Company 1",
warehouse=wh)
sn_doc.reload()
self.assertEqual(sn_doc.warehouse, wh)
# try cancelling the delivery from the first company
# block cancellation as Serial No belongs to different company
self.assertRaises(frappe.ValidationError, dn.cancel)
# deliver from second company
dn_2 = create_delivery_note(
item_code="_Test Serialized Item With Series",
qty=1,
serial_no=serial_nos[0],
company="_Test Company 1",
warehouse=wh)
sn_doc.reload()
# check Serial No details after delivery from **second** company
self.assertEqual(sn_doc.status, "Delivered")
self.assertEqual(sn_doc.company, "_Test Company 1")
self.assertEqual(sn_doc.warehouse, None)
self.assertEqual(sn_doc.delivery_document_no, dn_2.name)
# cannot cancel any intermediate document before last Delivery Note
self.assertRaises(frappe.ValidationError, se.cancel)
self.assertRaises(frappe.ValidationError, dn.cancel)
self.assertRaises(frappe.ValidationError, pr.cancel)
def create_asset_repair(**args):
from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import make_purchase_invoice
from erpnext.stock.doctype.warehouse.test_warehouse import create_warehouse
args = frappe._dict(args)
if args.asset:
asset = args.asset
else:
asset = create_asset(is_existing_asset=1, submit=1)
asset_repair = frappe.new_doc("Asset Repair")
asset_repair.update({
"asset": asset.name,
"asset_name": asset.asset_name,
"failure_date": nowdate(),
"description": "Test Description",
"repair_cost": 0,
"company": asset.company
})
if args.stock_consumption:
asset_repair.stock_consumption = 1
asset_repair.warehouse = create_warehouse("Test Warehouse",
company=asset.company)
asset_repair.append(
"stock_items", {
"item": args.item or args.item_code or "_Test Item",
"valuation_rate":
args.rate if args.get("rate") is not None else 100,
"consumed_quantity": args.qty or 1
})
asset_repair.insert(ignore_if_duplicate=True)
if args.submit:
asset_repair.repair_status = "Completed"
asset_repair.cost_center = "_Test Cost Center - _TC"
if args.stock_consumption:
stock_entry = frappe.get_doc({
"doctype": "Stock Entry",
"stock_entry_type": "Material Receipt",
"company": asset.company
})
stock_entry.append(
'items', {
"t_warehouse": asset_repair.warehouse,
"item_code": asset_repair.stock_items[0].item,
"qty": asset_repair.stock_items[0].consumed_quantity
})
stock_entry.submit()
if args.capitalize_repair_cost:
asset_repair.capitalize_repair_cost = 1
asset_repair.repair_cost = 1000
if asset.calculate_depreciation:
asset_repair.increase_in_asset_life = 12
asset_repair.purchase_invoice = make_purchase_invoice().name
asset_repair.submit()
return asset_repair
def test_inter_company_transfer_fallback_on_cancel(self):
"""
Test Serial No state changes on cancellation.
If Delivery cancelled, it should fall back on last Receipt in the same company.
If Receipt is cancelled, it should be Inactive in the same company.
"""
# Receipt in **first** company
se = make_serialized_item(target_warehouse="_Test Warehouse - _TC")
serial_nos = get_serial_nos(se.get("items")[0].serial_no)
sn_doc = frappe.get_doc("Serial No", serial_nos[0])
# Delivery from first company
dn = create_delivery_note(
item_code="_Test Serialized Item With Series",
qty=1,
serial_no=serial_nos[0])
# Receipt in **second** company
wh = create_warehouse("_Test Warehouse", company="_Test Company 1")
pr = make_purchase_receipt(
item_code="_Test Serialized Item With Series",
qty=1,
serial_no=serial_nos[0],
company="_Test Company 1",
warehouse=wh)
# Delivery from second company
dn_2 = create_delivery_note(
item_code="_Test Serialized Item With Series",
qty=1,
serial_no=serial_nos[0],
company="_Test Company 1",
warehouse=wh)
sn_doc.reload()
self.assertEqual(sn_doc.status, "Delivered")
self.assertEqual(sn_doc.company, "_Test Company 1")
self.assertEqual(sn_doc.delivery_document_no, dn_2.name)
dn_2.cancel()
sn_doc.reload()
# Fallback on Purchase Receipt if Delivery is cancelled
self.assertEqual(sn_doc.status, "Active")
self.assertEqual(sn_doc.company, "_Test Company 1")
self.assertEqual(sn_doc.warehouse, wh)
self.assertEqual(sn_doc.purchase_document_no, pr.name)
pr.cancel()
sn_doc.reload()
# Inactive in same company if Receipt cancelled
self.assertEqual(sn_doc.status, "Inactive")
self.assertEqual(sn_doc.company, "_Test Company 1")
self.assertEqual(sn_doc.warehouse, None)
dn.cancel()
sn_doc.reload()
# Fallback on Purchase Receipt in FIRST company if
# Delivery from FIRST company is cancelled
self.assertEqual(sn_doc.status, "Active")
self.assertEqual(sn_doc.company, "_Test Company")
self.assertEqual(sn_doc.warehouse, "_Test Warehouse - _TC")
self.assertEqual(sn_doc.purchase_document_no, se.name)