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 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 _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 _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 _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 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 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 _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 _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 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 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 _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 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 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_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 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.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 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 _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 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 _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 _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
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 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])
