def test_salary_slip_with_holidays_excluded(self):
no_of_days = self.get_no_of_days()
dataent.db.set_value("HR Settings", None,
"include_holidays_in_total_working_days", 0)
make_employee("*****@*****.**")
dataent.db.set_value(
"Employee",
dataent.get_value("Employee",
{"employee_name": "*****@*****.**"},
"name"), "relieving_date", None)
dataent.db.set_value(
"Employee",
dataent.get_value("Employee",
{"employee_name": "*****@*****.**"},
"name"), "status", "Active")
ss = make_employee_salary_slip("*****@*****.**", "Monthly")
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.deductions[0].amount, 5000)
self.assertEqual(ss.deductions[1].amount, 5000)
self.assertEqual(ss.gross_pay, 78000)
self.assertEqual(ss.net_pay, 67418.0)
def test_payroll_frequency(self):
fiscal_year = get_fiscal_year(nowdate(),
company=epaas.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)
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_employee_salary_slip_read_permission(self):
make_employee("*****@*****.**")
salary_slip_test_employee = make_employee_salary_slip(
"*****@*****.**", "Monthly")
dataent.set_user("*****@*****.**")
self.assertTrue(salary_slip_test_employee.has_permission("read"))
def setUp(self):
for dt in ["Salary Slip", "Salary Structure", "Salary Structure Assignment"]:
dataent.db.sql("delete from `tab%s`" % dt)
self.make_holiday_list()
dataent.db.set_value("Company", epaas.get_default_company(), "default_holiday_list", "Salary Structure Test Holiday List")
make_employee("*****@*****.**")
make_employee("*****@*****.**")
def test_email_salary_slip(self):
dataent.db.sql("delete from `tabEmail Queue`")
hr_settings = dataent.get_doc("HR Settings", "HR Settings")
hr_settings.email_salary_slip_to_employee = 1
hr_settings.save()
make_employee("*****@*****.**")
ss = make_employee_salary_slip("*****@*****.**", "Monthly")
ss.submit()
email_queue = dataent.db.sql("""select name from `tabEmail Queue`""")
self.assertTrue(email_queue)
def test_leave_grant(self):
leave_type = "_Test Leave Type"
# create the leave policy
leave_policy = dataent.get_doc({
"doctype":
"Leave Policy",
"leave_policy_details": [{
"leave_type": leave_type,
"annual_allocation": 20
}]
}).insert()
leave_policy.submit()
# create employee and assign the leave period
employee = "*****@*****.**"
employee_doc_name = make_employee(employee)
dataent.db.set_value("Employee", employee_doc_name, "leave_policy",
leave_policy.name)
# clear the already allocated leave
dataent.db.sql(
'''delete from `tabLeave Allocation` where employee=%s''',
"*****@*****.**")
# create the leave period
leave_period = create_leave_period(add_months(today(), -3),
add_months(today(), 3))
# test leave_allocation
leave_period.grant_leave_allocation(employee=employee_doc_name)
self.assertEqual(
get_leave_balance_on(employee_doc_name, leave_type, today()), 20)
def test_loan(self):
branch = "Test Employee Branch"
applicant = make_employee("*****@*****.**")
company = epaas.get_default_company()
holiday_list = make_holiday("test holiday for loan")
company_doc = dataent.get_doc('Company', company)
if not company_doc.default_payroll_payable_account:
company_doc.default_payroll_payable_account = dataent.db.get_value(
'Account', {
'company': company,
'root_type': 'Liability',
'account_type': ''
}, 'name')
company_doc.save()
if not dataent.db.exists('Branch', branch):
dataent.get_doc({'doctype': 'Branch', 'branch': branch}).insert()
employee_doc = dataent.get_doc('Employee', applicant)
employee_doc.branch = branch
employee_doc.holiday_list = holiday_list
employee_doc.save()
loan = create_loan(applicant, "Personal Loan", 280000,
"Repay Over Number of Periods", 20)
loan.repay_from_salary = 1
loan.submit()
salary_structure = "Test Salary Structure for Loan"
make_salary_structure(salary_structure, "Monthly", employee_doc.name)
dates = get_start_end_dates('Monthly', nowdate())
make_payroll_entry(start_date=dates.start_date,
end_date=dates.end_date,
branch=branch)
name = dataent.db.get_value('Salary Slip', {
'posting_date': nowdate(),
'employee': applicant
}, 'name')
salary_slip = dataent.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:
dataent.delete_doc('Salary Slip', name)
def test_salary_structures_assignment(self):
salary_structure = make_salary_structure("Salary Structure Sample", "Monthly")
employee = "*****@*****.**"
employee_doc_name = make_employee(employee)
# clear the already assigned stuctures
dataent.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 = dataent.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 test_loan_repayment_salary_slip(self):
from epaas.hr.doctype.loan.test_loan import create_loan_type, create_loan
applicant = make_employee("*****@*****.**")
create_loan_type("Car Loan", 500000, 6.4)
loan = create_loan(applicant, "Car Loan", 11000,
"Repay Over Number of Periods", 20)
loan.repay_from_salary = 1
loan.submit()
ss = make_employee_salary_slip("*****@*****.**", "Monthly")
ss.submit()
self.assertEqual(ss.total_loan_repayment, 582)
self.assertEqual(
ss.net_pay,
(flt(ss.gross_pay) -
(flt(ss.total_deduction) + flt(ss.total_loan_repayment))))
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")
def test_date_range(self):
employee = make_employee("*****@*****.**")
employee_doc = dataent.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_leave_balance_value_and_amount(self):
employee = "*****@*****.**"
leave_type = "_Test Leave Type Encashment"
# create the leave policy
leave_policy = dataent.get_doc({
"doctype": "Leave Policy",
"leave_policy_details": [{
"leave_type": leave_type,
"annual_allocation": 10
}]
}).insert()
leave_policy.submit()
# create employee, salary structure and assignment
employee = make_employee(employee)
dataent.db.set_value("Employee", employee, "leave_policy", leave_policy.name)
salary_structure = make_salary_structure("Salary Structure for Encashment", "Monthly", employee,
other_details={"leave_encashment_amount_per_day": 50})
# create the leave period and assign the leaves
leave_period = create_leave_period(add_months(today(), -3), add_months(today(), 3))
leave_period.grant_leave_allocation(employee=employee)
leave_encashment = dataent.get_doc(dict(
doctype = 'Leave Encashment',
employee = employee,
leave_type = leave_type,
leave_period = leave_period.name,
payroll_date = today()
)).insert()
self.assertEqual(leave_encashment.leave_balance, 10)
self.assertEqual(leave_encashment.encashable_days, 5)
self.assertEqual(leave_encashment.encashment_amount, 250)
leave_encashment.submit()
self.assertTrue(dataent.db.get_value("Leave Encashment", leave_encashment.name, "additional_salary"))
def setUp(self):
make_employee("*****@*****.**")
make_employee("*****@*****.**")
create_payroll_period()
create_exemption_category()
dataent.db.sql("""delete from `tabEmployee Tax Exemption Declaration`""")
def test_payment_days(self):
no_of_days = self.get_no_of_days()
# Holidays not included in working days
dataent.db.set_value("HR Settings", None,
"include_holidays_in_total_working_days", 1)
# set joinng date in the same month
make_employee("*****@*****.**")
if getdate(nowdate()).day >= 15:
date_of_joining = getdate(add_days(nowdate(), -10))
relieving_date = getdate(add_days(nowdate(), -10))
elif getdate(nowdate()).day < 15 and getdate(nowdate()).day >= 5:
date_of_joining = getdate(add_days(nowdate(), -3))
relieving_date = getdate(add_days(nowdate(), -3))
elif getdate(nowdate()).day < 5 and not getdate(nowdate()).day == 1:
date_of_joining = getdate(add_days(nowdate(), -1))
relieving_date = getdate(add_days(nowdate(), -1))
elif getdate(nowdate()).day == 1:
date_of_joining = getdate(nowdate())
relieving_date = getdate(nowdate())
dataent.db.set_value(
"Employee",
dataent.get_value("Employee",
{"employee_name": "*****@*****.**"},
"name"), "date_of_joining", date_of_joining)
dataent.db.set_value(
"Employee",
dataent.get_value("Employee",
{"employee_name": "*****@*****.**"},
"name"), "relieving_date", None)
dataent.db.set_value(
"Employee",
dataent.get_value("Employee",
{"employee_name": "*****@*****.**"},
"name"), "status", "Active")
ss = make_employee_salary_slip("*****@*****.**", "Monthly")
self.assertEqual(ss.total_working_days, no_of_days[0])
self.assertEqual(ss.payment_days,
(no_of_days[0] - getdate(date_of_joining).day + 1))
# set relieving date in the same month
dataent.db.set_value(
"Employee",
dataent.get_value("Employee",
{"employee_name": "*****@*****.**"},
"name"), "date_of_joining",
(add_days(nowdate(), -60)))
dataent.db.set_value(
"Employee",
dataent.get_value("Employee",
{"employee_name": "*****@*****.**"},
"name"), "relieving_date", relieving_date)
dataent.db.set_value(
"Employee",
dataent.get_value("Employee",
{"employee_name": "*****@*****.**"},
"name"), "status", "Left")
ss.save()
self.assertEqual(ss.total_working_days, no_of_days[0])
self.assertEqual(ss.payment_days, getdate(relieving_date).day)
dataent.db.set_value(
"Employee",
dataent.get_value("Employee",
{"employee_name": "*****@*****.**"},
"name"), "relieving_date", None)
dataent.db.set_value(
"Employee",
dataent.get_value("Employee",
{"employee_name": "*****@*****.**"},
"name"), "status", "Active")
def test_tax_for_payroll_period(self):
data = {}
# test the impact of tax exemption declaration, tax exemption proof submission
# and deduct check boxes in annual tax calculation
# as per assigned salary structure 40500 in monthly salary so 236000*5/100/12
dataent.db.sql("""delete from `tabPayroll Period`""")
dataent.db.sql("""delete from `tabSalary Component`""")
payroll_period = create_payroll_period()
create_tax_slab(payroll_period)
employee = make_employee("*****@*****.**")
delete_docs = [
"Salary Slip", "Additional Salary",
"Employee Tax Exemption Declaration",
"Employee Tax Exemption Proof Submission",
"Employee Benefit Claim", "Salary Structure Assignment"
]
for doc in delete_docs:
dataent.db.sql("delete from `tab%s` where employee='%s'" %
(doc, employee))
from epaas.hr.doctype.salary_structure.test_salary_structure import \
make_salary_structure, create_salary_structure_assignment
salary_structure = make_salary_structure(
"Stucture to test tax",
"Monthly",
other_details={"max_benefits": 100000},
test_tax=True)
create_salary_structure_assignment(employee, salary_structure.name,
payroll_period.start_date)
# create salary slip for whole period deducting tax only on last period
# to find the total tax amount paid
create_salary_slips_for_payroll_period(employee,
salary_structure.name,
payroll_period,
deduct_random=False)
tax_paid = get_tax_paid_in_period(employee)
# total taxable income 586000, 250000 @ 5%, 86000 @ 20% ie. 12500 + 17200
annual_tax = 113568
try:
self.assertEqual(tax_paid, annual_tax)
except AssertionError:
print("\nSalary Slip - Annual tax calculation failed\n")
raise
dataent.db.sql("""delete from `tabSalary Slip` where employee=%s""",
(employee))
# create exemption declaration so the tax amount varies
create_exemption_declaration(employee, payroll_period.name)
# create for payroll deducting in random months
data["deducted_dates"] = create_salary_slips_for_payroll_period(
employee, salary_structure.name, payroll_period)
tax_paid = get_tax_paid_in_period(employee)
# No proof, benefit claim sumitted, total tax paid, should not change
try:
self.assertEqual(tax_paid, annual_tax)
except AssertionError:
print("\nSalary Slip - Tax calculation failed on following case\n",
data, "\n")
raise
# Submit proof for total 120000
data["proof-1"] = create_proof_submission(employee, payroll_period,
50000)
data["proof-2"] = create_proof_submission(employee, payroll_period,
70000)
# Submit benefit claim for total 50000
data["benefit-1"] = create_benefit_claim(employee, payroll_period,
15000, "Medical Allowance")
data["benefit-2"] = create_benefit_claim(employee, payroll_period,
35000,
"Leave Travel Allowance")
dataent.db.sql("""delete from `tabSalary Slip` where employee=%s""",
(employee))
data["deducted_dates"] = create_salary_slips_for_payroll_period(
employee, salary_structure.name, payroll_period)
tax_paid = get_tax_paid_in_period(employee)
# total taxable income 416000, 166000 @ 5% ie. 8300
try:
self.assertEqual(tax_paid, 88608)
except AssertionError:
print("\nSalary Slip - Tax calculation failed on following case\n",
data, "\n")
raise
# create additional salary of 150000
dataent.db.sql("""delete from `tabSalary Slip` where employee=%s""",
(employee))
data["additional-1"] = create_additional_salary(
employee, payroll_period, 50000)
data["additional-2"] = create_additional_salary(
employee, payroll_period, 100000)
data["deducted_dates"] = create_salary_slips_for_payroll_period(
employee, salary_structure.name, payroll_period)
# total taxable income 566000, 250000 @ 5%, 66000 @ 20%, 12500 + 13200
tax_paid = get_tax_paid_in_period(employee)
try:
self.assertEqual(tax_paid, 121211)
except AssertionError:
print("\nSalary Slip - Tax calculation failed on following case\n",
data, "\n")
raise
dataent.db.sql(
"""delete from `tabAdditional Salary` where employee=%s""",
(employee))
# undelete fixture data
dataent.db.rollback()
def setUp(self):
make_employee("*****@*****.**")
make_employee("*****@*****.**")
dataent.db.sql("""delete from `tabEmployee Transfer`""")
