def test_employee_leave_balance(self):
frappe.get_doc(test_records[0]).insert()
# 5 leaves
allocation1 = make_allocation_record(
employee=self.employee_id,
from_date=add_days(self.year_start, -11),
to_date=add_days(self.year_start, -1),
leaves=5,
)
# 30 leaves
allocation2 = make_allocation_record(employee=self.employee_id,
from_date=self.year_start,
to_date=self.year_end)
# expires 5 leaves
process_expired_allocation()
# 4 days leave
first_sunday = get_first_sunday(self.holiday_list,
for_date=self.year_start)
leave_application = make_leave_application(self.employee_id,
add_days(first_sunday, 1),
add_days(first_sunday, 4),
"_Test Leave Type")
leave_application.reload()
filters = frappe._dict({
"from_date": allocation1.from_date,
"to_date": allocation2.to_date,
"employee": self.employee_id,
})
report = execute(filters)
expected_data = [{
"leave_type":
"_Test Leave Type",
"employee":
self.employee_id,
"employee_name":
"*****@*****.**",
"leaves_allocated":
flt(allocation1.new_leaves_allocated +
allocation2.new_leaves_allocated),
"leaves_expired":
flt(allocation1.new_leaves_allocated),
"opening_balance":
flt(0),
"leaves_taken":
flt(leave_application.total_leave_days),
"closing_balance":
flt(allocation2.new_leaves_allocated -
leave_application.total_leave_days),
"indent":
1,
}]
self.assertEqual(report[1], expected_data)
def test_opening_balance_considers_carry_forwarded_leaves(self):
leave_type = create_leave_type(leave_type_name="_Test_CF_leave_expiry",
is_carry_forward=1)
leave_type.insert()
# 30 leaves allocated for first half of the year
allocation1 = make_allocation_record(
employee=self.employee_id,
from_date=self.year_start,
to_date=self.mid_year,
leave_type=leave_type.name,
)
# 4 days leave application in the first allocation
first_sunday = get_first_sunday(self.holiday_list,
for_date=self.year_start)
leave_application = make_leave_application(self.employee_id,
first_sunday,
add_days(first_sunday, 3),
leave_type.name)
leave_application.reload()
# 30 leaves allocated for second half of the year + carry forward leaves (26) from the previous allocation
allocation2 = make_allocation_record(
employee=self.employee_id,
from_date=add_days(self.mid_year, 1),
to_date=self.year_end,
carry_forward=True,
leave_type=leave_type.name,
)
# Case 1: carry forwarded leaves considered in opening balance for second alloc
filters = frappe._dict({
"from_date": add_days(self.mid_year, 1),
"to_date": self.year_end,
"employee": self.employee_id,
})
report = execute(filters)
# available leaves from old alloc
opening_balance = allocation1.new_leaves_allocated - leave_application.total_leave_days
self.assertEqual(report[1][0].opening_balance, opening_balance)
# Case 2: opening balance one day after alloc boundary = carry forwarded leaves + new leaves alloc
filters = frappe._dict({
"from_date": add_days(self.mid_year, 2),
"to_date": self.year_end,
"employee": self.employee_id,
})
report = execute(filters)
# available leaves from old alloc
opening_balance = allocation2.new_leaves_allocated + (
allocation1.new_leaves_allocated -
leave_application.total_leave_days)
self.assertEqual(report[1][0].opening_balance, opening_balance)
def setUp(self):
for dt in ["Leave Application", "Leave Allocation", "Salary Slip"]:
frappe.db.sql("delete from `tab%s`" % dt)
make_allocation_record(leave_type="_Test Leave Type LWP")
frappe.db.set_value("Company", "_Test Company", "default_holiday_list", "_Test Holiday List")
from erpnext.hr.doctype.leave_application.test_leave_application import _test_records as leave_applications
la = frappe.copy_doc(leave_applications[2])
la.insert()
la.status = "Approved"
la.submit()
def setUp(self):
for dt in ["Leave Application", "Leave Allocation", "Salary Slip"]:
frappe.db.sql("delete from `tab%s`" % dt)
make_allocation_record(leave_type="_Test Leave Type LWP")
frappe.db.set_value("Company", "_Test Company", "default_holiday_list",
"_Test Holiday List")
from erpnext.hr.doctype.leave_application.test_leave_application import _test_records as leave_applications
la = frappe.copy_doc(leave_applications[2])
la.insert()
la.status = "Approved"
la.submit()
def get_leave_application(employee):
now = now_datetime()
previous_month = now.month - 1
date = getdate()
year_start = getdate(get_year_start(date))
year_end = getdate(get_year_ending(date))
make_allocation_record(employee=employee,
from_date=year_start,
to_date=year_end)
from_date = now.replace(day=7).replace(month=previous_month).date()
to_date = now.replace(day=8).replace(month=previous_month).date()
return make_leave_application(employee, from_date, to_date,
"_Test Leave Type")
def test_get_leave_balance_near_alloc_expiry(self):
frappe.get_doc(test_records[0]).insert()
# 30 leaves allocated
allocation = make_allocation_record(
employee=self.employee_id, from_date=self.year_start, to_date=self.year_end
)
# 4 days leave application in the first allocation
first_sunday = get_first_sunday(self.holiday_list, for_date=self.year_start)
leave_application = make_leave_application(
self.employee_id, add_days(first_sunday, 1), add_days(first_sunday, 4), "_Test Leave Type"
)
leave_application.reload()
# Leave balance should show actual balance, and not "consumption balance as per remaining days", near alloc end date
# eg: 3 days left for alloc to end, leave balance should still be 26 and not 3
filters = frappe._dict(
{"date": add_days(self.year_end, -3), "company": "_Test Company", "employee": self.employee_id}
)
report = execute(filters)
expected_data = [
[
self.employee_id,
"*****@*****.**",
frappe.db.get_value("Employee", self.employee_id, "department"),
flt(allocation.new_leaves_allocated - leave_application.total_leave_days),
]
]
self.assertEqual(report[1], expected_data)
def test_employee_status_filter(self):
frappe.get_doc(test_records[0]).insert()
inactive_emp = make_employee("*****@*****.**",
company="_Test Company")
allocation = make_allocation_record(
employee=inactive_emp,
from_date=self.year_start,
to_date=self.year_end,
leaves=5,
)
# set employee as inactive
frappe.db.set_value("Employee", inactive_emp, "status", "Inactive")
filters = frappe._dict({
"from_date": allocation.from_date,
"to_date": allocation.to_date,
"employee": inactive_emp,
"employee_status": "Active",
})
report = execute(filters)
self.assertEqual(len(report[1]), 0)
filters = frappe._dict({
"from_date": allocation.from_date,
"to_date": allocation.to_date,
"employee": inactive_emp,
"employee_status": "Inactive",
})
report = execute(filters)
self.assertEqual(len(report[1]), 1)
def setUp(self):
self.make_salary_component(
["Basic Salary", "Allowance", "HRA", "Professional Tax", "TDS"])
for dt in ["Leave Application", "Leave Allocation", "Salary Slip"]:
frappe.db.sql("delete from `tab%s`" % dt)
make_allocation_record(leave_type="_Test Leave Type LWP")
self.make_holiday_list()
frappe.db.set_value("Company", erpnext.get_default_company(),
"default_holiday_list",
"Salary Slip Test Holiday List")
from erpnext.hr.doctype.leave_application.test_leave_application import _test_records as leave_applications
la = frappe.copy_doc(leave_applications[2])
la.insert()
la.status = "Approved"
la.submit()
def test_opening_balance_on_alloc_boundary_dates(self):
frappe.get_doc(test_records[0]).insert()
# 30 leaves allocated
allocation1 = make_allocation_record(employee=self.employee_id,
from_date=self.year_start,
to_date=self.year_end)
# 4 days leave application in the first allocation
first_sunday = get_first_sunday(self.holiday_list,
for_date=self.year_start)
leave_application = make_leave_application(self.employee_id,
add_days(first_sunday, 1),
add_days(first_sunday, 4),
"_Test Leave Type")
leave_application.reload()
# Case 1: opening balance for first alloc boundary
filters = frappe._dict({
"from_date": self.year_start,
"to_date": self.year_end,
"employee": self.employee_id
})
report = execute(filters)
self.assertEqual(report[1][0].opening_balance, 0)
# Case 2: opening balance after leave application date
filters = frappe._dict({
"from_date":
add_days(leave_application.to_date, 1),
"to_date":
self.year_end,
"employee":
self.employee_id,
})
report = execute(filters)
self.assertEqual(
report[1][0].opening_balance,
(allocation1.new_leaves_allocated -
leave_application.total_leave_days),
)
# Case 3: leave balance shows actual balance and not consumption balance as per remaining days near alloc end date
# eg: 3 days left for alloc to end, leave balance should still be 26 and not 3
filters = frappe._dict({
"from_date": add_days(self.year_end, -3),
"to_date": self.year_end,
"employee": self.employee_id,
})
report = execute(filters)
self.assertEqual(
report[1][0].opening_balance,
(allocation1.new_leaves_allocated -
leave_application.total_leave_days),
)
def test_employee_leave_balance_summary(self):
frappe.get_doc(test_records[0]).insert()
# 5 leaves
allocation1 = make_allocation_record(
employee=self.employee_id,
from_date=add_days(self.year_start, -11),
to_date=add_days(self.year_start, -1),
leaves=5,
)
# 30 leaves
allocation2 = make_allocation_record(
employee=self.employee_id, from_date=self.year_start, to_date=self.year_end
)
# 2 days leave within the first allocation
leave_application1 = make_leave_application(
self.employee_id,
add_days(self.year_start, -11),
add_days(self.year_start, -10),
"_Test Leave Type",
)
leave_application1.reload()
# expires 3 leaves
process_expired_allocation()
# 4 days leave within the second allocation
first_sunday = get_first_sunday(self.holiday_list, for_date=self.year_start)
leave_application2 = make_leave_application(
self.employee_id, add_days(first_sunday, 1), add_days(first_sunday, 4), "_Test Leave Type"
)
leave_application2.reload()
filters = frappe._dict(
{
"date": add_days(leave_application2.to_date, 1),
"company": "_Test Company",
"employee": self.employee_id,
}
)
report = execute(filters)
expected_data = [
[
self.employee_id,
"*****@*****.**",
frappe.db.get_value("Employee", self.employee_id, "department"),
flt(
allocation1.new_leaves_allocated # allocated = 5
+ allocation2.new_leaves_allocated # allocated = 30
- leave_application1.total_leave_days # leaves taken in the 1st alloc = 2
- (
allocation1.new_leaves_allocated - leave_application1.total_leave_days
) # leaves expired from 1st alloc = 3
- leave_application2.total_leave_days # leaves taken in the 2nd alloc = 4
),
]
]
self.assertEqual(report[1], expected_data)