def test_get_single(db, session):  # pylint: disable=unused-argument
    """Verify that the get_single() returns correct results as expected
    from database table.
    """
    # add a notification for user
    user_id = 'notf-user'
    request_id = 225
    request_type = 'registration'
    request_status = 3
    message = 'this is a test notification'
    notification = Notification(user_id=user_id,
                                request_id=request_id,
                                request_type=request_type,
                                request_status=request_status,
                                message=message)
    notification.add()
    notification_id = get_notification_id(session, request_id)
    notification_data = Notification.get_single(notification_id)
    notification_data_raw = get_single_notification(session, notification_id)

    # verify results of both
    assert notification_data_raw.id == notification_data.id
    assert notification_data_raw.user_id == notification_data.user_id
    assert notification_data_raw.request_id == notification_data.request_id
    assert notification_data_raw.request_status == notification_data.request_status
    assert notification_data_raw.message == notification_data.message
示例#2
0
    def put(self, **kwargs):
        """Put method handler for notification route."""
        user_id = kwargs.get('user_id')
        notification_id = kwargs.get('notification_id')

        if NotificationModel.exist_users(user_id):
            if NotificationModel.exists(notification_id):
                notification = NotificationModel.get_single(notification_id)
                if notification.user_id == user_id:
                    NotificationModel.mark_read(notification_id)
                    return Response(status=201, mimetype='application/json')
                else:
                    res = {'error': ['invalid user id']}
                    return Response(json.dumps(ErrorResponse().dump(res).data),
                                    status=400,
                                    mimetype='application/json')
            else:
                res = {
                    'error': [
                        'notification {id} does not exists'.format(
                            id=notification_id)
                    ]
                }
                return Response(json.dumps(ErrorResponse().dump(res).data),
                                status=400,
                                mimetype='application/json')
        else:
            res = {'error': ['user {id} does not exists'.format(id=user_id)]}
            return Response(json.dumps(ErrorResponse().dump(res).data),
                            status=400,
                            mimetype='application/json')
def test_mark_notification_as_read_api(flask_app, db):  # pylint: disable=unused-argument
    """Verify that a generated notification is not return when mark as read."""
    # generate a  registration request type notification
    user_id = 'test-user1'
    notification = Notification(
        user_id=user_id,
        request_id=1342,
        request_type='registration_request',
        request_status=6,
        message='a test notification has been generated')
    notification.add()

    api_url = '{api}?user_id={user_id}'.format(api=NOTIFICATION_API,
                                               user_id=user_id)
    rv = flask_app.get(api_url)
    assert rv.status_code == 200
    data = json.loads(rv.data.decode('utf-8'))
    notification_id = data['notifications'][0]['id']

    # mark notification as read
    body_data = {'notification_id': notification_id, 'user_id': user_id}
    headers = {'Content-Type': 'application/json'}
    rv = flask_app.put(NOTIFICATION_API,
                       data=json.dumps(body_data),
                       headers=headers)
    assert rv.status_code == 201
def test_with_existing_notification_data(flask_app, db):  # pylint: disable=unused-argument
    """Verify that the api responds correctly when notification data exists in table."""
    # generate a  registration request type notification
    user_id = 'test-user1'
    notification = Notification(user_id=user_id, request_id=1342, request_type='registration_request',
                                request_status=6, message='a test notification has been generated')
    notification.add()

    # get notification for user id = test-user1
    api_url = '{api}?user_id={user_id}'.format(api=NOTIFICATION_API, user_id=user_id)
    rv = flask_app.get(api_url)
    assert rv.status_code == 200
    data = json.loads(rv.data.decode('utf-8'))
    assert len(data.get('notifications')) == 1
    data = data.get('notifications')[0]
    assert data.get('request_id') == 1342
    assert data.get('request_status') == 6
    assert data.get('request_type') == 'registration_request'
    assert data.get('id') == 1
    assert data.get('message') == 'a test notification has been generated'

    # generate multiple notifications for the same user
    notification = Notification(user_id=user_id, request_id=1343, request_type='de_registration_request',
                                request_status=7, message='a test notification has been generated')
    notification.add()
    api_url = '{api}?user_id={user_id}'.format(api=NOTIFICATION_API, user_id=user_id)
    rv = flask_app.get(api_url)
    assert rv.status_code == 200
    data = json.loads(rv.data.decode('utf-8'))
    assert len(data.get('notifications')) == 2
示例#5
0
def test_registration_request_information_requested(flask_app, db):  # pylint: disable=unused-argument
    """Verify that when any of the section is marked as information requested the
    system automatically mark the whole request as information requested.
    """
    headers = {'Content-Type': 'application/json'}
    data = {
        'device_count': 1,
        'imei_per_device': 1,
        'imeis': "[['11110673016888']]",
        'm_location': 'local',
        'user_name': 'reg req approve rev user 7',
        'user_id': 'reg-req-approve-rev-user-7'
    }
    request = create_assigned_dummy_request(data, 'Registration',
                                            'reg-req-approve-rev-user-7', 'reg req approve rev user 7')
    assert request
    request_id = request.id
    user_id = request.user_id

    device_data = {
        'brand': 'samsung',
        'operating_system': 'android',
        'model_name': 's9',
        'model_num': '30jjd',
        'device_type': 'Smartphone',
        'technologies': '2G,3G,4G',
        'reg_id': request.id
    }
    request = create_dummy_devices(device_data, 'Registration', request)
    assert request

    # create user quota
    quota = DeviceQuota.create(user_id, 'individual')
    assert quota

    # approve all sections manually
    RegComments.add('device_quota', 'test comment on section', 'reg-req-approve-rev-user-7',
                    'reg req approve rev user 7', 6, request_id)
    RegComments.add('device_description', 'test comment on section', 'reg-req-approve-rev-user-7',
                    'reg req approve rev user 7', 6, request_id)
    RegComments.add('imei_classification', 'test comment on section', 'reg-req-approve-rev-user-7',
                    'reg req approve rev user 7', 5, request_id)
    RegComments.add('imei_registration', 'test comment on section', 'reg-req-approve-rev-user-7',
                    'reg req approve rev user 7', 6, request_id)
    RegComments.add('approval_documents', 'test comment on section', 'reg-req-approve-rev-user-7',
                    'reg req approve rev user 7', 6, request_id)

    body_data = {
        'request_id': request_id,
        'request_type': 'registration_request',
        'reviewer_id': 'reg-req-approve-rev-user-7'
    }
    rv = flask_app.put(SUBMIT_REVIEW_API, data=json.dumps(body_data), headers=headers)
    assert rv.status_code == 201
    data = json.loads(rv.data.decode('utf-8'))
    assert data['status'] == 5
    assert data['request_id'] == request_id
    assert data['message'] == 'case {0} updated successfully'.format(request_id)
    assert data['request_type'] == 'registration_request'
    assert Notification.exist_users(user_id)
def test_get(db, session):  # pylint: disable=unused-argument
    """Verify that the get() returns correct results as expected."""
    # get from method for notf-user
    user_id = 'notf-user'
    method_res = Notification.get(user_id)
    query_res = get_user_notifications(
        session, user_id)  # check if the results are really same
    assert len(query_res) == len(method_res)
 def get(self, **kwargs):
     """Get method handler for notification route."""
     user_id = kwargs.get('user_id')
     if user_id:
         notifications = NotificationModel.get(user_id)
         response = Notifications().dump(dict(notifications=notifications)).data
         return Response(json.dumps(response), status=200, mimetype='application/json')
     else:
         err = {'error': ['user_id cannot be empty']}
         return Response(json.dumps(ErrorResponse().dump(err).data),
                         status=422, mimetype='application/json')
def test_exist_users(db, session):  # pylint: disable=unused-argument
    """Verify that the exist_user() work correctly."""
    # add a notification for user
    user_id = 'notf-user'
    request_id = 223
    request_type = 'registration'
    request_status = 3
    message = 'this is a test notification'
    notification = Notification(user_id=user_id,
                                request_id=request_id,
                                request_type=request_type,
                                request_status=request_status,
                                message=message)
    notification.add()
    user_exists_bool = Notification.exist_users(user_id)

    # check if it really exists in db
    res = exists_user_notifications(session, user_id)
    assert res is user_exists_bool

    # remove the above notification and then check again
    assert delete_user_notifications(session, user_id)
    user_exists_bool = Notification.exist_users(user_id)
    res = exists_user_notifications(session, user_id)
    assert res is user_exists_bool
def test_registration_request_rejected_section(flask_app, db):  # pylint: disable=unused-argument
    """Verify that the registration request gets rejected when anyone of the section
    is marked as rejected, imeis are removed from approvedimeis and notification is
    being generated.
    """
    # only one section is reviewed and rejected
    headers = {'Content-Type': 'application/json'}
    data = {
        'device_count': 1,
        'imei_per_device': 1,
        'imeis': "[['23010403010533']]",
        'm_location': 'local',
        'user_name': '23423423rev user 1',
        'user_id': 'assign-rev23442342-user-1'
    }
    request = create_assigned_dummy_request(data, 'Registration', 'rev230987',
                                            'rev 230987')
    assert request
    request_id = request.id
    device_data = {
        'brand': 'samsung',
        'operating_system': 'android',
        'model_name': 's9',
        'model_num': '30jjd',
        'device_type': 'Smartphone',
        'technologies': '2G,3G,4G',
        'reg_id': request.id
    }
    request = create_dummy_devices(device_data, 'Registration', request)
    assert request
    # add one section with rejected status
    RegComments.add('device_quota', 'test comment on section', 'rev230987',
                    'rev 230987', 7, request_id)
    body_data = {
        'request_id': request_id,
        'request_type': 'registration_request',
        'reviewer_id': 'rev230987'
    }
    rv = flask_app.put(SUBMIT_REVIEW_API,
                       data=json.dumps(body_data),
                       headers=headers)
    assert rv.status_code == 201
    response = json.loads(rv.data.decode('utf-8'))
    assert response['status'] == 7
    assert response['request_id'] == request_id
    assert response['message'] == 'case {0} updated successfully'.format(
        request_id)
    assert response['request_type'] == 'registration_request'
    imei = ApprovedImeis.get_imei('23010403010533')
    assert imei.status == 'removed'
    assert imei.delta_status == 'remove'
    assert Notification.exist_users('assign-rev23442342-user-1')
def test_notification_put_api_with_invalid_data(flask_app, db):  # pylint: disable=unused-argument
    """Verify that the notification put api responds correctly in case of invalid input."""
    # invalid user id
    user_id = 'abcd-user'
    body_data = {'notification_id': 2, 'user_id': user_id}
    headers = {'Content-Type': 'application/json'}
    rv = flask_app.put(NOTIFICATION_API, data=json.dumps(body_data), headers=headers)
    assert rv.status_code == 400
    data = json.loads(rv.data.decode('utf-8'))
    assert data.get('error')[0] == 'user {0} does not exists'.format(user_id)

    # generate a notification with the same user id
    notification = Notification(user_id=user_id, request_id=1342, request_type='registration_request',
                                request_status=6, message='a test notification has been generated')
    notification.add()

    # invalid notification id test
    notification_id = 35
    body_data = {'notification_id': notification_id, 'user_id': user_id}
    rv = flask_app.put(NOTIFICATION_API, data=json.dumps(body_data), headers=headers)
    assert rv.status_code == 400
    data = json.loads(rv.data.decode('utf-8'))
    assert data.get('error')[0] == 'notification {0} does not exists'.format(notification_id)

    # wrong user for notification test
    user_id_2 = 'test-user1'
    notification = Notification(user_id=user_id_2, request_id=13, request_type='registration_request',
                                request_status=6, message='a test notification has been generated')
    notification.add()

    # get notification id
    rv = flask_app.get('{0}?user_id={1}'.format(NOTIFICATION_API, user_id_2))
    assert rv.status_code == 200
    data = json.loads(rv.data.decode('utf-8'))
    notification_id = data['notifications'][0]['id']

    # try to mark notification as read with wrong user
    body_data = {'notification_id': notification_id, 'user_id': user_id}
    rv = flask_app.put(NOTIFICATION_API, data=json.dumps(body_data), headers=headers)
    assert rv.status_code == 400
    data = json.loads(rv.data.decode('utf-8'))
    assert data.get('error')[0] == 'invalid user id'

    # string arguments test
    body_data = {'notification_id': '', 'user_id': ''}
    rv = flask_app.put(NOTIFICATION_API, data=json.dumps(body_data), headers=headers)
    assert rv.status_code == 422
    data = json.loads(rv.data.decode('utf-8'))
    assert data['notification_id'][0] == "Bad 'notification_id':'' argument format. Accepts only integer"
def test_exists(db, session):  # pylint: disable=unused-argument
    """Verify that exists() responds correctly while checking for existence of notifications."""
    # add a new notification
    user_id = 'notf-user'
    request_id = 224
    request_type = 'registration'
    request_status = 7
    message = 'this is a test notification'
    notification = Notification(user_id=user_id,
                                request_id=request_id,
                                request_type=request_type,
                                request_status=request_status,
                                message=message)
    notification.add()

    # get notification id
    notification_id = get_notification_id(session, request_id)
    notification_bool = Notification.exists(notification_id)

    # check if it really exists
    res = exists_notification(session, notification_id)
    assert res is notification_bool
示例#12
0
def test_de_registration_request_rejected_section(flask_app, db, app):
    """Verify that the de_registration request gets rejected when anyone of the section
        is marked as rejected, imeis are removed from approvedimeis and notification is
        being generated.
        """
    # de registration request
    headers = {'Content-Type': 'application/json'}
    de_registration_data = {
        'file': 'de-reg-test-file.txt',
        'device_count': 1,
        'user_id': 'dereg-section-submit-assign-rev-user-1',
        'user_name': 'submit assign rev user 1',
        'reason': 'because we have to run tests successfully'
    }
    request = create_assigned_dummy_request(de_registration_data, 'De_Registration', 'dereg-rejected-section-rev',
                                            'de reg rev')
    device_data = {
        'devices': """[
               {
                   "tac": "95762201",
                   "model_name": "TA-1034",
                   "brand_name": "NOKIA",
                   "model_num": "TA-1034",
                   "technology": "NONE",
                   "device_type": "Mobile Phone/Feature phone",
                   "count": 2,
                   "operating_system": "N/A"
               }
           ]""",
        'dereg_id': request.id
    }
    request = create_dummy_devices(device_data, 'De_Registration', request, db, file_content=['957622010005119'],
                                   file_path='{0}/{1}/{2}'.format(app.config['DRS_UPLOADS'], request.tracking_id,
                                                                  de_registration_data.get('file')))
    assert request
    request_id = request.id
    DeRegComments.add('device_description', 'test comment on section', 'dereg-rejected-section-rev', 'rev 230987', 7,
                      request_id)
    body_data = {
        'request_id': request_id,
        'request_type': 'de_registration_request',
        'reviewer_id': 'dereg-rejected-section-rev'
    }
    rv = flask_app.put(SUBMIT_REVIEW_API, data=json.dumps(body_data), headers=headers)
    assert rv.status_code == 201
    response = json.loads(rv.data.decode('utf-8'))
    assert response['status'] == 7
    assert response['request_id'] == request_id
    assert response['message'] == 'case {0} updated successfully'.format(request_id)
    assert response['request_type'] == 'de_registration_request'
    assert Notification.exist_users('dereg-section-submit-assign-rev-user-1')
def test_add_notification(db, session):  # pylint: disable=unused-argument
    """Verify that the notifications model add functionality works correctly."""
    # add a notification using model
    user_id = 'test-user'
    request_id = 213
    request_type = 'registration'
    request_status = 3
    message = 'this is a test notification'
    notification = Notification(user_id=user_id,
                                request_id=request_id,
                                request_type=request_type,
                                request_status=request_status,
                                message=message)
    notification.add()

    # check entry in database
    res = session.execute(
        text("""SELECT * FROM public.notification
                                    WHERE request_id='213'""")).fetchone()
    assert res.user_id == user_id
    assert res.request_id == request_id
    assert res.request_type == request_type
    assert res.request_status == 3
    assert res.message == message
    # marked_read should be false initially
    assert not res.marked_read

    # notification is not added without committing to the db using add()
    user_id = 'test-user'
    request_id = 2100
    request_type = 'de_registration'
    request_status = 7
    message = 'this is a test notification'
    notification = Notification(user_id=user_id,
                                request_id=request_id,
                                request_type=request_type,
                                request_status=request_status,
                                message=message)
    res = session.execute(
        text("""SELECT * FROM public.notification
                                    WHERE request_id='2100'""")).fetchone()
    assert not res
def test_mark_read(db, session):  # pylint: disable=unused-argument
    """Verify that mark_read() mark marked_read column as True."""
    # add a notification
    user_id = 'notf-user'
    request_id = 226
    request_type = 'registration'
    request_status = 3
    message = 'this is a test notification'
    notification = Notification(user_id=user_id,
                                request_id=request_id,
                                request_type=request_type,
                                request_status=request_status,
                                message=message)
    notification.add()

    # get notification id
    notification_id = get_notification_id(session, request_id)
    notification_data = get_single_notification(session, notification_id)
    assert notification_data.marked_read is False

    # call mark_read()
    Notification.mark_read(notification_id)
    notification_data = get_single_notification(session, notification_id)
    assert notification_data.marked_read is True
示例#15
0
def test_registration_request_approval(flask_app, db):  # pylint: disable=unused-argument
    """Verify that the api behave properly upon approval of the request."""
    # only one section is reviewed and rejected
    headers = {'Content-Type': 'application/json'}
    data = {
        'device_count': 1,
        'imei_per_device': 1,
        'imeis': "[['94310813016000']]",
        'm_location': 'local',
        'user_name': 'reg req approve rev user 5',
        'user_id': 'reg-req-approve-rev-user-5'
    }
    request = create_assigned_dummy_request(data, 'Registration',
                                            'reg-req-approve-rev-user-5', 'reg req approve rev user 5')
    assert request
    request_id = request.id
    user_id = request.user_id
    device_data = {
        'brand': 'samsung',
        'operating_system': 'android',
        'model_name': 's9',
        'model_num': '30jjd',
        'device_type': 'Smartphone',
        'technologies': '2G,3G,4G',
        'reg_id': request.id
    }
    request = create_dummy_devices(device_data, 'Registration', request)
    assert request

    # create user quota
    quota = DeviceQuota.create(user_id, 'individual')
    assert quota
    user_reg_quota = quota.reg_quota

    # approve all sections manually
    RegComments.add('device_quota', 'test comment on section', 'reg-req-approve-rev-user-5',
                    'reg req approve rev user 5', 6, request_id)
    RegComments.add('device_description', 'test comment on section', 'reg-req-approve-rev-user-5',
                    'reg req approve rev user 5', 6, request_id)
    RegComments.add('imei_classification', 'test comment on section', 'reg-req-approve-rev-user-5',
                    'reg req approve rev user 5', 6, request_id)
    RegComments.add('imei_registration', 'test comment on section', 'reg-req-approve-rev-user-5',
                    'reg req approve rev user 5', 6, request_id)
    RegComments.add('approval_documents', 'test comment on section', 'reg-req-approve-rev-user-5',
                    'reg req approve rev user 5', 6, request_id)

    body_data = {
        'request_id': request_id,
        'request_type': 'registration_request',
        'reviewer_id': 'reg-req-approve-rev-user-5'
    }
    rv = flask_app.put(SUBMIT_REVIEW_API, data=json.dumps(body_data), headers=headers)
    assert rv.status_code == 201
    data = json.loads(rv.data.decode('utf-8'))
    assert data['status'] == 6
    assert data['request_id'] == request_id
    assert data['message'] == 'case {0} updated successfully'.format(request_id)
    assert data['request_type'] == 'registration_request'
    imei = ApprovedImeis.get_imei('94310813016000')
    assert imei.status == 'whitelist'
    assert imei.delta_status == 'add'
    assert Notification.exist_users(user_id)
    assert DeviceQuota.get(user_id).reg_quota == user_reg_quota - 1
    def put():
        """PUT method handler, updates documents."""
        reg_id = request.form.to_dict().get('reg_id', None)
        if not reg_id or not reg_id.isdigit() or not RegDetails.exists(reg_id):
            return Response(app.json_encoder.encode(REG_NOT_FOUND_MSG),
                            status=CODES.get("UNPROCESSABLE_ENTITY"),
                            mimetype=MIME_TYPES.get("APPLICATION_JSON"))

        try:
            schema = RegistrationDocumentsUpdateSchema()
            time = datetime.now().strftime('%Y%m%d%H%M%S')
            args = request.form.to_dict()
            args = Utilities.update_args_with_file(request.files, args)
            reg_details = RegDetails.get_by_id(reg_id)
            if reg_details:
                args.update({
                    'reg_details_id': reg_details.id,
                    'status': reg_details.status
                })
            else:
                args.update({'reg_details_id': ''})
            validation_errors = schema.validate(args)
            if validation_errors:
                return Response(app.json_encoder.encode(validation_errors),
                                status=CODES.get("UNPROCESSABLE_ENTITY"),
                                mimetype=MIME_TYPES.get("APPLICATION_JSON"))

            tracking_id = reg_details.tracking_id
            updated = RegDocuments.bulk_update(request.files, reg_details,
                                               time)
            response = Utilities.store_files(request.files, tracking_id, time)
            if response:
                return Response(json.dumps(response),
                                status=CODES.get("UNPROCESSABLE_ENTITY"),
                                mimetype=MIME_TYPES.get("APPLICATION_JSON"))
            if reg_details.status == Status.get_status_id(
                    'Information Requested'):
                reg_details.update_status('In Review')
                message = 'The request {id} has been updated.'.format(
                    id=reg_details.id)
                notification = Notification(reg_details.reviewer_id,
                                            reg_details.id,
                                            'registration_request',
                                            reg_details.status, message)
                notification.add()
            else:
                reg_details.update_status('Pending Review')
            response = schema.dump(updated, many=True).data
            db.session.commit()
            return Response(json.dumps(response),
                            status=CODES.get("OK"),
                            mimetype=MIME_TYPES.get("APPLICATION_JSON"))
        except Exception as e:  # pragma: no cover
            db.session.rollback()
            app.logger.exception(e)

            data = {
                'message':
                _('request document updation failed, please try again later.')
            }

            return Response(app.json_encoder.encode(data),
                            status=CODES.get('INTERNAL_SERVER_ERROR'),
                            mimetype=MIME_TYPES.get('APPLICATION_JSON'))
        finally:
            db.session.close()