def test_unlinking_warehouse_from_item_defaults(self):
company = "_Test Company"
warehouse_names = [
f'_Test Warehouse {i} for Unlinking' for i in range(2)
]
warehouse_ids = []
for warehouse in warehouse_names:
warehouse_id = create_warehouse(warehouse, company=company)
warehouse_ids.append(warehouse_id)
item_names = [f'_Test Item {i} for Unlinking' for i in range(2)]
for item, warehouse in zip(item_names, warehouse_ids):
create_item(item, warehouse=warehouse, company=company)
# Delete warehouses
for warehouse in warehouse_ids:
frappe.delete_doc("Warehouse", warehouse)
# Check Item existance
for item in item_names:
self.assertTrue(bool(frappe.db.exists("Item", item)),
f"{item} doesn't exist")
item_doc = frappe.get_doc("Item", item)
for item_default in item_doc.item_defaults:
self.assertNotIn(
item_default.default_warehouse, warehouse_ids,
f"{item} linked to {item_default.default_warehouse} in {warehouse_ids}."
)
def make_items():
items = ['Test Finished Goods - A', 'Test FG A RW 1', 'Test FG A RW 2', 'Alternate Item For A RW 1']
for item_code in items:
if not frappe.db.exists('Item', item_code):
create_item(item_code)
create_stock_reconciliation(item_code="Test FG A RW 1",
warehouse='_Test Warehouse - _TC', qty=10, rate=2000)
if frappe.db.exists('Item', 'Test FG A RW 1'):
doc = frappe.get_doc('Item', 'Test FG A RW 1')
doc.allow_alternative_item = 1
doc.save()
if frappe.db.exists('Item', 'Test Finished Goods - A'):
doc = frappe.get_doc('Item', 'Test Finished Goods - A')
doc.is_sub_contracted_item = 1
doc.save()
if not frappe.db.get_value('BOM',
{'item': 'Test Finished Goods - A', 'docstatus': 1}):
make_bom(item = 'Test Finished Goods - A', raw_materials = ['Test FG A RW 1', 'Test FG A RW 2'])
if not frappe.db.get_value('Warehouse', {'warehouse_name': 'Test Supplier Warehouse'}):
frappe.get_doc({
'doctype': 'Warehouse',
'warehouse_name': 'Test Supplier Warehouse',
'company': '_Test Company'
}).insert(ignore_permissions=True)
def test_pp_to_mr_customer_provided(self):
"Test Material Request from Production Plan for Customer Provided Item."
create_item("CUST-0987",
is_customer_provided_item=1,
customer="_Test Customer",
is_purchase_item=0)
create_item("Production Item CUST")
for item, raw_materials in {
"Production Item CUST": ["Raw Material Item 1", "CUST-0987"]
}.items():
if not frappe.db.get_value("BOM", {"item": item}):
make_bom(item=item, raw_materials=raw_materials)
production_plan = create_production_plan(
item_code="Production Item CUST")
production_plan.make_material_request()
material_request = frappe.db.get_value(
"Material Request Item",
{
"production_plan": production_plan.name,
"item_code": "CUST-0987"
},
"parent",
)
mr = frappe.get_doc("Material Request", material_request)
self.assertTrue(mr.material_request_type, "Customer Provided")
self.assertTrue(mr.customer, "_Test Customer")
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 make_items():
items = ['Test Finished Goods - A', 'Test FG A RW 1', 'Test FG A RW 2', 'Alternate Item For A RW 1']
for item_code in items:
if not frappe.db.exists('Item', item_code):
create_item(item_code)
create_stock_reconciliation(item_code="Test FG A RW 1",
warehouse='_Test Warehouse - _TC', qty=10, rate=2000)
if frappe.db.exists('Item', 'Test FG A RW 1'):
doc = frappe.get_doc('Item', 'Test FG A RW 1')
doc.allow_alternative_item = 1
doc.save()
if frappe.db.exists('Item', 'Test Finished Goods - A'):
doc = frappe.get_doc('Item', 'Test Finished Goods - A')
doc.is_sub_contracted_item = 1
doc.save()
if not frappe.db.get_value('BOM',
{'item': 'Test Finished Goods - A', 'docstatus': 1}):
make_bom(item = 'Test Finished Goods - A', raw_materials = ['Test FG A RW 1', 'Test FG A RW 2'])
if not frappe.db.get_value('Warehouse', {'warehouse_name': 'Test Supplier Warehouse'}):
frappe.get_doc({
'doctype': 'Warehouse',
'warehouse_name': 'Test Supplier Warehouse',
'company': '_Test Company'
}).insert(ignore_permissions=True)
def test_material_transfer_gl_entry(self):
company = frappe.db.get_value('Warehouse', 'Stores - TCP1', 'company')
item_code = 'Hand Sanitizer - 001'
create_item(item_code =item_code, is_stock_item = 1,
is_purchase_item=1, opening_stock=1000, valuation_rate=10, company=company, warehouse="Stores - TCP1")
mtn = make_stock_entry(item_code=item_code, source="Stores - TCP1",
target="Finished Goods - TCP1", qty=45, company=company)
self.check_stock_ledger_entries("Stock Entry", mtn.name,
[[item_code, "Stores - TCP1", -45.0], [item_code, "Finished Goods - TCP1", 45.0]])
source_warehouse_account = get_inventory_account(mtn.company, mtn.get("items")[0].s_warehouse)
target_warehouse_account = get_inventory_account(mtn.company, mtn.get("items")[0].t_warehouse)
if source_warehouse_account == target_warehouse_account:
# no gl entry as both source and target warehouse has linked to same account.
self.assertFalse(frappe.db.sql("""select * from `tabGL Entry`
where voucher_type='Stock Entry' and voucher_no=%s""", mtn.name, as_dict=1))
else:
stock_value_diff = abs(frappe.db.get_value("Stock Ledger Entry", {"voucher_type": "Stock Entry",
"voucher_no": mtn.name, "warehouse": "Stores - TCP1"}, "stock_value_difference"))
self.check_gl_entries("Stock Entry", mtn.name,
sorted([
[source_warehouse_account, 0.0, stock_value_diff],
[target_warehouse_account, stock_value_diff, 0.0],
])
)
mtn.cancel()
def setUp(self):
set_perpetual_inventory(0)
for item in [
'Test Production Item 1', 'Subassembly Item 1',
'Raw Material Item 1', 'Raw Material Item 2'
]:
create_item(item, valuation_rate=100)
sr = frappe.db.get_value('Stock Reconciliation Item', {
'item_code': item,
'docstatus': 1
}, 'parent')
if sr:
sr_doc = frappe.get_doc('Stock Reconciliation', sr)
sr_doc.cancel()
create_item('Test Non Stock Raw Material', is_stock_item=0)
for item, raw_materials in {
'Subassembly Item 1':
['Raw Material Item 1', 'Raw Material Item 2'],
'Test Production Item 1': [
'Raw Material Item 1', 'Subassembly Item 1',
'Test Non Stock Raw Material'
]
}.items():
if not frappe.db.get_value('BOM', {'item': item}):
make_bom(item=item, raw_materials=raw_materials)
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 setUp(self):
for item in [
"Test Production Item 1",
"Subassembly Item 1",
"Raw Material Item 1",
"Raw Material Item 2",
]:
create_item(item, valuation_rate=100)
sr = frappe.db.get_value("Stock Reconciliation Item", {
"item_code": item,
"docstatus": 1
}, "parent")
if sr:
sr_doc = frappe.get_doc("Stock Reconciliation", sr)
sr_doc.cancel()
create_item("Test Non Stock Raw Material", is_stock_item=0)
for item, raw_materials in {
"Subassembly Item 1":
["Raw Material Item 1", "Raw Material Item 2"],
"Test Production Item 1": [
"Raw Material Item 1",
"Subassembly Item 1",
"Test Non Stock Raw Material",
],
}.items():
if not frappe.db.get_value("BOM", {"item": item}):
make_bom(item=item, raw_materials=raw_materials)
def test_customer_provided_parts_dn(self):
create_item('CUST-0987', is_customer_provided_item = 1, customer = '_Test Customer', is_purchase_item = 0)
dn = create_delivery_note(item_code='CUST-0987', rate=0)
self.assertEqual(dn.get("items")[0].allow_zero_valuation_rate, 1)
# test if Delivery Note with rate is allowed against Customer Provided Item
dn2 = create_delivery_note(item_code='CUST-0987', do_not_save=True)
self.assertRaises(frappe.ValidationError, dn2.save)
def test_get_sales_order_with_variant(self):
"Check if Template BOM is fetched in absence of Variant BOM."
rm_item = create_item("PIV_RM", valuation_rate=100)
if not frappe.db.exists("Item", {"item_code": "PIV"}):
item = create_item("PIV", valuation_rate=100)
variant_settings = {
"attributes": [
{
"attribute": "Colour"
},
],
"has_variants": 1,
}
item.update(variant_settings)
item.save()
parent_bom = make_bom(item="PIV",
raw_materials=[rm_item.item_code])
if not frappe.db.exists("BOM", {"item": "PIV"}):
parent_bom = make_bom(item="PIV",
raw_materials=[rm_item.item_code])
else:
parent_bom = frappe.get_doc("BOM", {"item": "PIV"})
if not frappe.db.exists("Item", {"item_code": "PIV-RED"}):
variant = create_variant("PIV", {"Colour": "Red"})
variant.save()
variant_bom = make_bom(item=variant.item_code,
raw_materials=[rm_item.item_code])
else:
variant = frappe.get_doc("Item", "PIV-RED")
if not frappe.db.exists("BOM", {"item": "PIV-RED"}):
variant_bom = make_bom(item=variant.item_code,
raw_materials=[rm_item.item_code])
"""Testing when item variant has a BOM"""
so = make_sales_order(item_code="PIV-RED", qty=5)
pln = frappe.new_doc("Production Plan")
pln.company = so.company
pln.get_items_from = "Sales Order"
pln.item_code = "PIV-RED"
pln.get_open_sales_orders()
self.assertEqual(pln.sales_orders[0].sales_order, so.name)
pln.get_so_items()
self.assertEqual(pln.po_items[0].item_code, "PIV-RED")
self.assertEqual(pln.po_items[0].bom_no, variant_bom.name)
so.cancel()
frappe.delete_doc("Sales Order", so.name)
variant_bom.cancel()
frappe.delete_doc("BOM", variant_bom.name)
"""Testing when item variant doesn't have a BOM"""
so = make_sales_order(item_code="PIV-RED", qty=5)
pln.get_open_sales_orders()
self.assertEqual(pln.sales_orders[0].sales_order, so.name)
pln.po_items = []
pln.get_so_items()
self.assertEqual(pln.po_items[0].item_code, "PIV-RED")
self.assertEqual(pln.po_items[0].bom_no, parent_bom.name)
frappe.db.rollback()
def test_close_work_order(self):
items = [
'Test FG Item for Closed WO', 'Test RM Item 1 for Closed WO',
'Test RM Item 2 for Closed WO'
]
company = '_Test Company with perpetual inventory'
for item_code in items:
create_item(item_code=item_code,
is_stock_item=1,
is_purchase_item=1,
opening_stock=100,
valuation_rate=10,
company=company,
warehouse='Stores - TCP1')
item = 'Test FG Item for Closed WO'
raw_materials = [
'Test RM Item 1 for Closed WO', 'Test RM Item 2 for Closed WO'
]
if not frappe.db.get_value('BOM', {'item': item}):
bom = make_bom(item=item,
source_warehouse='Stores - TCP1',
raw_materials=raw_materials,
do_not_save=True)
bom.with_operations = 1
bom.append(
'operations', {
'operation': '_Test Operation 1',
'workstation': '_Test Workstation 1',
'hour_rate': 20,
'time_in_mins': 60
})
bom.submit()
wo_order = make_wo_order_test_record(item=item,
company=company,
planned_start_date=now(),
qty=20,
skip_transfer=1)
job_cards = frappe.db.get_value('Job Card',
{'work_order': wo_order.name}, 'name')
if len(job_cards) == len(bom.operations):
for jc in job_cards:
job_card_doc = frappe.get_doc('Job Card', jc)
job_card_doc.append(
'time_logs', {
'from_time': now(),
'time_in_mins': 60,
'completed_qty': job_card_doc.for_quantity
})
job_card_doc.submit()
close_work_order(wo_order, "Closed")
self.assertEqual(wo_order.get('status'), "Closed")
def test_customer_provided_parts_se(self):
create_item(
"CUST-0987", is_customer_provided_item=1, customer="_Test Customer", is_purchase_item=0
)
se = make_stock_entry(
item_code="CUST-0987", purpose="Material Receipt", qty=4, to_warehouse="_Test Warehouse - _TC"
)
self.assertEqual(se.get("items")[0].allow_zero_valuation_rate, 1)
self.assertEqual(se.get("items")[0].amount, 0)
def test_get_sales_order_with_variant(self):
rm_item = create_item('PIV_RM', valuation_rate=100)
if not frappe.db.exists('Item', {"item_code": 'PIV'}):
item = create_item('PIV', valuation_rate=100)
variant_settings = {
"attributes": [
{
"attribute": "Colour"
},
],
"has_variants": 1
}
item.update(variant_settings)
item.save()
parent_bom = make_bom(item='PIV',
raw_materials=[rm_item.item_code])
if not frappe.db.exists('BOM', {"item": 'PIV'}):
parent_bom = make_bom(item='PIV',
raw_materials=[rm_item.item_code])
else:
parent_bom = frappe.get_doc('BOM', {"item": 'PIV'})
if not frappe.db.exists('Item', {"item_code": 'PIV-RED'}):
variant = create_variant("PIV", {"Colour": "Red"})
variant.save()
variant_bom = make_bom(item=variant.item_code,
raw_materials=[rm_item.item_code])
else:
variant = frappe.get_doc('Item', 'PIV-RED')
if not frappe.db.exists('BOM', {"item": 'PIV-RED'}):
variant_bom = make_bom(item=variant.item_code,
raw_materials=[rm_item.item_code])
"""Testing when item variant has a BOM"""
so = make_sales_order(item_code="PIV-RED", qty=5)
pln = frappe.new_doc('Production Plan')
pln.company = so.company
pln.get_items_from = 'Sales Order'
pln.item_code = 'PIV-RED'
pln.get_open_sales_orders()
self.assertEqual(pln.sales_orders[0].sales_order, so.name)
pln.get_so_items()
self.assertEqual(pln.po_items[0].item_code, 'PIV-RED')
self.assertEqual(pln.po_items[0].bom_no, variant_bom.name)
so.cancel()
frappe.delete_doc('Sales Order', so.name)
variant_bom.cancel()
frappe.delete_doc('BOM', variant_bom.name)
"""Testing when item variant doesn't have a BOM"""
so = make_sales_order(item_code="PIV-RED", qty=5)
pln.get_open_sales_orders()
self.assertEqual(pln.sales_orders[0].sales_order, so.name)
pln.po_items = []
pln.get_so_items()
self.assertEqual(pln.po_items[0].item_code, 'PIV-RED')
self.assertEqual(pln.po_items[0].bom_no, parent_bom.name)
frappe.db.rollback()
def test_customer_provided_items(self):
item_code = 'Stock-Reco-customer-Item-100'
create_item(item_code, is_customer_provided_item = 1,
customer = '_Test Customer', is_purchase_item = 0)
sr = create_stock_reconciliation(item_code = item_code, qty = 10, rate = 420)
self.assertEqual(sr.get("items")[0].allow_zero_valuation_rate, 1)
self.assertEqual(sr.get("items")[0].valuation_rate, 0)
self.assertEqual(sr.get("items")[0].amount, 0)
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_backdated_stock_reco_future_negative_stock(self):
"""
Test if a backdated stock reco causes future negative stock and is blocked.
-------------------------------------------
Var | Doc | Qty | Balance
-------------------------------------------
PR1 | PR | 10 | 10 (posting date: today-2)
SR3 | Reco | 0 | 1 (posting date: today-1) [backdated & blocked]
DN2 | DN | -2 | 8(-1) (posting date: today)
"""
from erpnext.stock.doctype.delivery_note.test_delivery_note import create_delivery_note
from erpnext.stock.stock_ledger import NegativeStockError
item_code = "Backdated-Reco-Item"
warehouse = "_Test Warehouse - _TC"
create_item(item_code)
pr1 = make_purchase_receipt(item_code=item_code,
warehouse=warehouse,
qty=10,
rate=100,
posting_date=add_days(nowdate(), -2))
dn2 = create_delivery_note(item_code=item_code,
warehouse=warehouse,
qty=2,
rate=120,
posting_date=nowdate())
pr1_balance = frappe.db.get_value("Stock Ledger Entry", {
"voucher_no": pr1.name,
"is_cancelled": 0
}, "qty_after_transaction")
dn2_balance = frappe.db.get_value("Stock Ledger Entry", {
"voucher_no": dn2.name,
"is_cancelled": 0
}, "qty_after_transaction")
self.assertEqual(pr1_balance, 10)
self.assertEqual(dn2_balance, 8)
# check if stock reco is blocked
sr3 = create_stock_reconciliation(item_code=item_code,
warehouse=warehouse,
qty=1,
rate=100,
posting_date=add_days(nowdate(), -1),
do_not_submit=True)
self.assertRaises(NegativeStockError, sr3.submit)
# teardown
sr3.cancel()
dn2.cancel()
pr1.cancel()
def test_job_card_scrap_item(self):
items = [
'Test FG Item for Scrap Item Test',
'Test RM Item 1 for Scrap Item Test',
'Test RM Item 2 for Scrap Item Test'
]
company = '_Test Company with perpetual inventory'
for item_code in items:
create_item(item_code=item_code,
is_stock_item=1,
is_purchase_item=1,
opening_stock=100,
valuation_rate=10,
company=company,
warehouse='Stores - TCP1')
item = 'Test FG Item for Scrap Item Test'
raw_materials = [
'Test RM Item 1 for Scrap Item Test',
'Test RM Item 2 for Scrap Item Test'
]
if not frappe.db.get_value('BOM', {'item': item}):
bom = make_bom(item=item,
source_warehouse='Stores - TCP1',
raw_materials=raw_materials,
do_not_save=True)
bom.with_operations = 1
bom.append(
'operations', {
'operation': '_Test Operation 1',
'workstation': '_Test Workstation 1',
'hour_rate': 20,
'time_in_mins': 60
})
bom.submit()
wo_order = make_wo_order_test_record(item=item,
company=company,
planned_start_date=now(),
qty=20,
skip_transfer=1)
job_card = frappe.db.get_value('Job Card',
{'work_order': wo_order.name}, 'name')
update_job_card(job_card)
stock_entry = frappe.get_doc(
make_stock_entry(wo_order.name, "Manufacture", 10))
for row in stock_entry.items:
if row.is_scrap_item:
self.assertEqual(row.qty, 1)
def setUp(self) -> None:
create_item("Test MR Report Item")
self.setup_material_request() # to order and receive
self.setup_material_request(order=True, days=1) # to receive (ordered)
self.setup_material_request(order=True, receive=True,
days=2) # complete (ordered & received)
self.filters = frappe._dict(
company="_Test Company",
from_date=today(),
to_date=add_days(today(), 30),
item_code="Test MR Report Item",
)
def test_pp_to_mr_customer_provided(self):
#Material Request from Production Plan for Customer Provided
create_item('CUST-0987', is_customer_provided_item = 1, customer = '_Test Customer', is_purchase_item = 0)
create_item('Production Item CUST')
for item, raw_materials in {'Production Item CUST': ['Raw Material Item 1', 'CUST-0987']}.items():
if not frappe.db.get_value('BOM', {'item': item}):
make_bom(item = item, raw_materials = raw_materials)
production_plan = create_production_plan(item_code = 'Production Item CUST')
production_plan.make_material_request()
material_request = frappe.db.get_value('Material Request Item', {'production_plan': production_plan.name, 'item_code': 'CUST-0987'}, 'parent')
mr = frappe.get_doc('Material Request', material_request)
self.assertTrue(mr.material_request_type, 'Customer Provided')
self.assertTrue(mr.customer, '_Test Customer')
def test_production_plan_with_multi_level_bom(self):
"""
Item Code | Qty |
|Test BOM 1 | 1 |
|Test BOM 2 | 2 |
|Test BOM 3 | 3 |
"""
for item_code in [
"Test BOM 1", "Test BOM 2", "Test BOM 3", "Test RM BOM 1"
]:
create_item(item_code, is_stock_item=1)
# created bom upto 3 level
if not frappe.db.get_value("BOM", {"item": "Test BOM 3"}):
make_bom(item="Test BOM 3",
raw_materials=["Test RM BOM 1"],
rm_qty=3)
if not frappe.db.get_value("BOM", {"item": "Test BOM 2"}):
make_bom(item="Test BOM 2", raw_materials=["Test BOM 3"], rm_qty=3)
if not frappe.db.get_value("BOM", {"item": "Test BOM 1"}):
make_bom(item="Test BOM 1", raw_materials=["Test BOM 2"], rm_qty=2)
item_code = "Test BOM 1"
pln = frappe.new_doc("Production Plan")
pln.company = "_Test Company"
pln.append(
"po_items",
{
"item_code": item_code,
"bom_no": frappe.db.get_value("BOM", {"item": "Test BOM 1"}),
"planned_qty": 3,
},
)
pln.get_sub_assembly_items("In House")
pln.submit()
pln.make_work_order()
# last level sub-assembly work order produce qty
to_produce_qty = frappe.db.get_value("Work Order", {
"production_plan": pln.name,
"production_item": "Test BOM 3"
}, "qty")
self.assertEqual(to_produce_qty, 18.0)
pln.cancel()
frappe.delete_doc("Production Plan", pln.name)
def test_customer_provided_parts_mr(self):
create_item('CUST-0987', is_customer_provided_item = 1, customer = '_Test Customer', is_purchase_item = 0)
existing_requested_qty = self._get_requested_qty("_Test Customer", "_Test Warehouse - _TC")
mr = make_material_request(item_code='CUST-0987', material_request_type='Customer Provided')
se = make_stock_entry(mr.name)
se.insert()
se.submit()
self.assertEqual(se.get("items")[0].amount, 0)
self.assertEqual(se.get("items")[0].material_request, mr.name)
mr = frappe.get_doc("Material Request", mr.name)
mr.submit()
current_requested_qty = self._get_requested_qty("_Test Customer", "_Test Warehouse - _TC")
self.assertEqual(mr.per_ordered, 100)
self.assertEqual(existing_requested_qty, current_requested_qty)
def test_serial_no_cancellation(self):
from erpnext.stock.doctype.stock_entry.test_stock_entry import make_stock_entry
item = create_item("Stock-Reco-Serial-Item-9", is_stock_item=1)
if not item.has_serial_no:
item.has_serial_no = 1
item.serial_no_series = "SRS9.####"
item.save()
item_code = item.name
warehouse = "_Test Warehouse - _TC"
se1 = make_stock_entry(item_code=item_code, target=warehouse, qty=10, basic_rate=700)
serial_nos = get_serial_nos(se1.items[0].serial_no)
# reduce 1 item
serial_nos.pop()
new_serial_nos = "\n".join(serial_nos)
sr = create_stock_reconciliation(
item_code=item.name, warehouse=warehouse, serial_no=new_serial_nos, qty=9
)
sr.cancel()
active_sr_no = frappe.get_all(
"Serial No", filters={"item_code": item_code, "warehouse": warehouse, "status": "Active"}
)
self.assertEqual(len(active_sr_no), 10)
def test_customer_provided_parts_mr(self):
from erpnext.stock.doctype.material_request.material_request import make_stock_entry
create_item('CUST-0987',
is_customer_provided_item=1,
customer='_Test Customer',
is_purchase_item=0)
mr = make_material_request(item_code='CUST-0987',
material_request_type='Customer Provided')
se = make_stock_entry(mr.name)
se.insert()
se.submit()
self.assertEqual(se.get("items")[0].amount, 0)
self.assertEqual(se.get("items")[0].material_request, mr.name)
mr = frappe.get_doc("Material Request", mr.name)
mr.submit()
self.assertEqual(mr.per_ordered, 100)
def test_bom_cost(self):
for item in ["BOM Cost Test Item 1", "BOM Cost Test Item 2", "BOM Cost Test Item 3"]:
item_doc = create_item(item, valuation_rate=100)
if item_doc.valuation_rate != 100.00:
frappe.db.set_value("Item", item_doc.name,
"valuation_rate", 100)
bom_no = frappe.db.get_value(
'BOM', {'item': 'BOM Cost Test Item 1'}, "name")
if not bom_no:
doc = make_bom(item='BOM Cost Test Item 1',
raw_materials=['BOM Cost Test Item 2', 'BOM Cost Test Item 3'], currency="INR")
else:
doc = frappe.get_doc("BOM", bom_no)
self.assertEquals(doc.total_cost, 200)
frappe.db.set_value("Item", "BOM Cost Test Item 2",
"valuation_rate", 200)
update_cost()
doc.load_from_db()
self.assertEquals(doc.total_cost, 300)
frappe.db.set_value("Item", "BOM Cost Test Item 2",
"valuation_rate", 100)
update_cost()
doc.load_from_db()
self.assertEquals(doc.total_cost, 200)
def test_batched_serial_no_purchase(self):
item = frappe.db.exists("Item",
{'item_name': 'Batched Serialized Item'})
if not item:
item = create_item("Batched Serialized Item")
item.has_batch_no = 1
item.create_new_batch = 1
item.has_serial_no = 1
item.batch_number_series = "BS-BATCH-.##"
item.serial_no_series = "BS-.####"
item.save()
else:
item = frappe.get_doc("Item",
{'item_name': 'Batched Serialized Item'})
pr = make_purchase_receipt(item_code=item.name, qty=5, rate=500)
self.assertTrue(
frappe.db.get_value('Batch', {
'item': item.name,
'reference_name': pr.name
}))
pr.load_from_db()
batch_no = pr.items[0].batch_no
pr.cancel()
self.assertFalse(
frappe.db.get_value('Batch', {
'item': item.name,
'reference_name': pr.name
}))
self.assertFalse(frappe.db.get_all('Serial No',
{'batch_no': batch_no}))
def test_serial_no_creation_and_inactivation(self):
item = create_item("_TestItemCreatedWithStockReco", is_stock_item=1)
if not item.has_serial_no:
item.has_serial_no = 1
item.save()
item_code = item.name
warehouse = "_Test Warehouse - _TC"
sr = create_stock_reconciliation(
item_code=item.name,
warehouse=warehouse,
serial_no="SR-CREATED-SR-NO",
qty=1,
do_not_submit=True,
rate=100,
)
sr.save()
self.assertEqual(cstr(sr.items[0].current_serial_no), "")
sr.submit()
active_sr_no = frappe.get_all(
"Serial No", filters={"item_code": item_code, "warehouse": warehouse, "status": "Active"}
)
self.assertEqual(len(active_sr_no), 1)
sr.cancel()
active_sr_no = frappe.get_all(
"Serial No", filters={"item_code": item_code, "warehouse": warehouse, "status": "Active"}
)
self.assertEqual(len(active_sr_no), 0)
def test_stock_reco_for_serial_and_batch_item(self):
item = create_item("_TestBatchSerialItemReco")
item.has_batch_no = 1
item.create_new_batch = 1
item.has_serial_no = 1
item.batch_number_series = "TBS-BATCH-.##"
item.serial_no_series = "TBS-.####"
item.save()
warehouse = "_Test Warehouse for Stock Reco2 - _TC"
sr = create_stock_reconciliation(item_code=item.item_code,
warehouse=warehouse,
qty=1,
rate=100)
batch_no = sr.items[0].batch_no
serial_nos = get_serial_nos(sr.items[0].serial_no)
self.assertEqual(len(serial_nos), 1)
self.assertEqual(
frappe.db.get_value("Serial No", serial_nos[0], "batch_no"),
batch_no)
sr.cancel()
self.assertEqual(
frappe.db.get_value("Serial No", serial_nos[0], "status"),
"Inactive")
self.assertEqual(frappe.db.exists("Batch", batch_no), None)
def test_stock_reco_for_serial_and_batch_item(self):
set_perpetual_inventory()
item = frappe.db.exists("Item", {'item_name': 'Batched and Serialised Item 1'})
if not item:
item = create_item("Batched and Serialised Item 1")
item.has_batch_no = 1
item.create_new_batch = 1
item.has_serial_no = 1
item.batch_number_series = "B-BATCH-.##"
item.serial_no_series = "S-.####"
item.save()
else:
item = frappe.get_doc("Item", {'item_name': 'Batched and Serialised Item 1'})
warehouse = "_Test Warehouse for Stock Reco2 - _TC"
sr = create_stock_reconciliation(item_code=item.item_code,
warehouse = warehouse, qty=1, rate=100)
batch_no = sr.items[0].batch_no
serial_nos = get_serial_nos(sr.items[0].serial_no)
self.assertEqual(len(serial_nos), 1)
self.assertEqual(frappe.db.get_value("Serial No", serial_nos[0], "batch_no"), batch_no)
sr.cancel()
self.assertEqual(frappe.db.get_value("Serial No", serial_nos[0], "status"), "Inactive")
self.assertEqual(frappe.db.exists("Batch", batch_no), None)
if frappe.db.exists("Serial No", serial_nos[0]):
frappe.delete_doc("Serial No", serial_nos[0])
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_deferred_expense_via_journal_entry(self):
deferred_account = create_account(account_name="Deferred Expense",
parent_account="Current Assets - _TC", company="_Test Company")
acc_settings = frappe.get_doc('Accounts Settings', 'Accounts Settings')
acc_settings.book_deferred_entries_via_journal_entry = 1
acc_settings.submit_journal_entries = 1
acc_settings.save()
item = create_item("_Test Item for Deferred Accounting", is_purchase_item=True)
item.enable_deferred_expense = 1
item.deferred_expense_account = deferred_account
item.save()
pi = make_purchase_invoice(item=item.name, qty=1, rate=100, do_not_save=True)
pi.set_posting_time = 1
pi.posting_date = '2019-03-15'
pi.items[0].enable_deferred_expense = 1
pi.items[0].service_start_date = "2019-01-10"
pi.items[0].service_end_date = "2019-03-15"
pi.items[0].deferred_expense_account = deferred_account
pi.save()
pi.submit()
pda1 = frappe.get_doc(dict(
doctype='Process Deferred Accounting',
posting_date=nowdate(),
start_date="2019-01-01",
end_date="2019-03-31",
type="Expense",
company="_Test Company"
))
pda1.insert()
pda1.submit()
expected_gle = [
["_Test Account Cost for Goods Sold - _TC", 0.0, 33.85, "2019-01-31"],
[deferred_account, 33.85, 0.0, "2019-01-31"],
["_Test Account Cost for Goods Sold - _TC", 0.0, 43.08, "2019-02-28"],
[deferred_account, 43.08, 0.0, "2019-02-28"],
["_Test Account Cost for Goods Sold - _TC", 0.0, 23.07, "2019-03-15"],
[deferred_account, 23.07, 0.0, "2019-03-15"]
]
gl_entries = gl_entries = frappe.db.sql("""select account, debit, credit, posting_date
from `tabGL Entry`
where voucher_type='Journal Entry' and voucher_detail_no=%s and posting_date <= %s
order by posting_date asc, account asc""", (pi.items[0].name, pi.posting_date), as_dict=1)
for i, gle in enumerate(gl_entries):
self.assertEqual(expected_gle[i][0], gle.account)
self.assertEqual(expected_gle[i][1], gle.credit)
self.assertEqual(expected_gle[i][2], gle.debit)
self.assertEqual(getdate(expected_gle[i][3]), gle.posting_date)
acc_settings = frappe.get_doc('Accounts Settings', 'Accounts Settings')
acc_settings.book_deferred_entries_via_journal_entry = 0
acc_settings.submit_journal_entriessubmit_journal_entries = 0
acc_settings.save()
def test_quality_check(self):
item_code = "_Test Item For QC"
if not frappe.db.exists('Item', item_code):
create_item(item_code)
repack = frappe.copy_doc(test_records[3])
repack.inspection_required = 1
for d in repack.items:
if not d.s_warehouse and d.t_warehouse:
d.item_code = item_code
d.qty = 1
d.uom = "Nos"
d.stock_uom = "Nos"
d.basic_rate = 5000
repack.insert()
self.assertRaises(frappe.ValidationError, repack.submit)
def setUp(self):
for item in ['Test Production Item 1', 'Subassembly Item 1',
'Raw Material Item 1', 'Raw Material Item 2']:
create_item(item, valuation_rate=100)
sr = frappe.db.get_value('Stock Reconciliation Item',
{'item_code': item, 'docstatus': 1}, 'parent')
if sr:
sr_doc = frappe.get_doc('Stock Reconciliation', sr)
sr_doc.cancel()
create_item('Test Non Stock Raw Material', is_stock_item=0)
for item, raw_materials in {'Subassembly Item 1': ['Raw Material Item 1', 'Raw Material Item 2'],
'Test Production Item 1': ['Raw Material Item 1', 'Subassembly Item 1',
'Test Non Stock Raw Material']}.items():
if not frappe.db.get_value('BOM', {'item': item}):
make_bom(item = item, raw_materials = raw_materials)
def setUp(self):
create_item("_Test Item with QA")
frappe.db.set_value("Item", "_Test Item with QA", "inspection_required_before_delivery", 1)
