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) }