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, 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_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_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_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_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_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_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 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 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_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_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_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_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 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_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_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 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)
