def test_max_continuous_leaves(self): employee = get_employee() leave_period = get_leave_period() dataent.delete_doc_if_exists("Leave Type", "Test Leave Type", force=1) leave_type = dataent.get_doc(dict( leave_type_name = 'Test Leave Type', doctype = 'Leave Type', max_leaves_allowed = 15, max_continuous_days_allowed = 3 )).insert() date = add_days(nowdate(), -7) allocate_leaves(employee, leave_period, leave_type.name, 10) leave_application = dataent.get_doc(dict( doctype = 'Leave Application', employee = employee.name, leave_type = leave_type.name, from_date = date, to_date = add_days(date, 4), company = "_Test Company", docstatus = 1, status = "Approved" )) self.assertRaises(dataent.ValidationError, leave_application.insert)
def get_todays_events(as_list=False): """Returns a count of todays events in calendar""" from dataent.desk.doctype.event.event import get_events from dataent.utils import nowdate today = nowdate() events = get_events(today, today) return events if as_list else len(events)
def test_earned_leave(self): leave_period = get_leave_period() employee = get_employee() leave_type = 'Test Earned Leave Type' if not dataent.db.exists('Leave Type', leave_type): dataent.get_doc(dict( leave_type_name = leave_type, doctype = 'Leave Type', is_earned_leave = 1, earned_leave_frequency = 'Monthly', rounding = 0.5, max_leaves_allowed = 6 )).insert() leave_policy = dataent.get_doc({ "doctype": "Leave Policy", "leave_policy_details": [{"leave_type": leave_type, "annual_allocation": 6}] }).insert() dataent.db.set_value("Employee", employee.name, "leave_policy", leave_policy.name) allocate_leaves(employee, leave_period, leave_type, 0, eligible_leaves = 12) from epaas.hr.utils import allocate_earned_leaves i = 0 while(i<14): allocate_earned_leaves() i += 1 self.assertEqual(get_leave_balance_on(employee.name, leave_type, nowdate()), 6)
def create_delivery_note(**args): dn = dataent.new_doc("Delivery Note") args = dataent._dict(args) dn.posting_date = args.posting_date or nowdate() dn.posting_time = args.posting_time or nowtime() dn.set_posting_time = 1 dn.company = args.company or "_Test Company" dn.customer = args.customer or "_Test Customer" dn.currency = args.currency or "INR" dn.is_return = args.is_return dn.return_against = args.return_against dn.append("items", { "item_code": args.item or args.item_code or "_Test Item", "warehouse": args.warehouse or "_Test Warehouse - _TC", "qty": args.qty or 1, "rate": args.rate or 100, "conversion_factor": 1.0, "expense_account": "Cost of Goods Sold - _TC", "cost_center": args.cost_center or "_Test Cost Center - _TC", "serial_no": args.serial_no, "target_warehouse": args.target_warehouse }) if not args.do_not_save: dn.insert() if not args.do_not_submit: dn.submit() return dn
def get_entries(filters): conditions = get_conditions(filters) journal_entries = dataent.db.sql("""SELECT "Journal Entry", jv.name, jv.posting_date, jv.cheque_no, jv.clearance_date, jvd.against_account, jvd.debit - jvd.credit FROM `tabJournal Entry Account` jvd, `tabJournal Entry` jv WHERE jvd.parent = jv.name and jv.docstatus=1 and jvd.account = %(account)s {0} order by posting_date DESC, jv.name DESC""".format(conditions), filters, as_list=1) payment_entries = dataent.db.sql("""SELECT "Payment Entry", name, posting_date, reference_no, clearance_date, party, if(paid_from=%(account)s, paid_amount * -1, received_amount) FROM `tabPayment Entry` WHERE docstatus=1 and (paid_from = %(account)s or paid_to = %(account)s) {0} order by posting_date DESC, name DESC""".format(conditions), filters, as_list=1) return sorted(journal_entries + payment_entries, key=lambda k: k[2] or getdate(nowdate()))
def test_purchase_invoice_blocked_invoice_must_be_in_future(self): pi = make_purchase_invoice(do_not_save=True) pi.release_date = nowdate() self.assertRaises(dataent.ValidationError, pi.save) pi.release_date = '' pi.save()
def make_payment_entry(advance): journal_entry = dataent.get_doc(make_bank_entry("Employee Advance", advance.name)) journal_entry.cheque_no = "123123" journal_entry.cheque_date = nowdate() journal_entry.save() return journal_entry
def get_product_list(search=None, start=0, limit=12): # limit = 12 because we show 12 items in the grid view # base query query = """select I.name, I.item_name, I.item_code, I.route, I.image, I.website_image, I.thumbnail, I.item_group, I.description, I.web_long_description as website_description, I.is_stock_item, case when (S.actual_qty - S.reserved_qty) > 0 then 1 else 0 end as in_stock, I.website_warehouse, I.has_batch_no from `tabItem` I left join tabBin S on I.item_code = S.item_code and I.website_warehouse = S.warehouse where (I.show_in_website = 1) and I.disabled = 0 and (I.end_of_life is null or I.end_of_life='0000-00-00' or I.end_of_life > %(today)s)""" # search term condition if search: query += """ and (I.web_long_description like %(search)s or I.description like %(search)s or I.item_name like %(search)s or I.name like %(search)s)""" search = "%" + cstr(search) + "%" # order by query += """ order by I.weightage desc, in_stock desc, I.modified desc limit %s, %s""" % (cint(start), cint(limit)) data = dataent.db.sql(query, { "search": search, "today": nowdate() }, as_dict=1) for item in data: set_product_info_for_website(item) return [get_item_for_list_in_html(r) for r in data]
def set_indicator(self): if self.docstatus==1: self.indicator_color = 'blue' self.indicator_title = 'Submitted' if self.valid_till and getdate(self.valid_till) < getdate(nowdate()): self.indicator_color = 'darkgrey' self.indicator_title = 'Expired'
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 make_raw_material_request(items, company, sales_order, project=None): if not dataent.has_permission("Sales Order", "write"): dataent.throw(_("Not permitted"), dataent.PermissionError) if isinstance(items, string_types): items = dataent._dict(json.loads(items)) for item in items.get('items'): item["include_exploded_items"] = items.get('include_exploded_items') item["ignore_existing_ordered_qty"] = items.get( 'ignore_existing_ordered_qty') item["include_raw_materials_from_sales_order"] = items.get( 'include_raw_materials_from_sales_order') raw_materials = get_items_for_material_requests(items, sales_order, company) if not raw_materials: dataent.msgprint( _("Material Request not created, as quantity for Raw Materials already available." )) return material_request = dataent.new_doc('Material Request') material_request.update( dict(doctype='Material Request', transaction_date=nowdate(), company=company, requested_by=dataent.session.user, material_request_type='Purchase')) for item in raw_materials: item_doc = dataent.get_cached_doc('Item', item.get('item_code')) schedule_date = add_days(nowdate(), cint(item_doc.lead_time_days)) material_request.append( 'items', { 'item_code': item.get('item_code'), 'qty': item.get('quantity'), 'schedule_date': schedule_date, 'warehouse': item.get('warehouse'), 'sales_order': sales_order, 'project': project }) material_request.insert() material_request.flags.ignore_permissions = 1 material_request.run_method("set_missing_values") material_request.submit() return material_request
def get_expired_batches(batches): """ :param batches: A list of dict in the form [{'expiry_date': datetime.date(20XX, 1, 1), 'name': 'batch_id'}, ...] """ return [ b.name for b in batches if b.expiry_date and b.expiry_date <= getdate(nowdate()) ]
def send_reminder(): dataent.has_permission('GST Settings', throw=True) last_sent = dataent.db.get_single_value('GST Settings', 'gstin_email_sent_on') if last_sent and date_diff(nowdate(), last_sent) < 3: dataent.throw(_("Please wait 3 days before resending the reminder.")) dataent.db.set_value('GST Settings', 'GST Settings', 'gstin_email_sent_on', nowdate()) # enqueue if large number of customers, suppliser dataent.enqueue( 'epaas.regional.doctype.gst_settings.gst_settings.send_gstin_reminder_to_all_parties' ) dataent.msgprint( _('Email Reminders will be sent to all parties with email contacts'))
def make_payament_entry_against_sales_invoice(doc, shopify_settings): from epaas.accounts.doctype.payment_entry.payment_entry import get_payment_entry payemnt_entry = get_payment_entry( doc.doctype, doc.name, bank_account=shopify_settings.cash_bank_account) payemnt_entry.flags.ignore_mandatory = True payemnt_entry.reference_no = doc.name payemnt_entry.reference_date = nowdate() payemnt_entry.submit()
def test_asset_depreciation_value_adjustment(self): pr = make_purchase_receipt(item_code="Macbook Pro", qty=1, rate=100000.0, location="Test Location") asset_name = dataent.db.get_value("Asset", {"purchase_receipt": pr.name}, 'name') asset_doc = dataent.get_doc('Asset', asset_name) asset_doc.calculate_depreciation = 1 month_end_date = get_last_day(nowdate()) purchase_date = nowdate() if nowdate() != month_end_date else add_days( nowdate(), -15) asset_doc.available_for_use_date = purchase_date asset_doc.purchase_date = purchase_date asset_doc.calculate_depreciation = 1 asset_doc.append( "finance_books", { "expected_value_after_useful_life": 200, "depreciation_method": "Straight Line", "total_number_of_depreciations": 3, "frequency_of_depreciation": 10, "depreciation_start_date": month_end_date }) asset_doc.submit() current_value = get_current_asset_value(asset_doc.name) adj_doc = make_asset_value_adjustment( asset=asset_doc.name, current_asset_value=current_value, new_asset_value=50000.0) adj_doc.submit() expected_gle = (("_Test Accumulated Depreciations - _TC", 0.0, 50000.0), ("_Test Depreciations - _TC", 50000.0, 0.0)) gle = dataent.db.sql( """select account, debit, credit from `tabGL Entry` where voucher_type='Journal Entry' and voucher_no = %s order by account""", adj_doc.journal_entry) self.assertEqual(gle, expected_gle)
def test_make_sales_order_with_terms(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.update( {"payment_terms_template": "_Test Payment Term Template"}) quotation.insert() self.assertRaises(dataent.ValidationError, make_sales_order, quotation.name) quotation.save() quotation.submit() self.assertEqual(quotation.payment_schedule[0].payment_amount, 8906.00) self.assertEqual(quotation.payment_schedule[0].due_date, quotation.transaction_date) self.assertEqual(quotation.payment_schedule[1].payment_amount, 8906.00) self.assertEqual(quotation.payment_schedule[1].due_date, add_days(quotation.transaction_date, 30)) 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() self.assertEqual(sales_order.payment_schedule[0].payment_amount, 8906.00) self.assertEqual(sales_order.payment_schedule[0].due_date, getdate(quotation.transaction_date)) self.assertEqual(sales_order.payment_schedule[1].payment_amount, 8906.00) self.assertEqual(sales_order.payment_schedule[1].due_date, getdate(add_days(quotation.transaction_date, 30)))
def validate(self): for task in self.get('asset_maintenance_tasks'): if task.end_date and (getdate(task.start_date) >= getdate( task.end_date)): throw( _("Start date should be less than end date for task {0}"). format(task.maintenance_task)) if getdate(task.next_due_date) < getdate(nowdate()): task.maintenance_status = "Overdue"
def test_purchase_invoice_temporary_blocked(self): pi = make_purchase_invoice(do_not_save=True) pi.release_date = add_days(nowdate(), 10) pi.save() pi.submit() pe = get_payment_entry('Purchase Invoice', dn=pi.name, bank_account="_Test Bank - _TC") self.assertRaises(dataent.ValidationError, pe.save)
def test_result_for_partial_material_request(self): so = make_sales_order() mr=make_material_request(so.name) mr.items[0].qty = 4 mr.schedule_date = add_months(nowdate(),1) mr.submit() report = execute() l = len(report[1]) self.assertEqual((so.items[0].qty - mr.items[0].qty), report[1][l-1]['pending_qty'])
def test_inter_company_jv(self): dataent.db.set_value("Account", "Sales Expenses - _TC", "inter_company_account", 1) dataent.db.set_value("Account", "Buildings - _TC", "inter_company_account", 1) dataent.db.set_value("Account", "Sales Expenses - _TC1", "inter_company_account", 1) dataent.db.set_value("Account", "Buildings - _TC1", "inter_company_account", 1) jv = make_journal_entry("Sales Expenses - _TC", "Buildings - _TC", 100, posting_date=nowdate(), cost_center="Main - _TC", save=False) jv.voucher_type = "Inter Company Journal Entry" jv.multi_currency = 0 jv.insert() jv.submit() jv1 = make_journal_entry("Sales Expenses - _TC1", "Buildings - _TC1", 100, posting_date=nowdate(), cost_center="Main - _TC1", save=False) jv1.inter_company_journal_entry_reference = jv.name jv1.company = "_Test Company 1" jv1.voucher_type = "Inter Company Journal Entry" jv1.multi_currency = 0 jv1.insert() jv1.submit() jv.reload() self.assertEqual(jv.inter_company_journal_entry_reference, jv1.name) self.assertEqual(jv1.inter_company_journal_entry_reference, jv.name) jv.cancel() jv1.reload() jv.reload() self.assertEqual(jv.inter_company_journal_entry_reference, "") self.assertEqual(jv1.inter_company_journal_entry_reference, "")
def validate_asset_finance_books(self, row): if flt(row.expected_value_after_useful_life) >= flt( self.gross_purchase_amount): dataent.throw( _("Row {0}: Expected Value After Useful Life must be less than Gross Purchase Amount" ).format(row.idx)) if not row.depreciation_start_date: dataent.throw( _("Row {0}: Depreciation Start Date is required").format( row.idx)) if not self.is_existing_asset: self.opening_accumulated_depreciation = 0 self.number_of_depreciations_booked = 0 else: depreciable_amount = flt(self.gross_purchase_amount) - flt( row.expected_value_after_useful_life) if flt(self.opening_accumulated_depreciation) > depreciable_amount: dataent.throw( _("Opening Accumulated Depreciation must be less than equal to {0}" ).format(depreciable_amount)) if self.opening_accumulated_depreciation: if not self.number_of_depreciations_booked: dataent.throw( _("Please set Number of Depreciations Booked")) else: self.number_of_depreciations_booked = 0 if cint(self.number_of_depreciations_booked) > cint( row.total_number_of_depreciations): dataent.throw( _("Number of Depreciations Booked cannot be greater than Total Number of Depreciations" )) if row.depreciation_start_date and getdate( row.depreciation_start_date) < getdate(nowdate()): dataent.msgprint(_( "Depreciation Row {0}: Depreciation Start Date is entered as past date" ).format(row.idx), title=_('Warning'), indicator='red') if row.depreciation_start_date and getdate( row.depreciation_start_date) < getdate(self.purchase_date): dataent.throw( _("Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date" ).format(row.idx)) if row.depreciation_start_date and getdate( row.depreciation_start_date) < getdate( self.available_for_use_date): dataent.throw( _("Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date" ).format(row.idx))
def postprocess(source, target_doc): target_doc.supplier = source_name if getdate(target_doc.schedule_date) < getdate(nowdate()): target_doc.schedule_date = None target_doc.set("items", [ d for d in target_doc.get("items") if d.get("item_code") in supplier_items and d.get("qty") > 0 ]) set_missing_values(source, target_doc)
def create_sms_log(args, sent_to): sl = dataent.new_doc('SMS Log') sl.sent_on = nowdate() sl.message = args['message'].decode('utf-8') sl.no_of_requested_sms = len(args['receiver_list']) sl.requested_numbers = "\n".join(args['receiver_list']) sl.no_of_sent_sms = len(sent_to) sl.sent_to = "\n".join(sent_to) sl.flags.ignore_permissions = True sl.save()
def test_staffing_plan(self): _set_up() dataent.db.set_value("Company", "_Test Company", "is_group", 1) if dataent.db.exists("Staffing Plan", "Test"): return staffing_plan = dataent.new_doc("Staffing Plan") staffing_plan.company = "_Test Company 10" staffing_plan.name = "Test" staffing_plan.from_date = nowdate() staffing_plan.to_date = add_days(nowdate(), 10) staffing_plan.append( "staffing_details", { "designation": "Designer", "number_of_positions": 6, "estimated_cost_per_position": 50000 }) staffing_plan.insert() staffing_plan.submit() self.assertEqual(staffing_plan.total_estimated_budget, 300000.00)
def test_expense_claim_status(self): payable_account = get_payable_account("Wind Power LLC") expense_claim = make_expense_claim(payable_account, 300, 200, "Wind Power LLC", "Travel Expenses - WP") je_dict = make_bank_entry("Expense Claim", expense_claim.name) je = dataent.get_doc(je_dict) je.posting_date = nowdate() je.cheque_no = random_string(5) je.cheque_date = nowdate() je.submit() expense_claim = dataent.get_doc("Expense Claim", expense_claim.name) self.assertEqual(expense_claim.status, "Paid") je.cancel() expense_claim = dataent.get_doc("Expense Claim", expense_claim.name) self.assertEqual(expense_claim.status, "Unpaid")
def set_maintenance_status(self): if not self.warranty_expiry_date and not self.amc_expiry_date: self.maintenance_status = None if self.warranty_expiry_date and getdate( self.warranty_expiry_date) < getdate(nowdate()): self.maintenance_status = "Out of Warranty" if self.amc_expiry_date and getdate(self.amc_expiry_date) < getdate( nowdate()): self.maintenance_status = "Out of AMC" if self.amc_expiry_date and getdate(self.amc_expiry_date) >= getdate( nowdate()): self.maintenance_status = "Under AMC" if self.warranty_expiry_date and getdate( self.warranty_expiry_date) >= getdate(nowdate()): self.maintenance_status = "Under Warranty"
def test_make_sales_order_with_different_currency(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() quotation.submit() sales_order = make_sales_order(quotation.name) sales_order.currency = "USD" sales_order.conversion_rate = 20.0 sales_order.delivery_date = "2019-01-01" sales_order.naming_series = "_T-Quotation-" sales_order.transaction_date = nowdate() sales_order.insert() self.assertEquals(sales_order.currency, "USD") self.assertNotEqual(sales_order.currency, quotation.currency)
def make_gl_entries(self): gl_entries = [] if ((self.purchase_receipt or (self.purchase_invoice and dataent.db.get_value( 'Purchase Invoice', self.purchase_invoice, 'update_stock'))) and self.purchase_receipt_amount and self.available_for_use_date <= nowdate()): fixed_aseet_account = get_asset_category_account( self.name, 'fixed_asset_account', asset_category=self.asset_category, company=self.company) cwip_account = get_asset_account( "capital_work_in_progress_account", self.name, self.asset_category, self.company) gl_entries.append( self.get_gl_dict({ "account": cwip_account, "against": fixed_aseet_account, "remarks": self.get("remarks") or _("Accounting Entry for Asset"), "posting_date": self.available_for_use_date, "credit": self.purchase_receipt_amount, "credit_in_account_currency": self.purchase_receipt_amount })) gl_entries.append( self.get_gl_dict({ "account": fixed_aseet_account, "against": cwip_account, "remarks": self.get("remarks") or _("Accounting Entry for Asset"), "posting_date": self.available_for_use_date, "debit": self.purchase_receipt_amount, "debit_in_account_currency": self.purchase_receipt_amount })) if gl_entries: from epaas.accounts.general_ledger import make_gl_entries make_gl_entries(gl_entries) self.db_set('booked_fixed_asset', 1)
def create_payment_entry(self, submit=True): """create entry""" dataent.flags.ignore_account_permission = True ref_doc = dataent.get_doc(self.reference_doctype, self.reference_name) if self.reference_doctype == "Sales Invoice": party_account = ref_doc.debit_to elif self.reference_doctype == "Purchase Invoice": party_account = ref_doc.credit_to else: party_account = get_party_account("Customer", ref_doc.get("customer"), ref_doc.company) party_account_currency = ref_doc.get( "party_account_currency") or get_account_currency(party_account) bank_amount = self.grand_total if party_account_currency == ref_doc.company_currency and party_account_currency != self.currency: party_amount = ref_doc.base_grand_total else: party_amount = self.grand_total payment_entry = get_payment_entry(self.reference_doctype, self.reference_name, party_amount=party_amount, bank_account=self.payment_account, bank_amount=bank_amount) payment_entry.update({ "reference_no": self.name, "reference_date": nowdate(), "remarks": "Payment Entry against {0} {1} via Payment Request {2}".format( self.reference_doctype, self.reference_name, self.name) }) if payment_entry.difference_amount: company_details = get_company_defaults(ref_doc.company) payment_entry.append( "deductions", { "account": company_details.exchange_gain_loss_account, "cost_center": company_details.cost_center, "amount": payment_entry.difference_amount }) if submit: payment_entry.insert(ignore_permissions=True) payment_entry.submit() return payment_entry
def test_movement_for_serialized_asset(self): asset_item = "Test Serialized Asset Item" pr = make_purchase_receipt(item_code=asset_item, rate = 1000, qty=3, location = "Mumbai") asset_name = dataent.db.get_value('Asset', {'purchase_receipt': pr.name}, 'name') asset = dataent.get_doc('Asset', asset_name) month_end_date = get_last_day(nowdate()) asset.available_for_use_date = nowdate() if nowdate() != month_end_date else add_days(nowdate(), -15) asset.calculate_depreciation = 1 asset.append("finance_books", { "expected_value_after_useful_life": 200, "depreciation_method": "Straight Line", "total_number_of_depreciations": 3, "frequency_of_depreciation": 10, "depreciation_start_date": month_end_date }) asset.submit() serial_nos = dataent.db.get_value('Asset Movement', {'reference_name': pr.name}, 'serial_no') mov1 = create_asset_movement(asset=asset_name, purpose = 'Transfer', company=asset.company, source_location = "Mumbai", target_location="Pune", serial_no=serial_nos) self.assertEqual(mov1.target_location, "Pune") serial_no = dataent.db.get_value('Serial No', {'asset': asset_name}, 'name') employee = make_employee("*****@*****.**") create_asset_movement(asset=asset_name, purpose = 'Transfer', company=asset.company, serial_no=serial_no, to_employee=employee) self.assertEqual(dataent.db.get_value('Serial No', serial_no, 'employee'), employee) create_asset_movement(asset=asset_name, purpose = 'Transfer', company=asset.company, serial_no=serial_no, from_employee=employee, to_employee="_T-Employee-00001") self.assertEqual(dataent.db.get_value('Serial No', serial_no, 'location'), "Pune") mov4 = create_asset_movement(asset=asset_name, purpose = 'Transfer', company=asset.company, source_location = "Pune", target_location="Nagpur", serial_no=serial_nos) self.assertEqual(mov4.target_location, "Nagpur") self.assertEqual(dataent.db.get_value('Serial No', serial_no, 'location'), "Nagpur") self.assertEqual(dataent.db.get_value('Serial No', serial_no, 'employee'), "_T-Employee-00001")