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_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_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_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_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_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,
"make_work_order_for_sub_assembly_items": 1
})
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_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 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)
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_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):
#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_pick_list_for_batched_and_serialised_item(self):
# check if oldest batch no and serial nos are picked
item = frappe.db.exists("Item",
{'item_name': 'Batched and Serialised Item'})
if not item:
item = create_item("Batched and Serialised Item")
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'})
pr1 = make_purchase_receipt(item_code="Batched and Serialised Item",
qty=2,
rate=100.0)
pr1.load_from_db()
oldest_batch_no = pr1.items[0].batch_no
oldest_serial_nos = pr1.items[0].serial_no
pr2 = make_purchase_receipt(item_code="Batched and Serialised Item",
qty=2,
rate=100.0)
pick_list = frappe.get_doc({
'doctype':
'Pick List',
'company':
'_Test Company',
'purpose':
'Material Transfer',
'locations': [{
'item_code': 'Batched and Serialised Item',
'qty': 2,
'stock_qty': 2,
'conversion_factor': 1,
}]
})
pick_list.set_item_locations()
self.assertEqual(pick_list.locations[0].batch_no, oldest_batch_no)
self.assertEqual(pick_list.locations[0].serial_no, oldest_serial_nos)
pr1.cancel()
pr2.cancel()
def test_creation_of_ledger_entry_on_submit(self):
''' test creation of gl entries on submission of document '''
deferred_account = create_account(account_name="Deferred Revenue",
parent_account="Current Liabilities - _TC", company="_Test Company")
item = create_item("_Test Item for Deferred Accounting")
item.enable_deferred_revenue = 1
item.deferred_revenue_account = deferred_account
item.no_of_months = 12
item.save()
si = create_sales_invoice(item=item.name, update_stock=0, posting_date="2019-01-10", do_not_submit=True)
si.items[0].enable_deferred_revenue = 1
si.items[0].service_start_date = "2019-01-10"
si.items[0].service_end_date = "2019-03-15"
si.items[0].deferred_revenue_account = deferred_account
si.save()
si.submit()
process_deferred_accounting = doc = frappe.get_doc(dict(
doctype='Process Deferred Accounting',
posting_date="2019-01-01",
start_date="2019-01-01",
end_date="2019-01-31",
type="Income"
))
process_deferred_accounting.insert()
process_deferred_accounting.submit()
expected_gle = [
[deferred_account, 33.85, 0.0, "2019-01-31"],
["Sales - _TC", 0.0, 33.85, "2019-01-31"]
]
check_gl_entries(self, si.name, expected_gle, "2019-01-10")
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")
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 setUp(self):
create_item("_Test Item with QA")
frappe.db.set_value("Item", "_Test Item with QA",
"inspection_required_before_delivery", 1)
