def test_warehouse_user(self): set_perpetual_inventory(0) for role in ("Stock User", "Sales User"): set_user_permission_doctypes(doctype="Stock Entry", role=role, apply_user_permissions=1, user_permission_doctypes=["Warehouse"]) frappe.defaults.add_default("Warehouse", "_Test Warehouse 1 - _TC", "*****@*****.**", "User Permission") frappe.defaults.add_default("Warehouse", "_Test Warehouse 2 - _TC1", "*****@*****.**", "User Permission") test_user = frappe.get_doc("User", "*****@*****.**") test_user.add_roles("Sales User", "Sales Manager", "Stock User") test_user.remove_roles("Stock Manager") frappe.get_doc("User", "*****@*****.**")\ .add_roles("Sales User", "Sales Manager", "Stock User", "Stock Manager") frappe.set_user("*****@*****.**") st1 = frappe.copy_doc(test_records[0]) st1.company = "_Test Company 1" st1.get("items")[0].t_warehouse="_Test Warehouse 2 - _TC1" self.assertRaises(frappe.PermissionError, st1.insert) frappe.set_user("*****@*****.**") st1 = frappe.copy_doc(test_records[0]) st1.company = "_Test Company 1" st1.get("items")[0].t_warehouse="_Test Warehouse 2 - _TC1" st1.insert() st1.submit() frappe.defaults.clear_default("Warehouse", "_Test Warehouse 1 - _TC", "*****@*****.**", parenttype="User Permission") frappe.defaults.clear_default("Warehouse", "_Test Warehouse 2 - _TC1", "*****@*****.**", parenttype="User Permission")
def test_monthly_budget_on_cancellation(self): from erpnext.accounts.utils import BudgetError frappe.db.set_value("Company", "_Test Company", "monthly_bgt_flag", "Stop") self.clear_account_balance() jv = frappe.copy_doc(test_records[0]) jv.get("entries")[0].account = "_Test Account Cost for Goods Sold - _TC" jv.get("entries")[0].cost_center = "_Test Cost Center - _TC" jv.get("entries")[0].credit = 30000.0 jv.get("entries")[1].debit = 30000.0 jv.submit() self.assertTrue(frappe.db.get_value("GL Entry", {"voucher_type": "Journal Voucher", "voucher_no": jv.name})) jv1 = frappe.copy_doc(test_records[0]) jv1.get("entries")[1].account = "_Test Account Cost for Goods Sold - _TC" jv1.get("entries")[1].cost_center = "_Test Cost Center - _TC" jv1.get("entries")[1].debit = 40000.0 jv1.get("entries")[0].credit = 40000.0 jv1.submit() self.assertTrue(frappe.db.get_value("GL Entry", {"voucher_type": "Journal Voucher", "voucher_no": jv1.name})) self.assertRaises(BudgetError, jv.cancel) frappe.db.set_value("Company", "_Test Company", "monthly_bgt_flag", "Ignore")
def test_sales_invoice_with_advance(self): from erpnext.accounts.doctype.journal_entry.test_journal_entry \ import test_records as jv_test_records jv = frappe.copy_doc(jv_test_records[0]) jv.insert() jv.submit() si = frappe.copy_doc(test_records[0]) si.append("advances", { "doctype": "Sales Invoice Advance", "journal_entry": jv.name, "jv_detail_no": jv.get("accounts")[0].name, "advance_amount": 400, "allocated_amount": 300, "remarks": jv.remark }) si.insert() si.submit() si.load_from_db() self.assertTrue(frappe.db.sql("""select name from `tabJournal Entry Account` where reference_name=%s""", si.name)) self.assertTrue(frappe.db.sql("""select name from `tabJournal Entry Account` where reference_name=%s and credit_in_account_currency=300""", si.name)) self.assertEqual(si.outstanding_amount, 261.8) si.cancel() self.assertTrue(not frappe.db.sql("""select name from `tabJournal Entry Account` where reference_name=%s""", si.name))
def test_incorrect_mapping_of_stock_entry(self): # submit material request of type Purchase mr = frappe.copy_doc(test_records[0]) mr.material_request_type = "Transfer" mr.insert() mr.submit() # map a stock entry from erpnext.stock.doctype.material_request.material_request import make_stock_entry se_doc = make_stock_entry(mr.name) se_doc.update({ "posting_date": "2013-03-01", "posting_time": "00:00", "fiscal_year": "_Test Fiscal Year 2013", }) se_doc.get("mtn_details")[0].update({ "qty": 60.0, "transfer_qty": 60.0, "s_warehouse": "_Test Warehouse - _TC", "t_warehouse": "_Test Warehouse 1 - _TC", "incoming_rate": 1.0 }) se_doc.get("mtn_details")[1].update({ "qty": 3.0, "transfer_qty": 3.0, "s_warehouse": "_Test Warehouse 1 - _TC", "incoming_rate": 1.0 }) # check for stopped status of Material Request se = frappe.copy_doc(se_doc) self.assertRaises(frappe.MappingMismatchError, se.insert)
def test_outstanding_amount_after_advance_jv_cancelation(self): from erpnext.accounts.doctype.journal_entry.test_journal_entry \ import test_records as jv_test_records jv = frappe.copy_doc(jv_test_records[1]) jv.accounts[0].is_advance = 'Yes' jv.insert() jv.submit() pi = frappe.copy_doc(test_records[0]) pi.append("advances", { "reference_type": "Journal Entry", "reference_name": jv.name, "reference_row": jv.get("accounts")[0].name, "advance_amount": 400, "allocated_amount": 300, "remarks": jv.remark }) pi.insert() pi.submit() pi.load_from_db() #check outstanding after advance allocation self.assertEqual(flt(pi.outstanding_amount), flt(pi.rounded_total - pi.total_advance)) #added to avoid Document has been modified exception jv = frappe.get_doc("Journal Entry", jv.name) jv.cancel() pi.load_from_db() #check outstanding after advance cancellation self.assertEqual(flt(pi.outstanding_amount), flt(pi.rounded_total + pi.total_advance))
def test_jv_against_sales_order(self): from erpnext.selling.doctype.sales_order.test_sales_order \ import test_records as so_test_records sales_order = frappe.copy_doc(so_test_records[0]) base_jv = frappe.copy_doc(test_records[0]) self.jv_against_voucher_testcase(base_jv, sales_order)
def test_journal_voucher_with_against_jv(self): self.clear_account_balance() jv_invoice = frappe.copy_doc(test_records[2]) jv_invoice.insert() jv_invoice.submit() self.assertTrue(frappe.db.sql("""select name from `tabJournal Voucher Detail` where account = %s and docstatus = 1 and parent = %s""", ("_Test Customer - _TC", jv_invoice.name))) self.assertTrue(not frappe.db.sql("""select name from `tabJournal Voucher Detail` where against_jv=%s""", jv_invoice.name)) jv_payment = frappe.copy_doc(test_records[0]) jv_payment.get("entries")[0].against_jv = jv_invoice.name jv_payment.insert() jv_payment.submit() self.assertTrue(frappe.db.sql("""select name from `tabJournal Voucher Detail` where against_jv=%s""", jv_invoice.name)) self.assertTrue(frappe.db.sql("""select name from `tabJournal Voucher Detail` where against_jv=%s and credit=400""", jv_invoice.name)) # cancel jv_invoice jv_invoice.cancel() self.assertTrue(not frappe.db.sql("""select name from `tabJournal Voucher Detail` where against_jv=%s""", jv_invoice.name))
def test_serialized(self): from erpnext.stock.doctype.stock_entry.test_stock_entry import make_serialized_item from erpnext.stock.doctype.serial_no.serial_no import get_serial_nos se = make_serialized_item() serial_nos = get_serial_nos(se.get("items")[0].serial_no) si = frappe.copy_doc(test_records[0]) si.update_stock = 1 si.get("items")[0].item_code = "_Test Serialized Item With Series" si.get("items")[0].qty = 1 si.get("items")[0].serial_no = serial_nos[0] si.insert() si.submit() self.assertFalse(frappe.db.get_value("Serial No", serial_nos[0], "warehouse")) self.assertEquals(frappe.db.get_value("Serial No", serial_nos[0], "delivery_document_no"), si.name) self.assertEquals(frappe.db.get_value("Serial No", serial_nos[0], "sales_invoice"), si.name) # check if the serial number is already linked with any other Sales Invoice _si = frappe.copy_doc(si.as_dict()) self.assertRaises(frappe.ValidationError, _si.insert) return si
def test_auto_material_request(self): frappe.db.sql("""delete from `tabMaterial Request Item`""") frappe.db.sql("""delete from `tabMaterial Request`""") self._clear_stock_account_balance() frappe.db.set_value("Stock Settings", None, "auto_indent", True) st1 = frappe.copy_doc(test_records[0]) st1.insert() st1.submit() st2 = frappe.copy_doc(test_records[1]) st2.insert() st2.submit() from erpnext.stock.utils import reorder_item reorder_item() mr_name = frappe.db.sql( """select parent from `tabMaterial Request Item` where item_code='_Test Item'""" ) self.assertTrue(mr_name)
def test_closing_entry(self): # clear GL Entries frappe.db.sql("""delete from `tabGL Entry`""") jv = frappe.copy_doc(jv_records[2]) jv.insert() jv.submit() jv1 = frappe.copy_doc(jv_records[0]) jv1.get("entries")[1].account = "_Test Account Cost for Goods Sold - _TC" jv1.get("entries")[1].cost_center = "_Test Cost Center - _TC" jv1.get("entries")[1].debit = 600.0 jv1.get("entries")[0].credit = 600.0 jv1.insert() jv1.submit() pcv = frappe.copy_doc(test_records[0]) pcv.insert() pcv.submit() gl_entries = frappe.db.sql("""select account, debit, credit from `tabGL Entry` where voucher_type='Period Closing Voucher' and voucher_no=%s order by account asc, debit asc""", pcv.name, as_dict=1) self.assertTrue(gl_entries) expected_gl_entries = sorted([ ["_Test Account Reserves and Surplus - _TC", 200.0, 0.0], ["_Test Account Cost for Goods Sold - _TC", 0.0, 600.0], ["Sales - _TC", 400.0, 0.0] ]) for i, gle in enumerate(gl_entries): self.assertEquals(expected_gl_entries[i][0], gle.account) self.assertEquals(expected_gl_entries[i][1], gle.debit) self.assertEquals(expected_gl_entries[i][2], gle.credit)
def test_delete_leaf(self): # for checking later parent_item_group = frappe.db.get_value("Item Group", "_Test Item Group B - 3", "parent_item_group") rgt = frappe.db.get_value("Item Group", parent_item_group, "rgt") ancestors = get_ancestors_of("Item Group", "_Test Item Group B - 3") ancestors = frappe.db.sql( """select name, rgt from `tabItem Group` where name in ({})""".format( ", ".join(["%s"] * len(ancestors)) ), tuple(ancestors), as_dict=True, ) frappe.delete_doc("Item Group", "_Test Item Group B - 3") records_to_test = test_records[2:] del records_to_test[4] self.test_basic_tree(records=records_to_test) # rgt of each ancestor would reduce by 2 for item_group in ancestors: new_lft, new_rgt = frappe.db.get_value("Item Group", item_group.name, ["lft", "rgt"]) self.assertEquals(new_rgt, item_group.rgt - 2) # insert it back frappe.copy_doc(test_records[6]).insert() self.test_basic_tree()
def test_gl_entries_with_auto_accounting_for_stock_against_pr(self): set_perpetual_inventory(1) self.assertEqual(cint(frappe.defaults.get_global_default("auto_accounting_for_stock")), 1) pr = frappe.copy_doc(pr_test_records[0]) pr.submit() pi = frappe.copy_doc(test_records[1]) for d in pi.get("items"): d.purchase_receipt = pr.name pi.insert() pi.submit() gl_entries = frappe.db.sql("""select account, debit, credit from `tabGL Entry` where voucher_type='Purchase Invoice' and voucher_no=%s order by account asc""", pi.name, as_dict=1) self.assertTrue(gl_entries) expected_values = dict((d[0], d) for d in [ ["_Test Payable - _TC", 0, 720], ["Stock Received But Not Billed - _TC", 500.0, 0], ["_Test Account Shipping Charges - _TC", 100.0, 0], ["_Test Account VAT - _TC", 120.0, 0], ]) for i, gle in enumerate(gl_entries): self.assertEquals(expected_values[gle.account][0], gle.account) self.assertEquals(expected_values[gle.account][1], gle.debit) self.assertEquals(expected_values[gle.account][2], gle.credit) set_perpetual_inventory(0)
def test_purchase_invoice_with_advance(self): from erpnext.accounts.doctype.journal_voucher.test_journal_voucher \ import test_records as jv_test_records jv = frappe.copy_doc(jv_test_records[1]) jv.insert() jv.submit() pi = frappe.copy_doc(test_records[0]) pi.append("advance_allocation_details", { "journal_voucher": jv.name, "jv_detail_no": jv.get("entries")[0].name, "advance_amount": 400, "allocated_amount": 300, "remarks": jv.remark }) pi.insert() pi.submit() pi.load_from_db() self.assertTrue(frappe.db.sql("""select name from `tabJournal Voucher Detail` where against_voucher=%s""", pi.name)) self.assertTrue(frappe.db.sql("""select name from `tabJournal Voucher Detail` where against_voucher=%s and debit=300""", pi.name)) self.assertEqual(pi.outstanding_amount, 1212.30) pi.cancel() self.assertTrue(not frappe.db.sql("""select name from `tabJournal Voucher Detail` where against_voucher=%s""", pi.name))
def test_jv_against_purchase_order(self): from erpnext.buying.doctype.purchase_order.test_purchase_order \ import test_records as po_test_records purchase_order = frappe.copy_doc(po_test_records[0]) base_jv = frappe.copy_doc(test_records[1]) self.jv_against_voucher_testcase(base_jv, purchase_order)
def test_warehouse_user(self): set_perpetual_inventory(0) frappe.defaults.add_default("Warehouse", "_Test Warehouse 1 - _TC", "*****@*****.**", "User Permission") frappe.defaults.add_default("Warehouse", "_Test Warehouse 2 - _TC1", "*****@*****.**", "User Permission") test_user = frappe.get_doc("User", "*****@*****.**") test_user.add_roles("Sales User", "Sales Manager", "Material User") test_user.remove_roles("Material Manager") frappe.get_doc("User", "*****@*****.**")\ .add_roles("Sales User", "Sales Manager", "Material User", "Material Manager") frappe.set_user("*****@*****.**") st1 = frappe.copy_doc(test_records[0]) st1.company = "_Test Company 1" st1.get("mtn_details")[0].t_warehouse="_Test Warehouse 2 - _TC1" self.assertRaises(frappe.PermissionError, st1.insert) frappe.set_user("*****@*****.**") st1 = frappe.copy_doc(test_records[0]) st1.company = "_Test Company 1" st1.get("mtn_details")[0].t_warehouse="_Test Warehouse 2 - _TC1" st1.insert() st1.submit() frappe.defaults.clear_default("Warehouse", "_Test Warehouse 1 - _TC", "*****@*****.**", parenttype="User Permission") frappe.defaults.clear_default("Warehouse", "_Test Warehouse 2 - _TC1", "*****@*****.**", parenttype="User Permission")
def test_purchase_invoice_with_advance(self): from erpnext.accounts.doctype.journal_entry.test_journal_entry \ import test_records as jv_test_records jv = frappe.copy_doc(jv_test_records[1]) jv.insert() jv.submit() pi = frappe.copy_doc(test_records[0]) pi.append("advances", { "reference_type": "Journal Entry", "reference_name": jv.name, "reference_row": jv.get("accounts")[0].name, "advance_amount": 400, "allocated_amount": 300, "remarks": jv.remark }) pi.insert() pi.submit() pi.load_from_db() self.assertTrue(frappe.db.sql("""select name from `tabJournal Entry Account` where reference_type='Purchase Invoice' and reference_name=%s and debit_in_account_currency=300""", pi.name)) self.assertEqual(pi.outstanding_amount, 1212.30) pi.cancel() self.assertFalse(frappe.db.sql("""select name from `tabJournal Entry Account` where reference_type='Purchase Invoice' and reference_name=%s""", pi.name))
def test_duplication(self): frappe.db.sql("delete from `tabTime Log`") frappe.get_doc(frappe.copy_doc(test_records[0])).insert() ts = frappe.get_doc(frappe.copy_doc(test_records[0])) self.assertRaises(OverlapError, ts.insert) frappe.db.sql("delete from `tabTime Log`")
def test_merge_leaves(self): frappe.rename_doc("Item Group", "_Test Item Group B - 2", "_Test Item Group B - 1", merge=True) records_to_test = test_records[2:] del records_to_test[3] self.test_basic_tree(records=records_to_test) # insert Group B - 2back frappe.copy_doc(test_records[5]).insert() self.test_basic_tree()
def test_completed_qty_for_purchase(self): frappe.db.sql("""delete from `tabBin`""") # submit material request of type Purchase mr = frappe.copy_doc(test_records[0]) mr.insert() mr.submit() # check if per complete is None self.assertEquals(mr.per_ordered, None) self.assertEquals(mr.get("indent_details")[0].ordered_qty, 0) self.assertEquals(mr.get("indent_details")[1].ordered_qty, 0) self._test_requested_qty(54.0, 3.0) # map a purchase order from erpnext.stock.doctype.material_request.material_request import make_purchase_order po_doc = make_purchase_order(mr.name) po_doc.supplier = "_Test Supplier" po_doc.transaction_date = "2013-07-07" po_doc.get("po_details")[0].qty = 27.0 po_doc.get("po_details")[1].qty = 1.5 po_doc.get("po_details")[0].schedule_date = "2013-07-09" po_doc.get("po_details")[1].schedule_date = "2013-07-09" # check for stopped status of Material Request po = frappe.copy_doc(po_doc) po.insert() po.load_from_db() mr.update_status('Stopped') self.assertRaises(frappe.InvalidStatusError, po.submit) frappe.db.set(po, "docstatus", 1) self.assertRaises(frappe.InvalidStatusError, po.cancel) # resubmit and check for per complete mr.load_from_db() mr.update_status('Submitted') po = frappe.copy_doc(po_doc) po.insert() po.submit() # check if per complete is as expected mr.load_from_db() self.assertEquals(mr.per_ordered, 50) self.assertEquals(mr.get("indent_details")[0].ordered_qty, 27.0) self.assertEquals(mr.get("indent_details")[1].ordered_qty, 1.5) self._test_requested_qty(27.0, 1.5) po.cancel() # check if per complete is as expected mr.load_from_db() self.assertEquals(mr.per_ordered, None) self.assertEquals(mr.get("indent_details")[0].ordered_qty, None) self.assertEquals(mr.get("indent_details")[1].ordered_qty, None) self._test_requested_qty(54.0, 3.0)
def test_delivery_note_gl_entry(self): self.clear_stock_account_balance() set_perpetual_inventory() self.assertEqual(cint(frappe.defaults.get_global_default("auto_accounting_for_stock")), 1) frappe.db.set_value("Item", "_Test Item", "valuation_method", "FIFO") _insert_purchase_receipt() dn = frappe.copy_doc(test_records[0]) dn.get("delivery_note_details")[0].expense_account = "Cost of Goods Sold - _TC" dn.get("delivery_note_details")[0].cost_center = "Main - _TC" stock_in_hand_account = frappe.db.get_value("Account", {"master_name": dn.get("delivery_note_details")[0].warehouse}) from erpnext.accounts.utils import get_balance_on prev_bal = get_balance_on(stock_in_hand_account, dn.posting_date) dn.insert() dn.submit() gl_entries = get_gl_entries("Delivery Note", dn.name) self.assertTrue(gl_entries) expected_values = { stock_in_hand_account: [0.0, 375.0], "Cost of Goods Sold - _TC": [375.0, 0.0] } for i, gle in enumerate(gl_entries): self.assertEquals([gle.debit, gle.credit], expected_values.get(gle.account)) # check stock in hand balance bal = get_balance_on(stock_in_hand_account, dn.posting_date) self.assertEquals(bal, prev_bal - 375.0) # back dated purchase receipt pr = frappe.copy_doc(pr_test_records[0]) pr.posting_date = "2013-01-01" pr.get("purchase_receipt_details")[0].rate = 100 pr.get("purchase_receipt_details")[0].base_amount = 100 pr.insert() pr.submit() gl_entries = get_gl_entries("Delivery Note", dn.name) self.assertTrue(gl_entries) expected_values = { stock_in_hand_account: [0.0, 666.67], "Cost of Goods Sold - _TC": [666.67, 0.0] } for i, gle in enumerate(gl_entries): self.assertEquals([gle.debit, gle.credit], expected_values.get(gle.account)) dn.cancel() self.assertFalse(get_gl_entries("Delivery Note", dn.name)) set_perpetual_inventory(0)
def test_purchase_receipt_return(self): self._clear_stock_account_balance() actual_qty_0 = self._get_actual_qty() from erpnext.stock.doctype.purchase_receipt.test_purchase_receipt import ( test_records as purchase_receipt_test_records, ) from erpnext.stock.doctype.purchase_receipt.purchase_receipt import make_purchase_invoice # submit purchase receipt pr = frappe.copy_doc(purchase_receipt_test_records[0]) pr.insert() pr.submit() actual_qty_1 = self._get_actual_qty() self.assertEquals(actual_qty_0 + 5, actual_qty_1) pi_doc = make_purchase_invoice(pr.name) pi = frappe.get_doc(pi_doc) pi.posting_date = pr.posting_date pi.credit_to = "_Test Supplier - _TC" for d in pi.get("entries"): d.expense_account = "_Test Account Cost for Goods Sold - _TC" d.cost_center = "_Test Cost Center - _TC" for d in pi.get("other_charges"): d.cost_center = "_Test Cost Center - _TC" pi.run_method("calculate_taxes_and_totals") pi.bill_no = "NA" pi.insert() pi.submit() # submit purchase return se = frappe.copy_doc(test_records[0]) se.purpose = "Purchase Return" se.purchase_receipt_no = pr.name se.posting_date = "2013-03-01" se.fiscal_year = "_Test Fiscal Year 2013" se.get("mtn_details")[0].qty = se.get("mtn_details")[0].transfer_qty = 5 se.get("mtn_details")[0].s_warehouse = "_Test Warehouse - _TC" se.insert() se.submit() actual_qty_2 = self._get_actual_qty() self.assertEquals(actual_qty_1 - 5, actual_qty_2) frappe.db.set_default("company", self.old_default_company) return se, pr.name
def test_si_gl_entry_with_aii_and_update_stock_with_warehouse_but_no_account(self): self.clear_stock_account_balance() set_perpetual_inventory() frappe.delete_doc("Account", "_Test Warehouse No Account - _TC") # insert purchase receipt from erpnext.stock.doctype.purchase_receipt.test_purchase_receipt import test_records \ as pr_test_records pr = frappe.copy_doc(pr_test_records[0]) pr.naming_series = "_T-Purchase Receipt-" pr.get("purchase_receipt_details")[0].warehouse = "_Test Warehouse No Account - _TC" pr.insert() pr.submit() si_doc = copy.deepcopy(test_records[1]) si_doc["update_stock"] = 1 si_doc["posting_time"] = "12:05" si_doc.get("entries")[0]["warehouse"] = "_Test Warehouse No Account - _TC" si = frappe.copy_doc(si_doc) si.insert() si.submit() # check stock ledger entries sle = frappe.db.sql("""select * from `tabStock Ledger Entry` where voucher_type = 'Sales Invoice' and voucher_no = %s""", si.name, as_dict=1)[0] self.assertTrue(sle) self.assertEquals([sle.item_code, sle.warehouse, sle.actual_qty], ["_Test Item", "_Test Warehouse No Account - _TC", -1.0]) # check gl entries gl_entries = frappe.db.sql("""select account, debit, credit from `tabGL Entry` where voucher_type='Sales Invoice' and voucher_no=%s order by account asc, debit asc""", si.name, as_dict=1) self.assertTrue(gl_entries) expected_gl_entries = sorted([ [si.debit_to, 630.0, 0.0], [si_doc.get("entries")[0]["income_account"], 0.0, 500.0], [si_doc.get("other_charges")[0]["account_head"], 0.0, 80.0], [si_doc.get("other_charges")[1]["account_head"], 0.0, 50.0], ]) for i, gle in enumerate(gl_entries): self.assertEquals(expected_gl_entries[i][0], gle.account) self.assertEquals(expected_gl_entries[i][1], gle.debit) self.assertEquals(expected_gl_entries[i][2], gle.credit) si.cancel() gle = frappe.db.sql("""select * from `tabGL Entry` where voucher_type='Sales Invoice' and voucher_no=%s""", si.name) self.assertFalse(gle) set_perpetual_inventory(0)
def test_purchase_invoice_change_naming_series(self): pi = frappe.copy_doc(test_records[1]) pi.insert() pi.naming_series = 'TEST-' self.assertRaises(frappe.CannotChangeConstantError, pi.save) pi = frappe.copy_doc(test_records[0]) pi.insert() pi.naming_series = 'TEST-' self.assertRaises(frappe.CannotChangeConstantError, pi.save)
def test_sales_invoice_change_naming_series(self): si = frappe.copy_doc(test_records[2]) si.insert() si.naming_series = 'TEST-' self.assertRaises(frappe.CannotChangeConstantError, si.save) si = frappe.copy_doc(test_records[1]) si.insert() si.naming_series = 'TEST-' self.assertRaises(frappe.CannotChangeConstantError, si.save)
def _insert_material_receipt(self): self._clear_stock_account_balance() se1 = frappe.copy_doc(test_records[0]) se1.insert() se1.submit() se2 = frappe.copy_doc(test_records[0]) se2.get("mtn_details")[0].item_code = "_Test Item Home Desktop 100" se2.insert() se2.submit() frappe.db.set_default("company", self.old_default_company)
def test_duplication(self): frappe.db.sql("delete from `tabTime Log`") tl1 = frappe.get_doc(frappe.copy_doc(test_records[0])) tl1.user = "******" tl1.insert() tl2 = frappe.get_doc(frappe.copy_doc(test_records[0])) tl2.user = "******" self.assertRaises(OverlapError, tl2.insert) frappe.db.sql("delete from `tabTime Log`")
def test_invoice_with_advance_and_multi_payment_terms(self): from erpnext.accounts.doctype.journal_entry.test_journal_entry \ import test_records as jv_test_records jv = frappe.copy_doc(jv_test_records[1]) jv.insert() jv.submit() pi = frappe.copy_doc(test_records[0]) pi.disable_rounded_total = 1 pi.allocate_advances_automatically = 0 pi.append("advances", { "reference_type": "Journal Entry", "reference_name": jv.name, "reference_row": jv.get("accounts")[0].name, "advance_amount": 400, "allocated_amount": 300, "remarks": jv.remark }) pi.insert() pi.update({ "payment_schedule": get_payment_terms("_Test Payment Term Template", pi.posting_date, pi.grand_total) }) pi.save() pi.submit() self.assertEqual(pi.payment_schedule[0].payment_amount, 756.15) self.assertEqual(pi.payment_schedule[0].due_date, pi.posting_date) self.assertEqual(pi.payment_schedule[1].payment_amount, 756.15) self.assertEqual(pi.payment_schedule[1].due_date, add_days(pi.posting_date, 30)) pi.load_from_db() self.assertTrue( frappe.db.sql( "select name from `tabJournal Entry Account` where reference_type='Purchase Invoice' and " "reference_name=%s and debit_in_account_currency=300", pi.name) ) self.assertEqual(pi.outstanding_amount, 1212.30) pi.cancel() self.assertFalse( frappe.db.sql( "select name from `tabJournal Entry Account` where reference_type='Purchase Invoice' and " "reference_name=%s", pi.name) )
def test_gl_entries_with_perpetual_inventory_against_pr(self): pr = frappe.copy_doc(pr_test_records[0]) set_perpetual_inventory(1, pr.company) self.assertTrue(cint(erpnext.is_perpetual_inventory_enabled(pr.company)), 1) pr.submit() pi = frappe.copy_doc(test_records[1]) for d in pi.get("items"): d.purchase_receipt = pr.name pi.insert() pi.submit() self.check_gle_for_pi(pi.name) set_perpetual_inventory(0, pr.company)
def test_material_request_type_manufacture(self): mr = frappe.copy_doc(test_records[1]).insert() mr = frappe.get_doc("Material Request", mr.name) mr.submit() completed_qty = mr.items[0].ordered_qty requested_qty = frappe.db.sql("""select indented_qty from `tabBin` where \ item_code= %s and warehouse= %s """, (mr.items[0].item_code, mr.items[0].warehouse))[0][0] prod_order = raise_production_orders(mr.name) po = frappe.get_doc("Production Order", prod_order[0]) po.wip_warehouse = "_Test Warehouse 1 - _TC" po.submit() mr = frappe.get_doc("Material Request", mr.name) self.assertEquals(completed_qty + po.qty, mr.items[0].ordered_qty) new_requested_qty = frappe.db.sql("""select indented_qty from `tabBin` where \ item_code= %s and warehouse= %s """, (mr.items[0].item_code, mr.items[0].warehouse))[0][0] self.assertEquals(requested_qty - po.qty, new_requested_qty) po.cancel() mr = frappe.get_doc("Material Request", mr.name) self.assertEquals(completed_qty, mr.items[0].ordered_qty) new_requested_qty = frappe.db.sql("""select indented_qty from `tabBin` where \ item_code= %s and warehouse= %s """, (mr.items[0].item_code, mr.items[0].warehouse))[0][0] self.assertEquals(requested_qty, new_requested_qty)
def test_completed_qty_for_issue(self): def _get_requested_qty(): return flt(frappe.db.get_value("Bin", {"item_code": "_Test Item Home Desktop 100", "warehouse": "_Test Warehouse - _TC"}, "indented_qty")) from erpnext.stock.doctype.material_request.material_request import make_stock_entry existing_requested_qty = _get_requested_qty() mr = frappe.copy_doc(test_records[0]) mr.material_request_type = "Material Issue" mr.submit() #testing bin value after material request is submitted self.assertEquals(_get_requested_qty(), existing_requested_qty + 54.0) # receive items to allow issue self._insert_stock_entry(60, 6, "_Test Warehouse - _TC") # make stock entry against MR se_doc = make_stock_entry(mr.name) se_doc.fiscal_year = "_Test Fiscal Year 2014" se_doc.get("items")[0].qty = 54.0 se_doc.insert() se_doc.submit() # check if per complete is as expected mr.load_from_db() self.assertEquals(mr.get("items")[0].ordered_qty, 54.0) self.assertEquals(mr.get("items")[1].ordered_qty, 3.0) #testing bin requested qty after issuing stock against material request self.assertEquals(_get_requested_qty(), existing_requested_qty)
def _test_purchase_return_return_against_purchase_order(self): self._clear_stock_account_balance() actual_qty_0 = self._get_actual_qty() from erpnext.buying.doctype.purchase_order.test_purchase_order \ import test_records as purchase_order_test_records from erpnext.buying.doctype.purchase_order.purchase_order import \ make_purchase_receipt, make_purchase_invoice # submit purchase receipt po = frappe.copy_doc(purchase_order_test_records[0]) po.is_subcontracted = None po.get("po_details")[0].item_code = "_Test Item" po.get("po_details")[0].rate = 50 po.insert() po.submit() pr_doc = make_purchase_receipt(po.name) pr = frappe.get_doc(pr_doc) pr.posting_date = po.transaction_date pr.insert() pr.submit() actual_qty_1 = self._get_actual_qty() self.assertEquals(actual_qty_0 + 10, actual_qty_1) pi_doc = make_purchase_invoice(po.name) pi = frappe.get_doc(pi_doc) pi.posting_date = pr.posting_date pi.credit_to = "_Test Supplier - _TC" for d in pi.get("entries"): d.expense_account = "_Test Account Cost for Goods Sold - _TC" d.cost_center = "_Test Cost Center - _TC" for d in pi.get("other_charges"): d.cost_center = "_Test Cost Center - _TC" pi.run_method("calculate_taxes_and_totals") pi.bill_no = "NA" pi.insert() pi.submit() # submit purchase return se = frappe.copy_doc(test_records[0]) se.purpose = "Purchase Return" se.purchase_receipt_no = pr.name se.posting_date = "2013-03-01" se.fiscal_year = "_Test Fiscal Year 2013" se.get("mtn_details")[0].qty = se.get( "mtn_details")[0].transfer_qty = 5 se.get("mtn_details")[0].s_warehouse = "_Test Warehouse - _TC" se.insert() se.submit() actual_qty_2 = self._get_actual_qty() self.assertEquals(actual_qty_1 - 5, actual_qty_2) frappe.db.set_default("company", self.old_default_company) return se, pr.name
def make(self): w = frappe.copy_doc(test_records[0]) w.is_pos = 0 w.insert() w.submit() return w
def test_cannot_submit_deleted_material_request(self): mr = frappe.copy_doc(test_records[0]) mr.insert() mr.delete() self.assertRaises(frappe.ValidationError, mr.submit)
def get_application(self, doc): application = frappe.copy_doc(doc) application.from_date = "2013-01-01" application.to_date = "2013-01-05" return application
def test_cannot_stop_unsubmitted_mr(self): mr = frappe.copy_doc(test_records[0]) mr.insert() self.assertRaises(frappe.InvalidStatusError, mr.update_status, 'Stopped')
def test_jv_against_sales_order(self): from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order sales_order = make_sales_order(do_not_save=True) base_jv = frappe.copy_doc(test_records[0]) self.jv_against_voucher_testcase(base_jv, sales_order)
def test_completed_qty_for_over_transfer(self): frappe.db.sql("""delete from `tabBin`""") frappe.db.sql("""delete from `tabStock Ledger Entry`""") # submit material request of type Purchase mr = frappe.copy_doc(test_records[0]) mr.material_request_type = "Transfer" mr.insert() mr.submit() # check if per complete is None self.assertEquals(mr.per_ordered, None) self.assertEquals(mr.get("indent_details")[0].ordered_qty, 0) self.assertEquals(mr.get("indent_details")[1].ordered_qty, 0) self._test_requested_qty(54.0, 3.0) # map a stock entry from erpnext.stock.doctype.material_request.material_request import make_stock_entry se_doc = make_stock_entry(mr.name) se_doc.update({ "posting_date": "2013-03-01", "posting_time": "00:00", "fiscal_year": "_Test Fiscal Year 2013", }) se_doc.get("mtn_details")[0].update({ "qty": 60.0, "transfer_qty": 60.0, "s_warehouse": "_Test Warehouse 1 - _TC", "incoming_rate": 1.0 }) se_doc.get("mtn_details")[1].update({ "qty": 3.0, "transfer_qty": 3.0, "s_warehouse": "_Test Warehouse 1 - _TC", "incoming_rate": 1.0 }) # make available the qty in _Test Warehouse 1 before transfer self._insert_stock_entry(60.0, 3.0) # check for stopped status of Material Request se = frappe.copy_doc(se_doc) se.insert() mr.update_status('Stopped') self.assertRaises(frappe.InvalidStatusError, se.submit) self.assertRaises(frappe.InvalidStatusError, se.cancel) mr.update_status('Submitted') se = frappe.copy_doc(se_doc) se.insert() se.submit() # check if per complete is as expected mr.load_from_db() self.assertEquals(mr.per_ordered, 100) self.assertEquals(mr.get("indent_details")[0].ordered_qty, 60.0) self.assertEquals(mr.get("indent_details")[1].ordered_qty, 3.0) self._test_requested_qty(0.0, 0.0) # check if per complete is as expected for Stock Entry cancelled se.cancel() mr.load_from_db() self.assertEquals(mr.per_ordered, 0) self.assertEquals(mr.get("indent_details")[0].ordered_qty, 0) self.assertEquals(mr.get("indent_details")[1].ordered_qty, 0) self._test_requested_qty(54.0, 3.0)
def create_voucher(self, test_record, args): doc = frappe.copy_doc(test_record) doc.update(args) doc.insert() doc.submit() return doc
def test_journal_entry_with_against_jv(self): jv_invoice = frappe.copy_doc(test_records[2]) base_jv = frappe.copy_doc(test_records[0]) self.jv_against_voucher_testcase(base_jv, jv_invoice)
def test_sales_invoice_calculation_export_currency_with_tax_inclusive_price(self): # prepare si = frappe.copy_doc(test_records[3]) si.currency = "USD" si.conversion_rate = 50 si.get("items")[0].price_list_rate = 55.56 si.get("items")[0].discount_percentage = 10 si.get("items")[1].price_list_rate = 187.5 si.get("items")[1].discount_percentage = 20 # change shipping to $2 si.get("taxes")[6].tax_amount = 2 si.insert() expected_values = [ { "item_code": "_Test Item Home Desktop 100", "price_list_rate": 55.56, "discount_percentage": 10, "rate": 50, "amount": 500, "base_price_list_rate": 2778, "base_rate": 2500, "base_amount": 25000, "net_rate": 40, "net_amount": 399.98, "base_net_rate": 2000, "base_net_amount": 19999 }, { "item_code": "_Test Item Home Desktop 200", "price_list_rate": 187.5, "discount_percentage": 20, "rate": 150, "amount": 750, "base_price_list_rate": 9375, "base_rate": 7500, "base_amount": 37500, "net_rate": 118.01, "net_amount": 590.05, "base_net_rate": 5900.5, "base_net_amount": 29502.5 } ] # check if children are saved self.assertEquals(len(si.get("items")), len(expected_values)) # check if item values are calculated for i, d in enumerate(si.get("items")): for key, val in expected_values[i].items(): self.assertEquals(d.get(key), val) # check net total self.assertEquals(si.base_net_total, 49501.5) self.assertEquals(si.net_total, 990.03) self.assertEquals(si.total, 1250) # check tax calculation expected_values = { "keys": ["base_tax_amount", "base_total", "tax_amount", "total"], "_Test Account Excise Duty - _TC": [5540.5, 55042, 110.81, 1100.84], "_Test Account Education Cess - _TC": [111, 55153, 2.22, 1103.06], "_Test Account S&H Education Cess - _TC": [55.5, 55208.5, 1.11, 1104.17], "_Test Account CST - _TC": [1104, 56312.5, 22.08, 1126.25], "_Test Account VAT - _TC": [6188, 62500.5, 123.76, 1250.01], "_Test Account Customs Duty - _TC": [4950.5, 67451, 99.01, 1349.02], "_Test Account Shipping Charges - _TC": [ 100, 67551, 2, 1351.02], "_Test Account Discount - _TC": [ -6755, 60796, -135.10, 1215.92] } for d in si.get("taxes"): for i, k in enumerate(expected_values["keys"]): self.assertEquals(d.get(k), expected_values[d.account_head][i]) self.assertEquals(si.base_grand_total, 60796) self.assertEquals(si.grand_total, 1215.92)
def test_sales_invoice_discount_amount(self): si = frappe.copy_doc(test_records[3]) si.discount_amount = 104.95 si.append("taxes", { "doctype": "Sales Taxes and Charges", "charge_type": "On Previous Row Amount", "account_head": "_Test Account Service Tax - _TC", "cost_center": "_Test Cost Center - _TC", "description": "Service Tax", "rate": 10, "row_id": 8, }) si.insert() expected_values = [ { "item_code": "_Test Item Home Desktop 100", "price_list_rate": 62.5, "discount_percentage": 0, "rate": 62.5, "amount": 625, "base_price_list_rate": 62.5, "base_rate": 62.5, "base_amount": 625, "net_rate": 46.54, "net_amount": 465.37, "base_net_rate": 46.54, "base_net_amount": 465.37 }, { "item_code": "_Test Item Home Desktop 200", "price_list_rate": 190.66, "discount_percentage": 0, "rate": 190.66, "amount": 953.3, "base_price_list_rate": 190.66, "base_rate": 190.66, "base_amount": 953.3, "net_rate": 139.62, "net_amount": 698.08, "base_net_rate": 139.62, "base_net_amount": 698.08 } ] # check if children are saved self.assertEquals(len(si.get("items")), len(expected_values)) # check if item values are calculated for i, d in enumerate(si.get("items")): for k, v in expected_values[i].items(): self.assertEquals(d.get(k), v) # check net total self.assertEquals(si.base_net_total, 1163.45) self.assertEquals(si.total, 1578.3) # check tax calculation expected_values = { "keys": ["tax_amount", "tax_amount_after_discount_amount", "total"], "_Test Account Excise Duty - _TC": [140, 130.31, 1293.76], "_Test Account Education Cess - _TC": [2.8, 2.61, 1296.37], "_Test Account S&H Education Cess - _TC": [1.4, 1.31, 1297.68], "_Test Account CST - _TC": [27.88, 25.96, 1323.64], "_Test Account VAT - _TC": [156.25, 145.43, 1469.07], "_Test Account Customs Duty - _TC": [125, 116.35, 1585.42], "_Test Account Shipping Charges - _TC": [100, 100, 1685.42], "_Test Account Discount - _TC": [-180.33, -168.54, 1516.88], "_Test Account Service Tax - _TC": [-18.03, -16.88, 1500] } for d in si.get("taxes"): for i, k in enumerate(expected_values["keys"]): self.assertEquals(d.get(k), expected_values[d.account_head][i]) self.assertEquals(si.base_grand_total, 1500) self.assertEquals(si.grand_total, 1500)
def test_make_time_log(self): from erpnext.manufacturing.doctype.production_order.production_order import make_time_log from frappe.utils import cstr from frappe.utils import time_diff_in_hours prod_order = frappe.get_doc({ "doctype": "Production Order", "production_item": "_Test FG Item 2", "bom_no": "BOM/_Test FG Item 2/001", "qty": 1, "wip_warehouse": "_Test Warehouse - _TC", "fg_warehouse": "_Test Warehouse 1 - _TC", "company": "_Test Company", "planned_start_date": "2014-11-25 00:00:00" }) prod_order.set_production_order_operations() prod_order.insert() prod_order.submit() d = prod_order.operations[0] d.completed_qty = flt(d.completed_qty) time_log = make_time_log(prod_order.name, cstr(d.idx) + ". " + d.operation, \ d.planned_start_time, d.planned_end_time, prod_order.qty - d.completed_qty, operation_id=d.name) self.assertEqual(prod_order.name, time_log.production_order) self.assertEqual((prod_order.qty - d.completed_qty), time_log.completed_qty) self.assertEqual( time_diff_in_hours(d.planned_end_time, d.planned_start_time), time_log.hours) time_log.save() time_log.submit() manufacturing_settings = frappe.get_doc({ "doctype": "Manufacturing Settings", "allow_production_on_holidays": 0 }) manufacturing_settings.save() prod_order.load_from_db() self.assertEqual(prod_order.operations[0].status, "Completed") self.assertEqual(prod_order.operations[0].completed_qty, prod_order.qty) self.assertEqual( get_datetime(prod_order.operations[0].actual_start_time), get_datetime(time_log.from_time)) self.assertEqual( get_datetime(prod_order.operations[0].actual_end_time), get_datetime(time_log.to_time)) self.assertEqual(prod_order.operations[0].actual_operation_time, 60) self.assertEqual(prod_order.operations[0].actual_operating_cost, 100) time_log.cancel() prod_order.load_from_db() self.assertEqual(prod_order.operations[0].status, "Pending") self.assertEqual(flt(prod_order.operations[0].completed_qty), 0) self.assertEqual(flt(prod_order.operations[0].actual_operation_time), 0) self.assertEqual(flt(prod_order.operations[0].actual_operating_cost), 0) time_log2 = frappe.copy_doc(time_log) time_log2.update({ "completed_qty": 10, "from_time": "2014-11-26 00:00:00", "to_time": "2014-11-26 00:00:00", "docstatus": 0 }) self.assertRaises(OverProductionLoggedError, time_log2.save)
def test_add_terms_after_save(self): si = frappe.copy_doc(test_records[2]) si.insert() self.assertTrue(si.payment_schedule) self.assertEqual(getdate(si.payment_schedule[0].due_date), getdate(si.due_date))
def test_jv_against_purchase_order(self): from erpnext.buying.doctype.purchase_order.test_purchase_order import create_purchase_order purchase_order = create_purchase_order(do_not_save=True) base_jv = frappe.copy_doc(test_records[1]) self.jv_against_voucher_testcase(base_jv, purchase_order)
def test_duplicate_variant(self): item = frappe.copy_doc(test_records[11]) item.append("variants", {"item_attribute": "Test Size", "item_attribute_value": "Small"}) self.assertRaises(DuplicateVariant, item.insert)
def test_from_greater_than_to(self): shipping_rule = frappe.copy_doc(test_records[0]) shipping_rule.name = test_records[0].get('name') shipping_rule.get("conditions")[0].from_value = 101 self.assertRaises(FromGreaterThanToError, shipping_rule.insert)
def test_warehouse_company_validation(self): from erpnext.stock.utils import InvalidWarehouseCompany mr = frappe.copy_doc(test_records[0]) mr.company = "_Test Company 1" self.assertRaises(InvalidWarehouseCompany, mr.insert)
def test_many_zero_to_values(self): shipping_rule = frappe.copy_doc(test_records[0]) shipping_rule.name = test_records[0].get('name') shipping_rule.get("conditions")[0].to_value = 0 self.assertRaises(ManyBlankToValuesError, shipping_rule.insert)
def start_process(self_program, self_academic_year,self_remove_permission, self_enrollees): # courses = [self_program] programs = [self_program] school_year = self_academic_year # if self_remove_permission: # This will remove any old permission # remove_old_permission(self_program, self_enrollees) for student in self_enrollees: if student.section_check: # for course in courses: # try: # exists_program = frappe.db.sql(f"SELECT name FROM `tabCourse` WHERE course_name='{course}'") # # if exists_program == (): # frappe.get_doc({ # "doctype": "Course", # "course_name": course # }).insert(ignore_permissions=True) # frappe.db.commit() # except Exception as e: # print(e) for program in programs: # try: submitted_ = frappe.db.sql(f"SELECT name,docstatus FROM `tabProgram Enrollment` " f"WHERE program=%s AND student=%s AND docstatus=1 order by creation DESC LIMIT 1", (program, student.student)) if submitted_ != (): continue exists_program = frappe.db.sql(f"SELECT name,docstatus FROM `tabProgram Enrollment` " f"WHERE program=%s AND student=%s order by creation DESC LIMIT 1", (program,student.student)) print(exists_program) if exists_program == (): frappe.get_doc({ "doctype": "Program Enrollment", "student": student.student, "academic_year": school_year, "program": program, "enrollment_date": frappe.utils.get_datetime().date(), "docstatus": 1 }).insert(ignore_permissions=True) frappe.db.commit() else: print(exists_program) for exists in exists_program: print(exists) if exists[1] == 2: course_es = frappe.db.sql(f"SELECT name FROM `tabCourse Enrollment` " f"WHERE `tabCourse Enrollment`.program_enrollment=%s " f"AND `tabCourse Enrollment`.student=%s", (exists[0], student.student), as_dict=True) print(course_es) for course_e in course_es: try: course_enrollment = frappe.get_doc("Course Enrollment", course_e['name']) course_enrollment.delete() frappe.db.commit() except Exception as e: print(e) # pass # doc = frappe.get_doc("Program Enrollment",exists[0]).delete() doc = frappe.get_doc("Program Enrollment",exists[0]) new_doc = frappe.copy_doc(doc) new_doc.amended_from = exists[0] new_doc.submit() frappe.db.commit() # break elif exists[0] == 0: doc = frappe.get_doc("Program Enrollment", exists[0]) doc.submit() frappe.db.commit() # try: # frappe.db.sql(f"UPDATE `tabProgram Enrollment` SET docstatus=1 " # f"WHERE program=%s AND student=%s",(program,student.student)) # frappe.db.commit() # except: # pass # except Exception as e: # print(e) # try: get_student = frappe.db.sql(f"SELECT user FROM `tabStudent` WHERE name=%s", (student.student), as_dict=1) exists_permission = frappe.db.sql(f"SELECT name FROM `tabUser Permission` " f"WHERE user=%s AND for_value=%s", (get_student[0]['user'],program)) if exists_permission == (): frappe.get_doc({ "doctype": "User Permission", "user": get_student[0]['user'], "allow": "Program", "for_value": program }).insert(ignore_permissions=True) frappe.db.commit()
def insert_existing_sle(self, valuation_method): frappe.db.set_value("Item", "_Test Item", "valuation_method", valuation_method) frappe.db.set_default("allow_negative_stock", 1) stock_entry = { "company": "_Test Company", "doctype": "Stock Entry", "posting_date": "2012-12-12", "posting_time": "01:00", "purpose": "Material Receipt", "fiscal_year": "_Test Fiscal Year 2012", "mtn_details": [ { "conversion_factor": 1.0, "doctype": "Stock Entry Detail", "item_code": "_Test Item", "parentfield": "mtn_details", "incoming_rate": 1000, "qty": 20.0, "stock_uom": "_Test UOM", "transfer_qty": 20.0, "uom": "_Test UOM", "t_warehouse": "_Test Warehouse - _TC", "expense_account": "Stock Adjustment - _TC", "cost_center": "_Test Cost Center - _TC" } ] } pr = frappe.copy_doc(stock_entry) pr.insert() pr.submit() pr1 = frappe.copy_doc(stock_entry) pr1.posting_date = "2012-12-15" pr1.posting_time = "02:00" pr1.get("mtn_details")[0].qty = 10 pr1.get("mtn_details")[0].transfer_qty = 10 pr1.get("mtn_details")[0].incoming_rate = 700 pr1.insert() pr1.submit() pr2 = frappe.copy_doc(stock_entry) pr2.posting_date = "2012-12-25" pr2.posting_time = "03:00" pr2.purpose = "Material Issue" pr2.get("mtn_details")[0].s_warehouse = "_Test Warehouse - _TC" pr2.get("mtn_details")[0].t_warehouse = None pr2.get("mtn_details")[0].qty = 15 pr2.get("mtn_details")[0].transfer_qty = 15 pr2.get("mtn_details")[0].incoming_rate = 0 pr2.insert() pr2.submit() pr3 = frappe.copy_doc(stock_entry) pr3.posting_date = "2012-12-31" pr3.posting_time = "08:00" pr3.purpose = "Material Issue" pr3.get("mtn_details")[0].s_warehouse = "_Test Warehouse - _TC" pr3.get("mtn_details")[0].t_warehouse = None pr3.get("mtn_details")[0].qty = 20 pr3.get("mtn_details")[0].transfer_qty = 20 pr3.get("mtn_details")[0].incoming_rate = 0 pr3.insert() pr3.submit() pr4 = frappe.copy_doc(stock_entry) pr4.posting_date = "2013-01-05" pr4.fiscal_year = "_Test Fiscal Year 2013" pr4.posting_time = "07:00" pr4.get("mtn_details")[0].qty = 15 pr4.get("mtn_details")[0].transfer_qty = 15 pr4.get("mtn_details")[0].incoming_rate = 1200 pr4.insert() pr4.submit()
def test_cannot_delete_submitted_mr(self): mr = frappe.copy_doc(test_records[0]) mr.insert() mr.submit() self.assertRaises(frappe.ValidationError, mr.delete)
def test_default_warehouse(self): item = frappe.copy_doc(test_records[0]) item.is_stock_item = 1 item.default_warehouse = None self.assertRaises(WarehouseNotSet, item.insert)
def test_pos_gl_entry_with_aii(self): self.clear_stock_account_balance() set_perpetual_inventory() self.make_pos_setting() self._insert_purchase_receipt() pos = copy.deepcopy(test_records[1]) pos["is_pos"] = 1 pos["update_stock"] = 1 pos["posting_time"] = "12:05" pos["cash_bank_account"] = "_Test Account Bank Account - _TC" pos["paid_amount"] = 600.0 si = frappe.copy_doc(pos) si.insert() si.submit() # check stock ledger entries sle = frappe.db.sql("""select * from `tabStock Ledger Entry` where voucher_type = 'Sales Invoice' and voucher_no = %s""", si.name, as_dict=1)[0] self.assertTrue(sle) self.assertEquals([sle.item_code, sle.warehouse, sle.actual_qty], ["_Test Item", "_Test Warehouse - _TC", -1.0]) # check gl entries gl_entries = frappe.db.sql("""select account, debit, credit from `tabGL Entry` where voucher_type='Sales Invoice' and voucher_no=%s order by account asc, debit asc""", si.name, as_dict=1) self.assertTrue(gl_entries) stock_in_hand = frappe.db.get_value( "Account", {"master_name": "_Test Warehouse - _TC"}) expected_gl_entries = sorted( [[si.debit_to, 630.0, 0.0], [pos["entries"][0]["income_account"], 0.0, 500.0], [pos["other_charges"][0]["account_head"], 0.0, 80.0], [pos["other_charges"][1]["account_head"], 0.0, 50.0], [stock_in_hand, 0.0, 75.0], [pos["entries"][0]["expense_account"], 75.0, 0.0], [si.debit_to, 0.0, 600.0], ["_Test Account Bank Account - _TC", 600.0, 0.0]]) for i, gle in enumerate(gl_entries): self.assertEquals(expected_gl_entries[i][0], gle.account) self.assertEquals(expected_gl_entries[i][1], gle.debit) self.assertEquals(expected_gl_entries[i][2], gle.credit) si.cancel() gle = frappe.db.sql( """select * from `tabGL Entry` where voucher_type='Sales Invoice' and voucher_no=%s""", si.name) self.assertFalse(gle) self.assertFalse(get_stock_and_account_difference([stock_in_hand])) set_perpetual_inventory(0) frappe.db.sql("delete from `tabPOS Setting`")
def test_completed_qty_for_purchase(self): existing_requested_qty_item1 = self._get_requested_qty( "_Test Item Home Desktop 100", "_Test Warehouse - _TC") existing_requested_qty_item2 = self._get_requested_qty( "_Test Item Home Desktop 200", "_Test Warehouse - _TC") # submit material request of type Purchase mr = frappe.copy_doc(test_records[0]) mr.insert() mr.submit() # check if per complete is None mr.load_from_db() self.assertEquals(mr.per_ordered, 0) self.assertEquals(mr.get("items")[0].ordered_qty, 0) self.assertEquals(mr.get("items")[1].ordered_qty, 0) # map a purchase order from erpnext.stock.doctype.material_request.material_request import make_purchase_order po_doc = make_purchase_order(mr.name) po_doc.supplier = "_Test Supplier" po_doc.transaction_date = "2013-07-07" po_doc.get("items")[0].qty = 27.0 po_doc.get("items")[1].qty = 1.5 po_doc.get("items")[0].schedule_date = "2013-07-09" po_doc.get("items")[1].schedule_date = "2013-07-09" # check for stopped status of Material Request po = frappe.copy_doc(po_doc) po.insert() po.load_from_db() mr.update_status('Stopped') self.assertRaises(frappe.InvalidStatusError, po.submit) frappe.db.set(po, "docstatus", 1) self.assertRaises(frappe.InvalidStatusError, po.cancel) # resubmit and check for per complete mr.load_from_db() mr.update_status('Submitted') po = frappe.copy_doc(po_doc) po.insert() po.submit() # check if per complete is as expected mr.load_from_db() self.assertEquals(mr.per_ordered, 50) self.assertEquals(mr.get("items")[0].ordered_qty, 27.0) self.assertEquals(mr.get("items")[1].ordered_qty, 1.5) current_requested_qty_item1 = self._get_requested_qty( "_Test Item Home Desktop 100", "_Test Warehouse - _TC") current_requested_qty_item2 = self._get_requested_qty( "_Test Item Home Desktop 200", "_Test Warehouse - _TC") self.assertEquals(current_requested_qty_item1, existing_requested_qty_item1 + 27.0) self.assertEquals(current_requested_qty_item2, existing_requested_qty_item2 + 1.5) po.cancel() # check if per complete is as expected mr.load_from_db() self.assertEquals(mr.per_ordered, 0) self.assertEquals(mr.get("items")[0].ordered_qty, 0) self.assertEquals(mr.get("items")[1].ordered_qty, 0) current_requested_qty_item1 = self._get_requested_qty( "_Test Item Home Desktop 100", "_Test Warehouse - _TC") current_requested_qty_item2 = self._get_requested_qty( "_Test Item Home Desktop 200", "_Test Warehouse - _TC") self.assertEquals(current_requested_qty_item1, existing_requested_qty_item1 + 54.0) self.assertEquals(current_requested_qty_item2, existing_requested_qty_item2 + 3.0)
def test_mr_changes_from_pending_to_cancelled_after_cancel(self): mr = frappe.copy_doc(test_records[0]) mr.insert() mr.submit() mr.cancel() self.assertEqual('Cancelled', mr.status)
def test_terms_added_after_save(self): pi = frappe.copy_doc(test_records[1]) pi.insert() self.assertTrue(pi.payment_schedule) self.assertEqual(pi.payment_schedule[0].due_date, pi.due_date)
def _test_sales_invoice_return(self, item_code, delivered_qty, returned_qty): from erpnext.stock.doctype.stock_entry.stock_entry import NotUpdateStockError from erpnext.accounts.doctype.sales_invoice.test_sales_invoice \ import test_records as sales_invoice_test_records # invalid sales invoice as update stock not checked si = frappe.copy_doc(sales_invoice_test_records[1]) si.insert() si.submit() se = frappe.copy_doc(test_records[0]) se.purpose = "Sales Return" se.sales_invoice_no = si.name se.get("mtn_details")[0].qty = returned_qty se.get("mtn_details")[0].transfer_qty = returned_qty self.assertRaises(NotUpdateStockError, se.insert) self._insert_material_receipt() # check currency available qty in bin actual_qty_0 = self._get_actual_qty() # insert a pos invoice with update stock si = frappe.copy_doc(sales_invoice_test_records[1]) si.update_stock = 1 si.get("entries")[0].warehouse = "_Test Warehouse - _TC" si.get("entries")[0].item_code = item_code si.get("entries")[0].qty = 5.0 si.insert() si.submit() # check available bin qty after invoice submission actual_qty_1 = self._get_actual_qty() self.assertEquals(actual_qty_0 - delivered_qty, actual_qty_1) # check if item is validated se = frappe.copy_doc(test_records[0]) se.purpose = "Sales Return" se.sales_invoice_no = si.name se.posting_date = "2013-03-10" se.fiscal_year = "_Test Fiscal Year 2013" se.get("mtn_details")[0].item_code = "_Test Item Home Desktop 200" se.get("mtn_details")[0].qty = returned_qty se.get("mtn_details")[0].transfer_qty = returned_qty # check if stock entry gets submitted self.assertRaises(frappe.DoesNotExistError, se.insert) # try again se = frappe.copy_doc(test_records[0]) se.purpose = "Sales Return" se.posting_date = "2013-03-10" se.fiscal_year = "_Test Fiscal Year 2013" se.sales_invoice_no = si.name se.get("mtn_details")[0].qty = returned_qty se.get("mtn_details")[0].transfer_qty = returned_qty # in both cases item code remains _Test Item when returning se.insert() se.submit() # check if available qty is increased actual_qty_2 = self._get_actual_qty() self.assertEquals(actual_qty_1 + returned_qty, actual_qty_2) return se
def test_serial_no_not_reqd(self): se = frappe.copy_doc(test_records[0]) se.get("items")[0].serial_no = "ABCD" se.insert() self.assertRaises(SerialNoNotRequiredError, se.submit)
def test_completed_qty_for_over_transfer(self): existing_requested_qty_item1 = self._get_requested_qty( "_Test Item Home Desktop 100", "_Test Warehouse - _TC") existing_requested_qty_item2 = self._get_requested_qty( "_Test Item Home Desktop 200", "_Test Warehouse - _TC") # submit material request of type Purchase mr = frappe.copy_doc(test_records[0]) mr.material_request_type = "Material Transfer" mr.insert() mr.submit() # check if per complete is None mr.load_from_db() self.assertEquals(mr.per_ordered, 0) self.assertEquals(mr.get("items")[0].ordered_qty, 0) self.assertEquals(mr.get("items")[1].ordered_qty, 0) # map a stock entry from erpnext.stock.doctype.material_request.material_request import make_stock_entry se_doc = make_stock_entry(mr.name) se_doc.update({ "posting_date": "2013-03-01", "posting_time": "00:00", "fiscal_year": "_Test Fiscal Year 2013", }) se_doc.get("items")[0].update({ "qty": 54.0, "transfer_qty": 54.0, "s_warehouse": "_Test Warehouse 1 - _TC", "basic_rate": 1.0 }) se_doc.get("items")[1].update({ "qty": 3.0, "transfer_qty": 3.0, "s_warehouse": "_Test Warehouse 1 - _TC", "basic_rate": 1.0 }) # make available the qty in _Test Warehouse 1 before transfer self._insert_stock_entry(60.0, 3.0) # check for stopped status of Material Request se = frappe.copy_doc(se_doc) se.insert() mr.update_status('Stopped') self.assertRaises(frappe.InvalidStatusError, se.submit) self.assertRaises(frappe.InvalidStatusError, se.cancel) mr.update_status('Submitted') se = frappe.copy_doc(se_doc) se.insert() se.submit() # check if per complete is as expected mr.load_from_db() self.assertEquals(mr.per_ordered, 100) self.assertEquals(mr.get("items")[0].ordered_qty, 54.0) self.assertEquals(mr.get("items")[1].ordered_qty, 3.0) current_requested_qty_item1 = self._get_requested_qty( "_Test Item Home Desktop 100", "_Test Warehouse - _TC") current_requested_qty_item2 = self._get_requested_qty( "_Test Item Home Desktop 200", "_Test Warehouse - _TC") self.assertEquals(current_requested_qty_item1, existing_requested_qty_item1) self.assertEquals(current_requested_qty_item2, existing_requested_qty_item2) # check if per complete is as expected for Stock Entry cancelled se.cancel() mr.load_from_db() self.assertEquals(mr.per_ordered, 0) self.assertEquals(mr.get("items")[0].ordered_qty, 0) self.assertEquals(mr.get("items")[1].ordered_qty, 0) current_requested_qty_item1 = self._get_requested_qty( "_Test Item Home Desktop 100", "_Test Warehouse - _TC") current_requested_qty_item2 = self._get_requested_qty( "_Test Item Home Desktop 200", "_Test Warehouse - _TC") self.assertEquals(current_requested_qty_item1, existing_requested_qty_item1 + 54.0) self.assertEquals(current_requested_qty_item2, existing_requested_qty_item2 + 3.0)
def test_purchase_invoice_revalue_purchase_receipt(self): from erpnext.stock.doctype.purchase_receipt.test_purchase_receipt import make_purchase_receipt from erpnext.stock.doctype.purchase_receipt.purchase_receipt import make_purchase_invoice from erpnext.accounts.doctype.purchase_invoice.purchase_invoice import ConfirmRevaluePurchaseReceipt old_setting = frappe.get_value("Buying Settings", "Buying Settings", "maintain_same_rate") frappe.set_value("Buying Settings", "Buying Settings", "maintain_same_rate", 0) pr = make_purchase_receipt(item_code='_Test Item Overbillable', rate=100, qty=10) pi = make_purchase_invoice(pr.name) pi.items[0].rate = 200 pi.items[0].qty = 5 pi.append( "taxes", { "category": "Valuation and Total", "charge_type": "Actual", "account_head": "_Test Account Excise Duty - _TC", "cost_center": "_Test Cost Center - _TC", "description": "Excise Duty", "tax_amount": 500 }) pi.save() self.assertRaises(ConfirmRevaluePurchaseReceipt, frappe.copy_doc(pi).submit) pi.revalue_purchase_receipt = 1 pi.save() pi.submit() sle = frappe.db.sql("""select stock_value_difference, incoming_rate from `tabStock Ledger Entry` where voucher_type='Purchase Receipt' and voucher_no=%s and item_code='_Test Item Overbillable'""", pr.name, as_dict=1) self.assertEqual(len(sle), 1) self.assertEqual([sle[0].stock_value_difference, sle[0].incoming_rate], [2000, 200]) # 5*100 + 5*(200+500/5) pi2 = make_purchase_invoice(pr.name) pi2.items[0].rate = 50 pi2.items[0].qty = 5 pi2.append( "taxes", { "category": "Valuation and Total", "charge_type": "Actual", "account_head": "_Test Account Excise Duty - _TC", "cost_center": "_Test Cost Center - _TC", "description": "Excise Duty", "tax_amount": 50 }) pi2.revalue_purchase_receipt = 1 pi2.save() pi2.submit() sle2 = frappe.db.sql("""select stock_value_difference, incoming_rate from `tabStock Ledger Entry` where voucher_type='Purchase Receipt' and voucher_no=%s and item_code='_Test Item Overbillable'""", pr.name, as_dict=1) self.assertEqual(len(sle2), 1) self.assertEqual( [sle2[0].stock_value_difference, sle2[0].incoming_rate], [1800, 180]) # 5*(200+500/5) + 5*(50+50/5) pi.cancel() sle3 = frappe.db.sql("""select stock_value_difference, incoming_rate from `tabStock Ledger Entry` where voucher_type='Purchase Receipt' and voucher_no=%s and item_code='_Test Item Overbillable'""", pr.name, as_dict=1) self.assertEqual(len(sle3), 1) self.assertEqual( [sle3[0].stock_value_difference, sle3[0].incoming_rate], [800, 80]) # 5*(100) + 5*(50+50/5) frappe.set_value("Buying Settings", "Buying Settings", "maintain_same_rate", old_setting)