Exemple #1
0
def test_validate_pass_code(app, session):  # pylint:disable=unused-argument
    """Assert that a valid passcode can be correctly validated."""
    entity_model = factory_entity_model(entity_info=TestEntityInfo.entity_passcode)
    entity = EntityService(entity_model)

    validated = entity.validate_pass_code(entity_model.pass_code)
    assert validated
Exemple #2
0
    def post():
        """Post a new Entity using the request body."""
        request_json = request.get_json()

        # If the record exists, just return existing record.
        entity = EntityService.find_by_business_identifier(
            request_json.get('businessIdentifier'),
            token_info=g.jwt_oidc_token_info,
            allowed_roles=ALL_ALLOWED_ROLES)
        if entity:
            return entity.as_dict(), http_status.HTTP_202_ACCEPTED

        valid_format, errors = schema_utils.validate(request_json, 'entity')
        if not valid_format:
            return {
                'message': schema_utils.serialize(errors)
            }, http_status.HTTP_400_BAD_REQUEST

        try:
            response, status = EntityService.save_entity(
                request_json).as_dict(), http_status.HTTP_201_CREATED
        except BusinessException as exception:
            response, status = {
                'code': exception.code,
                'message': exception.message
            }, exception.status_code
        return response, status
Exemple #3
0
def test_update_entity_existing_failures(session):  # pylint:disable=unused-argument
    """Assert that an Entity can be updated from a dictionary."""
    entity = EntityService.save_entity({
        'businessIdentifier': TestEntityInfo.bc_entity_passcode3['businessIdentifier'],
        'businessNumber': TestEntityInfo.bc_entity_passcode3['businessNumber'],
        'passCode': TestEntityInfo.bc_entity_passcode3['passCode'],
        'name': TestEntityInfo.bc_entity_passcode3['name'],
        'corpTypeCode': TestEntityInfo.bc_entity_passcode3['corpTypeCode']
    })

    assert entity
    assert entity.as_dict()['corp_type']['code'] == 'BC'

    updated_entity_info = {
        'businessIdentifier': TestEntityInfo.bc_entity_passcode4['businessIdentifier'],
        'businessNumber': TestEntityInfo.bc_entity_passcode4['businessNumber'],
        'name': TestEntityInfo.bc_entity_passcode4['name'],
        'corpTypeCode': TestEntityInfo.bc_entity_passcode4['corpTypeCode']
    }
    user_with_token = TestUserInfo.user_test
    user_with_token['keycloak_guid'] = TestJwtClaims.public_user_role['sub']

    with pytest.raises(BusinessException) as exception:
        EntityService.update_entity('invalidbusinessnumber', updated_entity_info,
                                    {'loginSource': '', 'realm_access': {'roles': ['system']},
                                     'corp_type': 'INVALID_CP'})

    assert exception.value.code == Error.DATA_NOT_FOUND.name
Exemple #4
0
def test_update_entity_existing_success(session):  # pylint:disable=unused-argument
    """Assert that an Entity can be updated from a dictionary."""
    entity = EntityService.save_entity({
        'businessIdentifier': TestEntityInfo.bc_entity_passcode3['businessIdentifier'],
        'businessNumber': TestEntityInfo.bc_entity_passcode3['businessNumber'],
        'passCode': TestEntityInfo.bc_entity_passcode3['passCode'],
        'name': TestEntityInfo.bc_entity_passcode3['name'],
        'corpTypeCode': TestEntityInfo.bc_entity_passcode3['corpTypeCode']
    })

    assert entity
    assert entity.as_dict()['corp_type']['code'] == 'BC'

    updated_entity_info = {
        'businessIdentifier': TestEntityInfo.bc_entity_passcode4['businessIdentifier'],
        'businessNumber': TestEntityInfo.bc_entity_passcode4['businessNumber'],
        'name': TestEntityInfo.bc_entity_passcode4['name'],
        'corpTypeCode': TestEntityInfo.bc_entity_passcode4['corpTypeCode']
    }
    user_with_token = TestUserInfo.user_test
    user_with_token['keycloak_guid'] = TestJwtClaims.public_user_role['sub']

    updated_entity = EntityService.update_entity(entity.as_dict().get('business_identifier'), updated_entity_info,
                                                 {'loginSource': '', 'realm_access': {'roles': ['system']},
                                                  'corp_type': 'BC'})

    assert updated_entity
    assert updated_entity.as_dict()['name'] == updated_entity_info['name']
    assert updated_entity.as_dict()['business_number'] == updated_entity_info['businessNumber']
Exemple #5
0
    def patch(business_identifier):
        """Update an existing business by it's business number."""
        request_json = request.get_json()

        valid_format, errors = schema_utils.validate(request_json, 'entity')
        if not valid_format:
            return {'message': schema_utils.serialize(errors)}, http_status.HTTP_400_BAD_REQUEST

        passcode_reset = request_json.get('resetPasscode', False)

        try:
            if passcode_reset:
                entity = EntityService.reset_passcode(business_identifier,
                                                      email_addresses=request_json.get('passcodeResetEmail', None))
            else:
                entity = EntityService.update_entity(business_identifier, request_json)

            if entity is not None:
                response, status = entity.as_dict(), http_status.HTTP_200_OK
            else:
                response, status = {'message': 'A business for {} was not found.'.format(business_identifier)}, \
                                   http_status.HTTP_404_NOT_FOUND
        except BusinessException as exception:
            response, status = {'code': exception.code, 'message': exception.message}, exception.status_code
        return response, status
Exemple #6
0
def test_validate_invalid_pass_code(app, session):  # pylint:disable=unused-argument
    """Assert that an invalid passcode in not validated."""
    entity_model = factory_entity_model(business_identifier='CP1234567', pass_code='12345678')
    entity = EntityService(entity_model)

    validated = entity.validate_pass_code('1234')
    assert not validated
Exemple #7
0
def test_delete_contact_entity_link(session, auth_mock):  # pylint:disable=unused-argument
    """Assert that a contact can not be deleted without entity."""
    entity_model = factory_entity_model()
    entity = EntityService(entity_model)

    org = factory_org_service()
    org_dictionary = org.as_dict()
    org_id = org_dictionary['id']

    contact = factory_contact_model()

    contact_link = ContactLinkModel()
    contact_link.contact = contact
    contact_link.entity = entity._model  # pylint:disable=protected-access
    contact_link.org = org._model  # pylint:disable=protected-access
    contact_link.commit()

    updated_entity = entity.delete_contact()

    dictionary = None
    dictionary = updated_entity.as_dict()
    assert len(dictionary['contacts']) == 0

    delete_contact_link = ContactLinkModel.find_by_entity_id(entity.identifier)
    assert not delete_contact_link

    exist_contact_link = ContactLinkModel.find_by_org_id(org_id)
    assert exist_contact_link
Exemple #8
0
def test_validate_pass_code(app, session):  # pylint:disable=unused-argument
    """Assert that a valid passcode can be correctly validated."""
    entity_model = factory_entity_model(business_identifier='CP1234567', pass_code='12345678')
    entity = EntityService(entity_model)

    validated = entity.validate_pass_code(entity_model.pass_code)
    assert validated
Exemple #9
0
def test_save_entity_existing(session):  # pylint:disable=unused-argument
    """Assert that an Entity can be updated from a dictionary."""
    entity = EntityService.save_entity({
        'businessIdentifier':
        TestEntityInfo.entity_passcode['businessIdentifier'],
        'businessNumber':
        TestEntityInfo.entity_passcode['businessNumber'],
        'passCode':
        TestEntityInfo.entity_passcode['passCode'],
        'name':
        TestEntityInfo.entity_passcode['name'],
        'corpTypeCode':
        TestEntityInfo.entity_passcode['corpTypeCode']
    })

    assert entity

    updated_entity_info = {
        'businessIdentifier':
        TestEntityInfo.entity_passcode2['businessIdentifier'],
        'businessNumber': TestEntityInfo.entity_passcode2['businessNumber'],
        'passCode': TestEntityInfo.entity_passcode['passCode'],
        'name': TestEntityInfo.entity_passcode['name'],
        'corpTypeCode': TestEntityInfo.entity_passcode['corpTypeCode']
    }

    updated_entity = EntityService.save_entity(updated_entity_info)

    assert updated_entity
    assert updated_entity.as_dict()['name'] == updated_entity_info['name']
    assert updated_entity.as_dict(
    )['business_number'] == updated_entity_info['businessNumber']
Exemple #10
0
def test_as_dict(session):  # pylint:disable=unused-argument
    """Assert that the Entity is exported correctly as a dictionary."""
    entity_model = factory_entity_model()
    entity = EntityService(entity_model)

    dictionary = entity.as_dict()
    assert dictionary['business_identifier'] == TestEntityInfo.entity1['businessIdentifier']
Exemple #11
0
def test_validate_invalid_pass_code(app, session):  # pylint:disable=unused-argument
    """Assert that an invalid passcode in not validated."""
    entity_model = factory_entity_model(entity_info=TestEntityInfo.entity_passcode)
    entity = EntityService(entity_model)

    validated = entity.validate_pass_code('222222222')
    assert not validated
Exemple #12
0
def test_update_contact_no_contact(session):  # pylint:disable=unused-argument
    """Assert that a contact for a non-existent contact cannot be updated."""
    entity_model = factory_entity_model(business_identifier='CP1234567')
    entity = EntityService(entity_model)

    with pytest.raises(BusinessException) as exception:
        entity.update_contact(TEST_UPDATED_CONTACT_INFO)
    assert exception.value.code == Error.DATA_NOT_FOUND.name
Exemple #13
0
def test_as_dict():
    """Assert that the Entity is exported correctly as a dictionary."""
    entity_model = EntityModel(business_identifier='CP1234567')
    entity = EntityService(entity_model)

    assert entity.as_dict() == {
        'businessIdentifier': 'CP1234567'
    }
Exemple #14
0
def test_update_contact_no_contact(session):  # pylint:disable=unused-argument
    """Assert that a contact for a non-existent contact cannot be updated."""
    entity_model = factory_entity_model()
    entity = EntityService(entity_model)

    with pytest.raises(BusinessException) as exception:
        entity.update_contact(TestContactInfo.contact2)
    assert exception.value.code == Error.DATA_NOT_FOUND.name
Exemple #15
0
def test_entity_find_by_entity_id_no_id(session, auth_mock):  # pylint:disable=unused-argument
    """Assert that an Entity can not be retrieved when no id input or entity not exists."""
    entity = EntityService.find_by_entity_id(None)

    assert entity is None

    entity = EntityService.find_by_entity_id(9999)

    assert entity is None
Exemple #16
0
def test_get_contact_by_business_identifier(session):  # pylint:disable=unused-argument
    """Assert that a contact can be retrieved by the associated business id."""
    entity_model = factory_entity_model()
    entity = EntityService(entity_model)
    entity.add_contact(TestContactInfo.contact1)

    contact = entity.get_contact()
    assert contact is not None
    assert contact.email == TestContactInfo.contact1['email']
Exemple #17
0
def test_add_contact_duplicate(session):  # pylint:disable=unused-argument
    """Assert that a contact cannot be added to an Entity if that Entity already has a contact."""
    entity_model = factory_entity_model(business_identifier='CP1234567')
    entity = EntityService(entity_model)
    entity.add_contact(TEST_CONTACT_INFO)

    with pytest.raises(BusinessException) as exception:
        entity.add_contact(TEST_UPDATED_CONTACT_INFO)
    assert exception.value.code == Error.DATA_ALREADY_EXISTS.name
Exemple #18
0
def test_delete_contact(session):  # pylint:disable=unused-argument
    """Assert that a contact can be deleted to an Entity."""
    entity_model = factory_entity_model()
    entity = EntityService(entity_model)
    entity.add_contact(TestContactInfo.contact1)

    updated_entity = entity.delete_contact()
    dictionary = updated_entity.as_dict()
    assert not dictionary['contacts']
Exemple #19
0
def test_get_contact_by_business_identifier(session):  # pylint:disable=unused-argument
    """Assert that a contact can be retrieved by the associated business id."""
    entity_model = factory_entity_model(business_identifier='CP1234567')
    entity = EntityService(entity_model)
    entity.add_contact(TEST_CONTACT_INFO)

    contact = entity.get_contact()
    assert contact is not None
    assert contact.email == TEST_CONTACT_INFO['email']
Exemple #20
0
def test_entity_name_sync(app, session):  # pylint:disable=unused-argument
    """Assert that the name syncing for entity affiliation is working correctly."""
    entity_model = factory_entity_model(
        entity_info=TestEntityInfo.entity_lear_mock)
    entity = EntityService(entity_model)
    entity.sync_name()

    dictionary = entity.as_dict()
    assert dictionary['name'] == 'Legal Name CP0002103'
Exemple #21
0
def test_add_contact_duplicate(session):  # pylint:disable=unused-argument
    """Assert that a contact cannot be added to an Entity if that Entity already has a contact."""
    entity_model = factory_entity_model()
    entity = EntityService(entity_model)
    entity.add_contact(TestContactInfo.contact1)

    with pytest.raises(BusinessException) as exception:
        entity.add_contact(TestContactInfo.contact2)
    assert exception.value.code == Error.DATA_ALREADY_EXISTS.name
Exemple #22
0
def test_entity_find_by_entity_id(session, auth_mock):  # pylint:disable=unused-argument
    """Assert that an Entity can be retrieved by entity identifier."""
    entity_model = factory_entity_model()
    entity = EntityService(entity_model)

    entity = EntityService.find_by_entity_id(entity.identifier)

    assert entity is not None
    dictionary = entity.as_dict()
    assert dictionary['business_identifier'] == TestEntityInfo.entity1['businessIdentifier']
Exemple #23
0
def test_add_contact(session):  # pylint:disable=unused-argument
    """Assert that a contact can be added to an Entity."""
    entity_model = factory_entity_model()
    entity = EntityService(entity_model)
    entity.add_contact(TestContactInfo.contact1)

    dictionary = entity.as_dict()
    assert dictionary['contacts']
    assert len(dictionary['contacts']) == 1
    assert dictionary['contacts'][0]['email'] == TestContactInfo.contact1['email']
Exemple #24
0
def test_add_contact(session):  # pylint:disable=unused-argument
    """Assert that a contact can be added to an Entity."""
    entity_model = factory_entity_model(business_identifier='CP1234567')
    entity = EntityService(entity_model)
    entity.add_contact(TEST_CONTACT_INFO)

    dictionary = entity.as_dict()
    assert dictionary['contacts']
    assert len(dictionary['contacts']) == 1
    assert dictionary['contacts'][0]['email'] == TEST_CONTACT_INFO['email']
Exemple #25
0
def test_reset_pass_code(app, session):  # pylint:disable=unused-argument
    """Assert that the new passcode in not the same as old passcode."""
    entity_model = factory_entity_model(entity_info=TestEntityInfo.entity_passcode)

    entity = EntityService(entity_model)
    old_passcode = entity.pass_code

    entity.reset_passcode(entity.business_identifier, '', TestJwtClaims.user_test)
    new_passcode = entity.pass_code

    assert old_passcode != new_passcode
Exemple #26
0
def test_delete_contact_no_entity(session, auth_mock):  # pylint:disable=unused-argument
    """Assert that a contact can not be deleted without entity."""
    entity_model = factory_entity_model()
    entity = EntityService(entity_model)
    entity.add_contact(TestContactInfo.contact1)

    updated_entity = entity.delete_contact()

    with pytest.raises(BusinessException) as exception:
        updated_entity.delete_contact()

    assert exception.value.code == Error.DATA_NOT_FOUND.name
Exemple #27
0
def test_reset_pass_code_confirm_activity_log(app, session):  # pylint:disable=unused-argument
    """Assert that the new passcode in not the same as old passcode."""
    entity_model = factory_entity_model(entity_info=TestEntityInfo.entity_passcode)

    entity = EntityService(entity_model)
    old_passcode = entity.pass_code

    with patch.object(activity_log_publisher, 'publish_activity', return_value=None) as mock_send:
        entity.reset_passcode(entity.business_identifier, '', TestJwtClaims.user_test)

        new_passcode = entity.pass_code

        assert old_passcode != new_passcode
        mock_send.assert_called
Exemple #28
0
    def delete_affiliation(org_id, business_identifier, email_addresses: str = None,
                           reset_passcode: bool = False, log_delete_draft: bool = False):
        """Delete the affiliation for the provided org id and business id."""
        current_app.logger.info(f'<delete_affiliation org_id:{org_id} business_identifier:{business_identifier}')
        org = OrgService.find_by_org_id(org_id, allowed_roles=(*CLIENT_AUTH_ROLES, STAFF))
        if org is None:
            raise BusinessException(Error.DATA_NOT_FOUND, None)

        entity = EntityService.find_by_business_identifier(business_identifier,
                                                           allowed_roles=(*CLIENT_AUTH_ROLES, STAFF))
        if entity is None:
            raise BusinessException(Error.DATA_NOT_FOUND, None)

        entity_id = entity.identifier

        affiliation = AffiliationModel.find_affiliation_by_org_and_entity_ids(org_id=org_id, entity_id=entity_id)
        if affiliation is None:
            raise BusinessException(Error.DATA_NOT_FOUND, None)

        if reset_passcode:
            entity.reset_passcode(entity.business_identifier, email_addresses)
        affiliation.delete()
        entity.set_pass_code_claimed(False)

        # When registering a business it will affiliate a NR -> unaffiliate a NR draft -> affiliate a business.
        # Users can also intentionally delete a draft. We want to log this action.
        should_publish = (log_delete_draft or not (entity.status == NRStatus.DRAFT.value and
                                                   entity.corp_type == CorpType.NR.value))
        if entity.corp_type != CorpType.RTMP.value and should_publish:
            name = entity.name if len(entity.name) > 0 else entity.business_identifier
            ActivityLogPublisher.publish_activity(Activity(org_id, ActivityAction.REMOVE_AFFILIATION.value,
                                                           name=name, id=entity.business_identifier))
Exemple #29
0
    def delete_affiliation(org_id, business_identifier, email_addresses: str = None,
                           reset_passcode: bool = False, token_info: Dict = None):
        """Delete the affiliation for the provided org id and business id."""
        current_app.logger.info(f'<delete_affiliation org_id:{org_id} business_identifier:{business_identifier}')
        org = OrgService.find_by_org_id(org_id, token_info=token_info, allowed_roles=(*CLIENT_AUTH_ROLES, STAFF))
        if org is None:
            raise BusinessException(Error.DATA_NOT_FOUND, None)

        entity = EntityService.find_by_business_identifier(business_identifier, token_info=token_info,
                                                           allowed_roles=(*CLIENT_AUTH_ROLES, STAFF))
        if entity is None:
            raise BusinessException(Error.DATA_NOT_FOUND, None)

        entity_id = entity.identifier

        affiliation = AffiliationModel.find_affiliation_by_org_and_entity_ids(org_id=org_id, entity_id=entity_id)
        if affiliation is None:
            raise BusinessException(Error.DATA_NOT_FOUND, None)

        if reset_passcode:
            entity.reset_passcode(entity.business_identifier, email_addresses, token_info)
        affiliation.delete()
        entity.set_pass_code_claimed(False)
        publish_activity(f'{ActivityAction.REMOVE_AFFILIATION.value}-{entity.name}', entity.name,
                         business_identifier, org_id)
Exemple #30
0
def test_reset(session, auth_mock):  # pylint: disable=unused-argument
    """Assert that can be reset data by the provided token."""
    user_with_token = TestUserInfo.user_tester
    user_with_token['keycloak_guid'] = TestJwtClaims.tester_role['sub']
    user = factory_user_model(user_info=user_with_token)
    org = factory_org_model(user_id=user.id)
    factory_membership_model(user.id, org.id)
    entity = factory_entity_model(user_id=user.id)

    ResetDataService.reset(TestJwtClaims.tester_role)

    with pytest.raises(BusinessException) as exception:
        UserService.find_by_jwt_token(user_with_token)
    assert exception.value.code == Error.DATA_NOT_FOUND.name

    found_org = OrgService.find_by_org_id(org.id)
    assert found_org is None

    found_entity = EntityService.find_by_entity_id(entity.id)
    assert found_entity is not None
    dictionary = found_entity.as_dict()
    assert dictionary['business_identifier'] == TestEntityInfo.entity1[
        'businessIdentifier']
    assert not dictionary['pass_code_claimed']

    found_memeber = MembershipService.get_members_for_org(org.id)
    assert found_memeber is None