def test_tgt_has_view_dates(self):
"""Test get view only fields for TGT."""
workflow = wf_factories.WorkflowFactory()
task_group = wf_factories.TaskGroupFactory(workflow=workflow)
tgt = wf_factories.TaskGroupTaskFactory(task_group=task_group)
resp = self.api.get(tgt, tgt.id)
self.assertIn("task_group_task", resp.json)
self.assertIn("view_start_date", resp.json["task_group_task"])
self.assertIn("view_end_date", resp.json["task_group_task"])
def setUp(self):
super(TestTaskGroupImport, self).setUp()
with factories.single_commit():
workflow = wf_factories.WorkflowFactory(slug=self.WF_SLUG)
task_group = wf_factories.TaskGroupFactory(
slug=self.TG_SLUG,
workflow=workflow
)
wf_factories.TaskGroupTaskFactory(task_group=task_group)
factories.PersonFactory(email="*****@*****.**")
def setUp(self):
super(TestCTGOT, self).setUp()
self.api = api_helper.Api()
with factories.single_commit():
assignee_1 = factories.PersonFactory(email=self.TASK_ASSIGNEE_1)
assignee_2 = factories.PersonFactory(email=self.TASK_ASSIGNEE_2)
workflow_admin = factories.PersonFactory(email=self.WORKFLOW_ADMIN)
nobody = factories.PersonFactory(email=self.NOBODY)
reader_role = all_models.Role.query.filter_by(name="Reader").one()
for person in [assignee_1, assignee_2, workflow_admin, nobody]:
bp_factories.UserRoleFactory(person=person,
role=reader_role,
context=None)
workflow = wf_factories.WorkflowFactory()
taskgroup = wf_factories.TaskGroupFactory(workflow=workflow)
task_1 = wf_factories.TaskGroupTaskFactory(task_group=taskgroup)
task_2 = wf_factories.TaskGroupTaskFactory(task_group=taskgroup)
factories.AccessControlPersonFactory(
ac_list=task_1.acr_name_acl_map["Task Assignees"],
person=assignee_1,
)
factories.AccessControlPersonFactory(
ac_list=task_2.acr_name_acl_map["Task Assignees"],
person=assignee_2,
)
sec_assignee = factories.PersonFactory(
email=self.TASK_SEC_ASSIGNEE)
factories.AccessControlPersonFactory(
ac_list=task_1.acr_name_acl_map["Task Secondary Assignees"],
person=sec_assignee,
)
factories.AccessControlPersonFactory(
ac_list=workflow.acr_name_acl_map["Admin"],
person=workflow_admin,
)
generator = wf_generator.WorkflowsGenerator()
self.cycle_id = generator.generate_cycle(workflow)[1].id
generator.activate_workflow(workflow)
def test_tg_task(self):
"""Test task group task mappings."""
with freeze_time("2017-03-07"):
workflow = wf_factories.WorkflowFactory()
task_group1 = wf_factories.TaskGroupFactory(workflow=workflow)
task_group1_slug = task_group1.slug
task_group_task1 = wf_factories.TaskGroupTaskFactory(
task_group=task_group1)
task_group_task1_slug = task_group_task1.slug
task_group_task2 = wf_factories.TaskGroupTaskFactory(
task_group=task_group1)
task_group_task2_slug = task_group_task2.slug
data = [
{
"object_name": "TaskGroupTask",
"filters": {
"expression": {
"op": {"name": "relevant"},
"object_name": "TaskGroup",
"slugs": [task_group1_slug],
},
},
"fields": "all",
}, {
"object_name": "TaskGroup",
"filters": {
"expression": {
"op": {"name": "relevant"},
"object_name": "__previous__",
"ids": ["0"],
},
},
"fields": "all",
},
]
response = self.export_csv(data)
self.assert200(response)
response_data = response.data
self.assertEqual(3, response_data.count(task_group1_slug))
self.assertIn(task_group_task1_slug, response_data)
self.assertIn(task_group_task2_slug, response_data)
def setUp(self):
super(TestCTGOT, self).setUp()
self.api = api_helper.Api()
with factories.single_commit():
assignee_1 = factories.PersonFactory(email=self.TASK_ASSIGNEE_1)
assignee_2 = factories.PersonFactory(email=self.TASK_ASSIGNEE_2)
workflow_owner = factories.PersonFactory(email=self.WORKFLOW_OWNER)
nobody = factories.PersonFactory(email=self.NOBODY)
workflow_owner_role = (all_models.Role.query
.filter_by(name="WorkflowOwner").one())
reader_role = all_models.Role.query.filter_by(name="Reader").one()
for person in [assignee_1, assignee_2, workflow_owner, nobody]:
bp_factories.UserRoleFactory(person=person,
role=reader_role,
context=None)
workflow = wf_factories.WorkflowFactory()
taskgroup = wf_factories.TaskGroupFactory(workflow=workflow)
task_1 = wf_factories.TaskGroupTaskFactory(task_group=taskgroup)
task_2 = wf_factories.TaskGroupTaskFactory(task_group=taskgroup)
role = all_models.AccessControlRole.query.filter(
all_models.AccessControlRole.name == "Task Assignees",
all_models.AccessControlRole.object_type == task_1.type,
).one()
factories.AccessControlListFactory(ac_role=role,
object=task_1,
person=assignee_1)
factories.AccessControlListFactory(ac_role=role,
object=task_2,
person=assignee_2)
bp_factories.UserRoleFactory(person=workflow_owner,
role=workflow_owner_role,
context=workflow.context)
generator = wf_generator.WorkflowsGenerator()
self.cycle_id = generator.generate_cycle(workflow)[1].id
generator.activate_workflow(workflow)
def test_update_verification_flag_negative(self, db_value, import_value):
slug = 'SomeCode'
with freezegun.freeze_time("2017-08-10"):
with factories.single_commit():
workflow = wf_factories.WorkflowFactory(
slug=slug,
is_verification_needed=db_value,
repeat_every=1,
unit=Workflow.WEEK_UNIT)
wf_factories.TaskGroupTaskFactory(
task_group=wf_factories.TaskGroupFactory(
workflow=workflow, context=factories.ContextFactory()),
# Two cycles should be created
start_date=date(2017, 8, 3),
end_date=date(2017, 8, 7))
person = factories.PersonFactory(
email="{}@email.py".format(slug))
wf_id = workflow.id
person_email = person.email
self.generator.activate_workflow(workflow)
workflow = Workflow.query.filter(Workflow.id == wf_id).first()
self.assertEqual(workflow.status, workflow.ACTIVE)
resp = self.import_data(
collections.OrderedDict([
("object_type", "Workflow"),
("code", slug),
("title", "SomeTitle"),
("Need Verification", import_value),
("force real-time email updates", "no"),
("Admin", person_email),
]))
self.assertEqual(1, resp[0]['ignored'])
workflow = Workflow.query.filter(Workflow.id == wf_id).first()
self.assertEqual(workflow.is_verification_needed, db_value)
# End all current cycles
for cycle in workflow.cycles:
self.generator.modify_object(cycle, {'is_current': False})
workflow = Workflow.query.filter(Workflow.id == wf_id).first()
self.assertEqual(workflow.status, workflow.INACTIVE)
resp = self.import_data(
collections.OrderedDict([
("object_type", "Workflow"),
("code", slug),
("title", "SomeTitle"),
("Need Verification", import_value),
("force real-time email updates", "no"),
("Admin", person_email),
]))
self.assertEqual(1, resp[0]['ignored'])
workflow = Workflow.query.filter(Workflow.id == wf_id).first()
self.assertEqual(workflow.is_verification_needed, db_value)
def test_creating_missing_acl_entries(self):
"""Test clean propagation of all ACL entries."""
with factories.single_commit():
audit = factories.AuditFactory()
wf_factories.TaskGroupTaskFactory()
factories.RelationshipFactory(source=audit, destination=audit.program)
propagation.propagate_all()
self.assertEqual(all_models.AccessControlList.query.count(), 25)
all_models.AccessControlList.query.delete()
db.session.commit()
self.assertEqual(all_models.AccessControlList.query.count(), 0)
propagation.propagate_all()
self.assertEqual(all_models.AccessControlList.query.count(), 25)
def clone(self):
"""Clone existing Task Group object."""
task_group = all_models.TaskGroup.query.get(self.task_group_id)
wf_factories.TaskGroupTaskFactory(task_group=task_group)
return self.api.post(all_models.TaskGroup, {
"task_group": {
"clone": self.task_group_id,
"clone_objects": True,
"clone_people": True,
"clone_tasks": True,
"context": None,
}
})
def clone(self):
"""Clone existing Workflow object."""
with factories.single_commit():
task_group = wf_factories.TaskGroupFactory(workflow_id=self.workflow_id)
wf_factories.TaskGroupTaskFactory(task_group=task_group)
return self.api.post(all_models.Workflow, {
"workflow": {
"clone": self.workflow_id,
"clone_objects": True,
"clone_people": True,
"clone_tasks": True,
"context": None,
}
})
def test_get_task_g_reader_no_role(self):
"""GET TaskGroupTask collection logged in as GlobalReader & No Role."""
with factories.single_commit():
wf_factories.TaskGroupTaskFactory()
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)
task_group_task = all_models.TaskGroupTask.query.one()
response = self.api_helper.get_collection(task_group_task,
(task_group_task.id, ))
self.assertTrue(
response.json["task_group_tasks_collection"]["task_group_tasks"])
def test_propagate_all(self):
"""Test clean propagation of all ACL entries."""
with factories.single_commit():
wf_factories.TaskGroupTaskFactory()
audit = factories.AuditFactory()
factories.RelationshipFactory(
source=audit,
destination=audit.program,
)
acl_ids = [acl.id for acl in audit.program._access_control_list]
propagation._propagate(acl_ids, self.user_id)
self.assertEqual(all_models.AccessControlList.query.count(), 17)
propagation.propagate_all()
self.assertEqual(all_models.AccessControlList.query.count(), 25)
def test_post_cycle_g_role_admin(self, g_rname):
"""Activate Workflow/POST Cycle logged in as {} & WF Admin."""
with factories.single_commit():
workflow = self.setup_helper.setup_workflow((g_rname, ))
task_group = wf_factories.TaskGroupFactory(workflow=workflow)
wf_factories.TaskGroupTaskFactory(task_group=task_group)
g_person = self.setup_helper.get_person(g_rname,
ac_roles.workflow.ADMIN_NAME)
self.api_helper.set_user(g_person)
workflow = all_models.Workflow.query.one()
data = workflow_api.get_cycle_post_dict(workflow)
response = self.api_helper.post(all_models.Cycle, data)
self.assertEqual(response.status_code, 201)
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_import_tgs_with_existing_slugs(self):
"""
When tgs with existing slugs are imported
they shouldn't be unmapped from the previous wf.
Proper error should be displayed.
"""
# pylint: disable=invalid-name
first_wf_slug = "WORKFLOW-1"
first_tg_slug = "TASKGROUP-1"
with factories.single_commit():
# create first workflow, it's tg and tgt
first_wf = wf_factories.WorkflowFactory(slug=first_wf_slug)
first_task_group = wf_factories.TaskGroupFactory(
slug=first_tg_slug, workflow=first_wf)
wf_factories.TaskGroupTaskFactory(task_group=first_task_group)
second_wf_slug = "WORKFLOW-2"
# create second workflow
wf_factories.WorkflowFactory(slug=second_wf_slug)
# second tg has slug equals to the slug of the first tg
second_tg_data = collections.OrderedDict([
("object_type", all_models.TaskGroup.__name__),
("code", first_tg_slug), ("workflow", second_wf_slug)
])
response = self.import_data(second_tg_data)
expected_error = (u"Line 3: TaskGroup '%s' already "
u"exists in the system and mapped "
u"to another workflow. Please, "
u"use different code for this TaskGroup" %
first_tg_slug)
self.assertEquals([expected_error], response[0]['row_errors'])
first_wf = db.session.query(models.Workflow).filter(
models.Workflow.slug == first_wf_slug).one()
second_wf = db.session.query(models.Workflow).filter(
models.Workflow.slug == second_wf_slug).one()
self.assertEqual(
db.session.query(models.TaskGroup).filter(
models.TaskGroup.workflow_id == first_wf.id).count(), 1)
self.assertEqual(
db.session.query(models.TaskGroup).filter(
models.TaskGroup.workflow_id == second_wf.id).count(), 0)
def test_recurring_wf_future_start_date(self, setup_date, freeze_date,
repeat_every, unit):
"""Test case for 0 number of cycles for future setup date"""
with freeze_time(freeze_date):
with factories.single_commit():
workflow = wf_factories.WorkflowFactory(
repeat_every=repeat_every, unit=unit)
group = wf_factories.TaskGroupFactory(workflow=workflow)
wf_factories.TaskGroupTaskFactory(task_group=group,
start_date=setup_date,
end_date=setup_date +
dtm.timedelta(days=4))
self.generator.activate_workflow(workflow)
active_wf = db.session.query(Workflow).filter(
Workflow.status == 'Active').one()
# no cycles should be generated:
self.assertEqual(len(active_wf.cycles), 0)
def _generate_workflows(approved, obj_num):
"""Generate workflows with appropriate data for tests"""
generator = wf_generator.WorkflowsGenerator()
with factories.single_commit():
workflows = [wf_factories.WorkflowFactory(object_approval=approved[i])
for i in range(obj_num)]
taskgroups = [wf_factories.TaskGroupFactory(workflow=workflows[i])
for i in range(obj_num)]
# flake8: noqa pylint: disable=unused-variable
tasks = [wf_factories.TaskGroupTaskFactory(task_group=taskgroups[i])
for i in range(obj_num)]
cycles = [generator.generate_cycle(workflows[i])[1].id
for i in range(obj_num)]
for workflow in workflows:
generator.activate_workflow(workflow)
return cycles
def test_one_time_wf_start_date_shifting(self, expected, setup_date):
"""Test case for correct cycle task start_ dates for one_time wf"""
with factories.single_commit():
workflow = wf_factories.WorkflowFactory()
group = wf_factories.TaskGroupFactory(workflow=workflow)
wf_factories.TaskGroupTaskFactory(task_group=group,
start_date=setup_date,
end_date=setup_date +
dtm.timedelta(days=4))
self.generator.generate_cycle(workflow)
self.generator.activate_workflow(workflow)
active_wf = db.session.query(Workflow).filter(
Workflow.status == 'Active').one()
self.assertEqual(
1, len(active_wf.cycles[0].cycle_task_group_object_tasks))
cycle_task = active_wf.cycles[0].cycle_task_group_object_tasks[0]
adj_start_date = cycle_task.start_date
self.assertEqual(expected, adj_start_date)
def test_build_cycle_without_admin(self, logger):
"""Build Cycle without Workflow Admin."""
workflow_setup_data = {
"WORKFLOW_WITHOUT_ADMIN": tuple(),
"WORKFLOW_WITH_ADMIN": (rbac_helper.GA_RNAME, )
}
with freezegun.freeze_time(datetime.date(2017, 9, 25)):
for slug, wfa_g_rnames in workflow_setup_data.iteritems():
with factories.single_commit():
workflow = self.setup_helper.setup_workflow(
wfa_g_rnames,
slug=slug,
repeat_every=1,
unit=all_models.Workflow.MONTH_UNIT,
)
task_group = wf_factories.TaskGroupFactory(
workflow=workflow)
wf_factories.TaskGroupTaskFactory(
task_group=task_group,
start_date=datetime.date(2017, 9, 26),
end_date=datetime.date(2017, 9, 30),
)
self.api_helper.put(
workflow, {
"status":
"Active",
"recurrences":
bool(workflow.repeat_every and workflow.unit)
})
with freezegun.freeze_time(datetime.date(2017, 10, 25)):
start_recurring_cycles()
workflow_without_admin = all_models.Workflow.query.filter_by(
slug="WORKFLOW_WITHOUT_ADMIN").one()
self.assertEqual(len(workflow_without_admin.cycles), 0)
logger.error.assert_called_once_with(
"Cannot start cycle on Workflow with slug == '%s' and id == '%s', "
"cause it doesn't have Admins", workflow_without_admin.slug,
workflow_without_admin.id)
workflow_with_admin = all_models.Workflow.query.filter_by(
slug="WORKFLOW_WITH_ADMIN").one()
self.assertEqual(len(workflow_with_admin.cycles), 1)
def test_recurring_wf_start_date_shifting(self, expected, setup_date,
freeze_date, repeat_every, unit):
"""Test case for correct next cycle task start_date for recurring wf"""
with freeze_time(freeze_date):
with factories.single_commit():
workflow = wf_factories.WorkflowFactory(
repeat_every=repeat_every, unit=unit)
group = wf_factories.TaskGroupFactory(workflow=workflow)
wf_factories.TaskGroupTaskFactory(task_group=group,
start_date=setup_date,
end_date=setup_date +
dtm.timedelta(days=4))
self.generator.activate_workflow(workflow)
active_wf = db.session.query(Workflow).filter(
Workflow.status == 'Active').one()
cycle_task = active_wf.cycles[1].cycle_task_group_object_tasks[0]
adj_start_date = cycle_task.start_date
self.assertEqual(expected, adj_start_date)
def test_import_change_task_date(self, start_date, end_date,
expected_errors):
"""Tests import can't change start/end from weekdays to weekends."""
wf_factories.TaskGroupTaskFactory(
task_group=self.task_group,
start_date=datetime.date(2018, 7, 10),
end_date=datetime.date(2018, 7, 17),
)
task_group_task_before = db.session.query(models.TaskGroupTask).one()
start_date_before = task_group_task_before.start_date
end_date_before = task_group_task_before.end_date
tgt_import_data = collections.OrderedDict([
("object_type", "Task Group Task"),
("code", task_group_task_before.slug),
("task type", "Rich Text"),
("task group", self.task_group.slug),
("summary", "Task group test task 1"),
("start date", start_date),
("end date", end_date),
("task assignees", self.person.email),
])
response = self.import_data(tgt_import_data)
task_group_task_after = db.session.query(models.TaskGroupTask).one()
start_date_after = task_group_task_after.start_date
end_date_after = task_group_task_after.end_date
expected_messages = {
"Task Group Task": {
"row_errors": expected_errors,
}
}
self._check_csv_response(response, expected_messages)
self.assertEquals(start_date_before, start_date_after)
self.assertEquals(end_date_before, end_date_after)
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 test_recalculate_date_not_started(self):
"""Changing start_date on notstarted workflow will
not affect next_cycle_start_date"""
setup_start_date = dtm.date(2017, 1, 15)
update_start_date = dtm.date(2017, 1, 1)
with freeze_time(dtm.date(2017, 8, 15)):
with factories.single_commit():
workflow = wf_factories.WorkflowFactory(repeat_every=1,
status=Workflow.DRAFT,
unit=Workflow.MONTH_UNIT)
group = wf_factories.TaskGroupFactory(workflow=workflow)
task_id = wf_factories.TaskGroupTaskFactory(
task_group=group,
start_date=setup_start_date,
end_date=setup_start_date + dtm.timedelta(days=4)).id
workflow_id = workflow.id
self.api.put(TaskGroupTask.query.get(task_id),
{"start_date": update_start_date,
"end_date": update_start_date + dtm.timedelta(4)})
self.assertIsNone(Workflow.query.get(workflow_id).next_cycle_start_date)
def test_recalculate_start_date(self, today, start_date, update_date,
expected_date):
with freezegun.freeze_time(today):
with glob_factories.single_commit():
workflow = factories.WorkflowFactory(
title="This is a test WF",
unit=all_models.Workflow.WEEK_UNIT,
repeat_every=1)
task_group = factories.TaskGroupFactory(workflow=workflow)
task = factories.TaskGroupTaskFactory(task_group=task_group,
start_date=start_date,
end_date=start_date +
datetime.timedelta(1))
wf_id = workflow.id
task_id = task.id
self.generator.activate_workflow(workflow)
task = all_models.TaskGroupTask.query.get(task_id)
self.api.put(task, {"start_date": update_date})
workflow = all_models.Workflow.query.get(wf_id)
self.assertEqual(expected_date, workflow.next_cycle_start_date)
def test_create_with_mapped_object(self, model_name):
"""Test cycle creation with mapped {0}."""
with factories.single_commit():
mapped_object = factories.get_model_factory(model_name)()
task_group = wf_factories.TaskGroupFactory()
wf_factories.TaskGroupTaskFactory(task_group=task_group)
wf_factories.TaskGroupObjectFactory(task_group=task_group,
object=mapped_object)
mapped_object_id = mapped_object.id
data = workflow_api.get_cycle_post_dict(task_group.workflow)
response = self.api_helper.post(all_models.Cycle, data)
self.assertEquals(response.status_code, 201)
cycle_id = response.json.get("cycle", {}).get("id")
cycle = all_models.Cycle.query.filter_by(id=cycle_id).first()
obj = cycle.cycle_task_groups[0].task_group.task_group_objects[
0].object
self.assertEquals(obj.id, mapped_object_id)
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 test_change_verification_flag_positive(self, title, unit,
repeat_every):
with freezegun.freeze_time("2017-08-10"):
with glob_factories.single_commit():
workflow = factories.WorkflowFactory(title=title,
unit=unit,
repeat_every=repeat_every)
factories.TaskGroupTaskFactory(
task_group=factories.TaskGroupFactory(
workflow=workflow,
context=glob_factories.ContextFactory()),
start_date=datetime.date(2017, 8, 3),
end_date=datetime.date(2017, 8, 7))
wf_id = workflow.id
workflow = all_models.Workflow.query.get(wf_id)
verif_default = all_models.Workflow.IS_VERIFICATION_NEEDED_DEFAULT
self.assertIs(workflow.is_verification_needed, verif_default)
self.generator.modify_object(
workflow, {'is_verification_needed': not verif_default})
workflow = all_models.Workflow.query.get(wf_id)
self.assertIs(workflow.is_verification_needed, not verif_default)
def test_recurring_wf_start_date_and_cycles(self, setup_date, freeze_date,
repeat_every, unit):
"""Test case for correct cycle start date and number of cycles"""
with freeze_time(freeze_date):
with factories.single_commit():
workflow = wf_factories.WorkflowFactory(
repeat_every=repeat_every, unit=unit)
group = wf_factories.TaskGroupFactory(workflow=workflow)
wf_factories.TaskGroupTaskFactory(task_group=group,
start_date=setup_date,
end_date=setup_date +
dtm.timedelta(days=4))
self.generator.activate_workflow(workflow)
active_wf = db.session.query(Workflow).filter(
Workflow.status == 'Active').one()
# freeze_date is chosen so that we expect 3 cycles to be generated:
self.assertEqual(len(active_wf.cycles), 3)
cycle_task = active_wf.cycles[0].cycle_task_group_object_tasks[0]
adj_start_date = cycle_task.start_date
self.assertEqual(setup_date, adj_start_date)
def test_create_with_mapped_object(self, model_name):
"""Test cycle creation with mapped {0}."""
with factories.single_commit():
mapped_object = factories.get_model_factory(model_name)()
task_group = wf_factories.TaskGroupFactory()
wf_factories.TaskGroupTaskFactory(task_group=task_group)
factories.RelationshipFactory(source=task_group,
destination=mapped_object)
mapped_object_id = mapped_object.id
data = workflow_api.get_cycle_post_dict(task_group.workflow)
response = self.api_helper.post(all_models.Cycle, data)
self.assertEquals(response.status_code, 201)
cycle_id = response.json.get("cycle", {}).get("id")
cycle = all_models.Cycle.query.filter_by(id=cycle_id).first()
mapped_objs = filter(
lambda obj: obj.__class__.__name__ == model_name,
cycle.cycle_task_groups[0].task_group.related_objects())
obj_id = mapped_objs.pop().id
self.assertEquals(obj_id, mapped_object_id)
def test_recalculate_date(self,
setup_start_date,
update_start_date,
expected_date):
"""Recalculate next cycle start date"""
with freeze_time(dtm.date(2017, 8, 15)):
with factories.single_commit():
workflow = wf_factories.WorkflowFactory(repeat_every=1,
status=Workflow.DRAFT,
unit=Workflow.MONTH_UNIT)
group = wf_factories.TaskGroupFactory(workflow=workflow)
task_id = wf_factories.TaskGroupTaskFactory(
task_group=group,
start_date=setup_start_date,
end_date=setup_start_date + dtm.timedelta(days=4)).id
self.generator.activate_workflow(workflow)
self.api.put(TaskGroupTask.query.get(task_id),
{"start_date": update_start_date,
"end_date": update_start_date + dtm.timedelta(4)})
active_wf = db.session.query(Workflow).filter(
Workflow.status == 'Active').one()
self.assertEqual(expected_date, active_wf.next_cycle_start_date)
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.CycleTaskFactory(
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"])
