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_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 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_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(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 _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 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_get_ctg_g_reader_no_role(self):
"""GET CycleTaskGroup collection logged in as GlobalReader & No Role."""
with factories.single_commit():
wf_factories.CycleTaskGroupFactory()
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_group = all_models.CycleTaskGroup.query.one()
response = self.api_helper.get_collection(cycle_task_group,
(cycle_task_group.id, ))
self.assertTrue(
response.json["cycle_task_groups_collection"]["cycle_task_groups"])
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 setUp(self):
"""Create indexable objects which provide required set of fulltext attrs
Fulltext attributes are: title, name, email, notes, description, slug
"""
super(TestCycleGroup, self).setUp()
with single_commit():
# Create cycles
objects = [
factories.CycleTaskGroupFactory(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 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 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 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)
