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_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 _create_cycle_structure():
"""Create cycle structure.
It will create workflow, cycle, group and 3 tasks in that group.
Retruns tuple:
workflow, cycle, group and list of tasks.
"""
workflow = wf_factories.WorkflowFactory(
status=all_models.Workflow.ACTIVE)
cycle = wf_factories.CycleFactory(workflow=workflow)
group = wf_factories.CycleTaskGroupFactory(
cycle=cycle,
context=cycle.workflow.context
)
tasks = []
for ind in xrange(3):
tasks.append(wf_factories.CycleTaskFactory(
title='task{}'.format(ind),
cycle=cycle,
cycle_task_group=group,
context=cycle.workflow.context,
start_date=datetime.datetime.now(),
end_date=datetime.datetime.now() + datetime.timedelta(7)
))
return workflow, cycle, group, tasks
def generate_tasks_for_cycle(self, group_count, task_count):
"""generate number of task groups and task for current task group"""
role_names = ("Task Assignees", "Task Secondary Assignees")
results = {}
with single_commit():
workflow = factories.WorkflowFactory()
cycle = factories.CycleFactory(workflow=workflow)
task_group = factories.TaskGroupFactory(workflow=workflow)
for idx in range(group_count):
person = 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.AccessControlListFactory(
object=task_group_task,
person=person,
ac_role_id=self.get_role_id_for_obj(
task_group_task, r_name))
task = factories.CycleTaskFactory(
cycle=cycle,
cycle_task_group=cycle_task_group,
task_group_task=task_group_task)
for r_name in role_names:
ggrc_factories.AccessControlListFactory(
object=task,
person=person,
ac_role_id=self.get_role_id_for_obj(task, r_name))
results[task.id] = cycle_task_group.slug
return results
def test_create_ctg_wf_member(self, member_role, response_code, exp_count):
"""Check creation cycle task group by workflow member"""
member = self.create_user_with_role(member_role)
with factories.single_commit():
workflow = wf_factories.WorkflowFactory()
workflow.add_person_with_role_name(member, 'Workflow Member')
task_group = wf_factories.TaskGroupFactory(
title='TestTG',
context=factories.ContextFactory(),
workflow=workflow)
wf_factories.TaskGroupTaskFactory(
title='TestTGT',
task_group=task_group,
start_date=datetime.date(2017, 8, 3),
end_date=datetime.date(2017, 8, 7))
cycle = wf_factories.CycleFactory(workflow=workflow)
self.generator.activate_workflow(workflow)
self.api.set_user(member)
response = self.api.post(
all_models.CycleTaskGroup, {
"cycle_task_group": {
"cycle": {
"id": cycle.id,
},
"contact": {
"id": member.id,
},
"title": 'title1',
},
})
self.assertEquals(response.status_code, response_code)
count = len(all_models.CycleTaskGroup.query.all())
self.assertEquals(count, exp_count)
def test_delete_ctg_wf_admin(self, admin_role):
"""Check deletion cycle task group by workflow member"""
admin = self.create_user_with_role(admin_role)
exp_count = 0
with factories.single_commit():
workflow = wf_factories.WorkflowFactory()
workflow.add_person_with_role_name(admin, 'Admin')
task_group = wf_factories.TaskGroupFactory(
title='TestTG',
context=factories.ContextFactory(),
workflow=workflow
)
wf_factories.TaskGroupTaskFactory(
title='TestTGT',
task_group=task_group,
start_date=datetime.date(2017, 8, 3),
end_date=datetime.date(2017, 8, 7)
)
cycle = wf_factories.CycleFactory(workflow=workflow)
cycle_task_group = wf_factories.CycleTaskGroupFactory(
cycle=cycle,
title='Title1'
)
ctg = all_models.CycleTaskGroup.query.get(cycle_task_group.id)
self.generator.activate_workflow(workflow)
self.api.set_user(admin)
response = self.api.delete(ctg)
self.assert200(response)
count = len(all_models.CycleTaskGroup.query.all())
self.assertEquals(count, exp_count)
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_is_in_history_task(self):
"""Check that the overdue event should be deleted is_in_history tasks."""
_, task, _ = self.setup_person_task_event(date(2015, 1, 5))
task.cycle = wf_factories.CycleFactory(is_current=False)
task.status = u"In Progress"
with freeze_time("2015-01-10 12:00:00"):
self.assertEquals(self.builder._should_delete_event_for(task),
True)
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_overdue_task_status(self, task_status, is_verification_needed,
should_delete_event, is_overdue):
"""{} task, verification needed {}, should be deleted {}, is overdue {}"""
start_date = date(2015, 1, 5) if is_overdue else date(2015, 1, 15)
_, task, _ = self.setup_person_task_event(start_date)
task.cycle = wf_factories.CycleFactory(
is_verification_needed=is_verification_needed, )
task.status = task_status
with freeze_time("2015-01-10 12:00:00"):
self.assertEquals(self.builder._should_delete_event_for(task),
should_delete_event)
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.CycleTaskFactory(
cycle=self.cycle,
cycle_task_group=self.group,
context=self.cycle.workflow.context)
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 test_get_cycle_g_reader_no_role(self):
"""GET Cycle collection logged in as GlobalReader & No Role."""
with factories.single_commit():
wf_factories.CycleFactory()
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 = all_models.Cycle.query.one()
response = self.api_helper.get_collection(cycle, (cycle.id, ))
self.assertTrue(response.json["cycles_collection"]["cycles"])
def activate(self):
"""Activate Workflow."""
workflow = all_models.Workflow.query.get(self.workflow_id)
cycle = wf_factories.CycleFactory(workflow=workflow)
return self.api.put(
workflow, {
"status": "Active",
"recurrences": bool(workflow.repeat_every and workflow.unit),
"cycles": [{
"id": cycle.id,
"type": "Cycle",
}]
})
def test_task_archived(self, recurrence, should_delete_event):
"""Check deletion of overdue event based on workflow archived states."""
_, task, _ = self.setup_person_task_event(date(2015, 1, 6))
with factories.single_commit():
workflow = wf_factories.WorkflowFactory(
unit=all_models.Workflow.WEEK_UNIT,
recurrences=recurrence,
next_cycle_start_date=date(2015, 1, 6),
)
task.cycle = wf_factories.CycleFactory(workflow=workflow)
task.status = u"In Progress"
with freeze_time("2015-01-10 12:00:00"):
self.assertEquals(self.builder._should_delete_event_for(task),
should_delete_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 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.CycleTaskFactory(cycle=cycle)
g_editor = self.setup_helper.get_workflow_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)
def setUp(self):
with ggrc_factories.single_commit():
self.workflow = factories.WorkflowFactory(
status=all_models.Workflow.ACTIVE)
self.cycle = factories.CycleFactory(workflow=self.workflow)
self.group = factories.CycleTaskGroupFactory(
cycle=self.cycle, context=self.cycle.workflow.context)
self.tasks = []
for ind, task_status in enumerate(self.DEFAULT_TASK_STATUSES):
self.tasks.append(
factories.CycleTaskFactory(
title='task{}'.format(ind),
cycle=self.cycle,
cycle_task_group=self.group,
context=self.cycle.workflow.context,
status=task_status,
))
# Emulate that current user is assignee for all test CycleTasks.
self.task_ids = [t.id for t in self.tasks]
def setUp(self):
"""Create indexable objects which provide required set of fulltext attrs
Fulltext attributes are: title, name, email, notes, description, slug
"""
super(TestCycle, self).setUp()
with single_commit():
# Create cycles
objects = [
factories.CycleFactory(title=title, description=desc)
for title, desc in (
('t01', 'd01'),
('t02', 'd02'),
('t11', 'd11'),
)
]
self.objects = dict((i.title, i.id) for i in objects)
def generate_tasks_for_cycle(cycle_count, task_count):
"""generate seceted number of cycles and tasks"""
results = {}
for _ in range(cycle_count):
workflow = factories.WorkflowFactory()
cycle = factories.CycleFactory(workflow=workflow)
person = PersonFactory(name="user for cycle {}".format(cycle.id))
task_group = factories.TaskGroupFactory(workflow=workflow)
for _ in range(task_count):
task_group_task = factories.TaskGroupTaskFactory(
task_group=task_group, contact=person)
cycle_task_group = factories.CycleTaskGroupFactory(
cycle=cycle, contact=person)
task = factories.CycleTaskFactory(
cycle=cycle,
cycle_task_group=cycle_task_group,
contact=person,
task_group_task=task_group_task)
results[task.id] = cycle.slug
return results
def generate_tasks_for_cycle(group_count, task_count):
"""generate number of task groups and task for current task group"""
results = {}
workflow = factories.WorkflowFactory()
cycle = factories.CycleFactory(workflow=workflow)
task_group = factories.TaskGroupFactory(workflow=workflow)
for idx in range(group_count):
person = 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, contact=person)
task = factories.CycleTaskFactory(
cycle=cycle,
cycle_task_group=cycle_task_group,
contact=person,
task_group_task=task_group_task)
results[task.id] = cycle_task_group.slug
return results
def setUp(self):
super(TestStatusApiPatch, self).setUp()
self.api = Api()
with factories.single_commit():
self.assignee = factories.PersonFactory(
email="*****@*****.**")
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.tasks = []
for ind in xrange(3):
self.tasks.append(
wf_factories.CycleTaskFactory(
title='task{}'.format(ind),
cycle=self.cycle,
cycle_task_group=self.group,
context=self.cycle.workflow.context))
# Emulate that current user is assignee for all test CycleTasks.
all_models.CycleTaskGroupObjectTask.current_user_wfo_or_assignee = (
MagicMock(return_value=True))
def test_create_ctg_wf_admin(self, admin_role):
"""Check creation cycle task group by workflow admin"""
admin = self.create_user_with_role(admin_role)
exp_count = 1
with factories.single_commit():
workflow = wf_factories.WorkflowFactory()
workflow.add_person_with_role_name(admin, 'Admin')
task_group = wf_factories.TaskGroupFactory(
title='TestTG',
context=factories.ContextFactory(),
workflow=workflow
)
wf_factories.TaskGroupTaskFactory(
title='TestTGT',
task_group=task_group,
start_date=datetime.date(2017, 8, 3),
end_date=datetime.date(2017, 8, 7)
)
cycle = wf_factories.CycleFactory(workflow=workflow)
self.generator.activate_workflow(workflow)
self.api.set_user(admin)
response = self.api.post(all_models.CycleTaskGroup, {
"cycle_task_group": {
"cycle": {
"id": cycle.id,
},
"contact": {
"id": admin.id,
},
"title": 'title1',
},
})
self.assert201(response)
count = len(all_models.CycleTaskGroup.query.all())
self.assertEquals(count, exp_count)
def generate_tasks_for_cycle(cycle_count, task_count):
"""generate seceted number of cycles and tasks"""
role_names = ("Task Assignees", "Task Secondary Assignees")
statuses = ["Assigned", "In Progress", "Finished", "Verified"]
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:
ggrc_factories.AccessControlPersonFactory(
person=person,
ac_list=task_group_task.acr_name_acl_map[r_name],
)
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,
status=statuses.pop())
for r_name in role_names:
ggrc_factories.AccessControlPersonFactory(
person=person,
ac_list=task.acr_name_acl_map[r_name],
)
results[task.id] = cycle.slug
return results
def test_create_cycle_task(self, member_role):
"""Check creation cycle task group by workflow member"""
member = self.create_user_with_role(member_role)
with factories.single_commit():
workflow = wf_factories.WorkflowFactory()
workflow.add_person_with_role_name(member, 'Workflow Member')
cycle = wf_factories.CycleFactory(workflow=workflow)
cycle_id = cycle.id
ctg_id = wf_factories.CycleTaskGroupFactory(
cycle=cycle,
title='TestCTG',
).id
self.generator.activate_workflow(workflow)
self.api.set_user(member)
response = self.api.post(all_models.CycleTaskGroupObjectTask, {
"cycle_task_group_object_task": {
"title": "New Cycle Task",
"start_date": datetime.datetime.now().strftime("%Y-%m-%d"),
"end_date": datetime.datetime.now().strftime("%Y-%m-%d"),
"context": None,
"task_type": "text",
"cycle_task_group": {
"id": ctg_id,
"type": "Task Group",
},
"cycle": {
"id": cycle_id,
"type": "Cycle",
},
}
})
self.assert403(response)
count = len(all_models.CycleTaskGroupObjectTask.query.all())
self.assertEquals(count, 0)
