def setUp(self): make_employee("*****@*****.**") make_employee("*****@*****.**") create_payroll_period() create_exemption_category() frappe.db.sql( """delete from `tabEmployee Tax Exemption Declaration`""")
def test_payroll_frequency(self): fiscal_year = get_fiscal_year(nowdate(), company=erpbee.get_default_company())[0] month = "%02d" % getdate(nowdate()).month m = get_month_details(fiscal_year, month) for payroll_frequency in [ "Monthly", "Bimonthly", "Fortnightly", "Weekly", "Daily" ]: make_employee(payroll_frequency + "*****@*****.**") ss = make_employee_salary_slip( payroll_frequency + "*****@*****.**", payroll_frequency, payroll_frequency + "_Test Payroll Frequency") if payroll_frequency == "Monthly": self.assertEqual(ss.end_date, m['month_end_date']) elif payroll_frequency == "Bimonthly": if getdate(ss.start_date).day <= 15: self.assertEqual(ss.end_date, m['month_mid_end_date']) else: self.assertEqual(ss.end_date, m['month_end_date']) elif payroll_frequency == "Fortnightly": self.assertEqual(ss.end_date, add_days(nowdate(), 13)) elif payroll_frequency == "Weekly": self.assertEqual(ss.end_date, add_days(nowdate(), 6)) elif payroll_frequency == "Daily": self.assertEqual(ss.end_date, nowdate())
def test_salary_slip_with_holidays_excluded(self): no_of_days = self.get_no_of_days() frappe.db.set_value("Payroll Settings", None, "include_holidays_in_total_working_days", 0) make_employee("*****@*****.**") frappe.db.set_value( "Employee", frappe.get_value( "Employee", { "employee_name": "*****@*****.**" }, "name"), "relieving_date", None) frappe.db.set_value( "Employee", frappe.get_value( "Employee", { "employee_name": "*****@*****.**" }, "name"), "status", "Active") ss = make_employee_salary_slip( "*****@*****.**", "Monthly", "Test Salary Slip With Holidays Excluded") self.assertEqual(ss.total_working_days, no_of_days[0] - no_of_days[1]) self.assertEqual(ss.payment_days, no_of_days[0] - no_of_days[1]) self.assertEqual(ss.earnings[0].amount, 50000) self.assertEqual(ss.earnings[0].default_amount, 50000) self.assertEqual(ss.earnings[1].amount, 3000) self.assertEqual(ss.gross_pay, 78000)
def test_employee_salary_slip_read_permission(self): make_employee("*****@*****.**") salary_slip_test_employee = make_employee_salary_slip( "*****@*****.**", "Monthly", "Test Employee Salary Slip Read Permission") frappe.set_user("*****@*****.**") self.assertTrue(salary_slip_test_employee.has_permission("read"))
def setUp(self): for dt in [ "Salary Slip", "Salary Structure", "Salary Structure Assignment" ]: frappe.db.sql("delete from `tab%s`" % dt) self.make_holiday_list() frappe.db.set_value("Company", erpbee.get_default_company(), "default_holiday_list", "Salary Structure Test Holiday List") make_employee("*****@*****.**") make_employee("*****@*****.**")
def test_email_salary_slip(self): frappe.db.sql("delete from `tabEmail Queue`") frappe.db.set_value("Payroll Settings", None, "email_salary_slip_to_employee", 1) make_employee("*****@*****.**") ss = make_employee_salary_slip("*****@*****.**", "Monthly", "Test Salary Slip Email") ss.company = "_Test Company" ss.save() ss.submit() email_queue = frappe.db.sql("""select name from `tabEmail Queue`""") self.assertTrue(email_queue)
def test_salary_structure_deduction_based_on_gross_pay(self): emp = make_employee("*****@*****.**") sal_struct = make_salary_structure("Salary Structure 2", "Monthly", dont_submit=True) sal_struct.earnings = [sal_struct.earnings[0]] sal_struct.earnings[0].amount_based_on_formula = 1 sal_struct.earnings[0].formula = "base" sal_struct.deductions = [sal_struct.deductions[0]] sal_struct.deductions[0].amount_based_on_formula = 1 sal_struct.deductions[0].condition = "gross_pay > 100" sal_struct.deductions[0].formula = "gross_pay * 0.2" sal_struct.submit() assignment = create_salary_structure_assignment( emp, "Salary Structure 2") ss = make_salary_slip(sal_struct.name, employee=emp) self.assertEqual(assignment.base * 0.2, ss.deductions[0].amount)
def test_multi_currency_payroll_entry(self): # pylint: disable=no-self-use company = erpbee.get_default_company() employee = make_employee("*****@*****.**", company=company) for data in frappe.get_all('Salary Component', fields=["name"]): if not frappe.db.get_value('Salary Component Account', { 'parent': data.name, 'company': company }, 'name'): get_salary_component_account(data.name) company_doc = frappe.get_doc('Company', company) salary_structure = make_salary_structure( "_Test Multi Currency Salary Structure", "Monthly", company=company, currency='USD') create_salary_structure_assignment(employee, salary_structure.name, company=company) frappe.db.sql( """delete from `tabSalary Slip` where employee=%s""", (frappe.db.get_value( "Employee", {"user_id": "*****@*****.**"}))) salary_slip = get_salary_slip( "*****@*****.**", "Monthly", "_Test Multi Currency Salary Structure") dates = get_start_end_dates('Monthly', nowdate()) payroll_entry = make_payroll_entry( start_date=dates.start_date, end_date=dates.end_date, payable_account=company_doc.default_payroll_payable_account, currency='USD', exchange_rate=70) payroll_entry.make_payment_entry() salary_slip.load_from_db() payroll_je = salary_slip.journal_entry payroll_je_doc = frappe.get_doc('Journal Entry', payroll_je) self.assertEqual(salary_slip.base_gross_pay, payroll_je_doc.total_debit) self.assertEqual(salary_slip.base_gross_pay, payroll_je_doc.total_credit) payment_entry = frappe.db.sql(''' Select ifnull(sum(je.total_debit),0) as total_debit, ifnull(sum(je.total_credit),0) as total_credit from `tabJournal Entry` je, `tabJournal Entry Account` jea Where je.name = jea.parent And jea.reference_name = %s ''', (payroll_entry.name), as_dict=1) self.assertEqual(salary_slip.base_net_pay, payment_entry[0].total_debit) self.assertEqual(salary_slip.base_net_pay, payment_entry[0].total_credit)
def test_loan_repayment_salary_slip(self): from erpbee.loan_management.doctype.loan.test_loan import create_loan_type, create_loan, make_loan_disbursement_entry, create_loan_accounts from erpbee.loan_management.doctype.process_loan_interest_accrual.process_loan_interest_accrual import process_loan_interest_accrual_for_term_loans from erpbee.payroll.doctype.salary_structure.test_salary_structure import make_salary_structure applicant = make_employee("*****@*****.**", company="_Test Company") create_loan_accounts() create_loan_type( "Car Loan", 500000, 8.4, is_term_loan=1, mode_of_payment='Cash', payment_account='Payment Account - _TC', loan_account='Loan Account - _TC', interest_income_account='Interest Income Account - _TC', penalty_income_account='Penalty Income Account - _TC') payroll_period = create_payroll_period(name="_Test Payroll Period 1", company="_Test Company") make_salary_structure("Test Loan Repayment Salary Structure", "Monthly", employee=applicant, currency='INR', payroll_period=payroll_period) frappe.db.sql("""delete from `tabLoan""") loan = create_loan(applicant, "Car Loan", 11000, "Repay Over Number of Periods", 20, posting_date=add_months(nowdate(), -1)) loan.repay_from_salary = 1 loan.submit() make_loan_disbursement_entry(loan.name, loan.loan_amount, disbursement_date=add_months( nowdate(), -1)) process_loan_interest_accrual_for_term_loans(posting_date=nowdate()) ss = make_employee_salary_slip( "*****@*****.**", "Monthly", "Test Loan Repayment Salary Structure") ss.submit() self.assertEqual(ss.total_loan_repayment, 592) self.assertEqual( ss.net_pay, (flt(ss.gross_pay) - (flt(ss.total_deduction) + flt(ss.total_loan_repayment))))
def test_timesheet_billing_based_on_project(self): emp = make_employee("*****@*****.**") timesheet = make_timesheet(emp, simulate=True, billable=1, project = '_Test Project', company='_Test Company') sales_invoice = create_sales_invoice(do_not_save=True) sales_invoice.project = '_Test Project' sales_invoice.submit() ts = frappe.get_doc('Timesheet', timesheet.name) self.assertEqual(ts.per_billed, 100) self.assertEqual(ts.time_logs[0].sales_invoice, sales_invoice.name)
def test_timesheet_billing_amount_not_billable(self): emp = make_employee("*****@*****.**") make_salary_structure_for_timesheet(emp) timesheet = make_timesheet(emp, simulate=True, billable=0) self.assertEqual(timesheet.total_hours, 2) self.assertEqual(timesheet.total_billable_hours, 0) self.assertEqual(timesheet.time_logs[0].billing_rate, 0) self.assertEqual(timesheet.time_logs[0].billing_amount, 0) self.assertEqual(timesheet.total_billable_amount, 0)
def test_add_log_based_on_employee_field(self): employee = make_employee("*****@*****.**") employee = frappe.get_doc("Employee", employee) employee.attendance_device_id = '3344' employee.save() time_now = now_datetime().__str__()[:-7] employee_checkin = add_log_based_on_employee_field('3344', time_now, 'mumbai_first_floor', 'IN') self.assertEqual(employee_checkin.employee, employee.name) self.assertEqual(employee_checkin.time, time_now) self.assertEqual(employee_checkin.device_id, 'mumbai_first_floor') self.assertEqual(employee_checkin.log_type, 'IN')
def make_expense_claim(payable_account, amount, sanctioned_amount, company, account, project=None, task_name=None, do_not_submit=False, taxes=None): employee = frappe.db.get_value("Employee", {"status": "Active"}) if not employee: employee = make_employee("test_employee@expense_claim.com", company=company) currency, cost_center = frappe.db.get_value( 'Company', company, ['default_currency', 'cost_center']) expense_claim = { "doctype": "Expense Claim", "employee": employee, "payable_account": payable_account, "approval_status": "Approved", "company": company, 'currency': currency, "expenses": [{ "expense_type": "Travel", "default_account": account, "currency": currency, "amount": amount, "sanctioned_amount": sanctioned_amount, "cost_center": cost_center }] } if taxes: expense_claim.update(taxes) expense_claim = frappe.get_doc(expense_claim) if project: expense_claim.project = project if task_name: expense_claim.task = task_name if do_not_submit: return expense_claim expense_claim.submit() return expense_claim
def test_paid_amount_and_status(self): employee_name = make_employee("*****@*****.**") advance = make_employee_advance(employee_name) journal_entry = make_payment_entry(advance) journal_entry.submit() advance.reload() self.assertEqual(advance.paid_amount, 1000) self.assertEqual(advance.status, "Paid") # try making over payment journal_entry1 = make_payment_entry(advance) self.assertRaises(EmployeeAdvanceOverPayment, journal_entry1.submit)
def test_movement(self): pr = make_purchase_receipt(item_code="Macbook Pro", qty=1, rate=100000.0, location="Test Location") asset_name = frappe.db.get_value("Asset", {"purchase_receipt": pr.name}, 'name') asset = frappe.get_doc('Asset', asset_name) asset.calculate_depreciation = 1 asset.available_for_use_date = '2020-06-06' asset.purchase_date = '2020-06-06' asset.append("finance_books", { "expected_value_after_useful_life": 10000, "next_depreciation_date": "2020-12-31", "depreciation_method": "Straight Line", "total_number_of_depreciations": 3, "frequency_of_depreciation": 10 }) if asset.docstatus == 0: asset.submit() # check asset movement is created if not frappe.db.exists("Location", "Test Location 2"): frappe.get_doc({ 'doctype': 'Location', 'location_name': 'Test Location 2' }).insert() movement1 = create_asset_movement(purpose = 'Transfer', company = asset.company, assets = [{ 'asset': asset.name , 'source_location': 'Test Location', 'target_location': 'Test Location 2'}], reference_doctype = 'Purchase Receipt', reference_name = pr.name) self.assertEqual(frappe.db.get_value("Asset", asset.name, "location"), "Test Location 2") movement2 = create_asset_movement(purpose = 'Transfer', company = asset.company, assets = [{ 'asset': asset.name , 'source_location': 'Test Location 2', 'target_location': 'Test Location'}], reference_doctype = 'Purchase Receipt', reference_name = pr.name) self.assertEqual(frappe.db.get_value("Asset", asset.name, "location"), "Test Location") movement1.cancel() self.assertEqual(frappe.db.get_value("Asset", asset.name, "location"), "Test Location") employee = make_employee("*****@*****.**", company="_Test Company") movement3 = create_asset_movement(purpose = 'Issue', company = asset.company, assets = [{ 'asset': asset.name , 'source_location': 'Test Location', 'to_employee': employee}], reference_doctype = 'Purchase Receipt', reference_name = pr.name) # after issuing asset should belong to an employee not at a location self.assertEqual(frappe.db.get_value("Asset", asset.name, "location"), None) self.assertEqual(frappe.db.get_value("Asset", asset.name, "custodian"), employee)
def make_employee_group(): employee = make_employee("*****@*****.**") employee_group = frappe.get_doc({ "doctype": "Employee Group", "employee_group_name": "_Test Employee Group", "employee_list": [{ "employee": employee }] }) employee_group_exist = frappe.db.exists("Employee Group", "_Test Employee Group") if not employee_group_exist: employee_group.insert() return employee_group.employee_group_name else: return employee_group_exist
def test_mark_absent(self): from erpbee.hr.doctype.employee.test_employee import make_employee employee = make_employee("*****@*****.**") date = nowdate() frappe.db.delete('Attendance', { 'employee': employee, 'attendance_date': date }) from erpbee.hr.doctype.attendance.attendance import mark_attendance attendance = mark_attendance(employee, date, 'Absent') fetch_attendance = frappe.get_value('Attendance', { 'employee': employee, 'attendance_date': date, 'status': 'Absent' }) self.assertEqual(attendance, fetch_attendance)
def test_sales_invoice_from_timesheet(self): emp = make_employee("*****@*****.**") timesheet = make_timesheet(emp, simulate=True, billable=1) sales_invoice = make_sales_invoice(timesheet.name, '_Test Item', '_Test Customer') sales_invoice.due_date = nowdate() sales_invoice.submit() timesheet = frappe.get_doc('Timesheet', timesheet.name) self.assertEqual(sales_invoice.total_billing_amount, 100) self.assertEqual(timesheet.status, 'Billed') self.assertEqual(sales_invoice.customer, '_Test Customer') item = sales_invoice.items[0] self.assertEqual(item.item_code, '_Test Item') self.assertEqual(item.qty, 2.00) self.assertEqual(item.rate, 50.00)
def test_mark_attendance_and_link_log(self): employee = make_employee("*****@*****.**") logs = make_n_checkins(employee, 3) mark_attendance_and_link_log(logs, 'Skip', nowdate()) log_names = [log.name for log in logs] logs_count = frappe.db.count('Employee Checkin', {'name':['in', log_names], 'skip_auto_attendance':1}) self.assertEqual(logs_count, 3) logs = make_n_checkins(employee, 4, 2) now_date = nowdate() frappe.db.delete('Attendance', {'employee':employee}) attendance = mark_attendance_and_link_log(logs, 'Present', now_date, 8.2) log_names = [log.name for log in logs] logs_count = frappe.db.count('Employee Checkin', {'name':['in', log_names], 'attendance':attendance.name}) self.assertEqual(logs_count, 4) attendance_count = frappe.db.count('Attendance', {'status':'Present', 'working_hours':8.2, 'employee':employee, 'attendance_date':now_date}) self.assertEqual(attendance_count, 1)
def test_year_to_date_computation(self): from erpbee.payroll.doctype.salary_structure.test_salary_structure import make_salary_structure applicant = make_employee("*****@*****.**", company="_Test Company") payroll_period = create_payroll_period(name="_Test Payroll Period 1", company="_Test Company") create_tax_slab(payroll_period, allow_tax_exemption=True, currency="INR", effective_date=getdate("2019-04-01"), company="_Test Company") salary_structure = make_salary_structure( "Monthly Salary Structure Test for Salary Slip YTD", "Monthly", employee=applicant, company="_Test Company", currency="INR", payroll_period=payroll_period) # clear salary slip for this employee frappe.db.sql( "DELETE FROM `tabSalary Slip` where employee_name = '*****@*****.**'" ) create_salary_slips_for_payroll_period(applicant, salary_structure.name, payroll_period, deduct_random=False) salary_slips = frappe.get_all( 'Salary Slip', fields=['year_to_date', 'net_pay'], filters={'employee_name': '*****@*****.**'}, order_by='posting_date') year_to_date = 0 for slip in salary_slips: year_to_date += flt(slip.net_pay) self.assertEqual(slip.year_to_date, year_to_date)
def test_date_range(self): employee = make_employee("*****@*****.**") employee_doc = frappe.get_doc("Employee", employee) date_of_joining = "2018-01-02" relieving_date = "2018-01-03" from_date = "2018-01-01" to_date = "2018-01-04" employee_doc.date_of_joining = date_of_joining employee_doc.relieving_date = relieving_date employee_doc.save() args = {"from_date": from_date, "to_date": to_date} data = get_data(args) filtered_data = [] for row in data: if row[1] == employee: filtered_data.append(row) for row in filtered_data: self.assertTrue( getdate(row[3]) >= getdate(date_of_joining) and getdate(row[3]) <= getdate(relieving_date))
def test_multi_currency_salary_slip(self): from erpbee.payroll.doctype.salary_structure.test_salary_structure import make_salary_structure applicant = make_employee("*****@*****.**", company="_Test Company") frappe.db.sql( """delete from `tabSalary Structure` where name='Test Multi Currency Salary Slip'""" ) salary_structure = make_salary_structure( "Test Multi Currency Salary Slip", "Monthly", employee=applicant, company="_Test Company", currency='USD') salary_slip = make_salary_slip(salary_structure.name, employee=applicant) salary_slip.exchange_rate = 70 salary_slip.calculate_net_pay() self.assertEqual(salary_slip.gross_pay, 78000) self.assertEqual(salary_slip.base_gross_pay, 78000 * 70)
def test_salary_slip_from_timesheet(self): emp = make_employee("*****@*****.**") salary_structure = make_salary_structure_for_timesheet(emp) timesheet = make_timesheet(emp, simulate = True, billable=1) salary_slip = make_salary_slip(timesheet.name) salary_slip.submit() self.assertEqual(salary_slip.total_working_hours, 2) self.assertEqual(salary_slip.hour_rate, 50) self.assertEqual(salary_slip.earnings[0].salary_component, "Timesheet Component") self.assertEqual(salary_slip.earnings[0].amount, 100) self.assertEqual(salary_slip.timesheets[0].time_sheet, timesheet.name) self.assertEqual(salary_slip.timesheets[0].working_hours, 2) timesheet = frappe.get_doc('Timesheet', timesheet.name) self.assertEqual(timesheet.status, 'Payslip') salary_slip.cancel() timesheet = frappe.get_doc('Timesheet', timesheet.name) self.assertEqual(timesheet.status, 'Submitted')
def test_timesheet_time_overlap(self): emp = make_employee("*****@*****.**") settings = frappe.get_single('Projects Settings') initial_setting = settings.ignore_employee_time_overlap settings.ignore_employee_time_overlap = 0 settings.save() update_activity_type("_Test Activity Type") timesheet = frappe.new_doc("Timesheet") timesheet.employee = emp timesheet.append( 'time_logs', { "billable": 1, "activity_type": "_Test Activity Type", "from_time": now_datetime(), "to_time": now_datetime() + datetime.timedelta(hours=3), "company": "_Test Company" } ) timesheet.append( 'time_logs', { "billable": 1, "activity_type": "_Test Activity Type", "from_time": now_datetime(), "to_time": now_datetime() + datetime.timedelta(hours=3), "company": "_Test Company" } ) self.assertRaises(frappe.ValidationError, timesheet.save) settings.ignore_employee_time_overlap = 1 settings.save() timesheet.save() # should not throw an error settings.ignore_employee_time_overlap = initial_setting settings.save()
def test_recurring_additional_salary(self): amount = 0 salary_component = None emp_id = make_employee("*****@*****.**") frappe.db.set_value("Employee", emp_id, "relieving_date", add_days(nowdate(), 1800)) salary_structure = make_salary_structure( "Test Salary Structure Additional Salary", "Monthly", employee=emp_id) add_sal = get_additional_salary(emp_id) ss = make_employee_salary_slip("*****@*****.**", "Monthly", salary_structure=salary_structure.name) for earning in ss.earnings: if earning.salary_component == "Recurring Salary Component": amount = earning.amount salary_component = earning.salary_component self.assertEqual(amount, add_sal.amount) self.assertEqual(salary_component, add_sal.salary_component)
def setUp(self): frappe.db.sql('''delete from `tabLeave Period`''') frappe.db.sql('''delete from `tabLeave Policy Assignment`''') frappe.db.sql('''delete from `tabLeave Allocation`''') frappe.db.sql('''delete from `tabLeave Ledger Entry`''') frappe.db.sql('''delete from `tabAdditional Salary`''') # create the leave policy leave_policy = create_leave_policy( leave_type="_Test Leave Type Encashment", annual_allocation=10) leave_policy.submit() # create employee, salary structure and assignment self.employee = make_employee("*****@*****.**") self.leave_period = create_leave_period(add_months(today(), -3), add_months(today(), 3)) data = { "assignment_based_on": "Leave Period", "leave_policy": leave_policy.name, "leave_period": self.leave_period.name } leave_policy_assignments = create_assignment_for_multiple_employees( [self.employee], frappe._dict(data)) salary_structure = make_salary_structure( "Salary Structure for Encashment", "Monthly", self.employee, other_details={"leave_encashment_amount_per_day": 50}) #grant Leaves frappe.get_doc( "Leave Policy Assignment", leave_policy_assignments[0]).grant_leave_alloc_for_employee()
def test_salary_structures_assignment(self): company_currency = erpbee.get_default_currency() salary_structure = make_salary_structure("Salary Structure Sample", "Monthly", currency=company_currency) employee = "*****@*****.**" employee_doc_name = make_employee(employee) # clear the already assigned stuctures frappe.db.sql( '''delete from `tabSalary Structure Assignment` where employee=%s and salary_structure=%s ''', ("*****@*****.**", salary_structure.name)) #test structure_assignment salary_structure.assign_salary_structure(employee=employee_doc_name, from_date='2013-01-01', base=5000, variable=200) salary_structure_assignment = frappe.get_doc( "Salary Structure Assignment", { 'employee': employee_doc_name, 'from_date': '2013-01-01' }) self.assertEqual(salary_structure_assignment.docstatus, 1) self.assertEqual(salary_structure_assignment.base, 5000) self.assertEqual(salary_structure_assignment.variable, 200)
def setUp(self): make_employee("*****@*****.**") make_employee("*****@*****.**") frappe.db.sql("""delete from `tabEmployee Transfer`""")
def test_multi_currency_salary_structure(self): make_employee("*****@*****.**") sal_struct = make_salary_structure("Salary Structure Multi Currency", "Monthly", currency='USD') self.assertEqual(sal_struct.currency, 'USD')
def test_loan(self): branch = "Test Employee Branch" applicant = make_employee("*****@*****.**", company="_Test Company") company = "_Test Company" holiday_list = make_holiday("test holiday for loan") company_doc = frappe.get_doc('Company', company) if not company_doc.default_payroll_payable_account: company_doc.default_payroll_payable_account = frappe.db.get_value( 'Account', { 'company': company, 'root_type': 'Liability', 'account_type': '' }, 'name') company_doc.save() if not frappe.db.exists('Branch', branch): frappe.get_doc({'doctype': 'Branch', 'branch': branch}).insert() employee_doc = frappe.get_doc('Employee', applicant) employee_doc.branch = branch employee_doc.holiday_list = holiday_list employee_doc.save() salary_structure = "Test Salary Structure for Loan" make_salary_structure(salary_structure, "Monthly", employee=employee_doc.name, company="_Test Company", currency=company_doc.default_currency) loan = create_loan(applicant, "Car Loan", 280000, "Repay Over Number of Periods", 20, posting_date=add_months(nowdate(), -1)) loan.repay_from_salary = 1 loan.submit() make_loan_disbursement_entry(loan.name, loan.loan_amount, disbursement_date=add_months( nowdate(), -1)) process_loan_interest_accrual_for_term_loans(posting_date=nowdate()) dates = get_start_end_dates('Monthly', nowdate()) make_payroll_entry( company="_Test Company", start_date=dates.start_date, payable_account=company_doc.default_payroll_payable_account, currency=company_doc.default_currency, end_date=dates.end_date, branch=branch, cost_center="Main - _TC", payment_account="Cash - _TC") name = frappe.db.get_value('Salary Slip', { 'posting_date': nowdate(), 'employee': applicant }, 'name') salary_slip = frappe.get_doc('Salary Slip', name) for row in salary_slip.loans: if row.loan == loan.name: interest_amount = (280000 * 8.4) / (12 * 100) principal_amount = loan.monthly_repayment_amount - interest_amount self.assertEqual(row.interest_amount, interest_amount) self.assertEqual(row.principal_amount, principal_amount) self.assertEqual(row.total_payment, interest_amount + principal_amount) if salary_slip.docstatus == 0: frappe.delete_doc('Salary Slip', name)