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)