def test_outstanding_amount_after_advance_jv_cancelation(self):
from epaas.accounts.doctype.journal_entry.test_journal_entry \
import test_records as jv_test_records
jv = dataent.copy_doc(jv_test_records[1])
jv.accounts[0].is_advance = 'Yes'
jv.insert()
jv.submit()
pi = dataent.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 = dataent.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_merge_leaves(self):
dataent.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
dataent.copy_doc(test_records[5]).insert()
self.test_basic_tree()
def test_purchase_invoice_change_naming_series(self): pi = dataent.copy_doc(test_records[1]) pi.insert() pi.naming_series = 'TEST-' self.assertRaises(dataent.CannotChangeConstantError, pi.save) pi = dataent.copy_doc(test_records[0]) pi.insert() pi.naming_series = 'TEST-' self.assertRaises(dataent.CannotChangeConstantError, pi.save)
def test_invoice_with_advance_and_multi_payment_terms(self):
from epaas.accounts.doctype.journal_entry.test_journal_entry \
import test_records as jv_test_records
jv = dataent.copy_doc(jv_test_records[1])
jv.insert()
jv.submit()
pi = dataent.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, 606.15)
self.assertEqual(pi.payment_schedule[0].due_date, pi.posting_date)
self.assertEqual(pi.payment_schedule[1].payment_amount, 606.15)
self.assertEqual(pi.payment_schedule[1].due_date, add_days(pi.posting_date, 30))
pi.load_from_db()
self.assertTrue(
dataent.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(
dataent.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 = dataent.copy_doc(pr_test_records[0])
set_perpetual_inventory(1, pr.company)
self.assertTrue(cint(epaas.is_perpetual_inventory_enabled(pr.company)), 1)
pr.submit()
pi = dataent.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_serial_no_reqd(self):
se = dataent.copy_doc(test_records[0])
se.get("items")[0].item_code = "_Test Serialized Item"
se.get("items")[0].qty = 2
se.get("items")[0].transfer_qty = 2
se.insert()
self.assertRaises(SerialNoRequiredError, se.submit)
def on_submit(self):
employee = dataent.get_doc("Employee", self.employee)
if self.create_new_employee_id:
new_employee = dataent.copy_doc(employee)
new_employee.name = None
new_employee.employee_number = None
new_employee = update_employee(new_employee, self.transfer_details, date=self.transfer_date)
if self.new_company and self.company != self.new_company:
new_employee.internal_work_history = []
new_employee.date_of_joining = self.transfer_date
new_employee.company = self.new_company
#move user_id to new employee before insert
if employee.user_id and not self.validate_user_in_details():
new_employee.user_id = employee.user_id
employee.db_set("user_id", "")
new_employee.insert()
self.db_set("new_employee_id", new_employee.name)
#relieve the old employee
employee.db_set("relieving_date", self.transfer_date)
employee.db_set("status", "Left")
else:
employee = update_employee(employee, self.transfer_details, date=self.transfer_date)
if self.new_company and self.company != self.new_company:
employee.company = self.new_company
employee.date_of_joining = self.transfer_date
employee.save()
def test_material_request_type_manufacture(self):
mr = dataent.copy_doc(test_records[1]).insert()
mr = dataent.get_doc("Material Request", mr.name)
mr.submit()
completed_qty = mr.items[0].ordered_qty
requested_qty = dataent.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_work_orders(mr.name)
po = dataent.get_doc("Work Order", prod_order[0])
po.wip_warehouse = "_Test Warehouse 1 - _TC"
po.submit()
mr = dataent.get_doc("Material Request", mr.name)
self.assertEqual(completed_qty + po.qty, mr.items[0].ordered_qty)
new_requested_qty = dataent.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.assertEqual(requested_qty - po.qty, new_requested_qty)
po.cancel()
mr = dataent.get_doc("Material Request", mr.name)
self.assertEqual(completed_qty, mr.items[0].ordered_qty)
new_requested_qty = dataent.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.assertEqual(requested_qty, new_requested_qty)
def test_gl_entries_without_perpetual_inventory(self):
dataent.db.set_value("Company", "_Test Company", "round_off_account", "Round Off - _TC")
wrapper = dataent.copy_doc(test_records[0])
set_perpetual_inventory(0, wrapper.company)
self.assertTrue(not cint(epaas.is_perpetual_inventory_enabled(wrapper.company)))
wrapper.insert()
wrapper.submit()
wrapper.load_from_db()
dl = wrapper
expected_gl_entries = {
"_Test Payable - _TC": [0, 1512.0],
"_Test Account Cost for Goods Sold - _TC": [1250, 0],
"_Test Account Shipping Charges - _TC": [100, 0],
"_Test Account Excise Duty - _TC": [140, 0],
"_Test Account Education Cess - _TC": [2.8, 0],
"_Test Account S&H Education Cess - _TC": [1.4, 0],
"_Test Account CST - _TC": [29.88, 0],
"_Test Account VAT - _TC": [156.25, 0],
"_Test Account Discount - _TC": [0, 168.03],
"Round Off - _TC": [0, 0.3]
}
gl_entries = dataent.db.sql("""select account, debit, credit from `tabGL Entry`
where voucher_type = 'Purchase Invoice' and voucher_no = %s""", dl.name, as_dict=1)
for d in gl_entries:
self.assertEqual([d.debit, d.credit], expected_gl_entries.get(d.account))
def test_purchase_invoice_with_subcontracted_item(self):
wrapper = dataent.copy_doc(test_records[0])
wrapper.get("items")[0].item_code = "_Test FG Item"
wrapper.insert()
wrapper.load_from_db()
expected_values = [
["_Test FG Item", 90, 59],
["_Test Item Home Desktop 200", 135, 177]
]
for i, item in enumerate(wrapper.get("items")):
self.assertEqual(item.item_code, expected_values[i][0])
self.assertEqual(item.item_tax_amount, expected_values[i][1])
self.assertEqual(item.valuation_rate, expected_values[i][2])
self.assertEqual(wrapper.base_net_total, 1250)
# tax amounts
expected_values = [
["_Test Account Shipping Charges - _TC", 100, 1350],
["_Test Account Customs Duty - _TC", 125, 1350],
["_Test Account Excise Duty - _TC", 140, 1490],
["_Test Account Education Cess - _TC", 2.8, 1492.8],
["_Test Account S&H Education Cess - _TC", 1.4, 1494.2],
["_Test Account CST - _TC", 29.88, 1524.08],
["_Test Account VAT - _TC", 156.25, 1680.33],
["_Test Account Discount - _TC", 168.03, 1512.30],
]
for i, tax in enumerate(wrapper.get("taxes")):
self.assertEqual(tax.account_head, expected_values[i][0])
self.assertEqual(tax.tax_amount, expected_values[i][1])
self.assertEqual(tax.total, expected_values[i][2])
def test_gl_entries_with_aia_for_non_stock_items(self):
pi = dataent.copy_doc(test_records[1])
set_perpetual_inventory(1, pi.company)
self.assertTrue(cint(epaas.is_perpetual_inventory_enabled(pi.company)), 1)
pi.get("items")[0].item_code = "_Test Non Stock Item"
pi.get("items")[0].expense_account = "_Test Account Cost for Goods Sold - _TC"
pi.get("taxes").pop(0)
pi.get("taxes").pop(1)
pi.insert()
pi.submit()
gl_entries = dataent.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 = sorted([
["_Test Payable - _TC", 0, 620],
["_Test Account Cost for Goods Sold - _TC", 500.0, 0],
["_Test Account VAT - _TC", 120.0, 0],
])
for i, gle in enumerate(gl_entries):
self.assertEqual(expected_values[i][0], gle.account)
self.assertEqual(expected_values[i][1], gle.debit)
self.assertEqual(expected_values[i][2], gle.credit)
set_perpetual_inventory(0, pi.company)
def test_dates_validation_error(self):
doc = dataent.copy_doc(test_records[1])
# Enter invalid dates valid_from >= valid_upto
doc.valid_from = "2017-04-20"
doc.valid_upto = "2017-04-17"
# Valid Upto Date can not be less/equal than Valid From Date
self.assertRaises(dataent.ValidationError, doc.save)
def test_repack_no_change_in_valuation(self):
company = dataent.db.get_value('Warehouse', '_Test Warehouse - _TC',
'company')
set_perpetual_inventory(0, company)
make_stock_entry(item_code="_Test Item",
target="_Test Warehouse - _TC",
qty=50,
basic_rate=100)
make_stock_entry(item_code="_Test Item Home Desktop 100",
target="_Test Warehouse - _TC",
qty=50,
basic_rate=100)
repack = dataent.copy_doc(test_records[3])
repack.posting_date = nowdate()
repack.posting_time = nowtime()
repack.insert()
repack.submit()
self.check_stock_ledger_entries(
"Stock Entry", repack.name,
[["_Test Item", "_Test Warehouse - _TC", -50.0],
["_Test Item Home Desktop 100", "_Test Warehouse - _TC", 1]])
gl_entries = dataent.db.sql("""select account, debit, credit
from `tabGL Entry` where voucher_type='Stock Entry' and voucher_no=%s
order by account desc""",
repack.name,
as_dict=1)
self.assertFalse(gl_entries)
set_perpetual_inventory(0, repack.company)
def test_landed_cost_voucher_for_serialized_item(self):
set_perpetual_inventory(1)
dataent.db.sql(
"delete from `tabSerial No` where name in ('SN001', 'SN002', 'SN003', 'SN004', 'SN005')"
)
pr = dataent.copy_doc(pr_test_records[0])
pr.items[0].item_code = "_Test Serialized Item"
pr.items[0].serial_no = "SN001\nSN002\nSN003\nSN004\nSN005"
pr.submit()
serial_no_rate = dataent.db.get_value("Serial No", "SN001",
"purchase_rate")
submit_landed_cost_voucher("Purchase Receipt", pr.name)
serial_no = dataent.db.get_value("Serial No",
"SN001",
["warehouse", "purchase_rate"],
as_dict=1)
self.assertEqual(serial_no.purchase_rate - serial_no_rate, 5.0)
self.assertEqual(serial_no.warehouse, "_Test Warehouse - _TC")
set_perpetual_inventory(0)
def test_make_sales_order(self):
from epaas.selling.doctype.quotation.quotation import make_sales_order
quotation = dataent.copy_doc(test_records[0])
quotation.transaction_date = nowdate()
quotation.valid_till = add_months(quotation.transaction_date, 1)
quotation.insert()
self.assertRaises(dataent.ValidationError, make_sales_order,
quotation.name)
quotation.submit()
sales_order = make_sales_order(quotation.name)
self.assertEqual(sales_order.doctype, "Sales Order")
self.assertEqual(len(sales_order.get("items")), 1)
self.assertEqual(
sales_order.get("items")[0].doctype, "Sales Order Item")
self.assertEqual(
sales_order.get("items")[0].prevdoc_docname, quotation.name)
self.assertEqual(sales_order.customer, "_Test Customer")
sales_order.delivery_date = "2014-01-01"
sales_order.naming_series = "_T-Quotation-"
sales_order.transaction_date = nowdate()
sales_order.insert()
def test_purchase_invoice_with_shipping_rule(self):
from epaas.accounts.doctype.shipping_rule.test_shipping_rule \
import create_shipping_rule
shipping_rule = create_shipping_rule(shipping_rule_type = "Buying", shipping_rule_name = "Shipping Rule - Purchase Invoice Test")
pi = dataent.copy_doc(test_records[0])
pi.shipping_rule = shipping_rule.name
pi.insert()
shipping_amount = 0.0
for condition in shipping_rule.get("conditions"):
if not condition.to_value or (flt(condition.from_value) <= pi.net_total <= flt(condition.to_value)):
shipping_amount = condition.shipping_amount
shipping_charge = {
"doctype": "Purchase Taxes and Charges",
"category": "Valuation and Total",
"charge_type": "Actual",
"account_head": shipping_rule.account,
"cost_center": shipping_rule.cost_center,
"tax_amount": shipping_amount,
"description": shipping_rule.name,
"add_deduct_tax": "Add"
}
pi.append("taxes", shipping_charge)
pi.save()
self.assertEqual(pi.net_total, 1250)
self.assertEqual(pi.total_taxes_and_charges, 462.3)
self.assertEqual(pi.grand_total, 1712.3)
def test_cannot_submit_cancelled_mr(self):
mr = dataent.copy_doc(test_records[0])
mr.insert()
mr.submit()
mr.load_from_db()
mr.cancel()
self.assertRaises(dataent.ValidationError, mr.submit)
def test_pending_mr_changes_to_stopped_after_stop(self):
mr = dataent.copy_doc(test_records[0])
mr.insert()
mr.submit()
mr.load_from_db()
mr.update_status('Stopped')
self.assertEqual(mr.status, 'Stopped')
def test_cannot_stop_cancelled_material_request(self):
mr = dataent.copy_doc(test_records[0])
mr.insert()
mr.submit()
mr.load_from_db()
mr.cancel()
self.assertRaises(dataent.ValidationError, mr.update_status, 'Stopped')
def test_serial_no_qty_more(self):
se = dataent.copy_doc(test_records[0])
se.get("items")[0].item_code = "_Test Serialized Item"
se.get("items")[0].qty = 2
se.get("items")[0].serial_no = "ABCD\nEFGH\nXYZ"
se.get("items")[0].transfer_qty = 2
se.insert()
self.assertRaises(SerialNoQtyError, se.submit)
def get_item(self, idx):
item_code = test_records[idx].get("item_code")
if not dataent.db.exists("Item", item_code):
item = dataent.copy_doc(test_records[idx])
item.insert()
else:
item = dataent.get_doc("Item", item_code)
return item
def test_incorrect_mapping_of_stock_entry(self):
# submit material request of type Transfer
mr = dataent.copy_doc(test_records[0])
mr.material_request_type = "Material Transfer"
mr.insert()
mr.submit()
# map a stock entry
from epaas.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": 60.0,
"transfer_qty": 60.0,
"s_warehouse": "_Test Warehouse - _TC",
"t_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
})
# check for stopped status of Material Request
se = dataent.copy_doc(se_doc)
self.assertRaises(dataent.MappingMismatchError, se.insert)
# submit material request of type Transfer
mr = dataent.copy_doc(test_records[0])
mr.material_request_type = "Material Issue"
mr.insert()
mr.submit()
# map a stock entry
from epaas.stock.doctype.material_request.material_request import make_stock_entry
se_doc = make_stock_entry(mr.name)
self.assertEqual(
se_doc.get("items")[0].s_warehouse, "_Test Warehouse - _TC")
def make_test_objects(doctype, test_records=None, verbose=None, reset=False):
'''Make test objects from given list of `test_records` or from `test_records.json`'''
records = []
def revert_naming(d):
if getattr(d, 'naming_series', None):
revert_series_if_last(d.naming_series, d.name)
if test_records is None:
test_records = dataent.get_test_records(doctype)
for doc in test_records:
if not doc.get("doctype"):
doc["doctype"] = doctype
d = dataent.copy_doc(doc)
if d.meta.get_field("naming_series"):
if not d.naming_series:
d.naming_series = "_T-" + d.doctype + "-"
if doc.get('name'):
d.name = doc.get('name')
else:
d.set_new_name()
if dataent.db.exists(d.doctype, d.name) and not reset:
dataent.db.rollback()
# do not create test records, if already exists
continue
# submit if docstatus is set to 1 for test record
docstatus = d.docstatus
d.docstatus = 0
try:
d.run_method("before_test_insert")
d.insert()
if docstatus == 1:
d.submit()
except dataent.NameError:
revert_naming(d)
except Exception as e:
if d.flags.ignore_these_exceptions_in_test and e.__class__ in d.flags.ignore_these_exceptions_in_test:
revert_naming(d)
else:
raise
records.append(d.name)
dataent.db.commit()
return records
def test_gl_entries_with_perpetual_inventory(self): pi = dataent.copy_doc(test_records[1]) set_perpetual_inventory(1, pi.company) self.assertTrue(cint(epaas.is_perpetual_inventory_enabled(pi.company)), 1) pi.insert() pi.submit() self.check_gle_for_pi(pi.name) set_perpetual_inventory(0, pi.company)
def make_new_document(args, schedule_date):
doc = dataent.get_doc(args.reference_doctype, args.reference_document)
new_doc = dataent.copy_doc(doc, ignore_no_copy=False)
update_doc(new_doc, doc, args, schedule_date)
new_doc.insert(ignore_permissions=True)
if args.submit_on_creation:
new_doc.submit()
return new_doc
def test_addition_of_new_fields(self):
# Based on https://github.com/dataent/epaas/issues/8456
test_fields_existance = [
'supplier', 'customer', 'uom', 'min_qty', 'lead_time_days',
'packing_unit', 'valid_from', 'valid_upto', 'note'
]
doc_fields = dataent.copy_doc(test_records[1]).__dict__.keys()
for test_field in test_fields_existance:
self.assertTrue(test_field in doc_fields)
def test_merge_groups(self):
dataent.rename_doc("Item Group", "_Test Item Group B", "_Test Item Group C", merge=True)
records_to_test = test_records[2:]
del records_to_test[1]
self.test_basic_tree(records=records_to_test)
# insert Group B back
dataent.copy_doc(test_records[3]).insert()
self.test_basic_tree()
# move its children back
for name in dataent.db.sql_list("""select name from `tabItem Group`
where parent_item_group='_Test Item Group C'"""):
doc = dataent.get_doc("Item Group", name)
doc.parent_item_group = "_Test Item Group B"
doc.save()
self.test_basic_tree()
def test_serial_duplicate(self):
se, serial_nos = self.test_serial_by_series()
se = dataent.copy_doc(test_records[0])
se.get("items")[0].item_code = "_Test Serialized Item With Series"
se.get("items")[0].qty = 1
se.get("items")[0].serial_no = serial_nos[0]
se.get("items")[0].transfer_qty = 1
se.insert()
self.assertRaises(SerialNoDuplicateError, se.submit)
def test_repack_with_additional_costs(self):
company = dataent.db.get_value('Warehouse', '_Test Warehouse - _TC',
'company')
set_perpetual_inventory(1, company)
make_stock_entry(item_code="_Test Item",
target="_Test Warehouse - _TC",
qty=50,
basic_rate=100)
repack = dataent.copy_doc(test_records[3])
repack.posting_date = nowdate()
repack.posting_time = nowtime()
repack.set("additional_costs", [
{
"description": "Actual Oerating Cost",
"amount": 1000
},
{
"description": "additional operating costs",
"amount": 200
},
])
repack.insert()
repack.submit()
stock_in_hand_account = get_inventory_account(
repack.company,
repack.get("items")[1].t_warehouse)
rm_stock_value_diff = abs(
dataent.db.get_value(
"Stock Ledger Entry", {
"voucher_type": "Stock Entry",
"voucher_no": repack.name,
"item_code": "_Test Item"
}, "stock_value_difference"))
fg_stock_value_diff = abs(
dataent.db.get_value(
"Stock Ledger Entry", {
"voucher_type": "Stock Entry",
"voucher_no": repack.name,
"item_code": "_Test Item Home Desktop 100"
}, "stock_value_difference"))
stock_value_diff = flt(fg_stock_value_diff - rm_stock_value_diff, 2)
self.assertEqual(stock_value_diff, 1200)
self.check_gl_entries(
"Stock Entry", repack.name,
sorted([[stock_in_hand_account, 1200, 0.0],
["Expenses Included In Valuation - _TC", 0.0, 1200.0]]))
set_perpetual_inventory(0, repack.company)
def test_mr_changes_from_stopped_to_pending_after_reopen(self):
mr = dataent.copy_doc(test_records[0])
mr.insert()
mr.submit()
self.assertEqual('Pending', mr.status)
mr.update_status('Stopped')
self.assertEqual('Stopped', mr.status)
mr.update_status('Submitted')
self.assertEqual('Pending', mr.status)
