def test_earned_leave_allocation(self): leave_period = create_leave_period("Test Earned Leave Period") leave_type = create_earned_leave_type("Test Earned Leave") leave_policy = frappe.get_doc({ "doctype": "Leave Policy", "title": "Test Leave Policy", "leave_policy_details": [{ "leave_type": leave_type.name, "annual_allocation": 6 }], }).submit() data = { "assignment_based_on": "Leave Period", "leave_policy": leave_policy.name, "leave_period": leave_period.name, } # second last day of the month # leaves allocated should be 0 since it is an earned leave and allocation happens via scheduler based on set frequency frappe.flags.current_date = add_days(get_last_day(getdate()), -1) leave_policy_assignments = create_assignment_for_multiple_employees( [self.employee.name], frappe._dict(data)) leaves_allocated = frappe.db.get_value( "Leave Allocation", {"leave_policy_assignment": leave_policy_assignments[0]}, "total_leaves_allocated", ) self.assertEqual(leaves_allocated, 0)
def test_grant_leaves_on_doj_for_earned_leaves_based_on_leave_period(self): # tests leave alloc based on leave period for earned leaves with "based on doj" configuration in leave type leave_period, leave_policy = setup_leave_period_and_policy( get_first_day(add_months(getdate(), -2)), based_on_doj=True) # joining date set to 2 months back self.employee.date_of_joining = get_first_day(add_months( getdate(), -2)) self.employee.save() # assignment created on the same day of the current month, should allocate leaves including the current month frappe.flags.current_date = get_first_day(getdate()) data = { "assignment_based_on": "Leave Period", "leave_policy": leave_policy.name, "leave_period": leave_period.name, } leave_policy_assignments = create_assignment_for_multiple_employees( [self.employee.name], frappe._dict(data)) leaves_allocated = frappe.db.get_value( "Leave Allocation", {"leave_policy_assignment": leave_policy_assignments[0]}, "total_leaves_allocated", ) self.assertEqual(leaves_allocated, 3)
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}, )
def test_earned_leaves_creation(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`''') leave_period = get_leave_period() employee = get_employee() leave_type = 'Test Earned Leave Type' frappe.delete_doc_if_exists("Leave Type", 'Test Earned Leave Type', force=1) frappe.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 = frappe.get_doc({ "doctype": "Leave Policy", "leave_policy_details": [{ "leave_type": leave_type, "annual_allocation": 6 }] }).insert() data = { "assignment_based_on": "Leave Period", "leave_policy": leave_policy.name, "leave_period": leave_period.name } leave_policy_assignments = create_assignment_for_multiple_employees( [employee.name], frappe._dict(data)) frappe.get_doc( "Leave Policy Assignment", leave_policy_assignments[0]).grant_leave_alloc_for_employee() from erpnext.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) # validate earned leaves creation without maximum leaves frappe.db.set_value('Leave Type', leave_type, 'max_leaves_allowed', 0) i = 0 while (i < 6): allocate_earned_leaves() i += 1 self.assertEqual( get_leave_balance_on(employee.name, leave_type, nowdate()), 9)
def test_earned_leaves_creation(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`""") leave_period = get_leave_period() employee = get_employee() leave_type = "Test Earned Leave Type" frappe.delete_doc_if_exists("Leave Type", "Test Earned Leave Type", force=1) frappe.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 = frappe.get_doc( { "doctype": "Leave Policy", "title": "Test Leave Policy", "leave_policy_details": [{"leave_type": leave_type, "annual_allocation": 6}], } ).insert() data = { "assignment_based_on": "Leave Period", "leave_policy": leave_policy.name, "leave_period": leave_period.name, } leave_policy_assignments = create_assignment_for_multiple_employees( [employee.name], frappe._dict(data) ) from erpnext.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) # validate earned leaves creation without maximum leaves frappe.db.set_value("Leave Type", leave_type, "max_leaves_allowed", 0) i = 0 while i < 6: allocate_earned_leaves() i += 1 self.assertEqual(get_leave_balance_on(employee.name, leave_type, nowdate()), 9)
def test_allow_to_grant_all_leave_after_cancellation_of_every_leave_allocation( self): leave_period = get_leave_period() employee = get_employee() # create the leave policy with leave type "_Test Leave Type", allocation = 10 leave_policy = create_leave_policy() leave_policy.submit() data = { "assignment_based_on": "Leave Period", "leave_policy": leave_policy.name, "leave_period": leave_period.name } leave_policy_assignments = create_assignment_for_multiple_employees( [employee.name], frappe._dict(data)) leave_policy_assignment_doc = frappe.get_doc( "Leave Policy Assignment", leave_policy_assignments[0]) leave_policy_assignment_doc.grant_leave_alloc_for_employee() leave_policy_assignment_doc.reload() # every leave is allocated no more leave can be granted now self.assertEqual(leave_policy_assignment_doc.leaves_allocated, 1) leave_allocation = frappe.get_list("Leave Allocation", filters={ "employee": employee.name, "leave_policy": leave_policy.name, "leave_policy_assignment": leave_policy_assignments[0], "docstatus": 1 })[0] leave_alloc_doc = frappe.get_doc("Leave Allocation", leave_allocation) # User all allowed to grant leave when there is no allocation against assignment leave_alloc_doc.cancel() leave_alloc_doc.delete() leave_policy_assignment_doc.reload() # User are now allowed to grant leave self.assertEqual(leave_policy_assignment_doc.leaves_allocated, 0)
def test_grant_leaves(self): leave_period = get_leave_period() employee = get_employee() # create the leave policy with leave type "_Test Leave Type", allocation = 10 leave_policy = create_leave_policy() leave_policy.submit() data = { "assignment_based_on": "Leave Period", "leave_policy": leave_policy.name, "leave_period": leave_period.name } leave_policy_assignments = create_assignment_for_multiple_employees( [employee.name], frappe._dict(data)) leave_policy_assignment_doc = frappe.get_doc( "Leave Policy Assignment", leave_policy_assignments[0]) leave_policy_assignment_doc.grant_leave_alloc_for_employee() leave_policy_assignment_doc.reload() self.assertEqual(leave_policy_assignment_doc.leaves_allocated, 1) leave_allocation = frappe.get_list("Leave Allocation", filters={ "employee": employee.name, "leave_policy": leave_policy.name, "leave_policy_assignment": leave_policy_assignments[0], "docstatus": 1 })[0] leave_alloc_doc = frappe.get_doc("Leave Allocation", leave_allocation) self.assertEqual(leave_alloc_doc.new_leaves_allocated, 10) self.assertEqual(leave_alloc_doc.leave_type, "_Test Leave Type") self.assertEqual(leave_alloc_doc.from_date, leave_period.from_date) self.assertEqual(leave_alloc_doc.to_date, leave_period.to_date) self.assertEqual(leave_alloc_doc.leave_policy, leave_policy.name) self.assertEqual(leave_alloc_doc.leave_policy_assignment, leave_policy_assignments[0])
def setUp(self): frappe.db.delete("Leave Period") frappe.db.delete("Leave Policy Assignment") frappe.db.delete("Leave Allocation") frappe.db.delete("Leave Ledger Entry") frappe.db.delete("Additional Salary") frappe.db.delete("Leave Encashment") if not frappe.db.exists("Leave Type", "_Test Leave Type Encashment"): frappe.get_doc(test_records[2]).insert() date = getdate() year_start = getdate(get_year_start(date)) year_end = getdate(get_year_ending(date)) make_holiday_list("_Test Leave Encashment", year_start, year_end) # 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("*****@*****.**", company="_Test Company") self.leave_period = create_leave_period(year_start, year_end, "_Test Company") 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}, )
def test_grant_leaves(self): leave_period = get_leave_period() # allocation = 10 leave_policy = create_leave_policy() leave_policy.submit() self.employee.date_of_joining = get_first_day(leave_period.from_date) self.employee.save() data = { "assignment_based_on": "Leave Period", "leave_policy": leave_policy.name, "leave_period": leave_period.name, } leave_policy_assignments = create_assignment_for_multiple_employees( [self.employee.name], frappe._dict(data)) self.assertEqual( frappe.db.get_value("Leave Policy Assignment", leave_policy_assignments[0], "leaves_allocated"), 1, ) leave_allocation = frappe.get_list( "Leave Allocation", filters={ "employee": self.employee.name, "leave_policy": leave_policy.name, "leave_policy_assignment": leave_policy_assignments[0], "docstatus": 1, }, )[0] leave_alloc_doc = frappe.get_doc("Leave Allocation", leave_allocation) self.assertEqual(leave_alloc_doc.new_leaves_allocated, 10) self.assertEqual(leave_alloc_doc.leave_type, "_Test Leave Type") self.assertEqual(getdate(leave_alloc_doc.from_date), getdate(leave_period.from_date)) self.assertEqual(getdate(leave_alloc_doc.to_date), getdate(leave_period.to_date)) self.assertEqual(leave_alloc_doc.leave_policy, leave_policy.name) self.assertEqual(leave_alloc_doc.leave_policy_assignment, leave_policy_assignments[0])
def test_earned_leave_alloc_for_passed_months_with_cf_leaves_based_on_leave_period( self): from erpnext.hr.doctype.leave_allocation.test_leave_allocation import create_leave_allocation leave_period, leave_policy = setup_leave_period_and_policy( get_first_day(add_months(getdate(), -2))) # initial leave allocation = 5 leave_allocation = create_leave_allocation( employee=self.employee.name, employee_name=self.employee.employee_name, leave_type="Test Earned Leave", from_date=add_months(getdate(), -12), to_date=add_months(getdate(), -3), new_leaves_allocated=5, carry_forward=0, ) leave_allocation.submit() # Case 3: assignment created on the last day of the leave period's latter month with carry forwarding frappe.flags.current_date = get_last_day(add_months(getdate(), -1)) data = { "assignment_based_on": "Leave Period", "leave_policy": leave_policy.name, "leave_period": leave_period.name, "carry_forward": 1, } # carry forwarded leaves = 5, 3 leaves allocated for passed months leave_policy_assignments = create_assignment_for_multiple_employees( [self.employee.name], frappe._dict(data)) details = frappe.db.get_value( "Leave Allocation", {"leave_policy_assignment": leave_policy_assignments[0]}, [ "total_leaves_allocated", "new_leaves_allocated", "unused_leaves", "name" ], as_dict=True, ) self.assertEqual(details.new_leaves_allocated, 2) self.assertEqual(details.unused_leaves, 5) self.assertEqual(details.total_leaves_allocated, 7)
def test_earned_leave_alloc_for_passed_months_based_on_leave_period(self): leave_period, leave_policy = setup_leave_period_and_policy( get_first_day(add_months(getdate(), -1))) # Case 1: assignment created one month after the leave period, should allocate 1 leave frappe.flags.current_date = get_first_day(getdate()) data = { "assignment_based_on": "Leave Period", "leave_policy": leave_policy.name, "leave_period": leave_period.name, } leave_policy_assignments = create_assignment_for_multiple_employees( [self.employee.name], frappe._dict(data)) leaves_allocated = frappe.db.get_value( "Leave Allocation", {"leave_policy_assignment": leave_policy_assignments[0]}, "total_leaves_allocated", ) self.assertEqual(leaves_allocated, 1)
def test_allow_to_grant_all_leave_after_cancellation_of_every_leave_allocation( self): leave_period = get_leave_period() # create the leave policy with leave type "_Test Leave Type", allocation = 10 leave_policy = create_leave_policy() leave_policy.submit() data = { "assignment_based_on": "Leave Period", "leave_policy": leave_policy.name, "leave_period": leave_period.name, } leave_policy_assignments = create_assignment_for_multiple_employees( [self.employee.name], frappe._dict(data)) # every leave is allocated no more leave can be granted now self.assertEqual( frappe.db.get_value("Leave Policy Assignment", leave_policy_assignments[0], "leaves_allocated"), 1, ) leave_allocation = frappe.get_list( "Leave Allocation", filters={ "employee": self.employee.name, "leave_policy": leave_policy.name, "leave_policy_assignment": leave_policy_assignments[0], "docstatus": 1, }, )[0] leave_alloc_doc = frappe.get_doc("Leave Allocation", leave_allocation) leave_alloc_doc.cancel() leave_alloc_doc.delete() self.assertEqual( frappe.db.get_value("Leave Policy Assignment", leave_policy_assignments[0], "leaves_allocated"), 0, )
def test_grant_leaves_on_doj_for_earned_leaves_based_on_joining_date(self): # tests leave alloc based on joining date for earned leaves with "based on doj" configuration in leave type leave_type = create_earned_leave_type("Test Earned Leave", based_on_doj=True) leave_policy = frappe.get_doc({ "doctype": "Leave Policy", "title": "Test Leave Policy", "leave_policy_details": [{ "leave_type": leave_type.name, "annual_allocation": 12 }], }).submit() # joining date set to 2 months back # leave should be allocated for current month too since this day is same as the joining day self.employee.date_of_joining = get_first_day(add_months( getdate(), -2)) self.employee.save() # assignment created on the first day of the current month frappe.flags.current_date = get_first_day(getdate()) data = { "assignment_based_on": "Joining Date", "leave_policy": leave_policy.name } leave_policy_assignments = create_assignment_for_multiple_employees( [self.employee.name], frappe._dict(data)) leaves_allocated = frappe.db.get_value( "Leave Allocation", {"leave_policy_assignment": leave_policy_assignments[0]}, "total_leaves_allocated", ) effective_from = frappe.db.get_value("Leave Policy Assignment", leave_policy_assignments[0], "effective_from") self.assertEqual(effective_from, self.employee.date_of_joining) self.assertEqual(leaves_allocated, 3)
def test_earned_leave_alloc_for_passed_months_on_month_end_based_on_leave_period( self): leave_period, leave_policy = setup_leave_period_and_policy( get_first_day(add_months(getdate(), -2))) # Case 2: assignment created on the last day of the leave period's latter month # should allocate 1 leave for current month even though the month has not ended # since the daily job might have already executed frappe.flags.current_date = get_last_day(getdate()) data = { "assignment_based_on": "Leave Period", "leave_policy": leave_policy.name, "leave_period": leave_period.name, } leave_policy_assignments = create_assignment_for_multiple_employees( [self.employee.name], frappe._dict(data)) leaves_allocated = frappe.db.get_value( "Leave Allocation", {"leave_policy_assignment": leave_policy_assignments[0]}, "total_leaves_allocated", ) self.assertEqual(leaves_allocated, 3)
def test_earned_leave_alloc_for_passed_months_based_on_joining_date(self): # tests leave alloc for earned leaves for assignment based on joining date in policy assignment leave_type = create_earned_leave_type("Test Earned Leave") leave_policy = frappe.get_doc({ "doctype": "Leave Policy", "title": "Test Leave Policy", "leave_policy_details": [{ "leave_type": leave_type.name, "annual_allocation": 12 }], }).submit() # joining date set to 2 months back self.employee.date_of_joining = get_first_day(add_months( getdate(), -2)) self.employee.save() # assignment created on the last day of the current month frappe.flags.current_date = get_last_day(getdate()) data = { "assignment_based_on": "Joining Date", "leave_policy": leave_policy.name } leave_policy_assignments = create_assignment_for_multiple_employees( [self.employee.name], frappe._dict(data)) leaves_allocated = frappe.db.get_value( "Leave Allocation", {"leave_policy_assignment": leave_policy_assignments[0]}, "total_leaves_allocated", ) effective_from = frappe.db.get_value("Leave Policy Assignment", leave_policy_assignments[0], "effective_from") self.assertEqual(effective_from, self.employee.date_of_joining) self.assertEqual(leaves_allocated, 3)