def test_list_returns_response_in_add_order(self):
self.login(self.workspace_member)
IResponseContainer(self.todo).list()
container = IResponseContainer(self.todo)
responses = [Response(), Response(), Response()]
[container.add(response) for response in responses]
self.assertEqual(responses, container.list())
def test_add_expects_response_objects(self):
self.login(self.workspace_member)
annotations = IAnnotations(self.todo)
self.assertNotIn(ResponseContainer.ANNOTATION_KEY, annotations.keys())
container = IResponseContainer(self.todo)
with self.assertRaises(ValueError):
container.add(object())
storage = annotations[ResponseContainer.ANNOTATION_KEY]
self.assertEqual([], list(storage.keys()))
def test_stores_response_in_the_annotations(self):
self.login(self.workspace_member)
annotations = IAnnotations(self.todo)
self.assertNotIn(ResponseContainer.ANNOTATION_KEY, annotations.keys())
response = Response()
container = IResponseContainer(self.todo)
container.add(response)
storage = annotations[ResponseContainer.ANNOTATION_KEY]
self.assertEqual([response], list(storage.values()))
def test_reassign_forwarding(self, browser):
self.login(self.administrator, browser=browser)
# self.add_additional_org_unit()
url = '{}/@workflow/forwarding-transition-reassign'.format(
self.inbox_forwarding.absolute_url())
# missing responsible
data = {'text': 'Wird gemacht.'}
with browser.expect_http_error(400):
browser.open(url,
method='POST',
data=json.dumps(data),
headers=self.api_headers)
# working
data = {
'text': 'Robert macht das.',
'responsible': 'james.bond',
'responsible_client': u'rk'
}
browser.open(url,
method='POST',
data=json.dumps(data),
headers=self.api_headers)
self.assertEqual(200, browser.status_code)
self.assertEqual('james.bond', self.inbox_forwarding.responsible)
self.assertEqual('rk', self.inbox_forwarding.responsible_client)
self.assertEqual('forwarding-state-open',
api.content.get_state(self.inbox_forwarding))
response = IResponseContainer(self.inbox_forwarding).list()[-1]
self.assertEqual(u'Robert macht das.', response.text)
self.assertEqual('forwarding-transition-reassign', response.transition)
def test_assign_to_dossier_stores_and_close_forwarding(self, browser):
self.login(self.secretariat_user, browser=browser)
url = '{}/@workflow/forwarding-transition-assign-to-dossier'.format(
self.inbox_forwarding.absolute_url())
dossier_uid = obj2brain(self.empty_dossier).UID
data = {'dossier': dossier_uid}
browser.open(url,
method='POST',
data=json.dumps(data),
headers=self.api_headers)
self.assertEqual(200, browser.status_code)
yearfolder = get_current_yearfolder(context=self.inbox)
self.assertEqual(1, len(yearfolder.objectValues()))
forwarding = yearfolder.objectValues()[0]
self.assertEqual('forwarding-state-closed',
api.content.get_state(forwarding))
response = IResponseContainer(forwarding).list()[-1]
task = self.empty_dossier.objectValues()[-1]
self.assertEqual('forwarding-transition-assign-to-dossier',
response.transition)
self.assertEqual(Oguid.for_object(task).id, response.successor_oguid)
def test_adds_a_response_to_the_given_context(self):
task = create(Builder('task'))
self.prepare_request(task,
text=u'Response text',
transition='base-response')
BaseResponseSyncerReceiver(task, self.request)()
response_container = IResponseContainer(task)
self.assertEqual(1, len(response_container))
response = response_container.list()[0]
self.assertEqual('Response text', response.text)
self.assertEqual('base-response', response.transition)
def test_create_a_response_object_with_all_changes(self):
self.login(self.workspace_member)
self.todo.title = u'before'
self.todo.responsible = self.workspace_member.getId()
changes_tracker = AutoResponseChangesTracker(self.todo, self.request)
with changes_tracker.track_changes(['title', 'responsible']):
self.todo.title = u'after'
self.todo.responsible = self.workspace_admin.getId()
self.assertItemsEqual([{
'field_id': 'responsible',
'before': {
u'token': u'beatrice.schrodinger',
u'title': u'Schr\xf6dinger B\xe9atrice'
},
'after': {
u'token': u'fridolin.hugentobler',
u'title': u'Hugentobler Fridolin'
},
'field_title': '',
}, {
'field_id': 'title',
'before': 'before',
'after': 'after',
'field_title': '',
}],
IResponseContainer(self.todo).list()[0].changes)
def test_adds_corresponding_answer(self):
self.login(self.dossier_responsible)
change_task_workflow_state(
self.subtask, 'task-transition-resolved-tested-and-closed')
self.assertEqual(
'task-transition-resolved-tested-and-closed',
IResponseContainer(self.subtask).list()[-1].transition)
def test_adding_a_response_sucessful(self, browser):
self.login(self.regular_user, browser=browser)
current_responses_count = len(IResponseContainer(self.task))
with freeze(datetime(2016, 12, 9, 9, 40)):
url = '{}/@responses'.format(self.task.absolute_url())
browser.open(url,
method="POST",
headers=self.api_headers,
data=json.dumps({'text': u'Angebot \xfcberpr\xfcft'}))
self.assertEquals(current_responses_count + 1,
len(IResponseContainer(self.task)))
self.assertEquals(201, browser.status_code)
self.maxDiff = None
self.assertEquals(
{
u'@id':
'{}/@responses/1481272800000000'.format(
self.task.absolute_url()),
'response_id':
1481272800000000,
'response_type':
'comment',
u'created':
u'2016-12-09T09:40:00',
u'changes': [],
u'creator': {
u'token': self.regular_user.id,
u'title': u'B\xe4rfuss K\xe4thi'
},
u'text':
u'Angebot \xfcberpr\xfcft',
u'transition':
u'task-commented',
u'successor_oguid':
u'',
u'rendered_text':
u'',
u'related_items': [],
u'mimetype':
u'',
u'added_objects': []
}, browser.json)
def test_do_not_create_a_response_object_if_there_are_no_changes(self):
self.login(self.workspace_member)
changes_tracker = AutoResponseChangesTracker(self.todo, self.request)
with changes_tracker.track_changes(['title']):
pass
self.assertEqual([], IResponseContainer(self.todo).list())
def is_already_done(self):
"""This method returns `True` if this exact request was already
executed.
This is the case when the sender client has a conflict error when
committing and the sender-request needs to be re-done. In this case
this view is called another time but the changes were already made
and committed - so we need to return "OK" and do nothing.
"""
response_container = IResponseContainer(self.context)
if len(response_container) == 0:
return False
last_response = response_container.list()[-1]
if last_response.transition == self.transition and \
api.user.get_current().getId() == last_response.creator:
return True
return False
def move_todo(todo, target):
todo_id = todo.getId()
data = {'source': todo.absolute_url()}
browser.open('{}/@move'.format(target.absolute_url()),
method='POST',
headers=self.api_headers,
data=json.dumps(data))
return IResponseContainer(todo).list()[-1], target[todo_id]
def test_sync_comment_on_predecessor_to_successor(self):
predecessor = create(Builder('task'))
successor = create(Builder('task').successor_from(predecessor))
sender = getMultiAdapter((predecessor, predecessor.REQUEST),
IResponseSyncerSender,
name='comment')
sender.sync_related_tasks('task-commented',
text=u'We need more stuff!')
response_container = IResponseContainer(successor)
self.assertEqual(1, len(response_container))
response = response_container.list()[0]
self.assertEqual('We need more stuff!', response.text)
self.assertEqual('task-commented', response.transition)
def is_already_accepted(self):
"""When the sender has a conflict error but the reseiver already
added the response, this view is called a second / third time in
conflict resolution. We need to detect whether it is already done
and not fail.
"""
response_container = IResponseContainer(self.context)
if len(response_container) == 0:
return False
last_response = response_container.list()[-1]
current_user = AccessControl.getSecurityManager().getUser()
if last_response.transition == ACCEPT_TASK_TRANSITION and \
last_response.creator == current_user.getId():
return True
else:
return False