def test_preconditions_failed_with_several_mandatory_evidences(self):
"""No preconditions failed if evidences required by CAs are present"""
ca1 = CustomAttributeMock(self.assessment,
attribute_type="Dropdown",
dropdown_parameters=("foo,evidence_required",
"0,2"),
value="evidence_required")
ca2 = CustomAttributeMock(self.assessment,
attribute_type="Dropdown",
dropdown_parameters=("foo,evidence_required",
"0,2"),
value="evidence_required")
# only one evidence provided yet
evidence = factories.EvidenceFactory(title="Mandatory evidence", )
factories.RelationshipFactory(
source=self.assessment,
destination=evidence,
)
# the second evidence
evidence = factories.EvidenceFactory(
title="Second mandatory evidence", )
factories.RelationshipFactory(
source=self.assessment,
destination=evidence,
)
preconditions_failed = self.assessment.preconditions_failed
self.assertEqual(preconditions_failed, False)
self.assertFalse(ca1.value.preconditions_failed)
self.assertFalse(ca2.value.preconditions_failed)
def test_evidevce_type(self, _):
"""Test related evidences"""
audit = factories.AuditFactory()
evidence1 = factories.EvidenceFactory(title='Simple title1',
kind=all_models.Evidence.FILE,
source_gdrive_id='123',
parent_obj={
'id': audit.id,
'type': audit.type
})
factories.RelationshipFactory(source=audit, destination=evidence1)
evidence2 = factories.EvidenceFactory(title='Simple title2',
kind=all_models.Evidence.URL,
source_gdrive_id='123',
parent_obj={
'id': audit.id,
'type': audit.type
})
factories.RelationshipFactory(source=audit, destination=evidence2)
self.assertEqual(len(audit.evidences), 2)
self.assertEqual(len(audit.evidences_url), 1)
self.assertEqual(len(audit.evidences_file), 1)
def test_create_evidence_gdrive_type(self):
"""Test create evidence.FILE via POST"""
with factories.single_commit():
audit = factories.AuditFactory()
assessment = factories.AssessmentFactory(audit=audit)
evidence = factories.EvidenceFactory(
title='Simple title',
kind=all_models.Evidence.FILE,
description='mega description',
source_gdrive_id='gdrive_file_id',
parent_obj={
'id': assessment.id,
'type': 'Assessment'
}
)
result = all_models.Evidence.query.filter(
all_models.Evidence.id == evidence.id).one()
self.assertEqual(result.title, COPIED_TITLE)
self.assertEqual(result.kind, all_models.Evidence.FILE)
self.assertFalse(result.archived)
self.assertEqual(result.link, COPIED_LINK)
self.assertEqual(result.description, 'mega description')
self.assertEqual(result.source_gdrive_id, 'gdrive_file_id')
def test_preconditions_failed_with_missing_several_mandatory_evidences(self):
"""Preconditions failed if count(evidences) < count(evidences_required)."""
ca1 = CustomAttributeMock(
self.assessment,
attribute_type="Dropdown",
dropdown_parameters=("foo,evidence_required", "0,2"),
value="evidence_required"
)
ca2 = CustomAttributeMock(
self.assessment,
attribute_type="Dropdown",
dropdown_parameters=("foo,evidence_required", "0,2"),
value="evidence_required"
)
# only one evidence provided yet
evidence = factories.EvidenceFactory(
title="Mandatory evidence",
)
factories.RelationshipFactory(
source=self.assessment,
destination=evidence,
)
preconditions_failed = self.assessment.preconditions_failed
self.assertEqual(preconditions_failed, True)
self.assertEqual(ca1.value.preconditions_failed, ["evidence"])
self.assertEqual(ca2.value.preconditions_failed, ["evidence"])
def test_audit_role_propagation_edit(self, role):
"""Audit user with role '{0}' should be able to edit related evidence"""
_, reader = self.generator.generate_person(user_role="Reader")
assignees_role = all_models.AccessControlRole.query.filter_by(
object_type=all_models.Audit.__name__, name=role).first()
with factories.single_commit():
audit = factories.AuditFactory()
factories.AccessControlListFactory(ac_role=assignees_role,
object=audit,
person=reader)
evidence = factories.EvidenceFactory()
evidence_id = evidence.id
factories.RelationshipFactory(source=audit, destination=evidence)
self.api.set_user(reader)
evidence = all_models.Evidence.query.get(evidence_id)
new_description = 'new description'
resp = self.api.modify_object(evidence,
{'description': new_description})
evidence = self.refresh_object(evidence)
self.assert200(resp)
self.assertEquals(new_description, evidence.description)
self.assertEquals(reader.id, evidence.modified_by_id)
def test_put_all_affected_evidence(self, kind, attr_name):
"""Test put all affected of evidence data assessment status changed"""
expected_status = models.Assessment.PROGRESS_STATE
with factories.single_commit():
evidence = factories.EvidenceFactory(kind=kind)
evidence_id = evidence.id
factories.RelationshipFactory(destination=self.assessment,
source=evidence)
person_id = factories.PersonFactory().id
role_id = models.AccessControlRole.query.filter(
models.AccessControlRole.object_type == "Evidence",
models.AccessControlRole.name == 'Admin',
).one().id
self.api.put(
evidence, {
attr_name:
"test text",
"access_control_list": [
acl_helper.get_acl_json(role_id, person_id),
]
})
assessment = self.refresh_object(self.assessment, self.assessment_id)
evidence = self.refresh_object(evidence, evidence_id)
self.assertEqual(assessment.status, expected_status)
self.assertEqual(getattr(evidence, attr_name), "test text")
def test_evidence_postfix_two_controls(self):
"""Test evidence postfix for assessment with two controls."""
with factories.single_commit():
audit = factories.AuditFactory()
control1 = factories.ControlFactory()
control2 = factories.ControlFactory()
snapshots = self._create_snapshots(audit, [control1, control2])
assessment = factories.AssessmentFactory(audit=audit)
factories.RelationshipFactory(source=assessment,
destination=snapshots[0])
factories.RelationshipFactory(source=assessment,
destination=snapshots[1])
evidence = factories.EvidenceFactory(title='Simple title',
kind=all_models.Evidence.FILE,
link='some link',
parent_obj={
'id': assessment.id,
'type': 'Assessment'
})
expec = '_ggrc_assessment-{}_control-{}_control-{}'.format(
assessment.id, control1.id, control2.id)
# pylint: disable=protected-access
result = evidence._build_file_name_postfix(assessment)
self.assertEqual(expec, result)
def test_filter_evidence_by_type_gdrive(self):
"""Test filter evidences by evidence type GDRIVE."""
evidence_gdrive = factories.EvidenceFactory(
title='Simple title',
source_gdrive_id='gdrive_id',
link='sample.site',
kind=all_models.Evidence.FILE)
evidence_gdrive_id = evidence_gdrive.id
query_request_data = [{
u'filters': {
u'expression': {
u'left': u'type',
u'op': {
u'name': u'='
},
u'right': all_models.Evidence.FILE
}
},
u'object_name': u'Evidence',
u'type': u'values'
}]
resp = self.api.send_request(self.api.client.post,
data=query_request_data,
api_link="/query")
self.assertEqual(1, resp.json[0]["Evidence"]["count"])
self.assertEqual(evidence_gdrive_id,
resp.json[0]["Evidence"]["values"][0]["id"])
def test_add_evidence_and_status(self, status, result_status):
"""Test add evidence and update {0} status to {1}
in single PUT."""
asmt_id = self.asmt.id
# putting assessment to 'In Progress' state
self.api.put(
self.asmt, {
"actions": {
"add_related": [{
"id": self.evidence.id,
"type": "Evidence"
}]
},
})
new_evidence = factories.EvidenceFactory()
response = self.api.put(
self.asmt, {
"status": status,
"actions": {
"add_related": [{
"id": new_evidence.id,
"type": "Evidence"
}]
},
})
self.assertEqual(response.status_code, 200)
response_asmt = response.json["assessment"]
self.assertEqual(response_asmt["status"], result_status)
asmt = all_models.Assessment.query.get(asmt_id)
self.assertEqual(asmt.status, result_status)
def test_filter_document_by_type(self, document_type):
"""Test filter documents by document type."""
data = {
all_models.Document.ATTACHMENT: factories.EvidenceFactory().id,
all_models.Document.URL: factories.UrlFactory().id,
}
query_request_data = [{
u'fields': [],
u'filters': {
u'expression': {
u'left': u'document_type',
u'op': {
u'name': u'='
},
u'right': document_type,
}
},
u'limit': [0, 5],
u'object_name': u'Document',
u'permissions': u'read',
u'type': u'values',
}]
resp = self.api.send_request(self.api.client.post,
data=query_request_data,
api_link="/query")
self.assertEqual(1, resp.json[0]["Document"]["count"])
self.assertEqual(data[document_type],
resp.json[0]["Document"]["values"][0]["id"])
def test_audit_role_propagation_edit(self, user_role, audit_role,
status_code):
"""'{0}' assigned as '{1}' should get '{2}' when editing audit evidence"""
_, user = self.generator.generate_person(user_role=user_role)
with factories.single_commit():
audit = factories.AuditFactory()
audit.add_person_with_role_name(user, audit_role)
evidence = factories.EvidenceFactory()
evidence_id = evidence.id
factories.RelationshipFactory(source=audit, destination=evidence)
self.api.set_user(user)
evidence = all_models.Evidence.query.get(evidence_id)
new_description = 'new description'
resp = self.api.modify_object(evidence,
{'description': new_description})
evidence = self.refresh_object(evidence)
if status_code == 200:
self.assert200(resp)
self.assertEquals(new_description, evidence.description)
self.assertEquals(user.id, evidence.modified_by_id)
else:
self.assertStatus(resp, status_code)
def test_evidense_export(self):
"""Test evidence fields of the assessments"""
with factories.single_commit():
evid_file = factories.EvidenceFactory(
title="Simple title",
kind=all_models.Evidence.FILE,
link="https://d.go.com/d/18YJavJlv8YvIoCy/edit",
description="mega description",
parent_obj={
"id": self.assessment.id,
"type": "Assessment"
}
)
evid_file_link = evid_file.link
evid_file_title = evid_file.title
evid_url = factories.EvidenceFactory(
title="Simple title",
kind=all_models.Evidence.URL,
link="google.com",
description="mega description",
parent_obj={
"id": self.assessment.id,
"type": "Assessment"
}
)
evid_url_link = evid_url.link
search_request = [{
"object_name": "Assessment",
"fields": "all",
"filters": {
"expression": {
"left": "id",
"op": {"name": "="},
"right": self.assessment.id
}
}
}]
resp = self.export_parsed_csv(search_request)["Assessment"][0]
expected_evid_file_string = evid_file_link + " " + evid_file_title
self.assertEquals(expected_evid_file_string, resp["Evidence File"])
self.assertEquals(evid_url_link, resp["Evidence URL"])
def test_put_empty_evidence_data(self, kind):
"""Test put empty evidence data assessment status changed"""
with factories.single_commit():
evidence = factories.EvidenceFactory(kind=kind)
factories.RelationshipFactory(destination=self.assessment,
source=evidence)
self.api.put(evidence, {})
assessment = self.refresh_object(self.assessment, self.assessment_id)
self.assertEqual(assessment.status, models.Assessment.FINAL_STATE)
def test_evidence_create_an_map(self):
"""Test document is created and mapped to audit"""
audit = factories.AuditFactory(slug="Audit")
evidence = factories.EvidenceFactory(title="evidence", )
factories.RelationshipFactory(
source=audit,
destination=evidence,
)
self.assertEqual(audit.document_evidence[0].title, "evidence")
def setUp(self):
"""Set up audit and cad for test cases."""
super(TestAssessmentCompleteWithAction, self).setUp()
self.api = ggrc.api_helper.Api()
with factories.single_commit():
self.audit = factories.AuditFactory()
self.asmt = factories.AssessmentFactory(audit=self.audit,
status="In Progress")
self.evidence = factories.EvidenceFactory()
def test_part_asmnt_exist(self):
"""Test Audit summary when not all kinds of Asmnt created"""
with factories.single_commit():
audit = factories.AuditFactory()
for status in ["Completed", "Verified"]:
assessment = factories.AssessmentFactory(audit=audit,
status=status)
evidence_url = factories.EvidenceFactory(
kind=all_models.Evidence.URL)
factories.RelationshipFactory(source=assessment,
destination=evidence_url)
evidence_file = factories.EvidenceFactory(
kind=all_models.Evidence.FILE, source_gdrive_id='12345')
factories.RelationshipFactory(source=assessment,
destination=evidence_file)
summary_link = "/api/{}/{}/summary".format(
audit._inflector.table_plural, audit.id)
response = self.api.client.get(summary_link)
self.assert200(response)
evid_count = len(all_models.Evidence.VALID_EVIDENCE_KINDS)
expected_data = {
"statuses": [
{
"name": "Completed",
"assessments": 1,
"evidence": evid_count,
"verified": 0
},
{
"name": "Completed",
"assessments": 1,
"evidence": evid_count,
"verified": 1
},
],
"total": {
"assessments": 2,
"evidence": 2 * evid_count
}
}
self.assertEqual(response.json, expected_data)
def test_put_ignored_evidence_attrs(self, kind, attr_name):
"""Test assessment status not changed after evidence attr {1} changed."""
expected_status = models.Assessment.FINAL_STATE
with factories.single_commit():
evidence = factories.EvidenceFactory(kind=kind)
factories.RelationshipFactory(destination=self.assessment,
source=evidence)
response = self.api.put(evidence, {attr_name: "test text"})
self.assert200(response)
assessment = self.refresh_object(self.assessment, self.assessment_id)
self.assertEqual(assessment.status, expected_status)
def test_evidences_copied_once(self, mock_gdrive):
"""Test evidences copied to GDrive only once"""
audit = factories.AuditFactory()
evidence = factories.EvidenceFactory(title='Simple title',
kind=all_models.Evidence.FILE,
source_gdrive_id='123',
parent_obj={
'id': audit.id,
'type': audit.type
})
factories.RelationshipFactory(source=audit, destination=evidence)
self.assertEqual(mock_gdrive.call_count, 1)
def test_evidence_filter(self):
"""Only evidence kind URL and FILE should be shown in summary"""
with factories.single_commit():
audit = factories.AuditFactory()
assessment = factories.AssessmentFactory(audit=audit)
evidence_url = factories.EvidenceFactory(
kind=all_models.Evidence.URL)
factories.RelationshipFactory(source=evidence_url,
destination=assessment)
evidence_file = factories.EvidenceFactory(
kind=all_models.Evidence.FILE, source_gdrive_id='12345')
factories.RelationshipFactory(source=assessment,
destination=evidence_file)
summary_link = "/api/{}/{}/summary".format(
audit._inflector.table_plural, audit.id)
response = self.api.client.get(summary_link)
self.assert200(response)
self.assertEqual(response.json['total']['evidence'], 2)
def test_evidence_url_type_with_parent(self):
"""Evidence of URL type should mapped to parent if parent specified"""
audit = factories.AuditFactory()
evidence = factories.EvidenceFactory(title='Simple title',
kind=all_models.Evidence.URL,
link='some_url.com',
description='mega description',
parent_obj={
'id': audit.id,
'type': 'Audit'
})
rel_evidences = audit.related_objects(_types=[evidence.type])
self.assertEqual(evidence, rel_evidences.pop())
def test_archived_audit(self, archived):
"""Test evidence archived if audit archived"""
audit = factories.AuditFactory(archived=archived)
evidence = factories.EvidenceFactory(title='Simple title',
kind=all_models.Evidence.URL,
link='some_url.com',
description='mega description',
parent_obj={
'id': audit.id,
'type': 'Audit'
})
self.assertEquals(archived, evidence.archived)
def test_map_parent(self, kind,
from_status, expected_status):
"""Move Assessment from '{1}' to '{2}' map evid with parent of type {0}"""
assessment = factories.AssessmentFactory(status=from_status)
factories.EvidenceFactory(
title='Simple title',
kind=kind,
link='some link',
parent_obj={
'id': assessment.id,
'type': 'Assessment'
})
self.assertEquals(expected_status, assessment.status)
def test_put_ignored_evidence_attrs(self, kind, attr_name, status):
"""Test assessment status not changed after evidence attr {2} changed."""
with factories.single_commit():
assessment = factories.AssessmentFactory(status=status)
assessment_id = assessment.id
evidence = factories.EvidenceFactory(kind=kind)
evidence_id = evidence.id
factories.RelationshipFactory(destination=assessment,
source=evidence)
self.api.put(evidence, {attr_name: "test text"})
assessment = self.refresh_object(assessment, assessment_id)
evidence = self.refresh_object(evidence, evidence_id)
self.assertEqual(assessment.status, status)
self.assertEqual(getattr(evidence, attr_name), "test text")
def test_evidences(self, _):
"""Test related evidences"""
audit = factories.AuditFactory()
evidence = factories.EvidenceFactory(title='Simple title',
kind=all_models.Evidence.FILE,
source_gdrive_id='123',
parent_obj={
'id': audit.id,
'type': audit.type
})
factories.RelationshipFactory(source=audit, destination=evidence)
self.assertEqual(len(audit.evidences), 1)
self.assertEqual(audit.evidences[0].title, COPIED_TITLE)
def test_get_parent_obj_audit_type(self):
"""Test parent object audit"""
audit = factories.AuditFactory()
evidence = factories.EvidenceFactory(title='Simple title',
kind=all_models.Evidence.FILE,
link='some_url.com',
description='mega description',
source_gdrive_id='qwerqwer',
parent_obj={
'id': audit.id,
'type': 'Audit'
})
rel_asses = evidence.related_objects(_types=[audit.type])
self.assertEqual(audit, rel_asses.pop())
def test_evidence_delete(self, kind, from_status,
expected_status):
"""Move Assessment from '{1}' to '{2}' delete evidence of type {0}"""
with factories.single_commit():
assessment = factories.AssessmentFactory(status=from_status)
evidence = factories.EvidenceFactory(kind=kind,
title='google.com',
link='google.com',
source_gdrive_id='some_id')
factories.RelationshipFactory(destination=assessment, source=evidence)
assessment_id = assessment.id
response = self.api.delete(evidence)
assessment = self.refresh_object(assessment, assessment_id)
self.assert200(response)
self.assertEqual(expected_status, assessment.status)
def test_put_status_evidence(self, kind, evidence_from_status,
evidence_to_status):
"""Test put evidence status and assessment status changed"""
expected_status = models.Assessment.PROGRESS_STATE
with factories.single_commit():
evidence = factories.EvidenceFactory(kind=kind,
status=evidence_from_status)
evidence_id = evidence.id
factories.RelationshipFactory(destination=self.assessment,
source=evidence)
self.api.put(evidence, {'status': evidence_to_status})
assessment = self.refresh_object(self.assessment, self.assessment_id)
evidence = self.refresh_object(evidence, evidence_id)
self.assertEqual(assessment.status, expected_status)
self.assertEqual(evidence.status, evidence_to_status)
def test_put_acl_null_evidence(self, kind):
"""Test put acl null of evidence data assessment status changed"""
expected_status = models.Assessment.PROGRESS_STATE
with factories.single_commit():
evidence = factories.EvidenceFactory(kind=kind)
factories.RelationshipFactory(destination=self.assessment,
source=evidence)
person = factories.PersonFactory()
role = models.AccessControlRole.query.filter(
models.AccessControlRole.object_type == "Evidence",
models.AccessControlRole.name == 'Admin',
).one()
evidence.add_person_with_role(person, role)
self.api.put(evidence, {"access_control_list": []})
assessment = self.refresh_object(self.assessment, self.assessment_id)
self.assertEqual(assessment.status, expected_status)
def test_evidence_acl(self):
"""Test evidence with ACR creation"""
person = factories.PersonFactory()
acr_class = all_models.AccessControlRole
acr = acr_class.query.filter(
acr_class.name == 'Admin',
acr_class.object_type == 'Evidence').one()
evidence = factories.EvidenceFactory(
title='Simple title',
kind=all_models.Evidence.URL,
link='simple_url.test',
access_control_list=[acl_helper.get_acl_json(acr.id, person.id)])
acl_class = all_models.AccessControlList
acl = acl_class.query.filter(acl_class.object_id == evidence.id).one()
self.assertTrue(acl)
def test_evidence_postfix_audit(self):
"""Test evidence file postfix for audit."""
audit = factories.AuditFactory()
evidence = factories.EvidenceFactory(title='Simple title',
kind=all_models.Evidence.FILE,
link='some link',
parent_obj={
'id': audit.id,
'type': 'Audit'
})
expected = '_ggrc_{}'.format(audit.slug).lower()
# pylint: disable=protected-access
result = evidence._build_file_name_postfix(audit)
self.assertEqual(expected, result)
