def test_work_order_with_non_transfer_item(self):
items = {
'Finished Good Transfer Item': 1,
'_Test FG Item': 1,
'_Test FG Item 1': 0
}
for item, allow_transfer in items.items():
make_item(item, {'include_item_in_manufacturing': allow_transfer})
fg_item = 'Finished Good Transfer Item'
test_stock_entry.make_stock_entry(item_code="_Test FG Item",
target="_Test Warehouse - _TC",
qty=1,
basic_rate=100)
test_stock_entry.make_stock_entry(item_code="_Test FG Item 1",
target="_Test Warehouse - _TC",
qty=1,
basic_rate=100)
if not frappe.db.get_value('BOM', {'item': fg_item}):
make_bom(item=fg_item,
raw_materials=['_Test FG Item', '_Test FG Item 1'])
wo = make_wo_order_test_record(production_item=fg_item)
ste = frappe.get_doc(
make_stock_entry(wo.name, "Material Transfer for Manufacture", 1))
ste.insert()
ste.submit()
self.assertEqual(len(ste.items), 1)
ste1 = frappe.get_doc(make_stock_entry(wo.name, "Manufacture", 1))
self.assertEqual(len(ste1.items), 3)
def test_job_card(self):
stock_entries = []
data = frappe.get_cached_value('BOM', {
'docstatus': 1,
'with_operations': 1,
'company': '_Test Company'
}, ['name', 'item'])
bom, bom_item = data
bom_doc = frappe.get_doc('BOM', bom)
work_order = make_wo_order_test_record(
item=bom_item,
qty=1,
bom_no=bom,
source_warehouse="_Test Warehouse - _TC")
for row in work_order.required_items:
stock_entry_doc = test_stock_entry.make_stock_entry(
item_code=row.item_code,
target="_Test Warehouse - _TC",
qty=row.required_qty,
basic_rate=100)
stock_entries.append(stock_entry_doc)
ste = frappe.get_doc(
make_stock_entry(work_order.name,
"Material Transfer for Manufacture", 1))
ste.submit()
stock_entries.append(ste)
job_cards = frappe.get_all('Job Card',
filters={'work_order': work_order.name})
self.assertEqual(len(job_cards), len(bom_doc.operations))
for i, job_card in enumerate(job_cards):
doc = frappe.get_doc("Job Card", job_card)
doc.append(
"time_logs", {
"from_time": now(),
"hours": i,
"to_time": add_to_date(now(), i),
"completed_qty": doc.for_quantity
})
doc.submit()
ste1 = frappe.get_doc(
make_stock_entry(work_order.name, "Manufacture", 1))
ste1.submit()
stock_entries.append(ste1)
for job_card in job_cards:
doc = frappe.get_doc("Job Card", job_card)
self.assertRaises(JobCardCancelError, doc.cancel)
stock_entries.reverse()
for stock_entry in stock_entries:
stock_entry.cancel()
def check_planned_qty(self):
planned0 = frappe.db.get_value("Bin", {
"item_code": "_Test FG Item",
"warehouse": "_Test Warehouse 1 - _TC"
}, "planned_qty") or 0
wo_order = make_wo_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(wo_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(wo_order.name, "Manufacture", 4))
s.insert()
s.submit()
self.assertEqual(
frappe.db.get_value("Work Order", wo_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 wo_order
def test_alternative_item_for_production_rm(self):
create_stock_reconciliation(item_code='Alternate Item For A RW 1',
warehouse='_Test Warehouse - _TC',
qty=5,
rate=2000)
create_stock_reconciliation(item_code='Test FG A RW 2',
warehouse='_Test Warehouse - _TC',
qty=5,
rate=2000)
pro_order = make_wo_order_test_record(
production_item='Test Finished Goods - A',
qty=5,
source_warehouse='_Test Warehouse - _TC',
wip_warehouse='Test Supplier Warehouse - _TC')
reserved_qty_for_production = frappe.db.get_value(
'Bin', {
'item_code': 'Test FG A RW 1',
'warehouse': '_Test Warehouse - _TC'
}, 'reserved_qty_for_production')
ste = frappe.get_doc(
make_stock_entry(pro_order.name,
"Material Transfer for Manufacture", 5))
ste.insert()
for item in ste.items:
if item.item_code == 'Test FG A RW 1':
item.item_code = 'Alternate Item For A RW 1'
item.item_name = 'Alternate Item For A RW 1'
item.description = 'Alternate Item For A RW 1'
item.original_item = 'Test FG A RW 1'
ste.submit()
reserved_qty_for_production_after_transfer = frappe.db.get_value(
'Bin', {
'item_code': 'Test FG A RW 1',
'warehouse': '_Test Warehouse - _TC'
}, 'reserved_qty_for_production')
self.assertEqual(reserved_qty_for_production_after_transfer,
flt(reserved_qty_for_production - 5))
ste1 = frappe.get_doc(
make_stock_entry(pro_order.name, "Manufacture", 5))
status = False
for d in ste1.items:
if d.item_code == 'Alternate Item For A RW 1':
status = True
self.assertEqual(status, True)
ste1.submit()
def test_cost_center_for_manufacture(self):
wo_order = make_wo_order_test_record()
ste = make_stock_entry(wo_order.name,
"Material Transfer for Manufacture",
wo_order.qty)
self.assertEquals(
ste.get("items")[0].get("cost_center"), "_Test Cost Center - _TC")
def test_allow_overproduction(self):
allow_overproduction("overproduction_percentage_for_work_order", 0)
wo_order = make_wo_order_test_record(planned_start_date=now(), qty=2)
test_stock_entry.make_stock_entry(item_code="_Test Item",
target="_Test Warehouse - _TC",
qty=10,
basic_rate=5000.0)
test_stock_entry.make_stock_entry(
item_code="_Test Item Home Desktop 100",
target="_Test Warehouse - _TC",
qty=10,
basic_rate=1000.0)
s = frappe.get_doc(
make_stock_entry(wo_order.name,
"Material Transfer for Manufacture", 3))
s.insert()
self.assertRaises(StockOverProductionError, s.submit)
allow_overproduction("overproduction_percentage_for_work_order", 50)
s.load_from_db()
s.submit()
self.assertEqual(s.docstatus, 1)
allow_overproduction("overproduction_percentage_for_work_order", 0)
def test_backflush_qty_for_overpduction_manufacture(self):
cancel_stock_entry = []
allow_overproduction("overproduction_percentage_for_work_order", 30)
wo_order = make_wo_order_test_record(planned_start_date=now(), qty=100)
ste1 = test_stock_entry.make_stock_entry(
item_code="_Test Item",
target="_Test Warehouse - _TC",
qty=120,
basic_rate=5000.0)
ste2 = test_stock_entry.make_stock_entry(
item_code="_Test Item Home Desktop 100",
target="_Test Warehouse - _TC",
qty=240,
basic_rate=1000.0)
cancel_stock_entry.extend([ste1.name, ste2.name])
s = frappe.get_doc(
make_stock_entry(wo_order.name,
"Material Transfer for Manufacture", 60))
s.submit()
cancel_stock_entry.append(s.name)
s = frappe.get_doc(make_stock_entry(wo_order.name, "Manufacture", 60))
s.submit()
cancel_stock_entry.append(s.name)
s = frappe.get_doc(
make_stock_entry(wo_order.name,
"Material Transfer for Manufacture", 60))
s.submit()
cancel_stock_entry.append(s.name)
s1 = frappe.get_doc(make_stock_entry(wo_order.name, "Manufacture", 50))
s1.submit()
cancel_stock_entry.append(s1.name)
self.assertEqual(s1.items[0].qty, 50)
self.assertEqual(s1.items[1].qty, 100)
cancel_stock_entry.reverse()
for ste in cancel_stock_entry:
doc = frappe.get_doc("Stock Entry", ste)
doc.cancel()
allow_overproduction("overproduction_percentage_for_work_order", 0)
def test_partial_material_consumption(self):
frappe.db.set_value("Manufacturing Settings", None,
"material_consumption", 1)
wo_order = make_wo_order_test_record(planned_start_date=now(), qty=4)
ste_cancel_list = []
ste1 = test_stock_entry.make_stock_entry(
item_code="_Test Item",
target="_Test Warehouse - _TC",
qty=20,
basic_rate=5000.0)
ste2 = test_stock_entry.make_stock_entry(
item_code="_Test Item Home Desktop 100",
target="_Test Warehouse - _TC",
qty=20,
basic_rate=1000.0)
ste_cancel_list.extend([ste1, ste2])
s = frappe.get_doc(
make_stock_entry(wo_order.name,
"Material Transfer for Manufacture", 4))
s.submit()
ste_cancel_list.append(s)
ste1 = frappe.get_doc(make_stock_entry(wo_order.name, "Manufacture",
2))
ste1.submit()
ste_cancel_list.append(ste1)
ste3 = frappe.get_doc(
make_stock_entry(wo_order.name,
"Material Consumption for Manufacture", 2))
self.assertEquals(ste3.fg_completed_qty, 2)
expected_qty = {"_Test Item": 2, "_Test Item Home Desktop 100": 4}
for row in ste3.items:
self.assertEquals(row.qty, expected_qty.get(row.item_code))
for ste_doc in ste_cancel_list:
ste_doc.cancel()
frappe.db.set_value("Manufacturing Settings", None,
"material_consumption", 0)
def test_scrap_material_qty(self):
wo_order = make_wo_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(wo_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(wo_order.name, "Manufacture", 2))
s.insert()
s.submit()
wo_order_details = frappe.db.get_value(
"Work Order",
wo_order.name,
["scrap_warehouse", "qty", "produced_qty", "bom_no"],
as_dict=1)
scrap_item_details = get_scrap_item_details(wo_order_details.bom_no)
self.assertEqual(wo_order_details.produced_qty, 2)
for item in s.items:
if item.bom_no and item.item_code in scrap_item_details:
self.assertEqual(wo_order_details.scrap_warehouse,
item.t_warehouse)
self.assertEqual(
flt(wo_order_details.qty) *
flt(scrap_item_details[item.item_code]), item.qty)
def test_work_order_with_non_stock_item(self):
items = {
'Finished Good Test Item For non stock': 1,
'_Test FG Item': 1,
'_Test FG Non Stock Item': 0
}
for item, is_stock_item in items.items():
make_item(item, {'is_stock_item': is_stock_item})
if not frappe.db.get_value('Item Price',
{'item_code': '_Test FG Non Stock Item'}):
frappe.get_doc({
'doctype': 'Item Price',
'item_code': '_Test FG Non Stock Item',
'price_list_rate': 1000,
'price_list': 'Standard Buying'
}).insert(ignore_permissions=True)
fg_item = 'Finished Good Test Item For non stock'
test_stock_entry.make_stock_entry(item_code="_Test FG Item",
target="_Test Warehouse - _TC",
qty=1,
basic_rate=100)
if not frappe.db.get_value('BOM', {'item': fg_item}):
make_bom(
item=fg_item,
rate=1000,
raw_materials=['_Test FG Item', '_Test FG Non Stock Item'])
wo = make_wo_order_test_record(production_item=fg_item)
se = frappe.get_doc(
make_stock_entry(wo.name, "Material Transfer for Manufacture", 1))
se.insert()
se.submit()
ste = frappe.get_doc(make_stock_entry(wo.name, "Manufacture", 1))
ste.insert()
self.assertEqual(len(ste.additional_costs), 1)
self.assertEqual(ste.total_additional_costs, 1000)
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.wo_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.wo_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_over_production(self):
wo_doc = self.check_planned_qty()
test_stock_entry.make_stock_entry(item_code="_Test Item",
target="_Test Warehouse - _TC",
qty=100,
basic_rate=100)
test_stock_entry.make_stock_entry(
item_code="_Test Item Home Desktop 100",
target="_Test Warehouse - _TC",
qty=100,
basic_rate=100)
s = frappe.get_doc(make_stock_entry(wo_doc.name, "Manufacture", 7))
s.insert()
self.assertRaises(StockOverProductionError, s.submit)
def make_stock_entry_from_pro(pro_id, purpose):
from erpbee.manufacturing.doctype.work_order.work_order import make_stock_entry
from erpbee.stock.stock_ledger import NegativeStockError
from erpbee.stock.doctype.stock_entry.stock_entry import IncorrectValuationRateError, \
DuplicateEntryForWorkOrderError, OperationsNotCompleteError
try:
st = frappe.get_doc(make_stock_entry(pro_id, purpose))
st.posting_date = frappe.flags.current_date
st.fiscal_year = str(frappe.flags.current_date.year)
for d in st.get("items"):
d.cost_center = "Main - " + frappe.get_cached_value('Company', st.company, 'abbr')
st.insert()
frappe.db.commit()
st.submit()
frappe.db.commit()
except (NegativeStockError, IncorrectValuationRateError, DuplicateEntryForWorkOrderError,
OperationsNotCompleteError):
frappe.db.rollback()
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)