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)