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"])