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)
