def test_cycle_state_after_post(self):
"""Test cycle status after adding a task."""
with single_commit():
ctg = factories.CycleTaskGroupFactory()
ct1 = factories.CycleTaskGroupObjectTaskFactory()
ct1.cycle_task_group = ctg
self.api.put(ct1, {"status": "In Progress"})
with single_commit():
ct2 = factories.CycleTaskGroupObjectTaskFactory()
ct2.cycle_task_group = ctg
self.assertEqual(
db.session.query(Cycle).filter(
Cycle.id == ctg.cycle.id).one().status, "In Progress")
self.assertEqual(
db.session.query(CycleTaskGroup).filter(
CycleTaskGroup.id == ctg.id).one().status, "In Progress")
self.assertEqual(
db.session.query(CycleTaskGroupObjectTask).filter(
CycleTaskGroupObjectTask.id == ct1.id).one().status,
"In Progress")
self.assertEqual(
db.session.query(CycleTaskGroupObjectTask).filter(
CycleTaskGroupObjectTask.id == ct2.id).one().status,
"Assigned")
def test_ctgot_new_comments(self):
"""Test if ctgot create with new comments"""
comment = self.api_helper.post(all_models.Comment, {
"comment": {
"context": None,
"description": "test1"
},
})
comment_json = comment.json.get("comment")
self.assertEqual(comment.status_code, 201)
self.assertEqual(comment_json.get("description"), "test1")
comment_id = comment_json.get("id")
comment_type = comment_json.get("type")
ctgot = wf_factories.CycleTaskGroupObjectTaskFactory()
ctgot_id = ctgot.id
response = self.api_helper.post(
all_models.Relationship, {
"relationship": {
"source": {
"id": ctgot_id,
"type": ctgot.type
},
"destination": {
"id": comment_id,
"type": comment_type
},
"context": None
},
})
self.assertEqual(response.status_code, 201)
def setUp(self):
self.instance = factories.CycleTaskGroupObjectTaskFactory()
self.assignee = ggrc_factories.PersonFactory()
self.s_assignee = ggrc_factories.PersonFactory()
self.query = CycleTaskGroupObjectTask.query.filter(
CycleTaskGroupObjectTask.id == self.instance.id
)
def generate_tasks_for_cycle(group_count, task_count):
"""generate number of task groups and task for current task group"""
role_names = ("Task Assignees", "Task Secondary Assignees")
results = {}
with ggrc_factories.single_commit():
workflow = factories.WorkflowFactory()
cycle = factories.CycleFactory(workflow=workflow)
task_group = factories.TaskGroupFactory(workflow=workflow)
for idx in range(group_count):
person = ggrc_factories.PersonFactory(
name="user for group {}".format(idx))
cycle_task_group = factories.CycleTaskGroupFactory(
cycle=cycle, contact=person)
for _ in range(task_count):
task_group_task = factories.TaskGroupTaskFactory(
task_group=task_group)
for r_name in role_names:
ggrc_factories.AccessControlPersonFactory(
ac_list=task_group_task.acr_name_acl_map[r_name],
person=person,
)
task = factories.CycleTaskGroupObjectTaskFactory(
cycle=cycle,
cycle_task_group=cycle_task_group,
task_group_task=task_group_task)
for r_name in role_names:
ggrc_factories.AccessControlPersonFactory(
person=person,
ac_list=task.acr_name_acl_map[r_name],
)
results[task.id] = cycle_task_group.slug
return results
def test_filter_by_object_approval(self, filter_flag):
"""Test filter CTGOT by object_approval flag if value is {0}."""
with factories.single_commit():
ctgts = {}
for flag in [True, False]:
workflow = wf_factories.WorkflowFactory(object_approval=flag)
task_group = wf_factories.TaskGroupFactory(workflow=workflow)
tgt = wf_factories.TaskGroupTaskFactory(task_group=task_group)
cycle = wf_factories.CycleFactory(workflow=workflow)
ctgts[flag] = wf_factories.CycleTaskGroupObjectTaskFactory(
cycle=cycle,
task_group_task=tgt
)
filter_params = "ids={}&object_approval={}".format(
",".join([str(c.id) for c in ctgts.values()]),
"true" if filter_flag else "false"
)
response = self.api_helper.get_query(all_models.CycleTaskGroupObjectTask,
filter_params)
self.assert200(response)
colections = response.json["cycle_task_group_object_tasks_collection"]
items = colections["cycle_task_group_object_tasks"]
self.assertEqual(1, len(items))
self.assertEqual(ctgts[filter_flag].id, items[0]["id"])
def test_cycle_task_model(self, model_name):
"""Test Relationship POST for CycleTask<->{0}.
Args:
model_name: Non-Relatable model with which we are trying to create
Relationship.
"""
with factories.single_commit():
workflow = wf_factories.WorkflowFactory()
cycle = wf_factories.CycleFactory(workflow=workflow)
cycle_task_group = wf_factories.CycleTaskGroupFactory(cycle=cycle)
task_group = wf_factories.TaskGroupFactory(workflow=workflow)
task_group_task = wf_factories.TaskGroupTaskFactory(
task_group=task_group)
wf_factories.CycleTaskGroupObjectTaskFactory(
cycle=cycle,
cycle_task_group=cycle_task_group,
task_group_task=task_group_task)
cycle_task = all_models.CycleTaskGroupObjectTask.query.one()
instance = getattr(all_models, model_name).query.one()
data_ct_src = relationship_api.get_relationship_post_dict(
cycle_task, instance)
data_ct_dst = relationship_api.get_relationship_post_dict(
instance, cycle_task)
response = self.api_helper.post(all_models.Relationship, data_ct_src)
self.assertEqual(response.status_code, 201)
response = self.api_helper.post(all_models.Relationship, data_ct_dst)
self.assertEqual(response.status_code, 201)
def test_cycle_task_permission_error(self):
"""Test cycle task update via import with non-admin user which is the
reason of error. Only admin can update cycle tasks via import."""
self._generate_cycle_tasks()
with freeze_time(self.ftime_active):
_, creator = self.object_generator.generate_person(
user_role="Creator")
cycle_task = wf_factories.CycleTaskGroupObjectTaskFactory(
description="task active description 1")
ct_data = collections.OrderedDict([
("object_type", "Cycle Task Group Object Task"),
("Code*", cycle_task.slug),
])
response = self.import_data(ct_data, person=creator, safe=False)
self._check_csv_response(response, self.expected_permission_error)
# Cycle tasks' data shouldn't be changed in test DB after import run from
# non-admin user
expected_cycle_task_permission_error = {}
expected_cycle_task_permission_error.update(
self.generated_cycle_tasks_active)
expected_cycle_task_permission_error.update(
self.generated_cycle_tasks_historical)
self._cmp_tasks(expected_cycle_task_permission_error)
def test_ct_without_revisions_error(self, logger):
"""Tests that notifications for CycleTask
without revisions are handled properly."""
contract = factories.ContractFactory(title=u"Test Contract")
cycle_task = wf_factories.CycleTaskGroupObjectTaskFactory(
title=u"task1")
relationship = factories.RelationshipFactory(source=contract,
destination=cycle_task)
db.session.delete(relationship)
db.session.commit()
relationship_revision = Revision(obj=relationship,
modified_by_id=None,
action="deleted",
content="{}")
revisions = [relationship_revision]
factories.EventFactory(modified_by_id=login.get_current_user_id(),
action="DELETE",
resource_id=relationship.id,
resource_type=relationship.type,
revisions=revisions)
contract_revision = db.session.query(Revision).filter(
Revision.resource_type == "Contract", Revision.action == "created",
Revision.resource_id == contract.id).one()
db.session.delete(contract_revision)
db.session.commit()
get_cycle_task_dict(cycle_task)
logger.warning.assert_called_once_with(
"Unmapped %s id %s from CycleTask id %s has no revisions logged. ",
"Contract", contract.id, cycle_task.id)
def test_handle_task_comment(self, send_email_mock):
"""Test handling of mapped comment to cycle task."""
with factories.single_commit():
person = factories.PersonFactory(email="*****@*****.**")
obj = wf_factories.CycleTaskGroupObjectTaskFactory(
slug=u"TSK-1",
title=u"task1",
)
comment = factories.CommentFactory(
description=u"One <a href=\"mailto:[email protected]\"></a>", )
comment.modified_by_id = person.id
comment.created_at = datetime.datetime(2018, 1, 10, 7, 31, 42)
url = "http://localhost/dashboard#!task&query=%22task%20slug%22%3DTSK-1"
people_mentions.handle_comment_mapped(obj, [comment])
expected_title = (u"[email protected] mentioned you "
u"on a comment within task1")
expected_body = (
u"[email protected] mentioned you on a comment within task1 "
u"at 01/09/2018 23:31:42 PST:\n"
u"One <a href=\"mailto:[email protected]\"></a>\n")
body = settings.EMAIL_MENTIONED_PERSON.render(
person_mention={
"comments": [expected_body],
"url": url,
})
send_email_mock.assert_called_once_with(u"*****@*****.**",
expected_title, body)
def test_overdue_task(self):
"""Check that the event should not be created overdue tasks."""
task = wf_factories.CycleTaskGroupObjectTaskFactory(
status=u"In Progress",
end_date=date(2015, 1, 1),
)
with freeze_time("2015-01-05 12:00:00"):
self.assertEquals(self.builder._should_create_event_for(task), False)
def test_filter_by_needs_verification(self, value, search_value):
"""Test index by needs verification {0} value and search_value {1}."""
workflow = wf_factories.WorkflowFactory(is_verification_needed=value)
cycle = wf_factories.CycleFactory(workflow=workflow,
is_verification_needed=value)
task = wf_factories.CycleTaskGroupObjectTaskFactory(
cycle=cycle,
title="test_index_{0}_{1}".format(value, search_value))
self.assert_indexed_fields(task, "needs verification",
{"": search_value})
def test_is_in_history_task(self):
"""Check that the event should not be created is_in_history tasks."""
with freeze_time("2015-01-01 12:00:00"):
cycle = wf_factories.CycleFactory(is_current=False)
task = wf_factories.CycleTaskGroupObjectTaskFactory(
status=u"In Progress",
end_date=date(2015, 1, 5),
cycle=cycle,
)
self.assertEquals(self.builder._should_create_event_for(task), False)
def test_generate_description_for_event(self):
"""Test generating description for Calendar Event."""
with factories.single_commit():
person = factories.PersonFactory()
event = factories.CalendarEventFactory(
due_date=date(2015, 1, 10),
attendee_id=person.id,
)
first_task = wf_factories.CycleTaskGroupObjectTaskFactory(
title=u"unicode ascii title",
end_date=date(2015, 1, 10),
)
second_task = wf_factories.CycleTaskGroupObjectTaskFactory(
title=u"Â тест",
end_date=date(2015, 1, 10),
)
third_task = wf_factories.CycleTaskGroupObjectTaskFactory(
title="some ordinary title",
end_date=date(2015, 1, 10),
)
factories.RelationshipFactory(source=first_task, destination=event)
factories.RelationshipFactory(source=event, destination=second_task)
factories.RelationshipFactory(source=event, destination=third_task)
task_ids = [first_task.id, second_task.id, third_task.id]
self.builder._preload_data()
self.builder._generate_description_for_event(event, task_ids)
link_not_encoded = (
u'(("Task Status" IN ("Finished","Declined") and '
u'"Needs Verification"="Yes") '
u'or ("Task Status" IN ("Assigned","In Progress"))'
u') and "Task Due Date"=01/10/2015'
)
expected_description = (
u"You have following tasks due today:\n"
u"- Â тест\n"
u"- some ordinary title\n"
u"- unicode ascii title\n"
u"Please click on the link below to review and take action "
u"on your task(s) due today:\n"
u"<a href='http://localhost/dashboard#!task&query={link}'>Link</a>"
).format(link=urllib.quote(link_not_encoded.encode('utf-8')))
self.assertEquals(event.description, expected_description)
def test_build_cycle_tasks(self):
"""Test generating one Calendar Event based on several cycle tasks."""
with factories.single_commit():
person = factories.PersonFactory()
tasks = [
wf_factories.CycleTaskGroupObjectTaskFactory(
title=u"First task",
end_date=date(2015, 1, 5),
),
wf_factories.CycleTaskGroupObjectTaskFactory(
title=u"Second task",
end_date=date(2015, 1, 5),
)
]
tasks[0].add_person_with_role_name(person, u"Task Assignees")
tasks[1].add_person_with_role_name(person, u"Task Secondary Assignees")
with freeze_time("2015-01-01 12:00:00"):
self.builder.build_cycle_tasks()
self.assertEquals(all_models.CalendarEvent.query.count(), 1)
event = self.get_event(person.id, tasks[0].end_date)
self.assertIsNotNone(event)
self.assertEquals(event.title, u"Your tasks are due today")
link_not_encoded = (
u'(("Task Status" IN ("Finished","Declined") and '
u'"Needs Verification"="Yes") '
u'or ("Task Status" IN ("Assigned","In Progress"))'
u') and "Task Due Date"=01/05/2015'
)
expected_description = (
u"You have following tasks due today:\n"
u"- First task\n"
u"- Second task\n"
u"Please click on the link below to review and take action "
u"on your task(s) due today:\n"
u"<a href='http://localhost/dashboard#!task&query={link}'>Link</a>"
).format(link=urllib.quote(link_not_encoded.encode('utf-8')))
self.assertEquals(event.description, expected_description)
for task in tasks:
relationship = self.get_relationship(task.id, event.id)
self.assertIsNotNone(relationship)
def test_related_object_name(self, with_related):
"""Test checks related object name"""
issue_name = "Test issue name"
issue = factories.IssueFactory(title=issue_name)
cycle_task = wf_factories.CycleTaskGroupObjectTaskFactory(
title=u"task1")
factories.RelationshipFactory(source=issue, destination=cycle_task)
task_dict = get_cycle_task_dict(cycle_task, with_related=with_related)
if with_related:
self.assertEqual(task_dict["related_objects"][0], (issue_name, ))
else:
self.assertEqual(task_dict["related_objects"], [])
def test_get_task_persons_ids_to_notify(self):
"""Test getting task persons ids that should be notified."""
recipient_types = [u"Task Assignees", u"Task Secondary Assignees"]
persons = [factories.PersonFactory(), factories.PersonFactory()]
persons_ids = [person.id for person in persons]
with factories.single_commit():
task = wf_factories.CycleTaskGroupObjectTaskFactory(end_date=date(
2018, 1, 1), )
task.add_person_with_role_name(persons[0], recipient_types[0])
task.add_person_with_role_name(persons[1], recipient_types[1])
ids = self.builder._get_task_persons_ids_to_notify(task)
self.assertEqual(ids, set(persons_ids))
def setUp(self):
super(TestStatusApiPost, self).setUp()
self.api = Api()
with factories.single_commit():
self.workflow = wf_factories.WorkflowFactory()
self.cycle = wf_factories.CycleFactory(workflow=self.workflow)
self.group = wf_factories.CycleTaskGroupFactory(
cycle=self.cycle, context=self.cycle.workflow.context)
self.task = wf_factories.CycleTaskGroupObjectTaskFactory(
cycle=self.cycle,
cycle_task_group=self.group,
context=self.cycle.workflow.context)
def test_ca_cleanup_on_obj_delete(self):
"""Test cleaning of fulltext and attributes tables on obj delete"""
with factories.single_commit():
for _ in range(2):
c_task = wf_factories.CycleTaskGroupObjectTaskFactory()
comment = factories.CommentFactory(
description=factories.random_str()
)
factories.RelationshipFactory(source=c_task, destination=comment)
self.compute_attributes()
c_task = all_models.CycleTaskGroupObjectTask.query.first()
last_comment_records = self.get_model_fulltext(
"CycleTaskGroupObjectTask", "last_comment", [c_task.id]
)
last_comment_attrs = self.get_model_ca(
"CycleTaskGroupObjectTask",
[c_task.id]
)
self.assertEqual(last_comment_records.count(), 1)
self.assertEqual(last_comment_attrs.count(), 1)
response = self.api.delete(c_task)
self.assert200(response)
last_comment_records = self.get_model_fulltext(
"CycleTaskGroupObjectTask", "last_comment", [c_task.id]
)
last_comment_attrs = self.get_model_ca(
"CycleTaskGroupObjectTask",
[c_task.id]
)
self.assertEqual(last_comment_attrs.count(), 0)
self.assertEqual(last_comment_records.count(), 0)
# Check that other records weren't affected
task_ids = [task.id for task in
all_models.CycleTaskGroupObjectTask.query.all()]
last_comment_records = self.get_model_fulltext(
"CycleTaskGroupObjectTask", "last_comment", task_ids
)
last_comment_attrs = self.get_model_ca(
"CycleTaskGroupObjectTask",
task_ids,
)
self.assertEqual(last_comment_records.count(), 1)
self.assertEqual(last_comment_attrs.count(), 1)
def test_task_status(self, task_status, is_verification_needed,
should_create_event):
"""Check that the event should be created for specified task statuses."""
with freeze_time("2015-01-1 12:00:00"):
cycle = wf_factories.CycleFactory(
is_verification_needed=is_verification_needed, )
task = wf_factories.CycleTaskGroupObjectTaskFactory(
status=task_status,
end_date=date(2015, 1, 5),
cycle=cycle,
)
self.assertEquals(self.builder._should_create_event_for(task),
should_create_event)
def generate_tasks_for_cycle(task_count):
"""generate number of task groups and task for current task group"""
results = []
with ggrc_factories.single_commit():
for idx in range(task_count):
person = ggrc_factories.PersonFactory(
name="user for group {}".format(idx)
)
task = factories.CycleTaskGroupObjectTaskFactory()
for role_name in ("Task Assignees", "Task Secondary Assignees"):
task.add_person_with_role_name(person, role_name)
results.append(task.id)
return results
def test_cycle_task_correct(self):
"""Test cycle task update via import with correct data"""
self._generate_cycle_tasks()
with freeze_time(self.ftime_active):
cycle_task = wf_factories.CycleTaskGroupObjectTaskFactory(
description="task active description 1")
self.import_data(
collections.OrderedDict([
("object_type", "Cycle Task Group Object Task"),
("Code*", cycle_task.slug),
("description", "task active description 1"),
]))
self._cmp_tasks(self.expected_cycle_task_correct)
def test_generate_events_for_task_without_event(self):
"""Test generating events for tasks without event."""
with factories.single_commit():
person = factories.PersonFactory()
task = wf_factories.CycleTaskGroupObjectTaskFactory(end_date=date(
2015, 1, 5), )
task.add_person_with_role_name(person, u"Task Assignees")
with freeze_time("2015-01-1 12:00:00"):
self.builder._preload_data()
self.builder._generate_events()
event = self.get_event(person.id, task.end_date)
self.assertIsNotNone(event)
relationship = self.get_relationship(task.id, event.id)
self.assertIsNotNone(relationship)
def test_get_cycle_task_dict(self):
"""Tests get_cycle_task_dict functionality."""
contract = factories.ContractFactory(title=u"Contract1")
cycle_task = wf_factories.CycleTaskGroupObjectTaskFactory(
title=u"task1")
relationship = factories.RelationshipFactory(source=contract,
destination=cycle_task)
db.session.delete(relationship)
db.session.commit()
relationship_revision = Revision(obj=relationship,
modified_by_id=None,
action="deleted",
content="{}")
contract_revision = Revision(obj=contract,
modified_by_id=None,
action="deleted",
content='{"display_name": "Contract1"}')
revisions = [relationship_revision, contract_revision]
factories.EventFactory(modified_by_id=login.get_current_user_id(),
action="DELETE",
resource_id=relationship.id,
resource_type=relationship.type,
revisions=revisions)
task_dict = get_cycle_task_dict(cycle_task)
self.assertEqual(task_dict["related_objects"][0],
u"Contract1 [removed from task]")
# Test if we handle the title of the object being empty
contract = factories.ContractFactory(title=u"")
cycle_task = wf_factories.CycleTaskGroupObjectTaskFactory(
title=u"task1")
factories.RelationshipFactory(source=contract, destination=cycle_task)
task_dict = get_cycle_task_dict(cycle_task)
self.assertEqual(task_dict["related_objects"][0], u"Untitled object")
def setup_person_task_event(end_date):
"""Setup task with person and event."""
with factories.single_commit():
person = factories.PersonFactory()
task = wf_factories.CycleTaskGroupObjectTaskFactory(
end_date=end_date, )
event = factories.CalendarEventFactory(
due_date=end_date,
attendee_id=person.id,
)
# pylint: disable=protected-access
for acl in task._access_control_list:
factories.AccessControlPersonFactory(ac_list=acl,
person=person)
factories.RelationshipFactory(source=task, destination=event)
return person, task, event
def test_task_status(
self, task_status, is_verification_needed, should_create_event
):
"""Task {}, is verification needed {}, should event be created {}."""
with factories.single_commit():
cycle = wf_factories.CycleFactory(
is_verification_needed=is_verification_needed,
)
task = wf_factories.CycleTaskGroupObjectTaskFactory(
status=task_status,
end_date=date(2015, 1, 5),
cycle=cycle,
)
with freeze_time("2015-01-1 12:00:00"):
self.assertEquals(self.builder._should_create_event_for(task),
should_create_event)
def test_task_archived(self, recurrence, should_create_event):
"""Check creation of event based on workflow archived states."""
with freeze_time("2015-01-01 12:00:00"):
workflow = wf_factories.WorkflowFactory(
unit=all_models.Workflow.WEEK_UNIT,
recurrences=recurrence,
next_cycle_start_date=date(2015, 1, 5),
)
cycle = wf_factories.CycleFactory(workflow=workflow)
task = wf_factories.CycleTaskGroupObjectTaskFactory(
status=u"In Progress",
end_date=date(2015, 1, 5),
cycle=cycle,
)
self.assertEquals(self.builder._should_create_event_for(task),
should_create_event)
def test_get_ct_g_reader_no_role(self):
"""GET CycleTask collection logged in as GlobalReader & No Role."""
with factories.single_commit():
wf_factories.CycleTaskGroupObjectTaskFactory()
self.setup_helper.setup_person(rbac_helper.GR_RNAME, "No Role")
g_reader = self.setup_helper.get_person(rbac_helper.GR_RNAME,
"No Role")
self.api_helper.set_user(g_reader)
cycle_task = all_models.CycleTaskGroupObjectTask.query.one()
response = self.api_helper.get_collection(cycle_task,
(cycle_task.id, ))
self.assertTrue(
response.json["cycle_task_group_object_tasks_collection"]
["cycle_task_group_object_tasks"])
def test_last_comment_value(self):
"""Test proper value in last_comment field"""
with factories.single_commit():
c_task = wf_factories.CycleTaskGroupObjectTaskFactory()
c_task_id = c_task.id
comment_1 = factories.CommentFactory(description=factories.random_str())
comment_2 = factories.CommentFactory(description=factories.random_str())
comment_2_id = comment_2.id
factories.RelationshipFactory(source=c_task, destination=comment_1)
factories.RelationshipFactory(source=c_task, destination=comment_2)
self.compute_attributes()
comment_2 = all_models.Comment.query.get(comment_2_id)
c_task = all_models.CycleTaskGroupObjectTask.query.get(c_task_id)
self.assertEqual(c_task.last_comment, comment_2.description)
def generate_tasks_for_cycle(cycle_count, task_count):
"""generate seceted number of cycles and tasks"""
role_names = ("Task Assignees", "Task Secondary Assignees")
results = {}
with ggrc_factories.single_commit():
for _ in range(cycle_count):
workflow = factories.WorkflowFactory()
cycle = factories.CycleFactory(
workflow=workflow,
)
cycle.contact = ggrc_factories.PersonFactory(
name="user for cycle {}".format(cycle.id)
)
person = ggrc_factories.PersonFactory(
name="user for cycle tasks {}".format(cycle.id)
)
task_group = factories.TaskGroupFactory(workflow=workflow)
for _ in range(task_count):
task_group_task = factories.TaskGroupTaskFactory(
task_group=task_group)
for r_name in role_names:
role = all_models.AccessControlRole.query.filter(
all_models.AccessControlRole.name == r_name,
all_models.AccessControlRole.object_type ==
task_group_task.type,
).one()
ggrc_factories.AccessControlListFactory(ac_role=role,
object=task_group_task,
person=person)
cycle_task_group = factories.CycleTaskGroupFactory(
cycle=cycle, contact=person)
task = factories.CycleTaskGroupObjectTaskFactory(
cycle=cycle,
cycle_task_group=cycle_task_group,
task_group_task=task_group_task
)
for r_name in role_names:
role = all_models.AccessControlRole.query.filter(
all_models.AccessControlRole.name == r_name,
all_models.AccessControlRole.object_type == task.type,
).one()
ggrc_factories.AccessControlListFactory(ac_role=role,
object=task,
person=person)
results[task.id] = cycle.slug
return results
def test_post_comment_editor_admin(self):
"""POST CycleTaskEntry logged in as GlobalEditor & WF Admin."""
with factories.single_commit():
workflow = self.setup_helper.setup_workflow(
(rbac_helper.GE_RNAME, ))
cycle = wf_factories.CycleFactory(workflow=workflow)
wf_factories.CycleTaskGroupObjectTaskFactory(cycle=cycle)
g_editor = self.setup_helper.get_person(rbac_helper.GE_RNAME,
ac_roles.workflow.ADMIN_NAME)
self.api_helper.set_user(g_editor)
cycle_task = all_models.CycleTaskGroupObjectTask.query.one()
data = workflow_api.get_cycle_task_entry_post_dict(cycle_task)
response = self.api_helper.post(all_models.CycleTaskEntry, data)
self.assertEqual(response.status_code, 201)
