def request_backlog(self, a_backlog): returned_values = ValueObject( self.view.do_get( self.req(name=a_backlog.name, scope=a_backlog.scope))) returned_values.backlog_info = ValueObject( json.loads(returned_values.backlog_info)) return returned_values
def _create_new_developer(self, name, rt_series): developer = ValueObject(dict(name=name, load=[])) for day, foo in rt_series: day_load = ValueObject( dict(day=day, remaining_time=0, is_working_day=None, is_overloaded=None)) developer.load.append(day_load) return developer
def _assert_add_time_fails(self, req, **parameters): error = self.assert_raises((RequestDone, PermissionError), self._add_time, req, **parameters) if isinstance(error, RequestDone): response = ValueObject(req.response.body_as_json()) self.assert_equals(1, len(response.errors)) current_data = ValueObject(response.current_data) if 'content_type' in current_data: self.assert_equals('contingent', current_data.content_type) contingent = ValueObject(current_data.content) self.assert_equals(0, contingent.actual) return error
def test_returns_old_contingent_if_no_permission_to_add(self): self.teh.revoke_permission('foo', Action.CONTINGENT_ADD_TIME) self._assert_add_time_fails(self.req, delta=12) json = ValueObject(self.req.response.body_as_json()) self.assert_equals(len(json.errors), 1) self.assert_true("Not enough permissions" in json.errors[0]) self.assert_equals(json.current_data['content_type'], 'contingent')
def mock_respond(req, data, code=200): self.data = ValueObject(data) self.code = code assert 'errors' in data self.errors = self.data.errors assert 'current_data' in data self.current_data = self.data.current_data
def _execute(self, cont_controller, date_converter=None, as_key=None): contingents = cont_controller.c_manager.select( criteria={'sprint': self.sprint.name}) contingent_amount = sum([i.amount for i in contingents]) contingent_actual = sum([i.actual for i in contingents]) return ValueObject(amount=contingent_amount, actual=contingent_actual)
def _sort_chronologically_and_convert_to_objects( self, remaining_time_by_day): remaining_times = [] for when in sorted(remaining_time_by_day.keys()): remaining_times.append( ValueObject(when=when, remaining_time=remaining_time_by_day[when])) return remaining_times
def as_dict(self): data = dict() for name in ('name', 'description', 'ts_mon', 'ts_tue', 'ts_wed', 'ts_thu', 'ts_fri', 'ts_sat', 'ts_sun', 'full_name', 'email', 'capacity'): data[name] = getattr(self, name) # Don't serialize the calendar - it contains an inifite amount of data. return ValueObject(data)
def mock_request(self, username='******', path_info='/', request_body='', **kwargs): response = ValueObject(headers=dict(), body='', code=None) as_json = lambda self: json.loads(self.body) response.body_as_json = new.instancemethod(as_json, response, response.__class__) perm = PermissionCache(self.env, username) attributes = dict( args=dict(), tz=localtz, perm=perm, method='GET', path_info=path_info, environ={}, session={}, form_token=None, ) attributes.update(kwargs) def read(): return request_body def write(string): response['body'] += string def redirect(url, permanent=False): raise RequestDone def get_header(header_name): header_name = header_name.lower() if header_name == 'content-length': return str(len(request_body)) return None req = Mock(authname=username, base_path=None, href=Href(path_info), chrome=dict(warnings=[], notices=[], scripts=[]), incookie=Cookie(), outcookie=Cookie(), response=response, end_headers=lambda: None, get_header=get_header, read=read, redirect=redirect, send_response=lambda code: response.update({'code': code}), send_header=lambda name, value: response['headers'].update( {name: value}), write=write, **attributes) # our jquery injects wines if it does not find trac's jquery req.chrome['scripts'].append(dict(href='/foo/jquery.js')) return req
def _execute(self, sp_controller, date_converter, as_key): assert self.sprint.start != None assert self.sprint.end != None assert self.sprint.start <= self.sprint.end developers = self.get_load_series_for_interval( sp_controller.env, self.sprint.start, self.sprint.end, sp_controller) load_totals = self._calculate_total_load_per_day(developers) return ValueObject(developers=developers, load_totals=load_totals)
def test_handle_nonexisting_sprints_gracefully(self): self._assert_add_time_fails(self.req, delta=12, sprint_name='doesnotexist') json = ValueObject(self.req.response.body_as_json()) self.assert_equals(len(json.errors), 1) self.assert_true("No sprint with name" in json.errors[0]) self.assert_equals(json.current_data, dict()) # no sprint, no contingent...
def _add_capacity_info_for_single_developer(self, dev, member, start, end): if dev is None: dev = ValueObject(dict(name=member.name, load=None)) dev.full_name = member.full_name dev.email = member.email hours_by_day = member.calendar.get_hours_for_interval(start, end) self._calculate_capacity_for_developer(dev, hours_by_day) return dev
def test_cannot_drag_task_if_not_a_team_member(self): req = self._request_for_ticket_change(username=Usernames.product_owner, simple_status='in_progress') self.teh.move_changetime_to_the_past([self.task]) response = self.assert_method_returns_error( TicketUpdateView(self.env).do_post, req, req.args) self.assert_contains("doesn't belong to the team", response.errors[0]) returned_ticket = ValueObject(response.current_data) self.assert_equals(Status.NEW, returned_ticket.status) self.assertEqual('', returned_ticket.owner)
def test_new_team_members_get_teammember_permissions(self): req = Mock(authname='admin', perm=MockPerm()) new_member_name = 'fnord' admin_panel = TeamAdminPanel(self.env) team_member = ValueObject(dict(name=new_member_name)) admin_panel.create_user_and_grant_permissions(req, team_member) permission_system = PermissionSystem(self.env) permissions = permission_system.get_user_permissions(new_member_name) self.assert_true(Role.TEAM_MEMBER in permissions) self.assert_true(permissions[Role.TEAM_MEMBER])
def assert_backlog_shows_story_with_all_tasks(self): expected_backlog = [ self.ticket( self.requirement_id, self.ticket(self.story_id, self.ticket(self.task1_id), self.ticket(self.task2_id))), ValueObject(id=-1, children=[ self.ticket(self.unchanged_task_id), ]) ] self.page.assert_shows_only(expected_backlog)
def assert_json_error(self, call_server, *args, **kwargs): """If you give code as an keyword argument, it is ensured that the server responded with that HTTP code.""" code = kwargs.pop('code', None) # REFACT: use assert_raises try: call_server(*args, **kwargs) self.fail() except GenericHTTPException, e: if code is not None: self.assertEqual(code, e.code) json_data = ValueObject(json.loads(e.detail)) return json_data
def _add_contingent(self, req, expected_amount=None, **client_json): response = ValueObject( AddContingentJSONView(self.env).do_put(req, client_json)) self.assert_equals('contingent', response.content_type) server_json = response.content # we pass the client_json as a string because % values are allowed server_json.amount = str(server_json.amount) client_json['actual'] = client_json.has_key( 'actual') and client_json.actual or 0 if expected_amount is not None: client_json['amount'] = expected_amount self.assert_equals(client_json, server_json)
def _ideal_burndown(self, commitment, commitment_when=None, capacities=None): commitment_when = commitment_when or now() - timedelta(days=3) if capacities is None: capacities = [(now() - timedelta(days=3), 6.0), (now() - timedelta(days=2), 4.0), (now() - timedelta(days=1), 2.0), (now(), 0)] first_burndown = ValueObject(when=commitment_when, remaining_time=commitment) ideal_burndown = calculate_ideal_burndown(capacities, first_burndown, self.sprint) return [remaining for (when, remaining) in ideal_burndown]
def setUp(self): self.super() self.tester.login_as(Usernames.admin) self.tester.create_sprint_with_team(self.sprint_name(), self.team_name()) self.tester.add_member_to_team(self.team_name(), Usernames.scrum_master) # REFACT: rename availableTime to reservedTime self.contingent = ValueObject(name='contingent', availableTime='23', spentTime='0', remainingTime='23') self.tester.create_new_contingent(self.contingent.name, self.contingent.availableTime, self.team_name(), self.sprint_name())
def runTest(self): # User "TeamMember" is not part of the team. This is why the test fails self.json_tester.login_as(Usernames.team_member) self.ensure_min_one_second_passed() exception = self.assert_raises(GenericHTTPException, \ lambda: self.json_tester.edit_ticket(self.task_id, simple_status='in_progress')) self.assert_contains("doesn't belong to the team", exception_to_unicode(exception)) response_json = json.loads(exception.detail) self.assertEqual(1, len(response_json['errors'])) ticket = ValueObject(response_json['current_data']) self.assertEqual(Status.NEW, ticket.status) self.assertEqual('', ticket.owner) task_owner = self.tester.get_owner_of_ticket(self.task_id) self.assertEqual('', task_owner)
def assert_backlog_shows_story_with_first_task_and_new_story(self): expected_backlog = [ self.ticket( self.requirement_id, self.ticket( self.story_id, self.ticket(self.task1_id), )), self.ticket(self.new_story_id), ValueObject(id=-1, children=[ self.ticket(self.unchanged_task_id), ]), ] self.page.assert_shows_only(expected_backlog)
def setUp(self): self.super() self.tester.delete_all_tickets() self.tester.login_as(Usernames.admin) team_name = self.tester.create_team_with_two_members() self.tester.add_member_to_team(team_name, Usernames.team_member) self.tester.add_member_to_team(team_name, Usernames.second_team_member) self.tester.create_sprint_with_team(self.sprint_name(), team_name) self.task1 = self.create_task('Task without owner', '') self.task2 = self.create_task('Task for team_member', Usernames.team_member) self.task3 = self.create_task('Task for second_team_member', Usernames.second_team_member) self.backlog = [ ValueObject(id=-1, children=[self.task1, self.task2, self.task3]) ]
def _add_time(self, req, contingent_name=None, sprint_name=None, delta=None): contingent_name = contingent_name or self.support sprint_name = sprint_name or self.sprint.name args = dict(sprint=sprint_name, contingent=contingent_name, delta=delta) response = ValueObject( AddTimeToContingentJSONView(self.env).do_post(req, args)) self.assert_equals('contingent', response.content_type) contingent = response.content self.assert_equals(contingent_name, contingent['name']) self.assert_equals(sprint_name, contingent['sprint']) return response
def _populate_with_sprint_and_viewer_timezone(self, sprint_name, viewer_timezone): sprint = self._load_sprint(sprint_name, native=True) if sprint is None: return days_to_remove = self._days_to_remove_from_burndown(sprint, viewer_timezone) container = ValueObject( remaining_times = self._get_remaining_time_series(sprint_name), capacity_data = self._get_capacity(sprint, viewer_timezone, self._is_filtered_backlog(), self._is_point_burndown()), ticks = self._calculate_ticks(sprint, viewer_timezone, days_to_remove), weekend_data = self._get_weekend_starts(sprint.start, sprint.end, viewer_timezone), today_data = self._get_today_data(sprint.start, sprint.end, viewer_timezone), ) self._compact_values_by_removing_days(container, days_to_remove) days_without_capacity_to_hide = ValuesPerTimeCompactor.final_shift(days_to_remove) container.trend_data = self._trend_line(container.remaining_times, sprint.end - days_without_capacity_to_hide) # REFACT: put container directly into data and then unsmart the values in the utc shifting method utc_remaining_times = self._smart_to_tuple_series(container.remaining_times) utc_capacity_data = self._smart_to_tuple_series(container.capacity_data) # need that in non utc form too to compact first_remaining_time = self._first_remaining_time(container.remaining_times) utc_ideal_data = self._calculate_ideal_burndown(utc_capacity_data, first_remaining_time, sprint) utc_trend_data = self._smart_to_tuple_series(container.trend_data) utc_ticks = self._smart_to_tuple_series(container.ticks) utc_weekend_data = self._smart_to_tuple_series(container.weekend_data) utc_today_data = self._smart_to_tuple_series(container.today_data) self.data.update(dict( utc_remaining_times=utc_remaining_times, utc_ideal_data=utc_ideal_data, utc_capacity_data=utc_capacity_data, utc_trend_data=utc_trend_data, utc_ticks=utc_ticks, utc_weekend_data=utc_weekend_data, utc_today_data=utc_today_data, )) self.burndown_data.update(dict( today_color=self._today_color(sprint, container.remaining_times, utc_ideal_data), ))
def _execute(self, sp_controller, date_converter, as_key): env = sp_controller.env cmd = SprintController.GetTotalRemainingTimeCommand cmd_total_rt = cmd(env, sprint=self.sprint, tickets=self.tickets) total_remaining_time = sp_controller.process_command(cmd_total_rt) load_per_developer = {} if total_remaining_time > 0: today = now(tz=utc) developers = self.get_load_series_for_interval( env, today, today, sp_controller) for dev in developers: if dev.load is not None: remaining = dev.load[0].remaining_time percentage = int(round(float(remaining) / \ float(total_remaining_time) * \ 100)) load_per_developer[dev.name] = percentage return ValueObject(load_per_developer)
def test_return_error_if_contingent_was_exceeded(self): self._assert_add_time_fails(self.req, delta=123) json = ValueObject(self.req.response.body_as_json()) self.assert_true( "CommandError: Amount for contingent" in json.errors[0])
def _db_defaults(self): return ValueObject(scheme='sqlite', host='localhost', user=None, password=None)
def totals(self): data = {} for field_name in self.shown_field_for_totals_row(): data[field_name] = self.value_for_total_field(field_name) return ValueObject(data)
def _change_ticket(self, username, **kwargs): self.teh.move_changetime_to_the_past([self.task]) req = self._request_for_ticket_change(username, **kwargs) json = TicketUpdateView(self.env).do_post(req, req.args) return ValueObject(json)
def _wrap_in_valueobjects(self, json_data): if isinstance(json_data, dict): return ValueObject(json_data) elif isinstance(json_data, list): return map(self._wrap_in_valueobjects, json_data) return json_data