def test_can_return_empty_list_if_no_capacity_is_there(self): team, member1, member2 = self.team_with_two_members() self.set_hours_for_day_on_team_member(0, today(), member1) self.set_hours_for_day_on_team_member(0, today(), member2) capacities = team.capacity(member1.timezone()).hourly_capacities_for_day(today()) self.assert_length(0, capacities)
def testCalendarForTeamMemberInterval(self): """Tests the calendar returned for a given interval of time""" self.tmc.set_hours_for_day(5, today()) cal = self.tmc.get_hours_for_interval(today() - (3 * one_day), today() + (3 * one_day)) self.assert_equals(cal[today()], 5) self.assert_equals(len(cal), 7)
def test_can_return_correct_capacities_per_hour(self): capacity = 6 self.tmc.set_hours_for_day(capacity, today()) capacities = self.tmc.hourly_capacities_for_day(today()) work_hours = self.tm.number_of_working_hours_on_workday() capacity_per_hour = capacity / float(work_hours) for capacity in capacities: self.assert_almost_equals(capacity_per_hour, capacity.capacity, max_delta=0.01)
def test_gets_read_only_backlog_for_ended_sprint(self): # ensure it ends before the weekend so the test doesn't fail on mondays... sprint_start = date_to_datetime(today() - timedelta(days=4)) sprint_end = sprint_start + timedelta(days=1) sprint = self.teh.create_sprint(name='fnord', start=sprint_start, end=sprint_end) self.assert_smaller_than(sprint.end, date_to_datetime(today())) backlog = self.teh.create_backlog(scope=sprint.name, b_type=BacklogType.SPRINT) backlog_access = self.access_rights_for_backlog(backlog) self.assert_true(backlog_access['is_read_only']) self.assert_equals('Cannot modify sprints that have ended.', backlog_access['reason'])
def test_capacity_can_take_timezone_parameter(self): team, member = self.team_with_one_member() self._set_default_capacity_for_member(0, member) set_user_attribute_in_session(self.env, 'tz', 'GMT', member.name) self.set_hours_for_day_on_team_member(9, today(member.timezone()), member) viewer_timezone = get_timezone('GMT -12:00') capacitator = team.capacity(viewer_timezone) # Need to take the member timezone for start and end, to make sure that we really cut off all # workhours he has on the previous day - even though they would be on the current day when # viewed from the viewers timezone. hourly_capacities = capacitator.hourly_capacities_in_interval(today(tz=member.timezone()), tomorrow(tz=member.timezone())) self.assert_length(7, hourly_capacities)
def test_can_return_hourly_capacity_on_specific_day(self): team, member1, member2 = self.team_with_two_members() capacities = team.capacity(member1.timezone()).hourly_capacities_for_day(today()) self.assert_length(10, capacities) for capacity in capacities[:-1]: self.assert_equals(2, capacity.capacity)
def get_remaining_time(self, day=None): """Returns the remaining time on a specific day, passed as a date or ordinal value. If none, returns remaining time for today""" if day is None: # if is today, just return the current remaining time return float(self.task[Key.REMAINING_TIME] or 0) timestamp = self._get_timestamp(day) available_timestamps = sorted(self.history) remaining_time = None if len(available_timestamps) > 0: if timestamp < available_timestamps[0]: return 0.0 elif timestamp >= available_timestamps[-1]: return self.history[available_timestamps[-1]] else: last_timestamp = available_timestamps[0] for a_timestamp in available_timestamps: if a_timestamp > timestamp: # the last one was the good one remaining_time = self.history[last_timestamp] break last_timestamp = a_timestamp else: # In case timestamp was built from an ordinal, we must use 0:00 to # check instead of the current time if timestamp >= to_timestamp(midnight(today(), tz=localtz)): remaining_time = float(self.task[Key.REMAINING_TIME] or 0) else: remaining_time = 0.0 return remaining_time
def test_can_return_backlog_info(self): sprint_start = date_to_datetime(today() - timedelta(days=4)) sprint_end = sprint_start + timedelta(days=1) sprint = self.teh.create_sprint(name='fnord', start=sprint_start, end=sprint_end) backlog = self.teh.create_backlog(scope=sprint.name, b_type=BacklogType.SPRINT) info = self.request_backlog(backlog).backlog_info self.assert_not_none(info.content['configured_columns'])
def test_can_combine_different_timezones(self): team, member1, member2 = self.team_with_two_members() set_user_attribute_in_session(self.env, 'tz', 'GMT', member1.name) set_user_attribute_in_session(self.env, 'tz', 'GMT +1:00', member2.name) capacities = team.capacity(member1.timezone()).hourly_capacities_for_day(today()) self.assert_length(11, capacities) self.assert_equals(1, capacities[0].capacity) self.assert_equals(1, capacities[-2].capacity)
def test_not_read_only_if_sprint_not_started(self): self.teh.grant_permission(Usernames.team_member, Action.BACKLOG_EDIT) sprint = self.teh.create_sprint(name='fnord', start=date_to_datetime(today() + timedelta(3))) backlog = self.teh.create_backlog(scope=sprint.name, b_type=BacklogType.SPRINT) backlog_access = self.access_rights_for_backlog(backlog) self.assert_false(backlog_access['is_read_only'], backlog_access['reason'])
def test_includes_times_from_previous_day_that_get_shifted_to_today_through_the_timezone_difference(self): team, member1, member2 = self.team_with_two_members() set_user_attribute_in_session(self.env, 'tz', 'GMT', member1.name) set_user_attribute_in_session(self.env, 'tz', 'GMT -7:00', member2.name) day = today(tz=member1.timezone()) yesterday = day - timedelta(days=1) self.set_hours_for_day_on_team_member(9, yesterday, member2) # member2s last hour of yesterday should happen on today for member1 capacities = team.capacity(member1.timezone()).hourly_capacities_for_day(day) member1_midnight = datetime.combine(day, time(0, tzinfo=member1.timezone())) self.assert_equals(member1_midnight, capacities[0].when) self.assert_equals(1, capacities[0].capacity)
def test_includes_times_from_next_day_that_get_shifted_to_today_through_the_timezone_difference(self): team, member1, member2 = self.team_with_two_members() set_user_attribute_in_session(self.env, 'tz', 'GMT', member1.name) set_user_attribute_in_session(self.env, 'tz', 'GMT +10:00', member2.name) day = today(tz=member1.timezone()) tomorrow = day + timedelta(days=1) self.set_hours_for_day_on_team_member(9, tomorrow, member2) # member2s first hour of tomorrow should happen on today for member1 capacities = team.capacity(member1.timezone()).hourly_capacities_for_day(day) member1_last_hour = datetime.combine(day, time(23, tzinfo=member1.timezone())) self.assert_equals(member1_last_hour, capacities[-2].when) self.assert_equals(1, capacities[-2].capacity)
def setUp(self): self.super() self.tester.login_as(Usernames.admin) # I had problems on mondays that the sprint start would sometimes be shifted # to the next day - definitely a bug, but not one I will solve now two_weeks_ago = today() - timedelta(14) team_name = self.tester.create_team_with_two_members() milestone_name = self.tester.create_milestone('MilestoneFor' + self.sprint_name()) self.tester.create_sprint_for_milestone(milestone_name, self.sprint_name(), team=team_name, start=two_weeks_ago, duration=30) story_id, task_ids = self.tester.create_userstory_with_tasks(self.sprint_name()) second_story_id, more_task_ids = self.tester.create_userstory_with_tasks(self.sprint_name()) self.original_order = [story_id] + task_ids + [second_story_id] + more_task_ids
def test_can_cut_off_times_that_would_be_on_next_day(self): team, member1, member2 = self.team_with_two_members() set_user_attribute_in_session(self.env, 'tz', 'GMT', member1.name) set_user_attribute_in_session(self.env, 'tz', 'GMT -8:00', member2.name) viewer_timezone = member1.timezone() self.set_hours_for_day_on_team_member(0, yesterday(viewer_timezone), member2) # 15:00 at his place is 23:00 here, so two values should be lost day = today(tz=member1.timezone()) capacities = team.capacity(viewer_timezone).hourly_capacities_for_day(day) self.assert_length(16, capacities) self.assert_equals(1, capacities[0].capacity) self.assert_equals(1, capacities[-2].capacity) last_hour_of_member1 = datetime.combine(day, time(23, tzinfo=member1.timezone())) self.assert_equals(last_hour_of_member1, capacities[-2].when)
def test_cuts_off_times_that_would_be_on_previous_day_for_the_viewer(self): team, member1 = self.team_with_one_member() set_user_attribute_in_session(self.env, 'tz', 'GMT +11:00', member1.name) viewer_timezone = utc # don't want to get values from tomorrow self.set_hours_for_day_on_team_member(0, tomorrow(viewer_timezone), member1) # 11:00 at his place is 0:00 here, so two values should be lost capacities = team.capacity(viewer_timezone).hourly_capacities_for_day(today()) self.assert_length(8, capacities) self.assert_equals(1, capacities[0].capacity) self.assert_equals(1, capacities[-2].capacity) start_of_day_for_member1 = midnight(now(tz=viewer_timezone)) self.assert_equals(start_of_day_for_member1, capacities[0].when)
def setUp(self): self.super() self.tester.login_as(Usernames.admin) # I had problems on mondays that the sprint start would sometimes be shifted # to the next day - definitely a bug, but not one I will solve now two_weeks_ago = today() - timedelta(14) team_name = self.tester.create_team_with_two_members() milestone_name = self.tester.create_milestone('MilestoneFor' + self.sprint_name()) self.tester.create_sprint_for_milestone(milestone_name, self.sprint_name(), team=team_name, start=two_weeks_ago, duration=30) story_id, task_ids = self.tester.create_userstory_with_tasks( self.sprint_name()) second_story_id, more_task_ids = self.tester.create_userstory_with_tasks( self.sprint_name()) self.original_order = [story_id] + task_ids + [second_story_id ] + more_task_ids
def test_normalize_date_can_work_with_dates(self): self.assert_isinstance(today(), date) normalize_date(today(), shift_to_next_work_day=True) normalize_date(today(), shift_to_next_work_day=False)
def test_returns_no_capacity_if_capacity_is_zero(self): self.tmc.set_hours_for_day(0, today()) # just something capacities = self.tmc.hourly_capacities_for_day(today()) self.assert_length(0, capacities)
def test_capacities_have_correct_timezone(self): self.tmc.set_hours_for_day(23, today()) # just something capacities = self.tmc.hourly_capacities_for_day(today()) start_time = capacities[0].when self.assert_equals(self.tm.timezone(), start_time.tzinfo)
def test_hours_will_increase_monotoneously_in_capacities(self): self.tmc.set_hours_for_day(23, today()) # just something capacities = self.tmc.hourly_capacities_for_day(today()) start_time = capacities[0].when for index, capacity in enumerate(capacities): self.assert_equals(start_time.hour + index, capacity.when.hour)
def test_can_return_list_of_capacities(self): self.tmc.set_hours_for_day(23, today()) # just to ensure there is some capacities = self.tmc.hourly_capacities_for_day(today()) self.assert_length(self.tm.number_of_working_hours_on_workday(), capacities)
def test_last_entry_of_hourly_capacity_is_zero(self): team, member1, member2 = self.team_with_two_members() capacities = team.capacity(member1.timezone()).hourly_capacities_for_day(today()) self.assert_equals(0, capacities[-1].capacity)