1486 lines
70 KiB
Python
1486 lines
70 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
import datetime
|
|
from freezegun import freeze_time
|
|
from dateutil.relativedelta import relativedelta
|
|
|
|
from odoo import Command
|
|
from odoo.tests import tagged
|
|
|
|
from odoo.addons.hr_holidays.tests.common import TestHrHolidaysCommon
|
|
|
|
|
|
@tagged('post_install', '-at_install', 'accruals')
|
|
class TestAccrualAllocations(TestHrHolidaysCommon):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
super(TestAccrualAllocations, cls).setUpClass()
|
|
cls.leave_type = cls.env['hr.leave.type'].create({
|
|
'name': 'Paid Time Off',
|
|
'time_type': 'leave',
|
|
'requires_allocation': 'yes',
|
|
'allocation_validation_type': 'officer',
|
|
})
|
|
cls.leave_type_hour = cls.env['hr.leave.type'].create({
|
|
'name': 'Paid Time Off',
|
|
'time_type': 'leave',
|
|
'requires_allocation': 'yes',
|
|
'allocation_validation_type': 'officer',
|
|
'request_unit': 'hour',
|
|
})
|
|
|
|
def setAllocationCreateDate(self, allocation_id, date):
|
|
""" This method is a hack in order to be able to define/redefine the create_date
|
|
of the allocations.
|
|
This is done in SQL because ORM does not allow to write onto the create_date field.
|
|
"""
|
|
self.env.cr.execute("""
|
|
UPDATE
|
|
hr_leave_allocation
|
|
SET create_date = '%s'
|
|
WHERE id = %s
|
|
""" % (date, allocation_id))
|
|
|
|
def test_frequency_hourly_calendar(self):
|
|
with freeze_time("2017-12-5"):
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'level_ids': [(0, 0, {
|
|
'start_count': 1,
|
|
'start_type': 'day',
|
|
'added_value': 1,
|
|
'added_value_type': 'day',
|
|
'frequency': 'hourly',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 10000
|
|
})],
|
|
})
|
|
allocation = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual allocation for employee',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 0,
|
|
'allocation_type': 'accrual',
|
|
})
|
|
allocation.action_validate()
|
|
self.assertFalse(allocation.nextcall, 'There should be no nextcall set on the allocation.')
|
|
self.assertEqual(allocation.number_of_days, 0, 'There should be no days allocated yet.')
|
|
allocation._update_accrual()
|
|
tomorrow = datetime.date.today() + relativedelta(days=2)
|
|
self.assertEqual(allocation.number_of_days, 0, 'There should be no days allocated yet. The accrual starts tomorrow.')
|
|
|
|
with freeze_time(tomorrow):
|
|
allocation._update_accrual()
|
|
nextcall = datetime.date.today() + relativedelta(days=1)
|
|
self.assertEqual(allocation.number_of_days, 8, 'There should be 8 day allocated.')
|
|
self.assertEqual(allocation.nextcall, nextcall, 'The next call date of the cron should be in 2 days.')
|
|
allocation._update_accrual()
|
|
self.assertEqual(allocation.number_of_days, 8, 'There should be only 8 day allocated.')
|
|
|
|
def test_frequency_hourly_worked_hours(self):
|
|
with freeze_time("2017-12-5"):
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'is_based_on_worked_time': True,
|
|
'level_ids': [(0, 0, {
|
|
'start_count': 1,
|
|
'start_type': 'day',
|
|
'added_value': 1,
|
|
'added_value_type': 'day',
|
|
'frequency': 'hourly',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 10000
|
|
})],
|
|
})
|
|
allocation = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual allocation for employee',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 0,
|
|
'allocation_type': 'accrual',
|
|
})
|
|
allocation.action_validate()
|
|
self.assertFalse(allocation.nextcall, 'There should be no nextcall set on the allocation.')
|
|
self.assertEqual(allocation.number_of_days, 0, 'There should be no days allocated yet.')
|
|
allocation._update_accrual()
|
|
tomorrow = datetime.date.today() + relativedelta(days=2)
|
|
self.assertEqual(allocation.number_of_days, 0, 'There should be no days allocated yet. The accrual starts tomorrow.')
|
|
|
|
holiday_type = self.env['hr.leave.type'].create({
|
|
'name': 'Paid Time Off',
|
|
'requires_allocation': 'no',
|
|
'responsible_ids': [(4, self.user_hrmanager_id)],
|
|
'time_type': 'leave',
|
|
'request_unit': 'half_day',
|
|
})
|
|
leave = self.env['hr.leave'].create({
|
|
'name': 'leave',
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': holiday_type.id,
|
|
'request_date_from': '2017-12-06 08:00:00',
|
|
'request_date_to': '2017-12-06 17:00:00',
|
|
'request_unit_half': True,
|
|
'request_date_from_period': 'am',
|
|
})
|
|
leave.action_validate()
|
|
|
|
with freeze_time(tomorrow):
|
|
allocation._update_accrual()
|
|
nextcall = datetime.date.today() + relativedelta(days=1)
|
|
self.assertEqual(allocation.number_of_days, 4, 'There should be 4 day allocated.')
|
|
self.assertEqual(allocation.nextcall, nextcall, 'The next call date of the cron should be in 2 days.')
|
|
allocation._update_accrual()
|
|
self.assertEqual(allocation.number_of_days, 4, 'There should be only 4 day allocated.')
|
|
|
|
def test_frequency_daily(self):
|
|
with freeze_time("2017-12-5"):
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'level_ids': [(0, 0, {
|
|
'start_count': 1,
|
|
'start_type': 'day',
|
|
'added_value': 1,
|
|
'added_value_type': 'day',
|
|
'frequency': 'daily',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 10000
|
|
})],
|
|
})
|
|
allocation = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual allocation for employee',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 0,
|
|
'allocation_type': 'accrual',
|
|
})
|
|
allocation.action_validate()
|
|
self.assertFalse(allocation.nextcall, 'There should be no nextcall set on the allocation.')
|
|
self.assertEqual(allocation.number_of_days, 0, 'There should be no days allocated yet.')
|
|
allocation._update_accrual()
|
|
tomorrow = datetime.date.today() + relativedelta(days=2)
|
|
self.assertEqual(allocation.number_of_days, 0, 'There should be no days allocated yet. The accrual starts tomorrow.')
|
|
|
|
with freeze_time(tomorrow):
|
|
allocation._update_accrual()
|
|
nextcall = datetime.date.today() + relativedelta(days=1)
|
|
self.assertEqual(allocation.number_of_days, 1, 'There should be 1 day allocated.')
|
|
self.assertEqual(allocation.nextcall, nextcall, 'The next call date of the cron should be in 2 days.')
|
|
allocation._update_accrual()
|
|
self.assertEqual(allocation.number_of_days, 1, 'There should be only 1 day allocated.')
|
|
|
|
def test_frequency_weekly(self):
|
|
with freeze_time("2017-12-5"):
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'level_ids': [(0, 0, {
|
|
'added_value_type': 'day',
|
|
'start_count': 1,
|
|
'start_type': 'day',
|
|
'added_value': 1,
|
|
'frequency': 'weekly',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 10000
|
|
})],
|
|
})
|
|
allocation = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual allocation for employee',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 0,
|
|
'allocation_type': 'accrual',
|
|
'date_from': '2021-09-03',
|
|
})
|
|
with freeze_time(datetime.date.today() + relativedelta(days=2)):
|
|
allocation.action_validate()
|
|
self.assertFalse(allocation.nextcall, 'There should be no nextcall set on the allocation.')
|
|
self.assertEqual(allocation.number_of_days, 0, 'There should be no days allocated yet.')
|
|
allocation._update_accrual()
|
|
nextWeek = allocation.date_from + relativedelta(days=1, weekday=0)
|
|
self.assertEqual(allocation.number_of_days, 0, 'There should be no days allocated yet. The accrual starts tomorrow.')
|
|
|
|
with freeze_time(nextWeek):
|
|
allocation._update_accrual()
|
|
nextWeek = datetime.date.today() + relativedelta(days=1, weekday=0)
|
|
# Prorated
|
|
self.assertAlmostEqual(allocation.number_of_days, 0.2857, 4, 'There should be 0.2857 day allocated.')
|
|
self.assertEqual(allocation.nextcall, nextWeek, 'The next call date of the cron should be in 2 weeks')
|
|
|
|
with freeze_time(nextWeek):
|
|
allocation._update_accrual()
|
|
nextWeek = datetime.date.today() + relativedelta(days=1, weekday=0)
|
|
self.assertAlmostEqual(allocation.number_of_days, 1.2857, 4, 'There should be 1.2857 day allocated.')
|
|
self.assertEqual(allocation.nextcall, nextWeek, 'The next call date of the cron should be in 2 weeks')
|
|
|
|
def test_frequency_bimonthly(self):
|
|
with freeze_time('2021-09-01'):
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'level_ids': [(0, 0, {
|
|
'added_value_type': 'day',
|
|
'start_count': 1,
|
|
'start_type': 'day',
|
|
'added_value': 1,
|
|
'frequency': 'bimonthly',
|
|
'first_day': 1,
|
|
'second_day': 15,
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 10000,
|
|
})],
|
|
})
|
|
allocation = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual allocation for employee',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 0,
|
|
'allocation_type': 'accrual',
|
|
'date_from': '2021-09-03',
|
|
})
|
|
self.setAllocationCreateDate(allocation.id, '2021-09-01 00:00:00')
|
|
allocation.action_validate()
|
|
self.assertFalse(allocation.nextcall, 'There should be no nextcall set on the allocation.')
|
|
self.assertEqual(allocation.number_of_days, 0, 'There should be no days allocated yet.')
|
|
allocation._update_accrual()
|
|
next_date = datetime.date(2021, 9, 15)
|
|
self.assertEqual(allocation.number_of_days, 0, 'There should be no days allocated yet. The accrual starts tomorrow.')
|
|
|
|
with freeze_time(next_date):
|
|
next_date = datetime.date(2021, 10, 1)
|
|
allocation._update_accrual()
|
|
# Prorated
|
|
self.assertAlmostEqual(allocation.number_of_days, 0.7857, 4, 'There should be 0.7857 day allocated.')
|
|
self.assertEqual(allocation.nextcall, next_date, 'The next call date of the cron should be October 1st')
|
|
|
|
with freeze_time(next_date):
|
|
allocation._update_accrual()
|
|
# Not Prorated
|
|
self.assertAlmostEqual(allocation.number_of_days, 1.7857, 4, 'There should be 1.7857 day allocated.')
|
|
|
|
def test_frequency_monthly(self):
|
|
with freeze_time('2021-09-01'):
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'level_ids': [(0, 0, {
|
|
'added_value_type': 'day',
|
|
'start_count': 1,
|
|
'start_type': 'day',
|
|
'added_value': 1,
|
|
'frequency': 'monthly',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 10000
|
|
})],
|
|
})
|
|
allocation = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual allocation for employee',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 0,
|
|
'allocation_type': 'accrual',
|
|
'date_from': '2021-08-31',
|
|
})
|
|
self.setAllocationCreateDate(allocation.id, '2021-09-01 00:00:00')
|
|
allocation.action_validate()
|
|
self.assertFalse(allocation.nextcall, 'There should be no nextcall set on the allocation.')
|
|
self.assertEqual(allocation.number_of_days, 0, 'There should be no days allocated yet.')
|
|
allocation._update_accrual()
|
|
next_date = datetime.date(2021, 10, 1)
|
|
self.assertEqual(allocation.number_of_days, 0, 'There should be no days allocated yet. The accrual starts tomorrow.')
|
|
|
|
with freeze_time(next_date):
|
|
next_date = datetime.date(2021, 11, 1)
|
|
allocation._update_accrual()
|
|
# Prorata = 1 since a whole month passed
|
|
self.assertEqual(allocation.number_of_days, 1, 'There should be 1 day allocated.')
|
|
self.assertEqual(allocation.nextcall, next_date, 'The next call date of the cron should be November 1st')
|
|
|
|
def test_frequency_biyearly(self):
|
|
with freeze_time('2021-09-01'):
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'level_ids': [(0, 0, {
|
|
'added_value_type': 'day',
|
|
'start_count': 1,
|
|
'start_type': 'day',
|
|
'added_value': 1,
|
|
'frequency': 'biyearly',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 10000,
|
|
})],
|
|
})
|
|
# this sets up an accrual on the 1st of January and the 1st of July
|
|
allocation = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual allocation for employee',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 0,
|
|
'allocation_type': 'accrual',
|
|
})
|
|
self.setAllocationCreateDate(allocation.id, '2021-09-01 00:00:00')
|
|
allocation.action_validate()
|
|
self.assertFalse(allocation.nextcall, 'There should be no nextcall set on the allocation.')
|
|
self.assertEqual(allocation.number_of_days, 0, 'There should be no days allocated yet.')
|
|
allocation._update_accrual()
|
|
next_date = datetime.date(2022, 1, 1)
|
|
self.assertEqual(allocation.number_of_days, 0, 'There should be no days allocated yet. The accrual starts tomorrow.')
|
|
|
|
with freeze_time(next_date):
|
|
next_date = datetime.date(2022, 7, 1)
|
|
allocation._update_accrual()
|
|
# Prorated
|
|
self.assertAlmostEqual(allocation.number_of_days, 0.6576, 4, 'There should be 0.6576 day allocated.')
|
|
self.assertEqual(allocation.nextcall, next_date, 'The next call date of the cron should be July 1st')
|
|
|
|
with freeze_time(next_date):
|
|
allocation._update_accrual()
|
|
# Not Prorated
|
|
self.assertAlmostEqual(allocation.number_of_days, 1.6576, 4, 'There should be 1.6576 day allocated.')
|
|
|
|
def test_frequency_yearly(self):
|
|
with freeze_time('2021-09-01'):
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'level_ids': [(0, 0, {
|
|
'added_value_type': 'day',
|
|
'start_count': 1,
|
|
'start_type': 'day',
|
|
'added_value': 1,
|
|
'frequency': 'yearly',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 10000,
|
|
})],
|
|
})
|
|
# this sets up an accrual on the 1st of January
|
|
allocation = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual allocation for employee',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 0,
|
|
'allocation_type': 'accrual',
|
|
})
|
|
self.setAllocationCreateDate(allocation.id, '2021-09-01 00:00:00')
|
|
allocation.action_validate()
|
|
self.assertFalse(allocation.nextcall, 'There should be no nextcall set on the allocation.')
|
|
self.assertEqual(allocation.number_of_days, 0, 'There should be no days allocated yet.')
|
|
allocation._update_accrual()
|
|
next_date = datetime.date(2022, 1, 1)
|
|
self.assertEqual(allocation.number_of_days, 0, 'There should be no days allocated yet. The accrual starts tomorrow.')
|
|
|
|
with freeze_time(next_date):
|
|
next_date = datetime.date(2023, 1, 1)
|
|
allocation._update_accrual()
|
|
self.assertAlmostEqual(allocation.number_of_days, 0.3315, 4, 'There should be 0.3315 day allocated.')
|
|
self.assertEqual(allocation.nextcall, next_date, 'The next call date of the cron should be January 1st 2023')
|
|
|
|
with freeze_time(next_date):
|
|
allocation._update_accrual()
|
|
self.assertAlmostEqual(allocation.number_of_days, 1.3315, 4, 'There should be 1.3315 day allocated.')
|
|
|
|
def test_check_gain(self):
|
|
# 2 accruals, one based on worked time, one not
|
|
# check gain
|
|
with freeze_time('2021-08-30'):
|
|
attendances = []
|
|
for index in range(5):
|
|
attendances.append((0, 0, {
|
|
'name': '%s_%d' % ('40 Hours', index),
|
|
'hour_from': 8,
|
|
'hour_to': 12,
|
|
'dayofweek': str(index),
|
|
'day_period': 'morning'
|
|
}))
|
|
attendances.append((0, 0, {
|
|
'name': '%s_%d' % ('40 Hours', index),
|
|
'hour_from': 12,
|
|
'hour_to': 13,
|
|
'dayofweek': str(index),
|
|
'day_period': 'lunch'
|
|
}))
|
|
attendances.append((0, 0, {
|
|
'name': '%s_%d' % ('40 Hours', index),
|
|
'hour_from': 13,
|
|
'hour_to': 17,
|
|
'dayofweek': str(index),
|
|
'day_period': 'afternoon'
|
|
}))
|
|
calendar_emp = self.env['resource.calendar'].create({
|
|
'name': '40 Hours',
|
|
'tz': self.employee_emp.tz,
|
|
'attendance_ids': attendances,
|
|
})
|
|
self.employee_emp.resource_calendar_id = calendar_emp.id
|
|
|
|
accrual_plan_not_based_on_worked_time = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'level_ids': [(0, 0, {
|
|
'added_value_type': 'day',
|
|
'start_count': 1,
|
|
'start_type': 'day',
|
|
'added_value': 5,
|
|
'frequency': 'weekly',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 10000,
|
|
})],
|
|
})
|
|
accrual_plan_based_on_worked_time = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'is_based_on_worked_time': True,
|
|
'level_ids': [(0, 0, {
|
|
'added_value_type': 'day',
|
|
'start_count': 1,
|
|
'start_type': 'day',
|
|
'added_value': 5,
|
|
'frequency': 'weekly',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 10000,
|
|
})],
|
|
})
|
|
allocation_not_worked_time = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual allocation for employee',
|
|
'accrual_plan_id': accrual_plan_not_based_on_worked_time.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 0,
|
|
'allocation_type': 'accrual',
|
|
'state': 'confirm',
|
|
})
|
|
allocation_worked_time = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual allocation for employee',
|
|
'accrual_plan_id': accrual_plan_based_on_worked_time.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 0,
|
|
'allocation_type': 'accrual',
|
|
'state': 'confirm',
|
|
})
|
|
(allocation_not_worked_time | allocation_worked_time).action_validate()
|
|
self.setAllocationCreateDate(allocation_not_worked_time.id, '2021-08-01 00:00:00')
|
|
self.setAllocationCreateDate(allocation_worked_time.id, '2021-08-01 00:00:00')
|
|
holiday_type = self.env['hr.leave.type'].create({
|
|
'name': 'Paid Time Off',
|
|
'requires_allocation': 'no',
|
|
'responsible_ids': [Command.link(self.user_hrmanager_id)],
|
|
'time_type': 'leave',
|
|
})
|
|
leave = self.env['hr.leave'].create({
|
|
'name': 'leave',
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': holiday_type.id,
|
|
'request_date_from': '2021-09-02',
|
|
'request_date_to': '2021-09-02',
|
|
})
|
|
leave.action_validate()
|
|
self.assertFalse(allocation_not_worked_time.nextcall, 'There should be no nextcall set on the allocation.')
|
|
self.assertFalse(allocation_worked_time.nextcall, 'There should be no nextcall set on the allocation.')
|
|
self.assertEqual(allocation_not_worked_time.number_of_days, 0, 'There should be no days allocated yet.')
|
|
self.assertEqual(allocation_worked_time.number_of_days, 0, 'There should be no days allocated yet.')
|
|
|
|
next_date = datetime.date(2021, 9, 6)
|
|
with freeze_time(next_date):
|
|
# next_date = datetime.date(2021, 9, 13)
|
|
self.env['hr.leave.allocation']._update_accrual()
|
|
# Prorated
|
|
self.assertAlmostEqual(allocation_not_worked_time.number_of_days, 4.2857, 4, 'There should be 4.2857 days allocated.')
|
|
# 3.75 -> starts 1 day after allocation date -> 31/08-3/09 => 4 days - 1 days time off => (3 / 4) * 5 days
|
|
# ^ result without prorata
|
|
# Prorated
|
|
self.assertAlmostEqual(allocation_worked_time.number_of_days, 3, 4, 'There should be 3 days allocated.')
|
|
self.assertEqual(allocation_not_worked_time.nextcall, datetime.date(2021, 9, 13), 'The next call date of the cron should be the September 13th')
|
|
self.assertEqual(allocation_worked_time.nextcall, datetime.date(2021, 9, 13), 'The next call date of the cron should be the September 13th')
|
|
|
|
with freeze_time(next_date + relativedelta(days=7)):
|
|
next_date = datetime.date(2021, 9, 20)
|
|
self.env['hr.leave.allocation']._update_accrual()
|
|
self.assertAlmostEqual(allocation_not_worked_time.number_of_days, 9.2857, 4, 'There should be 9.2857 days allocated.')
|
|
self.assertEqual(allocation_not_worked_time.nextcall, next_date, 'The next call date of the cron should be September 20th')
|
|
self.assertAlmostEqual(allocation_worked_time.number_of_days, 8, 4, 'There should be 8 days allocated.')
|
|
self.assertEqual(allocation_worked_time.nextcall, next_date, 'The next call date of the cron should be September 20th')
|
|
|
|
def test_check_max_value(self):
|
|
with freeze_time("2017-12-5"):
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'level_ids': [(0, 0, {
|
|
'added_value_type': 'day',
|
|
'start_count': 1,
|
|
'start_type': 'day',
|
|
'added_value': 1,
|
|
'frequency': 'daily',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 1,
|
|
})],
|
|
})
|
|
allocation = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual allocation for employee',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 0,
|
|
'allocation_type': 'accrual',
|
|
})
|
|
allocation.action_validate()
|
|
allocation._update_accrual()
|
|
tomorrow = datetime.date.today() + relativedelta(days=2)
|
|
self.assertEqual(allocation.number_of_days, 0, 'There should be no days allocated yet. The accrual starts tomorrow.')
|
|
|
|
with freeze_time(tomorrow):
|
|
allocation._update_accrual()
|
|
nextcall = datetime.date.today() + relativedelta(days=1)
|
|
allocation._update_accrual()
|
|
self.assertEqual(allocation.number_of_days, 1, 'There should be only 1 day allocated.')
|
|
|
|
with freeze_time(nextcall):
|
|
allocation._update_accrual()
|
|
nextcall = datetime.date.today() + relativedelta(days=1)
|
|
# The maximum value is 1 so this shouldn't change anything
|
|
allocation._update_accrual()
|
|
self.assertEqual(allocation.number_of_days, 1, 'There should be only 1 day allocated.')
|
|
|
|
def test_check_max_value_hours(self):
|
|
with freeze_time("2017-12-5"):
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'level_ids': [(0, 0, {
|
|
'added_value_type': 'hour',
|
|
'start_count': 1,
|
|
'start_type': 'day',
|
|
'added_value': 1,
|
|
'frequency': 'daily',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 4,
|
|
})],
|
|
})
|
|
allocation = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual allocation for employee',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 0,
|
|
'allocation_type': 'accrual',
|
|
})
|
|
allocation.action_validate()
|
|
allocation._update_accrual()
|
|
tomorrow = datetime.date.today() + relativedelta(days=2)
|
|
self.assertEqual(allocation.number_of_days, 0, 'There should be no days allocated yet. The accrual starts tomorrow.')
|
|
|
|
with freeze_time(tomorrow):
|
|
allocation._update_accrual()
|
|
nextcall = datetime.date.today() + relativedelta(days=10)
|
|
allocation._update_accrual()
|
|
self.assertEqual(allocation.number_of_days, 0.125, 'There should be only 0.125 days allocated.')
|
|
|
|
with freeze_time(nextcall):
|
|
allocation._update_accrual()
|
|
nextcall = datetime.date.today() + relativedelta(days=1)
|
|
# The maximum value is 1 so this shouldn't change anything
|
|
allocation._update_accrual()
|
|
self.assertEqual(allocation.number_of_days, 0.5, 'There should be only 0.5 days allocated.')
|
|
|
|
def test_accrual_transition_immediately(self):
|
|
with freeze_time("2017-12-5"):
|
|
# 1 accrual with 2 levels and level transition immediately
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'transition_mode': 'immediately',
|
|
'level_ids': [(0, 0, {
|
|
'added_value_type': 'day',
|
|
'start_count': 1,
|
|
'start_type': 'day',
|
|
'added_value': 1,
|
|
'frequency': 'weekly',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 1,
|
|
}), (0, 0, {
|
|
'start_count': 10,
|
|
'start_type': 'day',
|
|
'added_value': 1,
|
|
'frequency': 'weekly',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 1,
|
|
})],
|
|
})
|
|
allocation = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual allocation for employee',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 0,
|
|
'allocation_type': 'accrual',
|
|
})
|
|
allocation.action_validate()
|
|
next_date = datetime.date.today() + relativedelta(days=11)
|
|
second_level = self.env['hr.leave.accrual.level'].search([('accrual_plan_id', '=', accrual_plan.id), ('start_count', '=', 10)])
|
|
self.assertEqual(allocation._get_current_accrual_plan_level_id(next_date)[0], second_level, 'The second level should be selected')
|
|
|
|
def test_accrual_transition_after_period(self):
|
|
with freeze_time("2017-12-5"):
|
|
# 1 accrual with 2 levels and level transition after
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'transition_mode': 'end_of_accrual',
|
|
'level_ids': [(0, 0, {
|
|
'added_value_type': 'day',
|
|
'start_count': 1,
|
|
'start_type': 'day',
|
|
'added_value': 1,
|
|
'frequency': 'weekly',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 1,
|
|
}), (0, 0, {
|
|
'start_count': 10,
|
|
'start_type': 'day',
|
|
'added_value': 1,
|
|
'frequency': 'weekly',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 1,
|
|
})],
|
|
})
|
|
allocation = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual allocation for employee',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 0,
|
|
'allocation_type': 'accrual',
|
|
})
|
|
allocation.action_validate()
|
|
next_date = datetime.date.today() + relativedelta(days=11)
|
|
second_level = self.env['hr.leave.accrual.level'].search([('accrual_plan_id', '=', accrual_plan.id), ('start_count', '=', 10)])
|
|
self.assertEqual(allocation._get_current_accrual_plan_level_id(next_date)[0], second_level, 'The second level should be selected')
|
|
|
|
def test_unused_accrual_lost(self):
|
|
# 1 accrual with 2 levels and level transition immediately
|
|
with freeze_time('2021-12-15'):
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'level_ids': [(0, 0, {
|
|
'added_value_type': 'day',
|
|
'start_count': 1,
|
|
'start_type': 'day',
|
|
'added_value': 1,
|
|
'frequency': 'daily',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 1,
|
|
'action_with_unused_accruals': 'lost',
|
|
})],
|
|
})
|
|
allocation = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual allocation for employee',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 10,
|
|
'allocation_type': 'accrual',
|
|
})
|
|
allocation.action_validate()
|
|
|
|
# Reset the cron's lastcall
|
|
accrual_cron = self.env['ir.cron'].sudo().env.ref('hr_holidays.hr_leave_allocation_cron_accrual')
|
|
accrual_cron.lastcall = datetime.date(2021, 12, 15)
|
|
with freeze_time('2022-01-01'):
|
|
allocation._update_accrual()
|
|
self.assertEqual(allocation.number_of_days, 0, 'The number of days should be reset')
|
|
|
|
def test_unused_accrual_postponed(self):
|
|
# 1 accrual with 2 levels and level transition after
|
|
# This also tests retroactivity
|
|
with freeze_time('2021-12-15'):
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'level_ids': [(0, 0, {
|
|
'added_value_type': 'day',
|
|
'start_count': 1,
|
|
'start_type': 'day',
|
|
'added_value': 1,
|
|
'frequency': 'daily',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 25,
|
|
'action_with_unused_accruals': 'all',
|
|
})],
|
|
})
|
|
allocation = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual allocation for employee',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 10,
|
|
'allocation_type': 'accrual',
|
|
})
|
|
allocation.action_validate()
|
|
|
|
# Reset the cron's lastcall
|
|
accrual_cron = self.env['ir.cron'].sudo().env.ref('hr_holidays.hr_leave_allocation_cron_accrual')
|
|
accrual_cron.lastcall = datetime.date(2021, 12, 15)
|
|
with freeze_time('2022-01-01'):
|
|
allocation._update_accrual()
|
|
self.assertEqual(allocation.number_of_days, 25, 'The maximum number of days should be reached and kept.')
|
|
|
|
def test_unused_accrual_postponed_2(self):
|
|
with freeze_time('2021-01-01'):
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'level_ids': [(0, 0, {
|
|
'added_value_type': 'day',
|
|
'start_count': 0,
|
|
'start_type': 'day',
|
|
'added_value': 2,
|
|
'frequency': 'yearly',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 100,
|
|
'action_with_unused_accruals': 'maximum',
|
|
'postpone_max_days': 10,
|
|
})],
|
|
})
|
|
allocation = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual allocation for employee',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 0,
|
|
'allocation_type': 'accrual',
|
|
})
|
|
allocation.action_validate()
|
|
|
|
# Reset the cron's lastcall
|
|
accrual_cron = self.env['ir.cron'].sudo().env.ref('hr_holidays.hr_leave_allocation_cron_accrual')
|
|
accrual_cron.lastcall = datetime.date(2021, 1, 1)
|
|
with freeze_time('2023-01-26'):
|
|
allocation._update_accrual()
|
|
self.assertEqual(allocation.number_of_days, 4, 'The maximum number of days should be reached and kept.')
|
|
|
|
def test_unused_accrual_postponed_limit(self):
|
|
# 1 accrual with 2 levels and level transition after
|
|
# This also tests retroactivity
|
|
with freeze_time('2021-12-15'):
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'accrued_gain_time': 'start',
|
|
'level_ids': [(0, 0, {
|
|
'added_value_type': 'day',
|
|
'start_count': 1,
|
|
'start_type': 'day',
|
|
'added_value': 1,
|
|
'frequency': 'daily',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 25,
|
|
'action_with_unused_accruals': 'maximum',
|
|
'postpone_max_days': 15,
|
|
})],
|
|
})
|
|
allocation = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual allocation for employee',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 10,
|
|
'allocation_type': 'accrual',
|
|
})
|
|
allocation.action_validate()
|
|
|
|
# Reset the cron's lastcall
|
|
accrual_cron = self.env['ir.cron'].sudo().env.ref('hr_holidays.hr_leave_allocation_cron_accrual')
|
|
accrual_cron.lastcall = datetime.date(2021, 12, 15)
|
|
with freeze_time('2022-01-01'):
|
|
allocation._update_accrual()
|
|
self.assertEqual(allocation.number_of_days, 16, 'The maximum number of days should be reached and kept.')
|
|
|
|
def test_unused_accrual_postponed_limit_2(self):
|
|
with freeze_time('2021-01-01'):
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'level_ids': [(0, 0, {
|
|
'added_value_type': 'day',
|
|
'start_count': 0,
|
|
'start_type': 'day',
|
|
'added_value': 15,
|
|
'frequency': 'yearly',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 100,
|
|
'action_with_unused_accruals': 'maximum',
|
|
'postpone_max_days': 7,
|
|
})],
|
|
})
|
|
allocation = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual allocation for employee',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 0,
|
|
'allocation_type': 'accrual',
|
|
})
|
|
allocation.action_validate()
|
|
|
|
# Reset the cron's lastcall
|
|
accrual_cron = self.env['ir.cron'].sudo().env.ref('hr_holidays.hr_leave_allocation_cron_accrual')
|
|
accrual_cron.lastcall = datetime.date(2021, 1, 1)
|
|
with freeze_time('2023-01-26'):
|
|
allocation._update_accrual()
|
|
self.assertEqual(allocation.number_of_days, 7, 'The maximum number of days should be reached and kept.')
|
|
|
|
def test_accrual_skipped_period(self):
|
|
# Test that when an allocation is made in the past and the second level is technically reached
|
|
# that the first level is not skipped completely.
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'level_ids': [(0, 0, {
|
|
'added_value_type': 'day',
|
|
'start_count': 0,
|
|
'start_type': 'day',
|
|
'added_value': 15,
|
|
'frequency': 'biyearly',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 100,
|
|
'action_with_unused_accruals': 'all',
|
|
}), (0, 0, {
|
|
'start_count': 4,
|
|
'start_type': 'month',
|
|
'added_value': 10,
|
|
'frequency': 'biyearly',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 500,
|
|
'action_with_unused_accruals': 'all',
|
|
})],
|
|
})
|
|
with freeze_time('2020-8-16'):
|
|
allocation = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Allocation - Test',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 0,
|
|
'allocation_type': 'accrual',
|
|
'date_from': datetime.date(2020, 8, 16),
|
|
})
|
|
allocation.action_validate()
|
|
with freeze_time('2022-1-10'):
|
|
allocation._update_accrual()
|
|
self.assertAlmostEqual(allocation.number_of_days, 30.82, 2, "Invalid number of days")
|
|
|
|
def test_three_levels_accrual(self):
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'level_ids': [(0, 0, {
|
|
'added_value_type': 'day',
|
|
'start_count': 2,
|
|
'start_type': 'month',
|
|
'added_value': 3,
|
|
'frequency': 'monthly',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 3,
|
|
'action_with_unused_accruals': 'all',
|
|
'first_day': 31,
|
|
}), (0, 0, {
|
|
'start_count': 3,
|
|
'start_type': 'month',
|
|
'added_value': 6,
|
|
'frequency': 'monthly',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 6,
|
|
'action_with_unused_accruals': 'all',
|
|
'first_day': 31,
|
|
}), (0, 0, {
|
|
'start_count': 4,
|
|
'start_type': 'month',
|
|
'added_value': 1,
|
|
'frequency': 'monthly',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 100,
|
|
'action_with_unused_accruals': 'all',
|
|
'first_day': 31,
|
|
})],
|
|
})
|
|
with freeze_time('2022-1-31'):
|
|
allocation = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Allocation - Test',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 0,
|
|
'allocation_type': 'accrual',
|
|
'date_from': datetime.date(2022, 1, 31),
|
|
})
|
|
allocation.action_validate()
|
|
with freeze_time('2022-7-20'):
|
|
allocation._update_accrual()
|
|
# The first level gives 3 days
|
|
# The second level could give 6 days but since the first level was already giving
|
|
# 3 days, the second level gives 3 days to reach the second level's limit.
|
|
# The third level gives 1 day since it only counts for one iteration.
|
|
self.assertAlmostEqual(allocation.number_of_days, 7, 2)
|
|
|
|
def test_accrual_lost_previous_days(self):
|
|
# Test that when an allocation with two levels is made and that the first level has it's action
|
|
# with unused accruals set as lost that the days are effectively lost
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'level_ids': [
|
|
(0, 0, {
|
|
'added_value_type': 'day',
|
|
'start_count': 0,
|
|
'start_type': 'day',
|
|
'added_value': 1,
|
|
'frequency': 'monthly',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 12,
|
|
'action_with_unused_accruals': 'lost',
|
|
}),
|
|
(0, 0, {
|
|
'start_count': 1,
|
|
'start_type': 'year',
|
|
'added_value': 1,
|
|
'frequency': 'monthly',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 12,
|
|
'action_with_unused_accruals': 'lost',
|
|
}),
|
|
],
|
|
})
|
|
with freeze_time('2021-1-1'):
|
|
allocation = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Allocation - Test',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 0,
|
|
'allocation_type': 'accrual',
|
|
'date_from': datetime.date(2021, 1, 1),
|
|
})
|
|
allocation.action_validate()
|
|
with freeze_time('2022-4-4'):
|
|
allocation._update_accrual()
|
|
self.assertEqual(allocation.number_of_days, 3, "Invalid number of days")
|
|
|
|
def test_accrual_lost_first_january(self):
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'accrued_gain_time': 'start',
|
|
'level_ids': [
|
|
(0, 0, {
|
|
'added_value_type': 'day',
|
|
'start_count': 0,
|
|
'start_type': 'day',
|
|
'added_value': 3,
|
|
'frequency': 'yearly',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 12,
|
|
'action_with_unused_accruals': 'lost',
|
|
})
|
|
],
|
|
})
|
|
with freeze_time('2019-1-1'):
|
|
allocation = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Allocation - Test',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 0,
|
|
'allocation_type': 'accrual',
|
|
'date_from': datetime.date(2019, 1, 1),
|
|
})
|
|
allocation.action_validate()
|
|
|
|
with freeze_time('2022-4-1'):
|
|
allocation._update_accrual()
|
|
self.assertAlmostEqual(allocation.number_of_days, 3, 2, "Invalid number of days")
|
|
|
|
def test_accrual_maximum_leaves(self):
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'level_ids': [(0, 0, {
|
|
'added_value_type': 'day',
|
|
'start_count': 1,
|
|
'start_type': 'day',
|
|
'added_value': 1,
|
|
'frequency': 'daily',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 5,
|
|
})],
|
|
})
|
|
with freeze_time("2021-9-3"):
|
|
allocation = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual allocation for employee',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 0,
|
|
'allocation_type': 'accrual',
|
|
'date_from': '2021-09-03',
|
|
})
|
|
|
|
with freeze_time("2021-10-3"):
|
|
allocation.action_validate()
|
|
allocation._update_accrual()
|
|
|
|
self.assertEqual(allocation.number_of_days, 5, "Should accrue maximum 5 days")
|
|
|
|
def test_accrual_maximum_leaves_no_limit(self):
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'level_ids': [(0, 0, {
|
|
'added_value_type': 'day',
|
|
'start_count': 1,
|
|
'start_type': 'day',
|
|
'added_value': 1,
|
|
'frequency': 'daily',
|
|
'cap_accrued_time': False,
|
|
})],
|
|
})
|
|
with freeze_time("2021-9-3"):
|
|
allocation = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual allocation for employee',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 0,
|
|
'allocation_type': 'accrual',
|
|
'date_from': '2021-09-03',
|
|
})
|
|
|
|
with freeze_time("2021-10-3"):
|
|
allocation.action_validate()
|
|
allocation._update_accrual()
|
|
|
|
self.assertEqual(allocation.number_of_days, 29, "No limits for accrued days")
|
|
|
|
def test_accrual_leaves_taken_maximum(self):
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'level_ids': [(0, 0, {
|
|
'added_value_type': 'day',
|
|
'start_count': 0,
|
|
'start_type': 'day',
|
|
'added_value': 1,
|
|
'frequency': 'weekly',
|
|
'week_day': 'mon',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 5,
|
|
})],
|
|
})
|
|
with freeze_time("2022-1-1"):
|
|
allocation = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual allocation for employee',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 0,
|
|
'allocation_type': 'accrual',
|
|
'date_from': '2022-01-01',
|
|
})
|
|
allocation.action_validate()
|
|
|
|
with freeze_time("2022-3-2"):
|
|
allocation._update_accrual()
|
|
|
|
self.assertEqual(allocation.number_of_days, 5, "Maximum of 5 days accrued")
|
|
|
|
leave = self.env['hr.leave'].create({
|
|
'name': 'leave',
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'request_date_from': '2022-03-07',
|
|
'request_date_to': '2022-03-11',
|
|
})
|
|
leave.action_validate()
|
|
|
|
with freeze_time("2022-6-1"):
|
|
allocation._update_accrual()
|
|
self.assertEqual(allocation.number_of_days, 10, "Should accrue 5 additional days")
|
|
|
|
def test_accrual_leaves_taken_maximum_hours(self):
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'level_ids': [(0, 0, {
|
|
'added_value_type': 'hour',
|
|
'start_count': 0,
|
|
'start_type': 'day',
|
|
'added_value': 1,
|
|
'frequency': 'weekly',
|
|
'week_day': 'mon',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 10,
|
|
})],
|
|
})
|
|
with freeze_time(datetime.date(2022, 1, 1)):
|
|
allocation = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual allocation for employee',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type_hour.id,
|
|
'number_of_days': 0,
|
|
'allocation_type': 'accrual',
|
|
'date_from': '2022-01-01',
|
|
})
|
|
allocation.action_validate()
|
|
|
|
with freeze_time(datetime.date(2022, 4, 1)):
|
|
allocation._update_accrual()
|
|
|
|
self.assertEqual(allocation.number_of_days, 10 / self.hours_per_day, "Maximum of 10 hours accrued")
|
|
|
|
leave = self.env['hr.leave'].create({
|
|
'name': 'leave',
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type_hour.id,
|
|
'request_date_from': '2022-03-07',
|
|
'request_date_to': '2022-03-07',
|
|
})
|
|
leave.action_validate()
|
|
|
|
with freeze_time(datetime.date(2022, 6, 1)):
|
|
allocation._update_accrual()
|
|
self.assertEqual(allocation.number_of_days, 18 / self.hours_per_day, "Should accrue 8 additional hours")
|
|
|
|
def test_accrual_period_start(self):
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'accrued_gain_time': 'end',
|
|
'level_ids': [(0, 0, {
|
|
'added_value_type': 'day',
|
|
'start_count': 0,
|
|
'start_type': 'day',
|
|
'added_value': 1,
|
|
'frequency': 'weekly',
|
|
'week_day': 'mon',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 5,
|
|
})],
|
|
})
|
|
with freeze_time("2023-4-24"):
|
|
allocation = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual allocation for employee',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 0,
|
|
'allocation_type': 'accrual',
|
|
'date_from': '2023-04-24',
|
|
})
|
|
allocation.action_validate()
|
|
|
|
allocation._update_accrual()
|
|
|
|
self.assertEqual(allocation.number_of_days, 0, "Should accrue 0 days, because the period is not done yet.")
|
|
|
|
accrual_plan.accrued_gain_time = 'start'
|
|
with freeze_time("2023-4-24"):
|
|
allocation = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual allocation for employee',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 0,
|
|
'allocation_type': 'accrual',
|
|
'date_from': '2023-04-24',
|
|
})
|
|
allocation.action_validate()
|
|
|
|
allocation._update_accrual()
|
|
|
|
self.assertEqual(allocation.number_of_days, 1, "Should accrue 1 day, at the start of the period.")
|
|
|
|
def test_aaaccrual_period_start_multiple_runs(self):
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'accrued_gain_time': 'start',
|
|
'level_ids': [(0, 0, {
|
|
'added_value_type': 'day',
|
|
'start_count': 0,
|
|
'start_type': 'day',
|
|
'added_value': 1.5,
|
|
'frequency': 'monthly',
|
|
'first_day': 13,
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 15,
|
|
})],
|
|
})
|
|
with freeze_time("2023-4-13"):
|
|
allocation = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual allocation for employee',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 0,
|
|
'allocation_type': 'accrual',
|
|
'date_from': '2023-04-13',
|
|
})
|
|
allocation.action_validate()
|
|
allocation._update_accrual()
|
|
|
|
self.assertAlmostEqual(allocation.number_of_days, 1.5, 2)
|
|
|
|
with freeze_time("2023-9-13"):
|
|
allocation._update_accrual()
|
|
|
|
self.assertAlmostEqual(allocation.number_of_days, 9, 2)
|
|
|
|
def test_accrual_period_start_level_transfer(self):
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'accrued_gain_time': 'start',
|
|
'level_ids': [
|
|
(0, 0, {
|
|
'added_value_type': 'day',
|
|
'start_count': 0,
|
|
'start_type': 'day',
|
|
'added_value': 1,
|
|
'frequency': 'weekly',
|
|
'week_day': 'wed',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 10,
|
|
}),
|
|
(0, 0, {
|
|
'start_count': 3,
|
|
'start_type': 'month',
|
|
'added_value': 2,
|
|
'frequency': 'weekly',
|
|
'week_day': 'wed',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 5,
|
|
})
|
|
],
|
|
})
|
|
with freeze_time("2023-4-26"):
|
|
allocation = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual allocation for employee',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 0,
|
|
'allocation_type': 'accrual',
|
|
'date_from': '2023-04-26',
|
|
})
|
|
allocation.action_validate()
|
|
allocation._update_accrual()
|
|
self.assertEqual(allocation.number_of_days, 1, "Should accrue 1 day, at the start of the period.")
|
|
|
|
with freeze_time("2023-7-5"):
|
|
allocation._update_accrual()
|
|
self.assertEqual(allocation.number_of_days, 10, "Should accrue 10 days, days received, but not over limit.")
|
|
|
|
# first wednesday at the second level
|
|
with freeze_time("2023-8-02"):
|
|
allocation._update_accrual()
|
|
self.assertEqual(allocation.number_of_days, 5, "Should accrue 5 days, after level transfer 10 are cut to 5")
|
|
|
|
def test_accrual_carryover_at_allocation(self):
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'accrued_gain_time': 'start',
|
|
'carryover_date': 'allocation',
|
|
'level_ids': [(0, 0, {
|
|
'added_value_type': 'day',
|
|
'start_count': 0,
|
|
'start_type': 'day',
|
|
'added_value': 1,
|
|
'frequency': 'monthly',
|
|
'first_day': 27,
|
|
'cap_accrued_time': False,
|
|
'action_with_unused_accruals': 'lost',
|
|
})],
|
|
})
|
|
with freeze_time("2023-4-26"):
|
|
allocation = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual allocation for employee',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 0,
|
|
'allocation_type': 'accrual',
|
|
'date_from': '2023-04-26',
|
|
})
|
|
allocation.action_validate()
|
|
allocation._update_accrual()
|
|
self.assertEqual(allocation.number_of_days, 0, "Should accrue 0 days, days are added on 27th.")
|
|
|
|
with freeze_time("2023-4-27"):
|
|
allocation._update_accrual()
|
|
self.assertAlmostEqual(allocation.number_of_days, 1.03, 2, "Should accrue 1 day, days are added on 27th.")
|
|
|
|
with freeze_time("2023-12-27"):
|
|
allocation._update_accrual()
|
|
self.assertAlmostEqual(allocation.number_of_days, 9.03, 2, "Should accrue 9 day, after 8 months.")
|
|
|
|
with freeze_time("2024-04-26"):
|
|
allocation._update_accrual()
|
|
self.assertEqual(allocation.number_of_days, 0, "Allocations not lost on 1st of January, but on allocation date.")
|
|
|
|
with freeze_time("2024-04-27"):
|
|
allocation._update_accrual()
|
|
self.assertAlmostEqual(allocation.number_of_days, 1.03, 2, "Allocations lost, then 1 accrued.")
|
|
|
|
def test_accrual_carryover_at_other(self):
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'accrued_gain_time': 'start',
|
|
'carryover_date': 'other',
|
|
'carryover_day': 20,
|
|
'carryover_month': 'apr',
|
|
'level_ids': [(0, 0, {
|
|
'added_value_type': 'day',
|
|
'start_count': 0,
|
|
'start_type': 'day',
|
|
'added_value': 10,
|
|
'frequency': 'monthly',
|
|
'first_day': 11,
|
|
'cap_accrued_time': False,
|
|
'action_with_unused_accruals': 'maximum',
|
|
'postpone_max_days': 69,
|
|
})],
|
|
})
|
|
with freeze_time("2023-04-20"):
|
|
allocation = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual allocation for employee',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 0,
|
|
'allocation_type': 'accrual',
|
|
'date_from': '2023-04-20',
|
|
})
|
|
allocation.action_validate()
|
|
|
|
with freeze_time("2024-04-20"):
|
|
allocation._update_accrual()
|
|
self.assertEqual(allocation.number_of_days, 69, "Carryover at other date, level's maximum leave is 69.")
|
|
|
|
def test_accrual_carrover_other_period_end_multi_level(self):
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Accrual Plan For Test',
|
|
'accrued_gain_time': 'end',
|
|
'carryover_date': 'other',
|
|
'carryover_day': 5,
|
|
'carryover_month': 'jun',
|
|
'level_ids': [
|
|
(0, 0, {
|
|
'added_value_type': 'day',
|
|
'start_count': 5,
|
|
'start_type': 'day',
|
|
'added_value': 1,
|
|
'frequency': 'monthly',
|
|
'first_day': 9,
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 15,
|
|
'action_with_unused_accruals': 'maximum',
|
|
'postpone_max_days': 13,
|
|
}),
|
|
(0, 0, {
|
|
'start_count': 9,
|
|
'start_type': 'month',
|
|
'added_value': 2,
|
|
'frequency': 'biyearly',
|
|
'first_month_day': 17,
|
|
'first_month': 'feb',
|
|
'second_month_day': 29,
|
|
'second_month': 'oct',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 10,
|
|
'action_with_unused_accruals': 'maximum',
|
|
'postpone_max_days': 20,
|
|
}),
|
|
(0, 0, {
|
|
'start_count': 17,
|
|
'start_type': 'month',
|
|
'added_value': 12,
|
|
'frequency': 'yearly',
|
|
'yearly_month': 'jul',
|
|
'yearly_day': 15,
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 21,
|
|
'action_with_unused_accruals': 'lost',
|
|
}),
|
|
],
|
|
})
|
|
with freeze_time("2023-04-04"):
|
|
allocation = self.env['hr.leave.allocation'].with_user(self.user_hrmanager_id).with_context(tracking_disable=True).create({
|
|
'name': 'Accrual allocation for employee',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': self.leave_type.id,
|
|
'number_of_days': 9,
|
|
'allocation_type': 'accrual',
|
|
'date_from': '2023-04-4',
|
|
})
|
|
allocation.action_validate()
|
|
|
|
with freeze_time("2026-08-01"):
|
|
allocation._update_accrual()
|
|
self.assertAlmostEqual(allocation.number_of_days, 1.315, 3)
|
|
|
|
def test_accrual_creation_on_anterior_date(self):
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].with_context(tracking_disable=True).create({
|
|
'name': 'Weekly accrual',
|
|
'carryover_date': 'allocation',
|
|
'level_ids': [(0, 0, {
|
|
'added_value_type': 'day',
|
|
'start_count': 0,
|
|
'start_type': 'day',
|
|
'added_value': 1,
|
|
'frequency': 'weekly',
|
|
'cap_accrued_time': False,
|
|
'action_with_unused_accruals': 'lost',
|
|
})],
|
|
})
|
|
with freeze_time('2023-09-01'):
|
|
accrual_allocation = self.env['hr.leave.allocation'].new({
|
|
'name': 'Employee allocation',
|
|
'holiday_status_id': self.leave_type.id,
|
|
'date_from': '2023-01-01',
|
|
'employee_id': self.employee_emp.id,
|
|
'allocation_type': 'accrual',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
})
|
|
# As the duration is set to a onchange, we need to force that onchange to run
|
|
accrual_allocation._onchange_date_from()
|
|
accrual_allocation.action_validate()
|
|
# The amount of days should be computed as if it was accrued since
|
|
# the start date of the allocation.
|
|
self.assertAlmostEqual(accrual_allocation.number_of_days, 34.0, places=0)
|
|
self.assertFalse(accrual_allocation.lastcall == accrual_allocation.date_from)
|
|
accrual_allocation._update_accrual()
|
|
# The amount being already computed, the amount should stay the same after the cron
|
|
# running on the same day.
|
|
self.assertAlmostEqual(accrual_allocation.number_of_days, 34.0, places=0)
|
|
|
|
def test_future_accural_time(self):
|
|
leave_type = self.env['hr.leave.type'].create({
|
|
'name': 'Test Leave Type',
|
|
'time_type': 'leave',
|
|
'requires_allocation': 'yes',
|
|
'allocation_validation_type': 'no',
|
|
'request_unit': 'hour',
|
|
})
|
|
with freeze_time("2023-12-31"):
|
|
accrual_plan = self.env['hr.leave.accrual.plan'].create({
|
|
'name': 'Accrual Plan For Test',
|
|
'is_based_on_worked_time': False,
|
|
'accrued_gain_time': 'end',
|
|
'carryover_date': 'year_start',
|
|
'level_ids': [(0, 0, {
|
|
'start_count': 1,
|
|
'start_type': 'day',
|
|
'added_value': 1,
|
|
'added_value_type': 'hour',
|
|
'frequency': 'monthly',
|
|
'cap_accrued_time': True,
|
|
'maximum_leave': 100,
|
|
})],
|
|
})
|
|
allocation = self.env['hr.leave.allocation'].create({
|
|
'name': 'Accrual allocation for employee',
|
|
'accrual_plan_id': accrual_plan.id,
|
|
'employee_id': self.employee_emp.id,
|
|
'holiday_status_id': leave_type.id,
|
|
'number_of_days': 0.125,
|
|
'allocation_type': 'accrual',
|
|
'holiday_type': 'employee',
|
|
})
|
|
allocation.action_validate()
|
|
allocation_data = leave_type.get_allocation_data(self.employee_emp, datetime.date(2024, 2, 1))
|
|
self.assertEqual(allocation_data[self.employee_emp][0][1]['virtual_remaining_leaves'], 2)
|