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 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)