[MIG] resource: Migrated unittest cases to new api
- Converted yml test cases to python unittest - now, 'self.calendar' recordset from common.py will carry forward its context so no need to pass context explicitely to the methods calling using that recordset. - removed commented code - used odoo.fields.Datetime to covert dates instead of python datetime library
This commit is contained in:
Ravi Gohil
committed by
Yannick Tivisse
Yannick Tivisse
parent
839a4b8316
commit
dc77ed4f90
@@ -20,8 +20,4 @@ associated to every resource. It also manages the leaves of every resource.
|
||||
'views/resource_views.xml',
|
||||
],
|
||||
'demo': ['data/resource_demo.xml'],
|
||||
'test': [
|
||||
'test/resource.yml',
|
||||
'test/duplicate_resource.yml',
|
||||
],
|
||||
}
|
||||
|
||||
@@ -1,6 +0,0 @@
|
||||
-
|
||||
I duplicate the resource "Analyst"
|
||||
-
|
||||
!python {model: resource.resource}: |
|
||||
copied_id = self.copy(cr, uid, ref("resource_analyst"))
|
||||
assert copied_id, "Unable to Duplicate Resource"
|
||||
@@ -1,53 +0,0 @@
|
||||
-
|
||||
In order to test resource.
|
||||
-
|
||||
I assign working calendar '45 Hours/Week' to human resource.
|
||||
-
|
||||
!python {model: resource.resource}: |
|
||||
self.write(cr, uid, [ref('resource_analyst'), ref('resource_designer'), ref('resource_developer')], {'calendar_id' : ref('timesheet_group1'), 'resource_type': 'user'})
|
||||
|
||||
-
|
||||
I had Project of OpenERP Integration of 50 Hours with three human resource assigned on it. I have started project from this week start.
|
||||
-
|
||||
I check per day work hour availability of the Resource based on Working Calendar Assigned to each resource, for first day of the week.
|
||||
-
|
||||
!python {model: resource.resource}: |
|
||||
from openerp.tools import float_compare
|
||||
calendar_pool = self.pool.get('resource.calendar')
|
||||
resources = self.browse(cr, uid, [ref('resource_analyst'), ref('resource_designer'), ref('resource_developer')], context)
|
||||
from datetime import datetime, timedelta
|
||||
now = datetime.now()
|
||||
dt = now - timedelta(days=now.weekday())
|
||||
for resource in resources:
|
||||
result = calendar_pool.working_hours_on_day(cr, uid, resource.calendar_id, dt, context)
|
||||
assert float_compare(result, 8.0, precision_digits=2) == 0, 'Wrong calculation of day work hour availability of the Resource (found %d).' % result
|
||||
-
|
||||
Now, resource "Developer" drafted leave on Thursday in this week.
|
||||
-
|
||||
!python {model: resource.calendar.leaves}: |
|
||||
from datetime import datetime,timedelta
|
||||
now = datetime.now()
|
||||
dt = (now - timedelta(days=now.weekday()) ) + timedelta(days=3)
|
||||
self.write(cr, uid, [ref('resource_dummyleave')], {'resource_id': ref('resource_developer'), 'calendar_id': ref('timesheet_group1'), 'date_from': dt.strftime("%Y-%m-%d 09:00:00"), 'date_to': dt.strftime("%Y-%m-%d 18:00:00")})
|
||||
|
||||
-
|
||||
I check Actual working hours on resource 'Developer' from this week
|
||||
-
|
||||
!python {model: resource.calendar}: |
|
||||
from datetime import datetime
|
||||
from dateutil.relativedelta import relativedelta
|
||||
now = datetime.now()
|
||||
dt_from = now - relativedelta(days=now.weekday(), hour=8, minute=30)
|
||||
dt_to = dt_from + relativedelta(days=6, hour=17)
|
||||
hours = self.interval_hours_get(cr, uid, ref('timesheet_group1'), dt_from, dt_to, resource=ref('resource_developer'))
|
||||
assert hours > 27 , 'Invalid Total Week working hour calculated, got %r, expected > 27' % hours
|
||||
-
|
||||
Project Analysis work is of 20 hours which will start from Week start so i will calculate working schedule for resource Analyst for the same.
|
||||
-
|
||||
!python {model: resource.calendar}: |
|
||||
|
||||
from datetime import datetime, timedelta
|
||||
now = datetime.now()
|
||||
work_intreval = self.interval_min_get(cr, uid, ref('timesheet_group1'), now, 20.0, resource=ref('resource_designer'))
|
||||
assert len(work_intreval) >= 5, 'Wrong Schedule Calculated'
|
||||
|
||||
@@ -1,106 +1,102 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
||||
|
||||
from datetime import datetime
|
||||
|
||||
from openerp.tests import common
|
||||
from odoo.fields import Datetime
|
||||
from odoo.tests.common import TransactionCase
|
||||
|
||||
|
||||
class TestResourceCommon(common.TransactionCase):
|
||||
class TestResourceCommon(TransactionCase):
|
||||
|
||||
def setUp(self):
|
||||
super(TestResourceCommon, self).setUp()
|
||||
cr, uid = self.cr, self.uid
|
||||
self.context = context = dict(tz='UTC')
|
||||
|
||||
self.registry('res.users').write(cr, uid, uid, {'tz': 'UTC'}, context=context)
|
||||
self.env['res.users'].browse(self.env.uid).with_context(context).write({'tz': 'UTC'})
|
||||
|
||||
# Usefull models
|
||||
self.resource_resource = self.registry('resource.resource')
|
||||
self.resource_calendar = self.registry('resource.calendar')
|
||||
self.resource_attendance = self.registry('resource.calendar.attendance')
|
||||
self.resource_leaves = self.registry('resource.calendar.leaves')
|
||||
self.Resource = self.env['resource.resource']
|
||||
self.ResourceCalendar = self.env['resource.calendar']
|
||||
self.ResourceAttendance = self.env['resource.calendar.attendance']
|
||||
self.ResourceLeaves = self.env['resource.calendar.leaves']
|
||||
|
||||
# Some demo data
|
||||
self.date1 = datetime.strptime('2013-02-12 09:08:07', '%Y-%m-%d %H:%M:%S') # weekday() returns 1, isoweekday() returns 2
|
||||
self.date2 = datetime.strptime('2013-02-15 10:11:12', '%Y-%m-%d %H:%M:%S') # weekday() returns 4, isoweekday() returns 5
|
||||
self.date1 = Datetime.from_string('2013-02-12 09:08:07') # weekday() returns 1, isoweekday() returns 2
|
||||
self.date2 = Datetime.from_string('2013-02-15 10:11:12') # weekday() returns 4, isoweekday() returns 5
|
||||
# Leave1: 19/02/2013, from 9 to 12, is a day 1
|
||||
self.leave1_start = datetime.strptime('2013-02-19 09:00:00', '%Y-%m-%d %H:%M:%S')
|
||||
self.leave1_end = datetime.strptime('2013-02-19 12:00:00', '%Y-%m-%d %H:%M:%S')
|
||||
self.leave1_start = Datetime.from_string('2013-02-19 09:00:00')
|
||||
self.leave1_end = Datetime.from_string('2013-02-19 12:00:00')
|
||||
# Leave2: 22/02/2013, from 9 to 15, is a day 4
|
||||
self.leave2_start = datetime.strptime('2013-02-22 09:00:00', '%Y-%m-%d %H:%M:%S')
|
||||
self.leave2_end = datetime.strptime('2013-02-22 15:00:00', '%Y-%m-%d %H:%M:%S')
|
||||
self.leave2_start = Datetime.from_string('2013-02-22 09:00:00')
|
||||
self.leave2_end = Datetime.from_string('2013-02-22 15:00:00')
|
||||
# Leave3: 25/02/2013 (day0) -> 01/03/2013 (day4)
|
||||
self.leave3_start = datetime.strptime('2013-02-25 13:00:00', '%Y-%m-%d %H:%M:%S')
|
||||
self.leave3_end = datetime.strptime('2013-03-01 11:30:00', '%Y-%m-%d %H:%M:%S')
|
||||
self.leave3_start = Datetime.from_string('2013-02-25 13:00:00')
|
||||
self.leave3_end = Datetime.from_string('2013-03-01 11:30:00')
|
||||
|
||||
# Resource data
|
||||
# Calendar working days: 1 (8-16 -> 8hours), 4 (8-13, 16-23 -> 12hours)
|
||||
self.calendar_id = self.resource_calendar.create(
|
||||
cr, uid, {
|
||||
self.calendar = self.ResourceCalendar.with_context(context).create(
|
||||
{
|
||||
'name': 'TestCalendar',
|
||||
}, context=context
|
||||
}
|
||||
)
|
||||
self.att1_id = self.resource_attendance.create(
|
||||
cr, uid, {
|
||||
self.att1_id = self.ResourceAttendance.with_context(context).create(
|
||||
{
|
||||
'name': 'Att1',
|
||||
'dayofweek': '1',
|
||||
'hour_from': 8,
|
||||
'hour_to': 16,
|
||||
'calendar_id': self.calendar_id,
|
||||
}, context=context
|
||||
)
|
||||
self.att2_id = self.resource_attendance.create(
|
||||
cr, uid, {
|
||||
'calendar_id': self.calendar.id,
|
||||
}
|
||||
).id
|
||||
self.att2_id = self.ResourceAttendance.with_context(context).create(
|
||||
{
|
||||
'name': 'Att2',
|
||||
'dayofweek': '4',
|
||||
'hour_from': 8,
|
||||
'hour_to': 13,
|
||||
'calendar_id': self.calendar_id,
|
||||
}, context=context
|
||||
)
|
||||
self.att3_id = self.resource_attendance.create(
|
||||
cr, uid, {
|
||||
'calendar_id': self.calendar.id,
|
||||
}
|
||||
).id
|
||||
self.att3_id = self.ResourceAttendance.with_context(context).create(
|
||||
{
|
||||
'name': 'Att3',
|
||||
'dayofweek': '4',
|
||||
'hour_from': 16,
|
||||
'hour_to': 23,
|
||||
'calendar_id': self.calendar_id,
|
||||
}, context=context
|
||||
)
|
||||
self.resource1_id = self.resource_resource.create(
|
||||
cr, uid, {
|
||||
'calendar_id': self.calendar.id,
|
||||
}
|
||||
).id
|
||||
self.resource1_id = self.Resource.with_context(context).create(
|
||||
{
|
||||
'name': 'TestResource1',
|
||||
'resource_type': 'user',
|
||||
'time_efficiency': 150.0,
|
||||
'calendar_id': self.calendar_id,
|
||||
}, context=context
|
||||
)
|
||||
self.leave1_id = self.resource_leaves.create(
|
||||
cr, uid, {
|
||||
'calendar_id': self.calendar.id,
|
||||
}
|
||||
).id
|
||||
self.leave1_id = self.ResourceLeaves.with_context(context).create(
|
||||
{
|
||||
'name': 'GenericLeave',
|
||||
'calendar_id': self.calendar_id,
|
||||
'calendar_id': self.calendar.id,
|
||||
'date_from': self.leave1_start,
|
||||
'date_to': self.leave1_end,
|
||||
}, context=context
|
||||
)
|
||||
self.leave2_id = self.resource_leaves.create(
|
||||
cr, uid, {
|
||||
}
|
||||
).id
|
||||
self.leave2_id = self.ResourceLeaves.with_context(context).create(
|
||||
{
|
||||
'name': 'ResourceLeave',
|
||||
'calendar_id': self.calendar_id,
|
||||
'calendar_id': self.calendar.id,
|
||||
'resource_id': self.resource1_id,
|
||||
'date_from': self.leave2_start,
|
||||
'date_to': self.leave2_end,
|
||||
}, context=context
|
||||
)
|
||||
self.leave3_id = self.resource_leaves.create(
|
||||
cr, uid, {
|
||||
}
|
||||
).id
|
||||
self.leave3_id = self.ResourceLeaves.with_context(context).create(
|
||||
{
|
||||
'name': 'ResourceLeave2',
|
||||
'calendar_id': self.calendar_id,
|
||||
'calendar_id': self.calendar.id,
|
||||
'resource_id': self.resource1_id,
|
||||
'date_from': self.leave3_start,
|
||||
'date_to': self.leave3_end,
|
||||
}, context=context
|
||||
)
|
||||
# Some browse data
|
||||
self.calendar = self.resource_calendar.browse(cr, uid, self.calendar_id, context=context)
|
||||
}
|
||||
).id
|
||||
|
||||
@@ -6,7 +6,9 @@ from datetime import datetime, timedelta, date
|
||||
import babel.dates
|
||||
from dateutil.relativedelta import relativedelta
|
||||
|
||||
from openerp.addons.resource.tests.common import TestResourceCommon
|
||||
from odoo.fields import Datetime
|
||||
from odoo.tools import float_compare
|
||||
from odoo.addons.resource.tests.common import TestResourceCommon
|
||||
|
||||
from openerp.tests import TransactionCase
|
||||
|
||||
@@ -14,93 +16,91 @@ from openerp.tests import TransactionCase
|
||||
class TestResource(TestResourceCommon):
|
||||
|
||||
def test_00_intervals(self):
|
||||
cr, uid = self.cr, self.uid
|
||||
intervals = [
|
||||
(
|
||||
datetime.strptime('2013-02-04 09:00:00', '%Y-%m-%d %H:%M:%S'),
|
||||
datetime.strptime('2013-02-04 11:00:00', '%Y-%m-%d %H:%M:%S')
|
||||
Datetime.from_string('2013-02-04 09:00:00'),
|
||||
Datetime.from_string('2013-02-04 11:00:00')
|
||||
), (
|
||||
datetime.strptime('2013-02-04 08:00:00', '%Y-%m-%d %H:%M:%S'),
|
||||
datetime.strptime('2013-02-04 12:00:00', '%Y-%m-%d %H:%M:%S')
|
||||
Datetime.from_string('2013-02-04 08:00:00'),
|
||||
Datetime.from_string('2013-02-04 12:00:00')
|
||||
), (
|
||||
datetime.strptime('2013-02-04 11:00:00', '%Y-%m-%d %H:%M:%S'),
|
||||
datetime.strptime('2013-02-04 14:00:00', '%Y-%m-%d %H:%M:%S')
|
||||
Datetime.from_string('2013-02-04 11:00:00'),
|
||||
Datetime.from_string('2013-02-04 14:00:00')
|
||||
), (
|
||||
datetime.strptime('2013-02-04 17:00:00', '%Y-%m-%d %H:%M:%S'),
|
||||
datetime.strptime('2013-02-04 21:00:00', '%Y-%m-%d %H:%M:%S')
|
||||
Datetime.from_string('2013-02-04 17:00:00'),
|
||||
Datetime.from_string('2013-02-04 21:00:00')
|
||||
), (
|
||||
datetime.strptime('2013-02-03 08:00:00', '%Y-%m-%d %H:%M:%S'),
|
||||
datetime.strptime('2013-02-03 10:00:00', '%Y-%m-%d %H:%M:%S')
|
||||
Datetime.from_string('2013-02-03 08:00:00'),
|
||||
Datetime.from_string('2013-02-03 10:00:00')
|
||||
), (
|
||||
datetime.strptime('2013-02-04 18:00:00', '%Y-%m-%d %H:%M:%S'),
|
||||
datetime.strptime('2013-02-04 19:00:00', '%Y-%m-%d %H:%M:%S')
|
||||
Datetime.from_string('2013-02-04 18:00:00'),
|
||||
Datetime.from_string('2013-02-04 19:00:00')
|
||||
)
|
||||
]
|
||||
|
||||
# Test: interval cleaning
|
||||
cleaned_intervals = self.resource_calendar.interval_clean(intervals)
|
||||
cleaned_intervals = self.ResourceCalendar.interval_clean(intervals)
|
||||
self.assertEqual(len(cleaned_intervals), 3, 'resource_calendar: wrong interval cleaning')
|
||||
# First interval: 03, unchanged
|
||||
self.assertEqual(cleaned_intervals[0][0], datetime.strptime('2013-02-03 08:00:00', '%Y-%m-%d %H:%M:%S'), 'resource_calendar: wrong interval cleaning')
|
||||
self.assertEqual(cleaned_intervals[0][1], datetime.strptime('2013-02-03 10:00:00', '%Y-%m-%d %H:%M:%S'), 'resource_calendar: wrong interval cleaning')
|
||||
self.assertEqual(cleaned_intervals[0][0], Datetime.from_string('2013-02-03 08:00:00'), 'resource_calendar: wrong interval cleaning')
|
||||
self.assertEqual(cleaned_intervals[0][1], Datetime.from_string('2013-02-03 10:00:00'), 'resource_calendar: wrong interval cleaning')
|
||||
# Second intreval: 04, 08-14, combining 08-12 and 11-14, 09-11 being inside 08-12
|
||||
self.assertEqual(cleaned_intervals[1][0], datetime.strptime('2013-02-04 08:00:00', '%Y-%m-%d %H:%M:%S'), 'resource_calendar: wrong interval cleaning')
|
||||
self.assertEqual(cleaned_intervals[1][1], datetime.strptime('2013-02-04 14:00:00', '%Y-%m-%d %H:%M:%S'), 'resource_calendar: wrong interval cleaning')
|
||||
self.assertEqual(cleaned_intervals[1][0], Datetime.from_string('2013-02-04 08:00:00'), 'resource_calendar: wrong interval cleaning')
|
||||
self.assertEqual(cleaned_intervals[1][1], Datetime.from_string('2013-02-04 14:00:00'), 'resource_calendar: wrong interval cleaning')
|
||||
# Third interval: 04, 17-21, 18-19 being inside 17-21
|
||||
self.assertEqual(cleaned_intervals[2][0], datetime.strptime('2013-02-04 17:00:00', '%Y-%m-%d %H:%M:%S'), 'resource_calendar: wrong interval cleaning')
|
||||
self.assertEqual(cleaned_intervals[2][1], datetime.strptime('2013-02-04 21:00:00', '%Y-%m-%d %H:%M:%S'), 'resource_calendar: wrong interval cleaning')
|
||||
self.assertEqual(cleaned_intervals[2][0], Datetime.from_string('2013-02-04 17:00:00'), 'resource_calendar: wrong interval cleaning')
|
||||
self.assertEqual(cleaned_intervals[2][1], Datetime.from_string('2013-02-04 21:00:00'), 'resource_calendar: wrong interval cleaning')
|
||||
|
||||
# Test: disjoint removal
|
||||
working_interval = (datetime.strptime('2013-02-04 08:00:00', '%Y-%m-%d %H:%M:%S'), datetime.strptime('2013-02-04 18:00:00', '%Y-%m-%d %H:%M:%S'))
|
||||
result = self.resource_calendar.interval_remove_leaves(cr, uid, working_interval, intervals)
|
||||
working_interval = (Datetime.from_string('2013-02-04 08:00:00'), Datetime.from_string('2013-02-04 18:00:00'))
|
||||
result = self.ResourceCalendar.interval_remove_leaves(working_interval, intervals)
|
||||
self.assertEqual(len(result), 1, 'resource_calendar: wrong leave removal from interval')
|
||||
# First interval: 04, 14-17
|
||||
self.assertEqual(result[0][0], datetime.strptime('2013-02-04 14:00:00', '%Y-%m-%d %H:%M:%S'), 'resource_calendar: wrong leave removal from interval')
|
||||
self.assertEqual(result[0][1], datetime.strptime('2013-02-04 17:00:00', '%Y-%m-%d %H:%M:%S'), 'resource_calendar: wrong leave removal from interval')
|
||||
self.assertEqual(result[0][0], Datetime.from_string('2013-02-04 14:00:00'), 'resource_calendar: wrong leave removal from interval')
|
||||
self.assertEqual(result[0][1], Datetime.from_string('2013-02-04 17:00:00'), 'resource_calendar: wrong leave removal from interval')
|
||||
|
||||
# Test: schedule hours on intervals
|
||||
result = self.resource_calendar.interval_schedule_hours(cleaned_intervals, 5.5)
|
||||
result = self.ResourceCalendar.interval_schedule_hours(cleaned_intervals, 5.5)
|
||||
self.assertEqual(len(result), 2, 'resource_calendar: wrong hours scheduling in interval')
|
||||
# First interval: 03, 8-10 untouches
|
||||
self.assertEqual(result[0][0], datetime.strptime('2013-02-03 08:00:00', '%Y-%m-%d %H:%M:%S'), 'resource_calendar: wrong leave removal from interval')
|
||||
self.assertEqual(result[0][1], datetime.strptime('2013-02-03 10:00:00', '%Y-%m-%d %H:%M:%S'), 'resource_calendar: wrong leave removal from interval')
|
||||
self.assertEqual(result[0][0], Datetime.from_string('2013-02-03 08:00:00'), 'resource_calendar: wrong leave removal from interval')
|
||||
self.assertEqual(result[0][1], Datetime.from_string('2013-02-03 10:00:00'), 'resource_calendar: wrong leave removal from interval')
|
||||
# First interval: 04, 08-11:30
|
||||
self.assertEqual(result[1][0], datetime.strptime('2013-02-04 08:00:00', '%Y-%m-%d %H:%M:%S'), 'resource_calendar: wrong leave removal from interval')
|
||||
self.assertEqual(result[1][1], datetime.strptime('2013-02-04 11:30:00', '%Y-%m-%d %H:%M:%S'), 'resource_calendar: wrong leave removal from interval')
|
||||
self.assertEqual(result[1][0], Datetime.from_string('2013-02-04 08:00:00'), 'resource_calendar: wrong leave removal from interval')
|
||||
self.assertEqual(result[1][1], Datetime.from_string('2013-02-04 11:30:00'), 'resource_calendar: wrong leave removal from interval')
|
||||
|
||||
# Test: schedule hours on intervals, backwards
|
||||
cleaned_intervals.reverse()
|
||||
result = self.resource_calendar.interval_schedule_hours(cleaned_intervals, 5.5, remove_at_end=False)
|
||||
result = self.ResourceCalendar._model.interval_schedule_hours(cleaned_intervals, 5.5, remove_at_end=False)
|
||||
self.assertEqual(len(result), 2, 'resource_calendar: wrong hours scheduling in interval')
|
||||
# First interval: 03, 8-10 untouches
|
||||
self.assertEqual(result[0][0], datetime.strptime('2013-02-04 17:00:00', '%Y-%m-%d %H:%M:%S'), 'resource_calendar: wrong leave removal from interval')
|
||||
self.assertEqual(result[0][1], datetime.strptime('2013-02-04 21:00:00', '%Y-%m-%d %H:%M:%S'), 'resource_calendar: wrong leave removal from interval')
|
||||
self.assertEqual(result[0][0], Datetime.from_string('2013-02-04 17:00:00'), 'resource_calendar: wrong leave removal from interval')
|
||||
self.assertEqual(result[0][1], Datetime.from_string('2013-02-04 21:00:00'), 'resource_calendar: wrong leave removal from interval')
|
||||
# First interval: 04, 08-11:30
|
||||
self.assertEqual(result[1][0], datetime.strptime('2013-02-04 12:30:00', '%Y-%m-%d %H:%M:%S'), 'resource_calendar: wrong leave removal from interval')
|
||||
self.assertEqual(result[1][1], datetime.strptime('2013-02-04 14:00:00', '%Y-%m-%d %H:%M:%S'), 'resource_calendar: wrong leave removal from interval')
|
||||
self.assertEqual(result[1][0], Datetime.from_string('2013-02-04 12:30:00'), 'resource_calendar: wrong leave removal from interval')
|
||||
self.assertEqual(result[1][1], Datetime.from_string('2013-02-04 14:00:00'), 'resource_calendar: wrong leave removal from interval')
|
||||
|
||||
def test_10_calendar_basics(self):
|
||||
""" Testing basic method of resource.calendar """
|
||||
cr, uid = self.cr, self.uid
|
||||
|
||||
# --------------------------------------------------
|
||||
# Test1: get_next_day
|
||||
# --------------------------------------------------
|
||||
|
||||
# Test: next day: next day after day1 is day4
|
||||
date = self.resource_calendar.get_next_day(cr, uid, self.calendar_id, day_date=self.date1.date())
|
||||
date = self.calendar.get_next_day(day_date=self.date1.date())
|
||||
self.assertEqual(date, self.date2.date(), 'resource_calendar: wrong next day computing')
|
||||
|
||||
# Test: next day: next day after day4 is (day1+7)
|
||||
date = self.resource_calendar.get_next_day(cr, uid, self.calendar_id, day_date=self.date2.date())
|
||||
date = self.calendar.get_next_day(day_date=self.date2.date())
|
||||
self.assertEqual(date, self.date1.date() + relativedelta(days=7), 'resource_calendar: wrong next day computing')
|
||||
|
||||
# Test: next day: next day after day4+1 is (day1+7)
|
||||
date = self.resource_calendar.get_next_day(cr, uid, self.calendar_id, day_date=self.date2.date() + relativedelta(days=1))
|
||||
date = self.calendar.get_next_day(day_date=self.date2.date() + relativedelta(days=1))
|
||||
self.assertEqual(date, self.date1.date() + relativedelta(days=7), 'resource_calendar: wrong next day computing')
|
||||
|
||||
# Test: next day: next day after day1-1 is day1
|
||||
date = self.resource_calendar.get_next_day(cr, uid, self.calendar_id, day_date=self.date1.date() + relativedelta(days=-1))
|
||||
date = self.calendar.get_next_day(day_date=self.date1.date() + relativedelta(days=-1))
|
||||
self.assertEqual(date, self.date1.date(), 'resource_calendar: wrong next day computing')
|
||||
|
||||
# --------------------------------------------------
|
||||
@@ -108,174 +108,134 @@ class TestResource(TestResourceCommon):
|
||||
# --------------------------------------------------
|
||||
|
||||
# Test: previous day: previous day before day1 is (day4-7)
|
||||
date = self.resource_calendar.get_previous_day(cr, uid, self.calendar_id, day_date=self.date1.date())
|
||||
date = self.calendar.get_previous_day(day_date=self.date1.date())
|
||||
self.assertEqual(date, self.date2.date() + relativedelta(days=-7), 'resource_calendar: wrong previous day computing')
|
||||
|
||||
# Test: previous day: previous day before day4 is day1
|
||||
date = self.resource_calendar.get_previous_day(cr, uid, self.calendar_id, day_date=self.date2.date())
|
||||
date = self.calendar.get_previous_day(day_date=self.date2.date())
|
||||
self.assertEqual(date, self.date1.date(), 'resource_calendar: wrong previous day computing')
|
||||
|
||||
# Test: previous day: previous day before day4+1 is day4
|
||||
date = self.resource_calendar.get_previous_day(cr, uid, self.calendar_id, day_date=self.date2.date() + relativedelta(days=1))
|
||||
date = self.calendar.get_previous_day(day_date=self.date2.date() + relativedelta(days=1))
|
||||
self.assertEqual(date, self.date2.date(), 'resource_calendar: wrong previous day computing')
|
||||
|
||||
# Test: previous day: previous day before day1-1 is (day4-7)
|
||||
date = self.resource_calendar.get_previous_day(cr, uid, self.calendar_id, day_date=self.date1.date() + relativedelta(days=-1))
|
||||
date = self.calendar.get_previous_day(day_date=self.date1.date() + relativedelta(days=-1))
|
||||
self.assertEqual(date, self.date2.date() + relativedelta(days=-7), 'resource_calendar: wrong previous day computing')
|
||||
|
||||
# --------------------------------------------------
|
||||
# Test3: misc
|
||||
# --------------------------------------------------
|
||||
|
||||
weekdays = self.resource_calendar.get_weekdays(cr, uid, self.calendar_id)
|
||||
weekdays = self.calendar.get_weekdays()
|
||||
self.assertEqual(weekdays, [1, 4], 'resource_calendar: wrong weekdays computing')
|
||||
|
||||
# attendances = self.resource_calendar.get_attendances_for_weekdays(cr, uid, self.calendar_id, [2, 3, 4, 5])
|
||||
# self.assertEqual(set([att.id for att in attendances]), set([self.att2_id, self.att3_id]),
|
||||
# 'resource_calendar: wrong attendances filtering by weekdays computing')
|
||||
|
||||
def test_20_calendar_working_intervals(self):
|
||||
""" Testing working intervals computing method of resource.calendar """
|
||||
cr, uid = self.cr, self.uid
|
||||
context = self.context
|
||||
_format = '%Y-%m-%d %H:%M:%S'
|
||||
|
||||
# Test: day0 without leaves: 1 interval
|
||||
intervals = self.resource_calendar.get_working_intervals_of_day(cr, uid, self.calendar_id, start_dt=self.date1, context=context)
|
||||
intervals = self.calendar.get_working_intervals_of_day(start_dt=self.date1)
|
||||
self.assertEqual(len(intervals), 1, 'resource_calendar: wrong working intervals')
|
||||
self.assertEqual(intervals[0][0], datetime.strptime('2013-02-12 09:08:07', _format), 'resource_calendar: wrong working intervals')
|
||||
self.assertEqual(intervals[0][1], datetime.strptime('2013-02-12 16:00:00', _format), 'resource_calendar: wrong working intervals')
|
||||
self.assertEqual(intervals[0][0], Datetime.from_string('2013-02-12 09:08:07'), 'resource_calendar: wrong working intervals')
|
||||
self.assertEqual(intervals[0][1], Datetime.from_string('2013-02-12 16:00:00'), 'resource_calendar: wrong working intervals')
|
||||
|
||||
# Test: day3 without leaves: 2 interval
|
||||
intervals = self.resource_calendar.get_working_intervals_of_day(cr, uid, self.calendar_id, start_dt=self.date2, context=context)
|
||||
intervals = self.calendar.get_working_intervals_of_day(start_dt=self.date2)
|
||||
self.assertEqual(len(intervals), 2, 'resource_calendar: wrong working intervals')
|
||||
self.assertEqual(intervals[0][0], datetime.strptime('2013-02-15 10:11:12', _format), 'resource_calendar: wrong working intervals')
|
||||
self.assertEqual(intervals[0][1], datetime.strptime('2013-02-15 13:00:00', _format), 'resource_calendar: wrong working intervals')
|
||||
self.assertEqual(intervals[1][0], datetime.strptime('2013-02-15 16:00:00', _format), 'resource_calendar: wrong working intervals')
|
||||
self.assertEqual(intervals[1][1], datetime.strptime('2013-02-15 23:00:00', _format), 'resource_calendar: wrong working intervals')
|
||||
self.assertEqual(intervals[0][0], Datetime.from_string('2013-02-15 10:11:12'), 'resource_calendar: wrong working intervals')
|
||||
self.assertEqual(intervals[0][1], Datetime.from_string('2013-02-15 13:00:00'), 'resource_calendar: wrong working intervals')
|
||||
self.assertEqual(intervals[1][0], Datetime.from_string('2013-02-15 16:00:00'), 'resource_calendar: wrong working intervals')
|
||||
self.assertEqual(intervals[1][1], Datetime.from_string('2013-02-15 23:00:00'), 'resource_calendar: wrong working intervals')
|
||||
|
||||
# Test: day0 with leaves outside range: 1 interval
|
||||
intervals = self.resource_calendar.get_working_intervals_of_day(cr, uid, self.calendar_id, start_dt=self.date1.replace(hour=0), compute_leaves=True, context=context)
|
||||
intervals = self.calendar.get_working_intervals_of_day(start_dt=self.date1.replace(hour=0), compute_leaves=True)
|
||||
self.assertEqual(len(intervals), 1, 'resource_calendar: wrong working intervals')
|
||||
self.assertEqual(intervals[0][0], datetime.strptime('2013-02-12 08:00:00', _format), 'resource_calendar: wrong working intervals')
|
||||
self.assertEqual(intervals[0][1], datetime.strptime('2013-02-12 16:00:00', _format), 'resource_calendar: wrong working intervals')
|
||||
self.assertEqual(intervals[0][0], Datetime.from_string('2013-02-12 08:00:00'), 'resource_calendar: wrong working intervals')
|
||||
self.assertEqual(intervals[0][1], Datetime.from_string('2013-02-12 16:00:00'), 'resource_calendar: wrong working intervals')
|
||||
|
||||
# Test: day0 with leaves: 2 intervals because of leave between 9 ans 12, ending at 15:45:30
|
||||
intervals = self.resource_calendar.get_working_intervals_of_day(cr, uid, self.calendar_id,
|
||||
start_dt=self.date1.replace(hour=8) + relativedelta(days=7),
|
||||
end_dt=self.date1.replace(hour=15, minute=45, second=30) + relativedelta(days=7),
|
||||
compute_leaves=True, context=context)
|
||||
intervals = self.calendar.get_working_intervals_of_day(start_dt=self.date1.replace(hour=8) + relativedelta(days=7),
|
||||
end_dt=self.date1.replace(hour=15, minute=45, second=30) + relativedelta(days=7),
|
||||
compute_leaves=True)
|
||||
self.assertEqual(len(intervals), 2, 'resource_calendar: wrong working intervals')
|
||||
self.assertEqual(intervals[0][0], datetime.strptime('2013-02-19 08:08:07', _format), 'resource_calendar: wrong working intervals')
|
||||
self.assertEqual(intervals[0][1], datetime.strptime('2013-02-19 09:00:00', _format), 'resource_calendar: wrong working intervals')
|
||||
self.assertEqual(intervals[1][0], datetime.strptime('2013-02-19 12:00:00', _format), 'resource_calendar: wrong working intervals')
|
||||
self.assertEqual(intervals[1][1], datetime.strptime('2013-02-19 15:45:30', _format), 'resource_calendar: wrong working intervals')
|
||||
self.assertEqual(intervals[0][0], Datetime.from_string('2013-02-19 08:08:07'), 'resource_calendar: wrong working intervals')
|
||||
self.assertEqual(intervals[0][1], Datetime.from_string('2013-02-19 09:00:00'), 'resource_calendar: wrong working intervals')
|
||||
self.assertEqual(intervals[1][0], Datetime.from_string('2013-02-19 12:00:00'), 'resource_calendar: wrong working intervals')
|
||||
self.assertEqual(intervals[1][1], Datetime.from_string('2013-02-19 15:45:30'), 'resource_calendar: wrong working intervals')
|
||||
|
||||
def test_30_calendar_working_days(self):
|
||||
""" Testing calendar hours computation on a working day """
|
||||
cr, uid = self.cr, self.uid
|
||||
context = self.context
|
||||
_format = '%Y-%m-%d %H:%M:%S'
|
||||
|
||||
# Test: day1, beginning at 10:30 -> work from 10:30 (arrival) until 16:00
|
||||
intervals = self.resource_calendar.get_working_intervals_of_day(cr, uid, self.calendar_id, start_dt=self.date1.replace(hour=10, minute=30, second=0), context=context)
|
||||
intervals = self.calendar.get_working_intervals_of_day(start_dt=self.date1.replace(hour=10, minute=30, second=0))
|
||||
self.assertEqual(len(intervals), 1, 'resource_calendar: wrong working interval / day computing')
|
||||
self.assertEqual(intervals[0][0], datetime.strptime('2013-02-12 10:30:00', _format), 'resource_calendar: wrong working interval / day computing')
|
||||
self.assertEqual(intervals[0][1], datetime.strptime('2013-02-12 16:00:00', _format), 'resource_calendar: wrong working interval / day computing')
|
||||
self.assertEqual(intervals[0][0], Datetime.from_string('2013-02-12 10:30:00'), 'resource_calendar: wrong working interval / day computing')
|
||||
self.assertEqual(intervals[0][1], Datetime.from_string('2013-02-12 16:00:00'), 'resource_calendar: wrong working interval / day computing')
|
||||
# Test: hour computation for same interval, should give 5.5
|
||||
wh = self.resource_calendar.get_working_hours_of_date(cr, uid, self.calendar_id, start_dt=self.date1.replace(hour=10, minute=30, second=0), context=context)
|
||||
wh = self.calendar.get_working_hours_of_date(start_dt=self.date1.replace(hour=10, minute=30, second=0))
|
||||
self.assertEqual(wh, 5.5, 'resource_calendar: wrong working interval / day time computing')
|
||||
|
||||
# Test: day1+7 on leave, without leave computation
|
||||
intervals = self.resource_calendar.get_working_intervals_of_day(
|
||||
cr, uid, self.calendar_id,
|
||||
start_dt=self.date1.replace(hour=7, minute=0, second=0) + relativedelta(days=7), context=context
|
||||
intervals = self.calendar.get_working_intervals_of_day(
|
||||
start_dt=self.date1.replace(hour=7, minute=0, second=0) + relativedelta(days=7)
|
||||
)
|
||||
# Result: day1 (08->16)
|
||||
self.assertEqual(len(intervals), 1, 'resource_calendar: wrong working interval/day computing')
|
||||
self.assertEqual(intervals[0][0], datetime.strptime('2013-02-19 08:00:00', _format), 'resource_calendar: wrong working interval / day computing')
|
||||
self.assertEqual(intervals[0][1], datetime.strptime('2013-02-19 16:00:00', _format), 'resource_calendar: wrong working interval / day computing')
|
||||
self.assertEqual(intervals[0][0], Datetime.from_string('2013-02-19 08:00:00'), 'resource_calendar: wrong working interval / day computing')
|
||||
self.assertEqual(intervals[0][1], Datetime.from_string('2013-02-19 16:00:00'), 'resource_calendar: wrong working interval / day computing')
|
||||
|
||||
# Test: day1+7 on leave, with generic leave computation
|
||||
intervals = self.resource_calendar.get_working_intervals_of_day(
|
||||
cr, uid, self.calendar_id,
|
||||
intervals = self.calendar.get_working_intervals_of_day(
|
||||
start_dt=self.date1.replace(hour=7, minute=0, second=0) + relativedelta(days=7),
|
||||
compute_leaves=True, context=context
|
||||
compute_leaves=True
|
||||
)
|
||||
# Result: day1 (08->09 + 12->16)
|
||||
self.assertEqual(len(intervals), 2, 'resource_calendar: wrong working interval/day computing')
|
||||
self.assertEqual(intervals[0][0], datetime.strptime('2013-02-19 08:00:00', _format), 'resource_calendar: wrong working interval / day computing')
|
||||
self.assertEqual(intervals[0][1], datetime.strptime('2013-02-19 09:00:00', _format), 'resource_calendar: wrong working interval / day computing')
|
||||
self.assertEqual(intervals[1][0], datetime.strptime('2013-02-19 12:00:00', _format), 'resource_calendar: wrong working interval / day computing')
|
||||
self.assertEqual(intervals[1][1], datetime.strptime('2013-02-19 16:00:00', _format), 'resource_calendar: wrong working interval / day computing')
|
||||
self.assertEqual(intervals[0][0], Datetime.from_string('2013-02-19 08:00:00'), 'resource_calendar: wrong working interval / day computing')
|
||||
self.assertEqual(intervals[0][1], Datetime.from_string('2013-02-19 09:00:00'), 'resource_calendar: wrong working interval / day computing')
|
||||
self.assertEqual(intervals[1][0], Datetime.from_string('2013-02-19 12:00:00'), 'resource_calendar: wrong working interval / day computing')
|
||||
self.assertEqual(intervals[1][1], Datetime.from_string('2013-02-19 16:00:00'), 'resource_calendar: wrong working interval / day computing')
|
||||
|
||||
# Test: day1+14 on leave, with generic leave computation
|
||||
intervals = self.resource_calendar.get_working_intervals_of_day(
|
||||
cr, uid, self.calendar_id,
|
||||
intervals = self.calendar.get_working_intervals_of_day(
|
||||
start_dt=self.date1.replace(hour=7, minute=0, second=0) + relativedelta(days=14),
|
||||
compute_leaves=True, context=context
|
||||
compute_leaves=True
|
||||
)
|
||||
# Result: day1 (08->16)
|
||||
self.assertEqual(len(intervals), 1, 'resource_calendar: wrong working interval/day computing')
|
||||
self.assertEqual(intervals[0][0], datetime.strptime('2013-02-26 08:00:00', _format), 'resource_calendar: wrong working interval / day computing')
|
||||
self.assertEqual(intervals[0][1], datetime.strptime('2013-02-26 16:00:00', _format), 'resource_calendar: wrong working interval / day computing')
|
||||
self.assertEqual(intervals[0][0], Datetime.from_string('2013-02-26 08:00:00'), 'resource_calendar: wrong working interval / day computing')
|
||||
self.assertEqual(intervals[0][1], Datetime.from_string('2013-02-26 16:00:00'), 'resource_calendar: wrong working interval / day computing')
|
||||
|
||||
# Test: day1+14 on leave, with resource leave computation
|
||||
intervals = self.resource_calendar.get_working_intervals_of_day(
|
||||
cr, uid, self.calendar_id,
|
||||
intervals = self.calendar.get_working_intervals_of_day(
|
||||
start_dt=self.date1.replace(hour=7, minute=0, second=0) + relativedelta(days=14),
|
||||
compute_leaves=True,
|
||||
resource_id=self.resource1_id, context=context
|
||||
resource_id=self.resource1_id
|
||||
)
|
||||
# Result: nothing, because on leave
|
||||
self.assertEqual(len(intervals), 0, 'resource_calendar: wrong working interval/day computing')
|
||||
|
||||
def test_40_calendar_hours_scheduling(self):
|
||||
""" Testing calendar hours scheduling """
|
||||
cr, uid = self.cr, self.uid
|
||||
context = self.context
|
||||
_format = '%Y-%m-%d %H:%M:%S'
|
||||
|
||||
# --------------------------------------------------
|
||||
# Test0: schedule hours backwards (old interval_min_get)
|
||||
# Done without calendar
|
||||
# --------------------------------------------------
|
||||
|
||||
# Done without calendar
|
||||
# res = self.resource_calendar.interval_min_get(cr, uid, None, self.date1, 40, resource=False)
|
||||
# res: (datetime.datetime(2013, 2, 7, 9, 8, 7), datetime.datetime(2013, 2, 12, 9, 8, 7))
|
||||
|
||||
# --------------------------------------------------
|
||||
# Test1: schedule hours backwards (old interval_min_get)
|
||||
# --------------------------------------------------
|
||||
|
||||
# res = self.resource_calendar.interval_min_get(cr, uid, self.calendar_id, self.date1, 40, resource=False)
|
||||
# (datetime.datetime(2013, 1, 29, 9, 0), datetime.datetime(2013, 1, 29, 16, 0))
|
||||
# (datetime.datetime(2013, 2, 1, 8, 0), datetime.datetime(2013, 2, 1, 13, 0))
|
||||
# (datetime.datetime(2013, 2, 1, 16, 0), datetime.datetime(2013, 2, 1, 23, 0))
|
||||
# (datetime.datetime(2013, 2, 5, 8, 0), datetime.datetime(2013, 2, 5, 16, 0))
|
||||
# (datetime.datetime(2013, 2, 8, 8, 0), datetime.datetime(2013, 2, 8, 13, 0))
|
||||
# (datetime.datetime(2013, 2, 8, 16, 0), datetime.datetime(2013, 2, 8, 23, 0))
|
||||
# (datetime.datetime(2013, 2, 12, 8, 0), datetime.datetime(2013, 2, 12, 9, 0))
|
||||
|
||||
res = self.resource_calendar.schedule_hours(cr, uid, self.calendar_id, -40, day_dt=self.date1.replace(minute=0, second=0), context=context)
|
||||
res = self.calendar.schedule_hours(-40, day_dt=self.date1.replace(minute=0, second=0))
|
||||
# current day, limited at 09:00 because of day_dt specified -> 1 hour
|
||||
self.assertEqual(res[-1][0], datetime.strptime('2013-02-12 08:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[-1][1], datetime.strptime('2013-02-12 09:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[-1][0], Datetime.from_string('2013-02-12 08:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[-1][1], Datetime.from_string('2013-02-12 09:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
# previous days: 5+7 hours / 8 hours / 5+7 hours -> 32 hours
|
||||
self.assertEqual(res[-2][0], datetime.strptime('2013-02-08 16:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[-2][1], datetime.strptime('2013-02-08 23:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[-3][0], datetime.strptime('2013-02-08 08:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[-3][1], datetime.strptime('2013-02-08 13:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[-4][0], datetime.strptime('2013-02-05 08:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[-4][1], datetime.strptime('2013-02-05 16:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[-5][0], datetime.strptime('2013-02-01 16:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[-5][1], datetime.strptime('2013-02-01 23:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[-6][0], datetime.strptime('2013-02-01 08:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[-6][1], datetime.strptime('2013-02-01 13:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[-2][0], Datetime.from_string('2013-02-08 16:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[-2][1], Datetime.from_string('2013-02-08 23:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[-3][0], Datetime.from_string('2013-02-08 08:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[-3][1], Datetime.from_string('2013-02-08 13:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[-4][0], Datetime.from_string('2013-02-05 08:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[-4][1], Datetime.from_string('2013-02-05 16:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[-5][0], Datetime.from_string('2013-02-01 16:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[-5][1], Datetime.from_string('2013-02-01 23:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[-6][0], Datetime.from_string('2013-02-01 08:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[-6][1], Datetime.from_string('2013-02-01 13:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
# 7 hours remaining
|
||||
self.assertEqual(res[-7][0], datetime.strptime('2013-01-29 09:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[-7][1], datetime.strptime('2013-01-29 16:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[-7][0], Datetime.from_string('2013-01-29 09:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[-7][1], Datetime.from_string('2013-01-29 16:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
# Compute scheduled hours
|
||||
td = timedelta()
|
||||
for item in res:
|
||||
@@ -283,74 +243,53 @@ class TestResource(TestResourceCommon):
|
||||
self.assertEqual(seconds(td) / 3600.0, 40.0, 'resource_calendar: wrong hours scheduling')
|
||||
|
||||
# --------------------------------------------------
|
||||
# Test2: schedule hours forward (old interval_get)
|
||||
# Test2: schedule hours forward
|
||||
# --------------------------------------------------
|
||||
|
||||
# res = self.resource_calendar.interval_get(cr, uid, self.calendar_id, self.date1, 40, resource=False, byday=True)
|
||||
# (datetime.datetime(2013, 2, 12, 9, 0), datetime.datetime(2013, 2, 12, 16, 0))
|
||||
# (datetime.datetime(2013, 2, 15, 8, 0), datetime.datetime(2013, 2, 15, 13, 0))
|
||||
# (datetime.datetime(2013, 2, 15, 16, 0), datetime.datetime(2013, 2, 15, 23, 0))
|
||||
# (datetime.datetime(2013, 2, 22, 8, 0), datetime.datetime(2013, 2, 22, 13, 0))
|
||||
# (datetime.datetime(2013, 2, 22, 16, 0), datetime.datetime(2013, 2, 22, 23, 0))
|
||||
# (datetime.datetime(2013, 2, 26, 8, 0), datetime.datetime(2013, 2, 26, 16, 0))
|
||||
# (datetime.datetime(2013, 3, 1, 8, 0), datetime.datetime(2013, 3, 1, 9, 0))
|
||||
|
||||
res = self.resource_calendar.schedule_hours(
|
||||
cr, uid, self.calendar_id, 40,
|
||||
day_dt=self.date1.replace(minute=0, second=0), context=context
|
||||
res = self.calendar.schedule_hours(
|
||||
40, day_dt=self.date1.replace(minute=0, second=0)
|
||||
)
|
||||
self.assertEqual(res[0][0], datetime.strptime('2013-02-12 09:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[0][1], datetime.strptime('2013-02-12 16:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[1][0], datetime.strptime('2013-02-15 08:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[1][1], datetime.strptime('2013-02-15 13:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[2][0], datetime.strptime('2013-02-15 16:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[2][1], datetime.strptime('2013-02-15 23:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[3][0], datetime.strptime('2013-02-19 08:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[3][1], datetime.strptime('2013-02-19 16:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[4][0], datetime.strptime('2013-02-22 08:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[4][1], datetime.strptime('2013-02-22 13:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[5][0], datetime.strptime('2013-02-22 16:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[5][1], datetime.strptime('2013-02-22 23:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[6][0], datetime.strptime('2013-02-26 08:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[6][1], datetime.strptime('2013-02-26 09:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[0][0], Datetime.from_string('2013-02-12 09:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[0][1], Datetime.from_string('2013-02-12 16:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[1][0], Datetime.from_string('2013-02-15 08:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[1][1], Datetime.from_string('2013-02-15 13:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[2][0], Datetime.from_string('2013-02-15 16:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[2][1], Datetime.from_string('2013-02-15 23:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[3][0], Datetime.from_string('2013-02-19 08:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[3][1], Datetime.from_string('2013-02-19 16:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[4][0], Datetime.from_string('2013-02-22 08:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[4][1], Datetime.from_string('2013-02-22 13:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[5][0], Datetime.from_string('2013-02-22 16:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[5][1], Datetime.from_string('2013-02-22 23:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[6][0], Datetime.from_string('2013-02-26 08:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[6][1], Datetime.from_string('2013-02-26 09:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
td = timedelta()
|
||||
for item in res:
|
||||
td += item[1] - item[0]
|
||||
self.assertEqual(seconds(td) / 3600.0, 40.0, 'resource_calendar: wrong hours scheduling')
|
||||
|
||||
# res = self.resource_calendar.interval_get(cr, uid, self.calendar_id, self.date1, 40, resource=self.resource1_id, byday=True)
|
||||
# (datetime.datetime(2013, 2, 12, 9, 0), datetime.datetime(2013, 2, 12, 16, 0))
|
||||
# (datetime.datetime(2013, 2, 15, 8, 0), datetime.datetime(2013, 2, 15, 13, 0))
|
||||
# (datetime.datetime(2013, 2, 15, 16, 0), datetime.datetime(2013, 2, 15, 23, 0))
|
||||
# (datetime.datetime(2013, 3, 1, 8, 0), datetime.datetime(2013, 3, 1, 13, 0))
|
||||
# (datetime.datetime(2013, 3, 1, 16, 0), datetime.datetime(2013, 3, 1, 23, 0))
|
||||
# (datetime.datetime(2013, 3, 5, 8, 0), datetime.datetime(2013, 3, 5, 16, 0))
|
||||
# (datetime.datetime(2013, 3, 8, 8, 0), datetime.datetime(2013, 3, 8, 9, 0))
|
||||
|
||||
res = self.resource_calendar.schedule_hours(
|
||||
cr, uid, self.calendar_id, 40,
|
||||
day_dt=self.date1.replace(minute=0, second=0),
|
||||
compute_leaves=True,
|
||||
resource_id=self.resource1_id, context=context
|
||||
res = self.calendar.schedule_hours(
|
||||
40, day_dt=self.date1.replace(minute=0, second=0),
|
||||
compute_leaves=True, resource_id=self.resource1_id
|
||||
)
|
||||
self.assertEqual(res[0][0], datetime.strptime('2013-02-12 09:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[0][1], datetime.strptime('2013-02-12 16:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[1][0], datetime.strptime('2013-02-15 08:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[1][1], datetime.strptime('2013-02-15 13:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[2][0], datetime.strptime('2013-02-15 16:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[2][1], datetime.strptime('2013-02-15 23:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[3][0], datetime.strptime('2013-02-19 08:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[3][1], datetime.strptime('2013-02-19 09:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[4][0], datetime.strptime('2013-02-19 12:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[4][1], datetime.strptime('2013-02-19 16:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[5][0], datetime.strptime('2013-02-22 08:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[5][1], datetime.strptime('2013-02-22 09:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[6][0], datetime.strptime('2013-02-22 16:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[6][1], datetime.strptime('2013-02-22 23:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[7][0], datetime.strptime('2013-03-01 11:30:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[7][1], datetime.strptime('2013-03-01 13:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[8][0], datetime.strptime('2013-03-01 16:00:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[8][1], datetime.strptime('2013-03-01 22:30:00', _format), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[0][0], Datetime.from_string('2013-02-12 09:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[0][1], Datetime.from_string('2013-02-12 16:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[1][0], Datetime.from_string('2013-02-15 08:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[1][1], Datetime.from_string('2013-02-15 13:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[2][0], Datetime.from_string('2013-02-15 16:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[2][1], Datetime.from_string('2013-02-15 23:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[3][0], Datetime.from_string('2013-02-19 08:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[3][1], Datetime.from_string('2013-02-19 09:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[4][0], Datetime.from_string('2013-02-19 12:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[4][1], Datetime.from_string('2013-02-19 16:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[5][0], Datetime.from_string('2013-02-22 08:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[5][1], Datetime.from_string('2013-02-22 09:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[6][0], Datetime.from_string('2013-02-22 16:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[6][1], Datetime.from_string('2013-02-22 23:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[7][0], Datetime.from_string('2013-03-01 11:30:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[7][1], Datetime.from_string('2013-03-01 13:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[8][0], Datetime.from_string('2013-03-01 16:00:00'), 'resource_calendar: wrong hours scheduling')
|
||||
self.assertEqual(res[8][1], Datetime.from_string('2013-03-01 22:30:00'), 'resource_calendar: wrong hours scheduling')
|
||||
td = timedelta()
|
||||
for item in res:
|
||||
td += item[1] - item[0]
|
||||
@@ -362,38 +301,34 @@ class TestResource(TestResourceCommon):
|
||||
|
||||
# old API: resource without leaves
|
||||
# res: 2 weeks -> 40 hours
|
||||
res = self.resource_calendar._interval_hours_get(
|
||||
cr, uid, self.calendar_id,
|
||||
res = self.calendar._interval_hours_get(
|
||||
self.date1.replace(hour=6, minute=0),
|
||||
self.date2.replace(hour=23, minute=0) + relativedelta(days=7),
|
||||
resource_id=self.resource1_id, exclude_leaves=True, context=context)
|
||||
resource_id=self.resource1_id, exclude_leaves=True)
|
||||
self.assertEqual(res, 40.0, 'resource_calendar: wrong _interval_hours_get compatibility computation')
|
||||
|
||||
# new API: resource without leaves
|
||||
# res: 2 weeks -> 40 hours
|
||||
res = self.resource_calendar.get_working_hours(
|
||||
cr, uid, self.calendar_id,
|
||||
res = self.calendar.get_working_hours(
|
||||
self.date1.replace(hour=6, minute=0),
|
||||
self.date2.replace(hour=23, minute=0) + relativedelta(days=7),
|
||||
compute_leaves=False, resource_id=self.resource1_id, context=context)
|
||||
compute_leaves=False, resource_id=self.resource1_id)
|
||||
self.assertEqual(res, 40.0, 'resource_calendar: wrong get_working_hours computation')
|
||||
|
||||
# old API: resource and leaves
|
||||
# res: 2 weeks -> 40 hours - (3+4) leave hours
|
||||
res = self.resource_calendar._interval_hours_get(
|
||||
cr, uid, self.calendar_id,
|
||||
res = self.calendar._interval_hours_get(
|
||||
self.date1.replace(hour=6, minute=0),
|
||||
self.date2.replace(hour=23, minute=0) + relativedelta(days=7),
|
||||
resource_id=self.resource1_id, exclude_leaves=False, context=context)
|
||||
resource_id=self.resource1_id, exclude_leaves=False)
|
||||
self.assertEqual(res, 33.0, 'resource_calendar: wrong _interval_hours_get compatibility computation')
|
||||
|
||||
# new API: resource and leaves
|
||||
# res: 2 weeks -> 40 hours - (3+4) leave hours
|
||||
res = self.resource_calendar.get_working_hours(
|
||||
cr, uid, self.calendar_id,
|
||||
res = self.calendar.get_working_hours(
|
||||
self.date1.replace(hour=6, minute=0),
|
||||
self.date2.replace(hour=23, minute=0) + relativedelta(days=7),
|
||||
compute_leaves=True, resource_id=self.resource1_id, context=context)
|
||||
compute_leaves=True, resource_id=self.resource1_id)
|
||||
self.assertEqual(res, 33.0, 'resource_calendar: wrong get_working_hours computation')
|
||||
|
||||
# --------------------------------------------------
|
||||
@@ -401,69 +336,105 @@ class TestResource(TestResourceCommon):
|
||||
# --------------------------------------------------
|
||||
|
||||
# Test without calendar and default_interval
|
||||
res = self.resource_calendar.get_working_hours(
|
||||
cr, uid, None,
|
||||
res = self.ResourceCalendar.with_context(self.context).get_working_hours(
|
||||
self.date1.replace(hour=6, minute=0),
|
||||
self.date2.replace(hour=23, minute=0),
|
||||
compute_leaves=True, resource_id=self.resource1_id,
|
||||
default_interval=(8, 16), context=context)
|
||||
default_interval=(8, 16))
|
||||
self.assertEqual(res, 32.0, 'resource_calendar: wrong get_working_hours computation')
|
||||
|
||||
self.att0_0_id = self.resource_attendance.create(
|
||||
cr, uid, {
|
||||
self.att0_0_id = self.ResourceAttendance.with_context(self.context).create(
|
||||
{
|
||||
'name': 'Att0',
|
||||
'dayofweek': '0',
|
||||
'hour_from': 7.5,
|
||||
'hour_to': 12.5,
|
||||
'calendar_id': self.calendar_id,
|
||||
}, context=context
|
||||
'calendar_id': self.calendar.id,
|
||||
}
|
||||
)
|
||||
self.att0_1_id = self.resource_attendance.create(
|
||||
cr, uid, {
|
||||
self.att0_1_id = self.ResourceAttendance.with_context(self.context).create(
|
||||
{
|
||||
'name': 'Att0',
|
||||
'dayofweek': '0',
|
||||
'hour_from': 13,
|
||||
'hour_to': 14,
|
||||
'calendar_id': self.calendar_id,
|
||||
}, context=context
|
||||
'calendar_id': self.calendar.id,
|
||||
}
|
||||
)
|
||||
date1 = datetime.strptime('2013-02-11 07:30:00', '%Y-%m-%d %H:%M:%S')
|
||||
date2 = datetime.strptime('2013-02-11 14:00:00', '%Y-%m-%d %H:%M:%S')
|
||||
res = self.resource_calendar.get_working_hours(
|
||||
cr, uid, self.calendar_id,
|
||||
date1 = Datetime.from_string('2013-02-11 07:30:00')
|
||||
date2 = Datetime.from_string('2013-02-11 14:00:00')
|
||||
res = self.calendar.get_working_hours(
|
||||
date1,
|
||||
date2,
|
||||
compute_leaves=False, resource_id=self.resource1_id, context=context)
|
||||
compute_leaves=False, resource_id=self.resource1_id)
|
||||
# 7h30 -> 12h30 = 5 / 13h -> 14h = 1 / -> 6h
|
||||
self.assertEqual(res, 6, 'resource_calendar: wrong get_working_hours computation')
|
||||
|
||||
|
||||
def test_50_calendar_schedule_days(self):
|
||||
""" Testing calendar days scheduling """
|
||||
cr, uid = self.cr, self.uid
|
||||
_format = '%Y-%m-%d %H:%M:%S'
|
||||
|
||||
# --------------------------------------------------
|
||||
# Test1: with calendar
|
||||
# --------------------------------------------------
|
||||
|
||||
res = self.resource_calendar.schedule_days_get_date(cr, uid, self.calendar_id, 5, day_date=self.date1, context={'tz': 'UTC'})
|
||||
self.assertEqual(res.date(), datetime.strptime('2013-02-26 00:0:00', _format).date(), 'resource_calendar: wrong days scheduling')
|
||||
res = self.resource_calendar.schedule_days_get_date(cr, uid, self.calendar_id, -2, day_date=self.date1, context={'tz': 'UTC'})
|
||||
self.assertEqual(res.date(), datetime.strptime('2013-02-08 00:00:00', _format).date(), 'resource_calendar: wrong days scheduling')
|
||||
res = self.calendar.schedule_days_get_date(5, day_date=self.date1)
|
||||
self.assertEqual(res.date(), Datetime.from_string('2013-02-26 00:00:00').date(), 'resource_calendar: wrong days scheduling')
|
||||
res = self.calendar.schedule_days_get_date(-2, day_date=self.date1)
|
||||
self.assertEqual(res.date(), Datetime.from_string('2013-02-08 00:00:00').date(), 'resource_calendar: wrong days scheduling')
|
||||
|
||||
res = self.resource_calendar.schedule_days_get_date(
|
||||
cr, uid, self.calendar_id, 5, day_date=self.date1,
|
||||
compute_leaves=True, resource_id=self.resource1_id, context={'tz': 'UTC'})
|
||||
self.assertEqual(res.date(), datetime.strptime('2013-03-01 00:0:00', _format).date(), 'resource_calendar: wrong days scheduling')
|
||||
res = self.calendar.schedule_days_get_date(
|
||||
5, day_date=self.date1,
|
||||
compute_leaves=True, resource_id=self.resource1_id)
|
||||
self.assertEqual(res.date(), Datetime.from_string('2013-03-01 00:00:00').date(), 'resource_calendar: wrong days scheduling')
|
||||
|
||||
# --------------------------------------------------
|
||||
# Test2: misc
|
||||
# --------------------------------------------------
|
||||
|
||||
# Without calendar, should only count days -> 12 -> 16, 5 days with default intervals
|
||||
res = self.resource_calendar.schedule_days_get_date(cr, uid, None, 5, day_date=self.date1, default_interval=(8, 16), context={'tz': 'UTC'})
|
||||
self.assertEqual(res, datetime.strptime('2013-02-16 16:00:00', _format), 'resource_calendar: wrong days scheduling')
|
||||
res = self.ResourceCalendar.with_context(self.context).schedule_days_get_date(5, day_date=self.date1, default_interval=(8, 16))
|
||||
self.assertEqual(res, Datetime.from_string('2013-02-16 16:00:00'), 'resource_calendar: wrong days scheduling')
|
||||
|
||||
def test_60_project(self):
|
||||
# I assign working calendar '45 Hours/Week' to human resource.
|
||||
resources = self.env.ref('resource.resource_analyst') + self.env.ref('resource.resource_designer') + self.env.ref('resource.resource_developer')
|
||||
resources.write({'calendar_id': self.ref('resource.timesheet_group1'), 'resource_type': 'user'})
|
||||
|
||||
# I had Project of Odoo Integration of 50 Hours with three human resource assigned on it. I have started project from this week start.
|
||||
# I check per day work hour availability of the Resource based on Working Calendar Assigned to each resource, for first day of the week.
|
||||
now = datetime.now()
|
||||
dt = now - timedelta(days=now.weekday())
|
||||
for resource in resources:
|
||||
result = resource.calendar_id.working_hours_on_day(dt)
|
||||
self.assertEqual(float_compare(result, 8.0, precision_digits=2), 0, 'Wrong calculation of day work hour availability of the Resource (found %d).' % result)
|
||||
|
||||
# Now, resource "Developer" drafted leave on Thursday in this week.
|
||||
now = datetime.now()
|
||||
dt = (now - timedelta(days=now.weekday())) + timedelta(days=3)
|
||||
vals = {
|
||||
'resource_id': self.ref('resource.resource_developer'),
|
||||
'calendar_id': self.ref('resource.timesheet_group1'),
|
||||
'date_from': dt.strftime("%Y-%m-%d 09:00:00"),
|
||||
'date_to': dt.strftime("%Y-%m-%d 18:00:00")
|
||||
}
|
||||
self.env.ref('resource.resource_dummyleave').write(vals)
|
||||
|
||||
# I check Actual working hours on resource 'Developer' from this week
|
||||
now = datetime.now()
|
||||
dt_from = now - relativedelta(days=now.weekday(), hour=8, minute=30)
|
||||
dt_to = dt_from + relativedelta(days=6, hour=17)
|
||||
hours = self.env.ref('resource.timesheet_group1').interval_hours_get(dt_from, dt_to, resource=self.ref('resource.resource_developer'))
|
||||
self.assertGreater(hours, 27, 'Invalid Total Week working hour calculated, got %r, expected > 27' % hours)
|
||||
|
||||
# Project Analysis work is of 20 hours which will start from Week start so i will calculate working schedule for resource Analyst for the same.
|
||||
now = datetime.now()
|
||||
work_intreval = self.env.ref('resource.timesheet_group1').interval_min_get(now, 20.0, resource=self.ref('resource.resource_designer'))
|
||||
self.assertGreaterEqual(len(work_intreval), 5, 'Wrong Schedule Calculated')
|
||||
|
||||
def test_70_duplicate_resource(self):
|
||||
resource_id = self.env.ref('resource.resource_analyst').copy()
|
||||
self.assertTrue(resource_id, 'Unable to Duplicate Resource')
|
||||
|
||||
|
||||
WAR_START = date(1932, 11, 2)
|
||||
WAR_END = date(1932, 12, 10)
|
||||
@@ -569,10 +540,8 @@ class TestWorkDays(TransactionCase):
|
||||
|
||||
weekdays = [d for d in self._days if d.weekday() not in (5, 6)]
|
||||
self.assertEqual(weekdays, list(r1._iter_work_days(WAR_START, WAR_END)))
|
||||
self.assertEqual(
|
||||
[d for d in weekdays
|
||||
if d < date(1932, 11, 9) or d > date(1932, 11, 12)
|
||||
],
|
||||
self.assertEqual([
|
||||
d for d in weekdays if d < date(1932, 11, 9) or d > date(1932, 11, 12)],
|
||||
list(r2._iter_work_days(WAR_START, WAR_END))
|
||||
)
|
||||
|
||||
@@ -593,12 +562,11 @@ class TestWorkDays(TransactionCase):
|
||||
'resource_id': r.id
|
||||
})
|
||||
|
||||
self.assertEqual(
|
||||
[d for d in self._days
|
||||
if d.weekday() not in (5, 6)
|
||||
if d < date(1932, 11, 9) or d > date(1932, 11, 12)
|
||||
if d < date(1932, 12, 2)
|
||||
],
|
||||
self.assertEqual([
|
||||
d for d in self._days
|
||||
if d.weekday() not in (5, 6)
|
||||
if d < date(1932, 11, 9) or d > date(1932, 11, 12)
|
||||
if d < date(1932, 12, 2)],
|
||||
list(r._iter_work_days(WAR_START, WAR_END))
|
||||
)
|
||||
|
||||
@@ -608,11 +576,11 @@ class TestWorkDays(TransactionCase):
|
||||
self.assertTrue(r._is_work_day(date(1932, 11, 14)))
|
||||
self.assertTrue(r._is_work_day(date(1932, 12, 1)))
|
||||
|
||||
self.assertFalse(r._is_work_day(date(1932, 11, 11))) # global leave
|
||||
self.assertFalse(r._is_work_day(date(1932, 11, 13))) # sun
|
||||
self.assertFalse(r._is_work_day(date(1932, 11, 19))) # sat
|
||||
self.assertFalse(r._is_work_day(date(1932, 11, 20))) # sun
|
||||
self.assertFalse(r._is_work_day(date(1932, 12, 6))) # personal leave
|
||||
self.assertFalse(r._is_work_day(date(1932, 11, 11))) # global leave
|
||||
self.assertFalse(r._is_work_day(date(1932, 11, 13))) # sun
|
||||
self.assertFalse(r._is_work_day(date(1932, 11, 19))) # sat
|
||||
self.assertFalse(r._is_work_day(date(1932, 11, 20))) # sun
|
||||
self.assertFalse(r._is_work_day(date(1932, 12, 6))) # personal leave
|
||||
|
||||
def seconds(td):
|
||||
assert isinstance(td, timedelta)
|
||||
|
||||
Reference in New Issue
Block a user