def test_task_group_import_objects(self, model_name, is_mapped): """"Test import TaskGroup with mapping to object: {0}""" wf_slug = "WORKFLOW-1" tg_slug = "TASKGROUP-1" mapped_slug = "MAPPEDOBJECT-1" with factories.single_commit(): factories.get_model_factory(model_name)(slug=mapped_slug) workflow = wf_factories.WorkflowFactory(slug=wf_slug) wf_factories.TaskGroupFactory(slug=tg_slug, workflow=workflow) tg_data = collections.OrderedDict([ ("object_type", all_models.TaskGroup.__name__), ("code", tg_slug), ("workflow", wf_slug), ("objects", "{}: {}".format(model_name, mapped_slug)) ]) result = self.import_data(tg_data) task_group = all_models.TaskGroup.query.one() if is_mapped: self.assertEqual(len(task_group.task_group_objects), 1) self.assertEqual(task_group.task_group_objects[0].object.slug, mapped_slug) self.assertEqual(len(result[0]['row_warnings']), 0) else: self.assertEqual(len(task_group.task_group_objects), 0) self.assertEqual(len(result[0]['row_warnings']), 1) self.assertEqual( result[0]['row_warnings'][0], errors.INVALID_TASKGROUP_MAPPING_WARNING.format( line=3, object_class=model_name ) )
def test_with_snapshots_query_count(self, model_name, snapshot_models, query_limit): """Test query count during export of {0} with mapped {1} snapshots.""" with factories.single_commit(): audit = factories.AuditFactory() snap_objects = [] for snap_model in snapshot_models: snap_objects.append(factories.get_model_factory(snap_model)()) snapshots = self._create_snapshots(audit, snap_objects) model_factory = factories.get_model_factory(model_name) for _ in range(3): obj = model_factory(audit=audit) for snapshot in snapshots: factories.RelationshipFactory(source=obj, destination=snapshot) data = [{ "object_name": model_name, "filters": { "expression": {}, }, "fields": "all", }] with utils.QueryCounter() as counter: response = self.export_parsed_csv(data) self.assertNotEqual(counter.get, 0) self.assertLessEqual(counter.get, query_limit) self.assertEqual(len(response[model_name]), 3)
def test_task_group_import_objects(self, model_name, header_name, is_mapped): """"Tests import TaskGroup with mapping to object: {0}.""" mapped_slug = "MAPPEDOBJECT-1" with factories.single_commit(): factories.get_model_factory(model_name)(slug=mapped_slug) tg_data = collections.OrderedDict([ ("object_type", all_models.TaskGroup.__name__), ("code", self.TG_SLUG), ("workflow", self.WF_SLUG), ("map:{}".format(header_name), "{}".format(mapped_slug)) ]) result = self.import_data(tg_data) task_group = all_models.TaskGroup.query.one() mapped_objs = filter(lambda obj: obj.__class__.__name__ == model_name, task_group.related_objects()) if is_mapped: self.assertEqual(len(mapped_objs), 1) self.assertEqual(mapped_objs.pop().slug, mapped_slug) self.assertEqual(len(result[0]['row_warnings']), 0) else: self.assertEqual(len(mapped_objs), 0) self.assertEqual(len(result[0]['block_warnings']), 1) self.assertEqual( result[0]['block_warnings'][0], errors.UNSUPPORTED_MAPPING.format( line=2, obj_a="Task Group", obj_b=header_name, column_name="map:{}".format(header_name) ) )
def test_clone_status(self, model, code, _): """Test response status on clonning operation""" factories.get_model_factory(model.__name__)() response = self.api.send_request(self.api.client.post, data=[{}], api_link="/api/{}/clone".format( model._inflector.table_singular)) self.assertEqual(response.status_code, code)
def test_clone_status(self, model, code, _): """Test response status on clonning operation""" factories.get_model_factory(model.__name__)() response = self.api.send_request( self.api.client.post, data=[{}], api_link="/api/{}/clone".format(model._inflector.table_singular) ) self.assertEqual(response.status_code, code)
def test_obj_mapped_similar(self, obj_types, asmnt_types, similar): """Test similar assessments for mapped objects of same type.""" with factories.single_commit(): obj1 = get_model_factory(obj_types[0])() obj2 = get_model_factory(obj_types[1])() factories.RelationshipFactory(source=obj1, destination=obj2) audit = factories.AuditFactory() assessment1 = factories.AssessmentFactory( audit=audit, assessment_type=asmnt_types[0]) assessment2 = factories.AssessmentFactory( audit=audit, assessment_type=asmnt_types[1]) assessment_ids = [assessment1.id, assessment2.id] snapshots = self._create_snapshots(audit, [obj1, obj2]) factories.RelationshipFactory(source=audit, destination=assessment1) factories.RelationshipFactory(source=audit, destination=assessment2) factories.RelationshipFactory(source=audit, destination=snapshots[0]) factories.RelationshipFactory(source=audit, destination=snapshots[1]) factories.RelationshipFactory(source=snapshots[0], destination=assessment1) factories.RelationshipFactory(source=snapshots[1], destination=assessment2) # Check related assessments for first object query = [{ "object_name": "Assessment", "type": "ids", "filters": { "expression": { "op": { "name": "similar" }, "object_name": obj_types[0], "ids": [obj1.id], }, }, }] response = self.client.post( "/query", data=json.dumps(query), headers={"Content-Type": "application/json"}, ) self.assertStatus(response, 200) expected_ids = [ assessment_ids[num] for num, _ in enumerate(assessment_ids) if similar[num] ] self.assertListEqual(response.json[0]["Assessment"]["ids"], expected_ids)
def test_obj_mapped_similar(self, obj_types, asmnt_types, similar): """Test similar assessments for mapped objects of same type.""" with factories.single_commit(): obj1 = get_model_factory(obj_types[0])() obj2 = get_model_factory(obj_types[1])() factories.RelationshipFactory(source=obj1, destination=obj2) audit = factories.AuditFactory() assessment1 = factories.AssessmentFactory( audit=audit, assessment_type=asmnt_types[0] ) assessment2 = factories.AssessmentFactory( audit=audit, assessment_type=asmnt_types[1] ) assessment_ids = [assessment1.id, assessment2.id] snapshots = self._create_snapshots(audit, [obj1, obj2]) factories.RelationshipFactory(source=audit, destination=assessment1) factories.RelationshipFactory(source=audit, destination=assessment2) factories.RelationshipFactory(source=audit, destination=snapshots[0]) factories.RelationshipFactory(source=audit, destination=snapshots[1]) factories.RelationshipFactory( source=snapshots[0], destination=assessment1 ) factories.RelationshipFactory( source=snapshots[1], destination=assessment2 ) # Check related assessments for first object query = [{ "object_name": "Assessment", "type": "ids", "filters": { "expression": { "op": {"name": "similar"}, "object_name": obj_types[0], "ids": [obj1.id], }, }, }] response = self.client.post( "/query", data=json.dumps(query), headers={"Content-Type": "application/json"}, ) self.assertStatus(response, 200) expected_ids = [ assessment_ids[num] for num, _ in enumerate(assessment_ids) if similar[num] ] self.assertListEqual(response.json[0]["Assessment"]["ids"], expected_ids)
def test_query_total(self, model_name): """Test corresponding value of 'total' field.""" number_of_objects = 2 object_factory = factories.get_model_factory(model_name) object_class = models.get_model(model_name) total_before_creation = object_class.query.count() with factories.single_commit(): object_ids = [object_factory().id for _ in range(number_of_objects)] # Check that objects has been created correctly. created_objects_count = object_class.query.filter( object_class.id.in_(object_ids) ).count() self.assertEqual(created_objects_count, number_of_objects) data = [{ "object_name": model_name, "filters": {"expression": {}}, "limit": [0, 10], "order_by": [{"name": "updated_at", "desc": True}] }] # Check corresponding value of 'total' field. result = self._get_first_result_set(data, model_name, "total") self.assertEqual(number_of_objects, result - total_before_creation)
def multiple_setup_is_empty(self, model_name, field, persons, operator="is empty"): """Setup multiple entry for is_empty operation""" obj_factory = self.get_factory(model_name) objects = [] for num, _ in enumerate(persons): # Don't set searchable field for several objects, they should be empty if num >= MULTIPLE_ITEMS_COUNT: obj = obj_factory( **FIELD_SETTERS[field](model_name, persons[num])) else: obj = factories.get_model_factory(model_name)() db.session.add( SetupData(model=model_name, operator=operator, field=field, single=False, obj_id=obj.id, searchable_id=persons[num].id, searchable_type=persons[num].type)) objects.append(obj) return objects
def test_review_posted(self, model, send_email_mock): """Test mentions in request review comment {}.""" with factories.single_commit(): factories.PersonFactory(email="*****@*****.**") obj = factories.get_model_factory(model.__name__)() url = urljoin(get_url_root(), utils.view_url_for(obj)) with freeze_time("2018-01-10 07:31:42"): resp, _ = generate_review_object( obj, email_message= u"Test <a href=\"mailto:[email protected]\"></a>", ) self.assertEqual(201, resp.status_code) expected_title = (u"[email protected] mentioned you on " u"a comment within {title}").format(title=obj.title) expected_body = ( u"[email protected] mentioned you on a comment within {title} " u"at 01/09/2018 23:31:42 PST:\n" u"<p>Review requested from</p>" u"<p>[email protected]</p>" u"<p>with a comment:" u" Test <a href=\"mailto:[email protected]\"></a></p>\n" ).format(title=obj.title) 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_comment_bulk_update(self, model, comments, update_mock): """Test bulk comment's update requests are sent correctly""" with factories.single_commit(): factory = factories.get_model_factory(model) obj = factory() factories.IssueTrackerIssueFactory( enabled=True, issue_tracked_obj=obj, issue_id=123, ) request_data = { "comments": [ {"type": obj.type, "id": obj.id, "comment_description": comment} for comment in comments ], "mail_data": {"user_email": "*****@*****.**"}, } updater = issuetracker_bulk_sync.IssueTrackerCommentUpdater() result = updater.sync_issuetracker(request_data) builder = issue_tracker_params_builder.IssueParamsBuilder template = builder.COMMENT_TMPL url_builder = builder.get_ggrc_object_url self.assert200(result) # pylint: disable=consider-using-enumerate for i in range(len(comments)): self.assertEqual(update_mock.call_args_list[i][0][0], 123) self.assertEqual( update_mock.call_args_list[i][0][1]["comment"], template.format(author="*****@*****.**", model=model, comment=comments[i], link=url_builder(obj)) )
def test_post_readonly_relationship(self, restricted_model, factory_args): """Test post mapping to readonly object is forbidden""" with factories.single_commit(): user = self.generate_person() restricted_obj = factories.get_model_factory(restricted_model)( **factory_args) self.assign_person(restricted_obj, "Admin", user.id) obj_id, obj_type = restricted_obj.id, restricted_obj.type assessment = factories.AssessmentFactory(sox_302_enabled=True) self.assign_person(assessment, "Assignees", user.id) assessment_id = assessment.id self.set_current_person(user) response = self.api.post( all_models.Relationship, { "relationship": { "source": { "id": assessment_id, "type": "Assessment" }, "destination": { "id": obj_id, "type": obj_type }, "context": None }, }) self.assert403(response) self.assertEqual(response.json, 'Mapping of this objects is not allowed')
def test_issue_export(self, model_name): """Test export for issuetracked attributes. Attribute list: component_id, hotlist_id, issue_type, issue_priority, issue_severity""" factory = factories.get_model_factory(model_name) with factories.single_commit(): factories.IssueTrackerIssueFactory( issue_tracked_obj=factory(), component_id=12345, hotlist_id=54321, issue_type="PROCESS", issue_severity="S4", issue_priority="P4", enabled=True ) data = [{"object_name": model_name, "fields": "all", "filters": {"expression": {}}}] response = self.export_csv(data) self.assertEqual(response.status_code, 200) self.assertIn("Component ID", response.data) self.assertIn("12345", response.data) self.assertIn("Hotlist ID", response.data) self.assertIn("54321", response.data) self.assertIn("Issue Type", response.data) self.assertIn("PROCESS", response.data) self.assertIn("Priority", response.data) self.assertIn("P4", response.data) self.assertIn("Severity", response.data) self.assertIn("S4", response.data) self.assertIn("on", response.data)
def test_get_issue_json(self, model): """Test get_issue_json method issue's update""" with factories.single_commit(): factory = factories.get_model_factory(model) obj = factory() factories.IssueTrackerIssueFactory( enabled=True, issue_tracked_obj=obj, title='title', component_id=111, hotlist_id=222, issue_type="PROCESS", issue_priority="P2", issue_severity="S2", ) expected_result = { 'component_id': 111, 'severity': u'S2', 'title': u'title', 'hotlist_ids': [222], 'priority': u'P2', 'type': u'PROCESS' } updater = issuetracker_bulk_sync.IssueTrackerBulkUpdater() # pylint: disable=protected-access result = updater._get_issue_json(obj) self.assertEqual(expected_result, result)
def test_sort_by_deprecated_date(self): """Test sorting results of filter cycle tasks by deprecated date.""" dict_of_dates = {} date_list = ["2017-01-25", "2017-01-29", "2017-01-02", "2017-01-26"] cycle_task_factory = factories.get_model_factory( "CycleTaskGroupObjectTask") with factories.single_commit(): for date in date_list: with freeze_time(date): dict_of_dates[cycle_task_factory(status="Deprecated").id] = date sorted_dict = sorted(dict_of_dates.items(), key=operator.itemgetter(1)) sorted_list_ids = [item[0] for item in sorted_dict] query_request_data = [{ "object_name": "CycleTaskGroupObjectTask", 'filters': { 'expression': { 'left': 'task Last Deprecated Date', 'op': {'name': '='}, 'right': "2017-01", }, }, "order_by": [{"name": "last_deprecated_date"}], 'type': 'ids', }] result = self.api.send_request(self.api.client.post, data=query_request_data, api_link="/query") self.assertItemsEqual(sorted_list_ids, result.json[0]["CycleTaskGroupObjectTask"]["ids"])
def setup_models(self, parent_name): """Setup document, parent, relationship""" with factories.single_commit(): self.parent = get_model_factory(parent_name)() self.parent_id = self.parent.id self.parent_name = parent_name self.assign_person(self.parent, self.acr, self.user_id)
def test_filter_by_deprecated_date(self): """Test filter cycle task by last deprecated date.""" amount_of_cycle_tasks = 5 list_of_ids = [] cycle_task_factory = factories.get_model_factory( "CycleTaskGroupObjectTask") with factories.single_commit(): with freeze_time("2017-01-25"): for _ in range(amount_of_cycle_tasks): list_of_ids.append( cycle_task_factory(status="Deprecated").id ) query_request_data = [{ "object_name": "CycleTaskGroupObjectTask", 'filters': { 'expression': { 'left': 'task Last Deprecated Date', 'op': {'name': '='}, 'right': "2017-01-25", }, }, 'type': 'ids', }] result = self.api.send_request(self.api.client.post, data=query_request_data, api_link="/query") self.assertItemsEqual(list_of_ids, result.json[0]["CycleTaskGroupObjectTask"]["ids"])
def test_remove_folder(self, curr_folder, set_obj_type, set_obj_id, new_folder, expected_code, expected_rev_cnt): """Test remove_folder('{0}', '{1}', '{2}', '{3}')""" # pylint: disable=too-many-arguments obj_list = list() with factories.single_commit(): for model_name in self.FOLDERABLE_MODEL_NAMES: obj_id = factories.get_model_factory(model_name)( folder=curr_folder).id obj_list.append((model_name, obj_id)) self.api.login_as_normal() for obj_type, obj_id in obj_list: request_data = self._get_request_data( obj_type=obj_type if set_obj_type else self.NOT_PRESENT, obj_id=obj_id if set_obj_id else self.NOT_PRESENT, folder=new_folder, ) response = self.api.client.post(self.PATH_REMOVE_FOLDER, content_type="application/json", data=request_data) self.assertStatus(response, expected_code) count = all_models.Revision.query.filter( all_models.Revision.resource_type == obj_type, all_models.Revision.resource_id == obj_id).count() self.assertEqual(count, expected_rev_cnt)
def test_remove_folder(self, curr_folder, set_obj_type, set_obj_id, new_folder, expected_code, expected_rev_cnt): """Test remove_folder('{0}', '{1}', '{2}', '{3}')""" # pylint: disable=too-many-arguments obj_list = list() with factories.single_commit(): for model_name in self.FOLDERABLE_MODEL_NAMES: obj_id = factories.get_model_factory(model_name)(folder=curr_folder).id obj_list.append((model_name, obj_id)) self.api.login_as_normal() for obj_type, obj_id in obj_list: request_data = self._get_request_data( obj_type=obj_type if set_obj_type else self.NOT_PRESENT, obj_id=obj_id if set_obj_id else self.NOT_PRESENT, folder=new_folder, ) response = self.api.client.post( self.PATH_REMOVE_FOLDER, content_type="application/json", data=request_data) self.assertStatus(response, expected_code) count = all_models.Revision.query.filter( all_models.Revision.resource_type == obj_type, all_models.Revision.resource_id == obj_id ).count() self.assertEqual(count, expected_rev_cnt)
def test_audit_mapping_to_snapshots(self): """Test that all object types snapshots are mapped to an audit""" model_object_ids = {} with factories.single_commit(): program = factories.ProgramFactory(title="Test Program") for model_type in Types.all - Types.external: model_factory = factories.get_model_factory(model_type) model_object = model_factory( title="Test Snapshot - {}".format(model_type)) factories.RelationshipFactory(source=program, destination=model_object) model_object_ids[model_type] = model_object.id self.create_audit(program) audit = db.session.query(models.Audit).filter( models.Audit.title.like("%Snapshotable audit%")).first() snapshots = db.session.query(models.Snapshot).filter( models.Snapshot.parent_type == "Audit", models.Snapshot.parent_id == audit.id, ) self.assertEqual(snapshots.count(), len(Types.all - Types.external)) all_snapshots_correct = all( s.child_id == model_object_ids[s.child_type] for s in snapshots) self.assertTrue(all_snapshots_correct)
def test_query_count(self, model): """Test count of queries on HEAD request processing for {}""" obj_id = factories.get_model_factory(model.__name__)().id with utils.QueryCounter() as counter: response = self.api.head(model, obj_id) self.assert200(response) self.assertEqual(counter.get, 3)
def test_snapshot_update_is_idempotent(self, model_type): """Test that nothing has changed if there's nothing to update""" with factories.single_commit(): program = factories.ProgramFactory(title="Test Program") model_factory = factories.get_model_factory(model_type) model_object = model_factory( title="Test Snapshot - {}".format(model_type)) factories.RelationshipFactory(source=program, destination=model_object) self.create_audit(program) audit = db.session.query(models.Audit).filter( models.Audit.title == "Snapshotable audit").one() snapshots = db.session.query(models.Snapshot).filter( models.Snapshot.parent_type == "Audit", models.Snapshot.parent_id == audit.id, ) audit = self.refresh_object(audit) self.api.modify_object(audit, {"snapshots": {"operation": "upsert"}}) old_snapshots = {s.id: s for s in snapshots} snapshots = db.session.query(models.Snapshot).filter( models.Snapshot.parent_type == "Audit", models.Snapshot.parent_id == audit.id, ) new_snapshots = {s.id: s for s in snapshots} for _id, snapshot in new_snapshots.items(): self.assertEqual(snapshot_identity(old_snapshots[_id], snapshot), True)
def test_map_nonsnapshotable(self, nonsnapshotable): """Map '{}' shouldn't change review status""" control = factories.ControlFactory() _, review = self.generator.generate_object( all_models.Review, { "reviewable": { "type": control.type, "id": control.id, }, "context": None, "status": all_models.Review.STATES.REVIEWED, "access_control_list": build_reviewer_acl(), "notification_type": all_models.Review.NotificationTypes.EMAIL_TYPE }, ) review_id = review.id review = all_models.Review.query.get(review_id) self.assertEqual(review.status, all_models.Review.STATES.REVIEWED) self.generator.generate_relationship( source=control, destination=factories.get_model_factory(nonsnapshotable)(), context=None, ) review = all_models.Review.query.get(review_id) self.assertEqual(review.status, all_models.Review.STATES.REVIEWED)
def test_repeat_deprecated_state(self): """Test updating of last deprecated date by multiply changing of status.""" cycle_task = factories.get_model_factory("CycleTaskGroupObjectTask")() with freeze_time("2017-01-25"): self.api.modify_object(cycle_task, { "status": "Deprecated" }) with freeze_time("2017-01-26"): self.api.modify_object(cycle_task, { "status": "Finished" }) with freeze_time("2017-02-25"): self.api.modify_object(cycle_task, { "status": "Deprecated" }) with freeze_time("2017-02-26"): self.api.modify_object(cycle_task, { "status": "Finished" }) cycle_task_result = all_models.CycleTaskGroupObjectTask.query.filter( all_models.CycleTaskGroupObjectTask.id == cycle_task.id ).one() self.assertEquals(cycle_task_result.status, "Finished") self.assertEquals(cycle_task_result.last_deprecated_date, datetime.date(2017, 2, 25))
def test_reindex_cad_edit(self, definition_type, attribute_type, value): """Test reindex after CAD editing""" model_name = cad.get_inflector_model_name_dict()[definition_type] model_id = factories.get_model_factory(model_name)().id expected = [model_id] title = "test_title %s %s" % (definition_type, attribute_type) cad_model = models.all_models.CustomAttributeDefinition response = self.api.post(cad_model, [ self._create_cad_body( title, attribute_type, definition_type, model_name ) ]) self.assert200(response) cad_obj = db.session.query(cad_model).filter_by(title=title).first() title_edited = "%s_edited" % title self.api.put(cad_obj, {"title": title_edited}) self.assert200(response) ids = self.simple_query( model_name, expression=[title_edited, "=", value], type_="ids", field="ids" ) self.assertItemsEqual(ids, expected)
def test_issue_export(self, model_name): """Test export for issuetracked attributes. Attribute list: component_id, hotlist_id, issue_type, issue_priority, issue_severity""" factory = factories.get_model_factory(model_name) with factories.single_commit(): factories.IssueTrackerIssueFactory( issue_tracked_obj=factory(), component_id=12345, hotlist_id=54321, issue_type="PROCESS", issue_severity="S4", issue_priority="P4", enabled=True ) data = [{"object_name": model_name, "fields": "all", "filters": {"expression": {}}}] response = self.export_csv(data) self.assertEqual(response.status_code, 200) self.assertIn("Component ID", response.data) self.assertIn("12345", response.data) self.assertIn("Hotlist ID", response.data) self.assertIn("54321", response.data) self.assertIn("Issue Type", response.data) self.assertIn("PROCESS", response.data) self.assertIn("Priority", response.data) self.assertIn("P4", response.data) self.assertIn("Severity", response.data) self.assertIn("S4", response.data) self.assertIn("true", response.data)
def get_factory(self, model_name): """Get object factory class for model""" # pylint: disable=no-self-use base_factory = factories.get_model_factory(model_name) # Modify base factory to have possibility to create ACL # and CA in one step return type(base_factory.__name__ + "WithACL_CA", (base_factory, factories.WithACLandCAFactory), {})
def test_head_etag(self, model): """Test correctness of HEAD request processing for {}""" obj = factories.get_model_factory(model.__name__)() response = self.api.head(model, obj.id) self.assert200(response) self.assertEqual(response.data, "") exp_etag = common.etag(getattr(obj, "updated_at"), common.get_info(obj)) self.assertEqual(response.headers.get("Etag"), exp_etag)
def test_export_audit_mappings(self): """Test export of audit mapped objects""" snap_objects = [] mapped_slugs = defaultdict(list) with factories.single_commit(): audit = factories.AuditFactory(slug="Audit") # Create a group of mapped objects for current audit for _ in range(3): # All snapshotable objects should be mapped to Audit + Issue # and Assessment for type_ in Types.all.union(Types.scoped): if type_ == "Issue": obj = get_model_factory(type_)() factories.RelationshipFactory(source=audit, destination=obj) elif type_ in Types.scoped: obj = get_model_factory(type_)(audit=audit) factories.RelationshipFactory(source=audit, destination=obj) else: obj = get_model_factory(type_)() mapped_slugs[type_].append(obj.slug) snap_objects.append(obj) self._create_snapshots(audit, snap_objects) audit_data = self.export_parsed_csv([{ "object_name": "Audit", "filters": { "expression": {} }, "fields": "all", }])["Audit"][0] for type_, slugs in mapped_slugs.items(): if type_ in Types.all: format_ = "map:{} versions" else: format_ = "map:{}" mapping_name = format_.format(utils.title_from_camelcase(type_)) self.assertIn(mapping_name, audit_data) self.assertEqual(audit_data[mapping_name], "\n".join(sorted(slugs)))
def get_factory(self, model_name): """Get object factory class for model""" # pylint: disable=no-self-use base_factory = factories.get_model_factory(model_name) # Modify base factory to have possibility to create ACL # and CA in one step return type( base_factory.__name__ + "WithACL_CA", (base_factory, factories.WithACLandCAFactory), {} )
def test_redefine_status(self): """Test cycle task create and change status to Deprecated.""" cycle_task = factories.get_model_factory("CycleTaskFactory")() with freeze_time("2017-01-25"): self.api.modify_object(cycle_task, {"status": "Deprecated"}) cycle_task_result = all_models.CycleTaskGroupObjectTask.query.filter( all_models.CycleTaskGroupObjectTask.id == cycle_task.id).one() self.assertEquals(cycle_task_result.last_deprecated_date, datetime.date(2017, 1, 25))
def setup_models(self, parent_name): """Setup Review, Reviewer""" self.parent = get_model_factory(parent_name)() self.parent_id = self.parent.id self.parent_name = parent_name if self.role_at_review: _, review = self.setup_review(self.acr.id, self.user_id) self.review_id = review.id else: _, review = self.setup_review() self.review_id = review.id self.assign_person(self.parent, self.acr, self.user_id)
def test_set_invalid_status(self, model_name): """Test returning 400 code for setting invalid status.""" factory = factories.get_model_factory(model_name) # pylint: disable=protected-access if issubclass(factory._meta.model, synchronizable.Synchronizable): self.api.login_as_external() obj = factory() invalid_status = u"Invalid status." response = self.api.put(obj, {u"status": invalid_status}) self.assert400(response)
def test_create_comment_post(self, model): """Test create review comment for {}.""" obj = factories.get_model_factory(model.__name__)() obj_id = obj.id self.assertEqual(0, len(obj.related_objects(_types=["Comment"]))) resp, _ = generate_review_object(obj, email_message="Test message") self.assertEqual(201, resp.status_code) obj = model.query.get(obj_id) comments = list(obj.related_objects(_types=["Comment"])) self.assertEqual(1, len(comments)) self.assertEqual( u"<p>Review requested from</p><p>[email protected]</p>" u"<p>with a comment: Test message</p>", comments[0].description)
def test_updated_at_in_operator(self, model_name): """Test updated_at field filters correctly with ~ and !~ operators""" expected_in_id = set() expected_not_in_id = set() with freeze_time("2018-05-20 12:23:17"): expected_in = factories.get_model_factory(model_name)() expected_in_id.add(expected_in.id) with freeze_time("2018-06-25 12:00:00"): expected_not_in = factories.get_model_factory(model_name)() expected_not_in_id.add(expected_not_in.id) response_in = self.simple_query( model_name, expression=["Last Updated Date", "~", "05/20/2018"], type_="ids", field="ids") response_not_in = self.simple_query( model_name, expression=["Last Updated Date", "!~", "2018-05-20"], type_="ids", field="ids") self.assertItemsEqual(expected_in_id, response_in) self.assertItemsEqual(expected_not_in_id, response_not_in)
def build_object(self, model): """Fill all fields in model""" errors = [] obj = factories.get_model_factory(model.__name__)() aliases = sorted(self._get_aliases(model)) for alias in aliases: if alias.startswith('__mapping__'): title = alias.split(':')[1] mapped_model = ''.join([part.title() for part in title.split()]) destination_obj = factories.get_model_factory(mapped_model)() self._map_object(source=obj, destination=destination_obj) elif alias.startswith('__snapshot_mapping__'): title = alias.split(':')[1] mapped_model = ''.join([part.title() for part in title.split()]) destination_obj = factories.get_model_factory(mapped_model)() self._map_snapshot(destination_obj, obj) elif alias.startswith('__acl__'): role = alias.split(':')[1] self._create_acl(role, obj, self.user) elif not alias.startswith('__'): try: self._set_field(alias, obj, self.user) except KeyError: errors.append(alias) else: continue db.session.commit() self.assertEqual(errors, [], 'These columns are not filled for model: {}. ' 'Need to add rule for these into ' 'FIELDS_FILLED_RULES'.format( ', '.join(errors))) return obj
def test_issue_relevant_direct(self, target_cls, relevant_cls, mapped_directly): """Relevant op with Issue as `relevant` returns only direct mappings.""" with factories.single_commit(): target = factories.get_model_factory(target_cls.__name__)() relevant = factories.get_model_factory(relevant_cls.__name__)() if mapped_directly: factories.RelationshipFactory( source=target, destination=relevant, ) else: revision = all_models.Revision.query.filter_by( resource_id=target.id, resource_type=target.type, ).first() snapshot = factories.SnapshotFactory( child_id=target.id, child_type=target.type, revision_id=revision.id, ) factories.RelationshipFactory( source=snapshot, destination=relevant, ) target_id = target.id result = self._get_first_result_set( self._make_relevant_filter( target_type=target.type, relevant_obj=relevant, ), target.type, "ids", ) self.assertEqual(result, [target_id] if mapped_directly else [])
def test_update_status(self, model_name): """Test status updating.""" obj = factories.get_model_factory(model_name)() object_name = obj._inflector.table_singular for status in obj.VALID_STATES: # Try to update status. response = self.api.put(obj, {u"status": status}) self.assert200(response) # Check that status has been updated. response = self.api.get(get_model(model_name), obj.id) self.assert200(response) new_status = response.json.get(object_name, {}).get("status") self.assertEqual(new_status, status)
def setup_models(self, parent_name): """Setup Review, Reviewer""" self.parent = get_model_factory(parent_name)() self.parent_id = self.parent.id self.parent_name = parent_name if self.role_at_review: _, review = self.setup_review(self.acr.id, self.user_id) self.review_id = review.id else: acr_id = self.acr.id _, review = self.setup_review() self.parent = self.parent.__class__.query.get(self.parent_id) self.acr = self.acr.__class__.query.get(acr_id) self.review_id = review.id self.assign_person(self.parent, self.acr, self.user_id)
def test_import_deprecated_status_again(self, model_name): """Last Deprecated Date on {} isn't changed when status not changed.""" with freeze_time("2017-01-25"): obj = factories.get_model_factory(model_name)(status="Deprecated") resp = self.import_data(collections.OrderedDict([ ("object_type", model_name), ("code", obj.slug), ("State", "Deprecated"), ])) self._check_csv_response(resp, {}) updated_obj = models.inflector.get_model(model_name).query.get(obj.id) self.assertEqual(updated_obj.last_deprecated_date, datetime.date(2017, 1, 25))
def test_updated_at_in_operator(self, model_name): """Test updated_at field filters correctly with ~ and !~ operators""" expected_in_id = set() expected_not_in_id = set() with freeze_time("2018-05-20 12:23:17"): expected_in = factories.get_model_factory(model_name)() expected_in_id.add(expected_in.id) with freeze_time("2018-06-25 12:00:00"): expected_not_in = factories.get_model_factory(model_name)() expected_not_in_id.add(expected_not_in.id) response_in = self.simple_query( model_name, expression=["Last Updated Date", "~", "05/20/2018"], type_="ids", field="ids" ) response_not_in = self.simple_query( model_name, expression=["Last Updated Date", "!~", "2018-05-20"], type_="ids", field="ids" ) self.assertItemsEqual(expected_in_id, response_in) self.assertItemsEqual(expected_not_in_id, response_not_in)
def test_update_protected_attribute(self, factory_name): """Test update of protected attribute.""" api = api_helper.Api() api.login_as_external() with factories.single_commit(): factory = factories.get_model_factory(factory_name) instance = factory(folder="correct_folder") instance_class = instance.__class__ response = api.put(instance, {"folder": "new_folder"}) self.assert200(response) instance = instance_class.query.get(instance.id) self.assertEqual("correct_folder", instance.folder)
def test_redefine_status(self): """Test cycle task create and change status to Deprecated.""" cycle_task = factories.get_model_factory("CycleTaskGroupObjectTask")() with freeze_time("2017-01-25"): self.api.modify_object(cycle_task, { "status": "Deprecated" }) cycle_task_result = all_models.CycleTaskGroupObjectTask.query.filter( all_models.CycleTaskGroupObjectTask.id == cycle_task.id ).one() self.assertEquals(cycle_task_result.last_deprecated_date, datetime.date(2017, 1, 25))
def test_import_deprecated_status(self, model_name): """If import {} with Deprecated status, set Last Deprecated Date to now.""" obj = factories.get_model_factory(model_name)() with freeze_time("2017-01-25"): resp = self.import_data(collections.OrderedDict([ ("object_type", model_name), ("code", obj.slug), ("State", "Deprecated"), ])) self._check_csv_response(resp, {}) updated_obj = models.inflector.get_model(model_name).query.get(obj.id) self.assertEqual(updated_obj.last_deprecated_date, datetime.date(2017, 1, 25))
def test_add_file_to_gdrive_folder(self, factory_name): """Test add document file to {0:22}gdrive folder""" mock_path = "ggrc.gdrive.file_actions.add_gdrive_file_folder" with mock.patch(mock_path) as g_drive: g_drive.return_value = "magic_response" with factories.single_commit(): factory = factories.get_model_factory(factory_name) instance = factory(folder="correct_folder") factories.DocumentFileFactory( source_gdrive_id="correct_file", parent_obj={ "id": instance.id, "type": instance.type, } ) g_drive.assert_called_with("correct_file", "correct_folder")
def test_issue_title_export(self, model_name): """Test export for issuetracked title attribute.""" factory = factories.get_model_factory(model_name) with factories.single_commit(): factories.IssueTrackerIssueFactory( issue_tracked_obj=factory(), title="tickettitle", ) data = [{"object_name": model_name, "fields": "all", "filters": {"expression": {}}}] response = self.export_csv(data) self.assertEqual(response.status_code, 200) self.assertIn("Ticket Title", response.data) self.assertIn("tickettitle", response.data)
def test_import_last_deprecated_date(self, model_name): """Last Deprecated Date on {} should be not importable.""" with freeze_time("2017-01-25"): obj = factories.get_model_factory(model_name)(status="Deprecated") resp = self.import_data(collections.OrderedDict([ ("object_type", model_name), ("code", obj.slug), ("Last Deprecated Date", "02/25/2017"), ])) self._check_csv_response(resp, { model_name: self.warning_non_importable, }) updated_obj = models.inflector.get_model(model_name).query.get(obj.id) self.assertEqual(updated_obj.last_deprecated_date, datetime.date(2017, 1, 25))
def test_map_snapshotable(self, snapshotable): """Map '{}' should change review status""" with factories.single_commit(): risk = factories.RiskFactory() review = factories.ReviewFactory( status=all_models.Review.STATES.REVIEWED, reviewable=risk ) review_id = review.id self.generator.generate_relationship( source=risk, destination=factories.get_model_factory(snapshotable)(), context=None, ) review = all_models.Review.query.get(review_id) self.assertEqual(review.status, all_models.Review.STATES.UNREVIEWED)
def test_import_invalid_date(self, model_name): """Invalid date in Last Deprecated Date is ignored in {} import.""" with freeze_time("2017-01-25"): obj = factories.get_model_factory(model_name)(title="test", status="Deprecated") resp = self.import_data(collections.OrderedDict([ ("object_type", model_name), ("code", obj.slug), ("title", "New title"), ("Last Deprecated Date", "0125/2017"), ])) expected_errors = { model_name: self.warning_non_importable, } self._check_csv_response(resp, expected_errors)