def asmts_to_include_by_bulk_verify_filter(self, control_mapped_to_program,
audit, audit_w_auditor,
second_creator):
"""Creates assessment with 'In Review' state, map a comment, evidence url
and control snapshot to it.
Returns created assessment."""
expected_asmnt = rest_facade.create_asmt(audit,
verifiers=second_creator)
rest_facade.map_to_snapshot(expected_asmnt,
obj=control_mapped_to_program,
parent_obj=audit)
comment = rest_service.CommentsService().create_obj()
evidence = rest_service.EvidencesService().create_obj()
rest_facade.update_object(
expected_asmnt,
status=object_states.READY_FOR_REVIEW,
actions={
"add_related":
[comment.repr_min_dict(),
evidence.repr_min_dict()]
})
comment.modified_by = users.current_person().email
expected_asmnt.update_attrs(evidence_urls=[evidence.title],
comments=[comment.repr_ui()],
mapped_objects=[control_mapped_to_program],
status=object_states.READY_FOR_REVIEW,
custom_attribute_definitions=[])
return expected_asmnt.repr_ui()
def soft_assert_bulk_verify_for_in_review_state(page, asmt, soft_assert,
is_available):
"""Soft assert 'Bulk Verify' availability for assessments in 'In Review'
status."""
rest_facade.update_object(asmt, status=object_states.READY_FOR_REVIEW)
browsers.get_browser().refresh()
ui_utils.wait_for_spinner_to_disappear()
soft_assert.expect(
page.is_bulk_verify_displayed() == is_available,
"Bulk Verify should {} be available if assessment is in '{}' status."
.format("" if is_available else "not", object_states.READY_FOR_REVIEW))
def soft_assert_bulk_complete_for_completed_asmts(soft_assert, asmts, page):
"""Performs soft assert that 'Bulk complete' option/button is not
displayed for several assessments when all of them are in one of the
completed states."""
for asmt, status in zip(asmts, object_states.COMPLETED_STATES):
rest_facade.update_object(asmt, status=status)
browsers.get_browser().refresh()
ui_utils.wait_for_spinner_to_disappear()
soft_assert.expect(
not page.is_bulk_complete_displayed(),
"'Bulk complete' for assessment with '{}' status should not be "
"available.".format(status))
def soft_assert_bulk_complete_for_opened_asmts(soft_assert, asmts, page,
is_displayed=True):
"""Performs soft assert that 'Bulk complete' option/button is displayed or
not for several assessments when at least one of them is in one of the opened
states."""
for status in object_states.OPENED_STATES:
rest_facade.update_object(asmts[-1], status=status)
browsers.get_browser().refresh()
ui_utils.wait_for_spinner_to_disappear()
soft_assert.expect(
page.is_bulk_complete_displayed() == is_displayed,
"'Bulk complete' for assessment with '{}' status should {}be "
"available.".format(status, "" if is_displayed else "not "))
def test_notification_of_reverted_review(self, second_creator,
program_with_approved_review,
selenium):
"""Confirm user gets email notification when object review reverted to
'Unreviewed' state."""
users.set_current_user(entities_factory.PeopleFactory.superuser)
rest_facade.update_object(program_with_approved_review)
expected_email = entity.ReviewEmailUI(
recipient_email=second_creator.email,
obj_type=program_with_approved_review.type,
obj_title=program_with_approved_review.title)
actual_emails = (
emails_digest_service.ReviewDigestService().
get_reverted_review_emails())
self.general_contain_assert(expected_email, actual_emails)
def soft_assert_bulk_verify_for_not_in_review_state(page, asmts, soft_assert):
"""Soft assert 'Bulk Verify' availability for assessments with different from
'In Review' status."""
statuses = object_states.ASSESSMENT_STATUSES_NOT_READY_FOR_REVIEW
for asmt, status in zip(asmts, statuses):
if status == object_states.COMPLETED:
# normally assessment cannot be in completed state if it has verifiers
# GGRC-7802: validation should be added on backend side
rest_facade.update_acl([asmt], [], rewrite_acl=True,
**roles_rest_facade.get_role_name_and_id(
asmt.type, roles.VERIFIERS))
rest_facade.update_object(asmt, status=status)
browsers.get_browser().refresh()
ui_utils.wait_for_spinner_to_disappear()
soft_assert.expect(
not page.is_bulk_verify_displayed(),
"Bulk Verify should not be available if assessment is in "
"'{}' status.".format(status))
def test_bulk_verification(self, second_creator, login_as_creator,
audit_w_auditor, asmts_w_verifier,
login_as_second_creator, page, soft_assert,
selenium):
"""Check that assessments statuses actually have been updated after
bulk verify has been completed."""
for asmt in asmts_w_verifier:
rest_facade.update_object(asmt,
status=object_states.READY_FOR_REVIEW)
page = page(audit_w_auditor)
modal = page.open_bulk_verify_modal()
soft_assert.expect(
not modal.is_verify_button_active,
"'Bulk Verify' button should be disabled if no selected assessments."
)
soft_assert.expect(not modal.filter_section.is_expanded,
"'Filter' section should be collapsed.")
webui_facade.soft_assert_verified_state_after_bulk_verify(
page, audit_w_auditor, soft_assert)
soft_assert.assert_expectations()
def create_audit_with_control_and_update_control(
program, control_mapped_to_program, audit
):
"""Create Program and Control, map Control to Program, create Audit
under Program, update Control via REST API and return dictionary of executed
fixtures.
"""
return {"program": program,
"control": copy.deepcopy(control_mapped_to_program),
"audit": audit,
"updated_control": rest_facade.update_object(
control_mapped_to_program)}
def create_audit_with_control_with_cas_and_update_control_cav(
program, gcads_for_control, control_mapped_to_program, audit
):
"""Create Program, GCAs for Control and Control, map Control to Program,
create Audit under Program, update Control via REST API and return
dictionary of executed fixtures.
"""
from lib.entities.entities_factory import CustomAttributeDefinitionsFactory
cavs = [cav.__dict__ for cav
in CustomAttributeDefinitionsFactory.generate_cavs(
cads=gcads_for_control)]
return {"program": program,
"control": copy.deepcopy(control_mapped_to_program),
"audit": audit,
"updated_control": rest_facade.update_object(
control_mapped_to_program, custom_attribute_values=cavs)}
def create_audit_and_update_first_of_two_original_controls(
self, program, control_mapped_to_program, audit):
"""Create Audit with snapshotable Control and update original Control under
Program via REST API. After that create second Control and map it to
Program via REST API.
Preconditions:
- Execution and return of fixture
'create_audit_with_control_and_update_control'.
- Second Control created via REST API.
- Second Control mapped to Program via REST API.
"""
return {
"audit": audit,
"program": program,
"control": copy.deepcopy(control_mapped_to_program),
"updated_control":
rest_facade.update_object(control_mapped_to_program),
"second_control":
rest_facade.create_control_mapped_to_program(program)
}
