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)
