def test_invalid_reviewer(flask_app, db): # pylint: disable=unused-argument
"""Verify that only assigned reviewer can un-assign the request and api responds
accordingly.
"""
# registration test
headers = {'Content-Type': 'application/json'}
data = {
'device_count': 1,
'imei_per_device': 1,
'imeis': "[['86834403015010']]",
'm_location': 'local',
'user_name': 'assign rev user 1',
'user_id': 'assign-rev-user-1'
}
reviewer_id = 'unassign-rev-1'
reviewer_name = 'unassign rev'
request = create_assigned_dummy_request(data, 'Registration', reviewer_id,
reviewer_name)
assert request
request_id = request.id
# make api call
request_data = {
'request_id': request_id,
'reviewer_id': 'abc-rev',
'request_type': 'registration_request'
}
rv = flask_app.put(UNASSIGN_REVIEWER_API,
data=json.dumps(request_data),
headers=headers)
assert rv.status_code == 400
response_data = json.loads(rv.data.decode('utf-8'))
assert response_data['error'] == ['invalid reviewer abc-rev']
# de-registration test
data = {
'file': 'de-reg-test-file',
'device_count': 1,
'user_id': 'assign-rev-user-1',
'user_name': 'assign rev user 1',
'reason': 'because we have to run tests successfully'
}
request = create_assigned_dummy_request(data, 'De-Registration',
reviewer_id, reviewer_name)
assert request
request_id = request.id
# make api call
request_data['request_id'] = request_id
request_data['request_type'] = 'de_registration_request'
request_data['reviewer_id'] = 'abc-rev'
rv = flask_app.put(UNASSIGN_REVIEWER_API,
data=json.dumps(request_data),
headers=headers)
assert rv.status_code == 400
response_data = json.loads(rv.data.decode('utf-8'))
assert response_data['error'] == ['invalid reviewer abc-rev']
def test_empty_sections(flask_app, db): # pylint: disable=unused-argument
"""Verify that the api returns correct info when there is not data in sections table."""
# registration request
data = {
'device_count': 2,
'imei_per_device': 1,
'imeis': "[['86834403015010', '86834403015011']]",
'm_location': 'local',
'user_name': 'section rev user 1',
'user_id': 'section-rev-user-1'
}
reviewer_id = 'section-rev-1'
reviewer_name = 'section rev'
request = create_assigned_dummy_request(data, 'Registration', reviewer_id,
reviewer_name)
assert request
request_id = request.id
rv = flask_app.get(
'{0}?request_id={1}&request_type=registration_request'.format(
SECTIONS_API, request_id))
assert rv.status_code == 200
data = json.loads(rv.data.decode('utf-8'))['sections']
for sect in data:
assert sect.get('section_type') in [
'device_description', 'imei_classification', 'imei_registration',
'approval_documents', 'device_quota'
]
assert sect.get('comments') is None
assert sect.get('section_status') is None
# de-registration test
dereg_data = {
'file': 'de-reg-test-file',
'device_count': 1,
'user_id': 'assign-rev-user-1',
'user_name': 'assign rev user 1',
'reason': 'because we have to run tests successfully'
}
request = create_assigned_dummy_request(dereg_data, 'De-Registration',
reviewer_id, reviewer_name)
assert request
request_id = request.id
rv = flask_app.get(
'{0}?request_id={1}&request_type=de_registration_request'.format(
SECTIONS_API, request_id))
assert rv.status_code == 200
data = json.loads(rv.data.decode('utf-8'))['sections']
for sect in data:
assert sect.get('section_type') in [
'device_description', 'imei_classification', 'imei_registration',
'approval_documents'
]
assert sect.get('comments') is None
assert sect.get('section_status') is None
def test_invalid_reviewer_id(flask_app, db): # pylint: disable=unused-argument
"""Verify that only assigned reviewer can submit the review and api responds properly"""
# registration request
headers = {'Content-Type': 'application/json'}
data = {
'device_count': 1,
'imei_per_device': 1,
'imeis': "[['86834403015010']]",
'm_location': 'local',
'user_name': 'assign rev user 1',
'user_id': 'assign-rev-user-1'
}
request = create_assigned_dummy_request(data, 'Registration', 'rev230987',
'rev 230987')
assert request
assert request.reviewer_id == 'rev230987'
request_id = request.id
body_data = {
'request_id': request_id,
'request_type': 'registration_request',
'reviewer_id': 'rev1'
}
rv = flask_app.put(SUBMIT_REVIEW_API,
data=json.dumps(body_data),
headers=headers)
assert rv.status_code == 400
assert json.loads(
rv.data.decode('utf-8'))['error'] == ['invalid reviewer rev1']
# de registration request
data = {
'file': 'de-reg-test-file',
'device_count': 1,
'user_id': 'assign-rev-user-1',
'user_name': 'assign rev user 1',
'reason': 'because we have to run tests successfully'
}
request = create_assigned_dummy_request(data, 'De-Registration',
'rev342567', 'rev 23')
assert request
assert request.reviewer_id == 'rev342567'
request_id = request.id
body_data = {
'request_id': request_id,
'request_type': 'de_registration_request',
'reviewer_id': 'rev1'
}
rv = flask_app.put(SUBMIT_REVIEW_API,
data=json.dumps(body_data),
headers=headers)
assert rv.status_code == 400
assert json.loads(
rv.data.decode('utf-8'))['error'] == ['invalid reviewer rev1']
def test_registration_request_duplicated_imeis(flask_app, db): # pylint: disable=unused-argument
"""Verify that the system does not allow the request approval when
there are duplicated imeis in the request and responds properly.
"""
headers = {'Content-Type': 'application/json'}
data = {
'device_count': 1,
'imei_per_device': 1,
'imeis': "[['00010673016999']]",
'm_location': 'local',
'user_name': 'reg req approve rev user 6',
'user_id': 'reg-req-approve-rev-user-6'
}
request = create_assigned_dummy_request(data, 'Registration',
'reg-req-approve-rev-user-6', 'reg req approve rev user 6')
assert request
request_id = request.id
user_id = request.user_id
# add duplicated imei to approvedimeis
approved_imei = ApprovedImeis('00010673016999', 673739, 'whitelist', 'update')
approved_imei.add()
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-6',
'reg req approve rev user 6', 6, request_id)
RegComments.add('device_description', 'test comment on section', 'reg-req-approve-rev-user-6',
'reg req approve rev user 6', 6, request_id)
RegComments.add('imei_classification', 'test comment on section', 'reg-req-approve-rev-user-6',
'reg req approve rev user 6', 6, request_id)
RegComments.add('imei_registration', 'test comment on section', 'reg-req-approve-rev-user-6',
'reg req approve rev user 6', 6, request_id)
RegComments.add('approval_documents', 'test comment on section', 'reg-req-approve-rev-user-6',
'reg req approve rev user 6', 6, request_id)
body_data = {
'request_id': request_id,
'request_type': 'registration_request',
'reviewer_id': 'reg-req-approve-rev-user-6'
}
rv = flask_app.put(SUBMIT_REVIEW_API, data=json.dumps(body_data), headers=headers)
assert rv.status_code == 400
data = json.loads(rv.data.decode('utf-8'))
assert data['error'] == ['unable to approve case {0}, duplicated imeis found'.format(request_id)]
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_user_device_quota(flask_app, db): # pylint: disable=unused-argument
"""Verify that the api correctly responds the user's device quota."""
# registration request
reviewer_id = 'section-rev-1'
reviewer_name = 'section rev'
user_name = 'dev quota user'
user_id = 'dev_quota_user_1'
data = {
'device_count': 2,
'imei_per_device': 1,
'imeis': "[['86834403015010', '86834403015011']]",
'm_location': 'local',
'user_name': user_name,
'user_id': user_id
}
request = create_assigned_dummy_request(data, 'Registration', reviewer_id,
reviewer_name)
assert request
request_id = request.id
# create a device quota
quota = DeviceQuota.get_or_create(user_id, 3)
assert quota
# api call
rv = flask_app.get('{0}?request_id={1}'.format(DEVICE_QUOTA_API,
request_id))
assert rv.status_code == 200
response = json.loads(rv.data.decode('utf-8'))
assert response['allowed_import_quota'] == quota['reg_quota']
assert response['allowed_export_quota']
assert quota['user_id'] == user_id
assert response['request_device_count'] == 2
def test_valid_search_specs(flask_app):
"""Validate search specs parameters and respond with valid status code."""
# Check empty result is return
headers = {'Content-type': 'application/json'}
body_data = {
"start": 1,
"limit": 10,
"search_specs": {
"group": "reviewer",
"request_type": 1,
"user_id": "90X1A-XXXX"
},
"search_args": {
"id": "100000"
}
}
rv = flask_app.post(SEARCH_API,
data=json.dumps(body_data),
headers=headers)
assert rv.status_code == 200
data = json.loads(rv.data.decode('utf-8'))
assert data['requests'] == []
# Return all records
data = {
'device_count': 1,
'imei_per_device': 1,
'imeis': "[['86834403380296']]",
'm_location': 'local',
'user_name': 'Test_User_1',
'user_id': '717'
}
request = create_assigned_dummy_request(data, 'Registration',
'Test-Reviewer', 'reviewer-1')
assert request
device_data = {
'brand': 'Honor',
'operating_system': 'android',
'model_name': 'Honor 8X',
'model_num': '8X',
'device_type': 'Smartphone',
'technologies': ['2G', '3G', '4G'],
'reg_id': request.id
}
request = create_dummy_devices(device_data, 'Registration', request)
assert request
body_data['search_args'] = {}
rv = flask_app.post(SEARCH_API,
data=json.dumps(body_data),
headers=headers)
assert rv.status_code == 200
data = json.loads(rv.data.decode('utf-8'))
assert data['requests'] != []
def test_de_registration_request_none_status_section(flask_app, db, app):
"""Verify that if any status is none the the system does not allow
submission and api responds accordingly.
"""
headers = {'Content-Type': 'application/json'}
de_registration_data = {
'file': 'de-reg-test-file.txt',
'device_count': 1,
'user_id': 'dereg-req-approve-rev-user-13',
'user_name': 'dereg req approve rev user 13',
'reason': 'because we have to run tests successfully'
}
request = create_assigned_dummy_request(de_registration_data,
'De_Registration',
'dereg-req-approve-rev-user-13',
'dereg req approve rev user 13')
device_data = {
'devices': """[
{
"tac": "12111119",
"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=['121111191115009'],
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-req-approve-rev-user-13',
'dereg req approve rev user 13', 6, request_id)
body_data = {
'request_id': request_id,
'request_type': 'de_registration_request',
'reviewer_id': 'dereg-req-approve-rev-user-13'
}
rv = flask_app.put(SUBMIT_REVIEW_API,
data=json.dumps(body_data),
headers=headers)
assert rv.status_code == 400
response = json.loads(rv.data.decode('utf-8'))
assert response['error'] == [
'unable to update case {0}, complete the review process'.format(
request_id)
]
def test_registration_request_info_requested_status_priority(flask_app, db): # pylint: disable=unused-argument
"""Verify that the information requested section status has the 2nd highest priority means
when any of the section is marked as information requested the whole case will be marked as
information requested regardless of other section statuses.
"""
headers = {'Content-Type': 'application/json'}
data = {
'device_count': 1,
'imei_per_device': 1,
'imeis': "[['44414441016777']]",
'm_location': 'local',
'user_name': 'reg req approve rev user 10',
'user_id': 'reg-req-approve-rev-user-10'
}
request = create_assigned_dummy_request(data, 'Registration',
'reg-req-approve-rev-user-10', 'reg req approve rev user 10')
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
# mark only one section as information requested
RegComments.add('device_quota', 'test comment on section', 'reg-req-approve-rev-user-10',
'reg req approve rev user 10', 6, request_id)
RegComments.add('device_description', 'test comment on section', 'reg-req-approve-rev-user-10',
'reg req approve rev user 10', 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-10'
}
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
def test_device_count(flask_app):
"""Verifies valid device_count input search parameter
and respond with positive or empty result and status code."""
data = {
'device_count': 1,
'imei_per_device': 2,
'imeis': "[['86834403380270','86834403380271']]",
'm_location': 'local',
'user_name': 'Test_User',
'user_id': '800'
}
request = create_assigned_dummy_request(data, 'Registration',
'Test-Reviewer', 'reviewer-1')
assert request
device_data = {
'brand': 'Xiaomi',
'operating_system': 'android',
'model_name': 'Mi 8',
'model_num': 'Mi 8',
'device_type': 'Smartphone',
'technologies': ['2G', '3G'],
'reg_id': request.id
}
request_device = create_dummy_devices(device_data, 'Registration', request)
assert request_device
headers = {'Content-type': 'application/json'}
body_data = {
"start": 1,
"limit": 10,
"search_specs": {
"group": "importer",
"request_type": 1,
"user_id": "800"
},
"search_args": {}
}
body_data['search_args']['device_count'] = data['device_count']
rv = flask_app.post(SEARCH_API,
data=json.dumps(body_data),
headers=headers)
assert rv.status_code == 200
result = json.loads(rv.data.decode('utf-8'))
assert result['requests'] != []
body_data['search_args']['device_count'] = 10000
rv = flask_app.post(SEARCH_API,
data=json.dumps(body_data),
headers=headers)
assert rv.status_code == 200
result = json.loads(rv.data.decode('utf-8'))
assert result['requests'] == []
def test_multiple_tac_device_de_registration(flask_app, app, db, dirbs_core): # pylint: disable=unused-argument
"""Verify that the device description api returns description for multiple devices."""
# de registration request
de_registration_data = {
'file': 'de-reg-test-file.txt',
'device_count': 1,
'user_id': 'assign-rev-user-1',
'user_name': 'assign rev user 1',
'reason': 'because we have to run tests successfully'
}
request = create_assigned_dummy_request(de_registration_data,
'De_Registration', 'dereg-rev',
'de reg rev')
device_data = {
'devices': """[
{
"tac": "35732108",
"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"
},
{
"tac": "35733109",
"model_name": "TA-11132",
"brand_name": "NOKIA",
"model_num": "TA-11132",
"technology": "TEC",
"device_type": "Smartphone",
"count": 1,
"operating_system": "Android"
}
]""",
'dereg_id': request.id
}
request = create_dummy_devices(device_data,
'De_Registration',
request,
db,
file_content=['357321082345123'],
file_path='{0}/{1}/{2}'.format(
app.config['DRS_UPLOADS'],
request.tracking_id,
de_registration_data.get('file')))
rv = flask_app.get(
'{0}?request_id={1}&request_type=de_registration_request'.format(
DEVICE_DESCRIPTION_API, request.id))
assert rv.status_code == 200
data = json.loads(rv.data.decode('utf-8'))
assert data
assert data.get('user_device_description')
assert data.get('gsma_device_description')
assert len(data.get('user_device_description')) == 2
assert isinstance(data.get('gsma_device_description'), list)
def test_registration_request_rejected_status_priority(flask_app, db): # pylint: disable=unused-argument
"""Verify that the rejected section status have highest priority means
even if the first section is rejected, remaining are not reviewed, the
system allows the review submission and mark the request as rejected.
"""
headers = {'Content-Type': 'application/json'}
data = {
'device_count': 1,
'imei_per_device': 1,
'imeis': "[['33310001016666']]",
'm_location': 'local',
'user_name': 'reg req approve rev user 9',
'user_id': 'reg-req-approve-rev-user-9'
}
request = create_assigned_dummy_request(data, 'Registration',
'reg-req-approve-rev-user-9',
'reg req approve rev user 9')
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
# reject device quota and mark device_description as info-requested
RegComments.add('device_quota', 'test comment on section',
'reg-req-approve-rev-user-9', 'reg req approve rev user 9',
7, request_id)
RegComments.add('device_description', 'test comment on section',
'reg-req-approve-rev-user-9', 'reg req approve rev user 9',
5, request_id)
body_data = {
'request_id': request_id,
'request_type': 'registration_request',
'reviewer_id': 'reg-req-approve-rev-user-9'
}
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'] == 7
assert data['request_id'] == request_id
def test_registration_request_any_section_none(flask_app, db): # pylint: disable=unused-argument
"""Verify that the system does not allow to submit the review when any
of the section is not reviewed or status is none.
"""
headers = {'Content-Type': 'application/json'}
data = {
'device_count': 1,
'imei_per_device': 1,
'imeis': "[['22210376016777']]",
'm_location': 'local',
'user_name': 'reg req approve rev user 8',
'user_id': 'reg-req-approve-rev-user-8'
}
request = create_assigned_dummy_request(data, 'Registration',
'reg-req-approve-rev-user-8',
'reg req approve rev user 8')
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 only 2 section, leave rest of them none
RegComments.add('device_quota', 'test comment on section',
'reg-req-approve-rev-user-8', 'reg req approve rev user 8',
6, request_id)
RegComments.add('device_description', 'test comment on section',
'reg-req-approve-rev-user-8', 'reg req approve rev user 8',
6, request_id)
body_data = {
'request_id': request_id,
'request_type': 'registration_request',
'reviewer_id': 'reg-req-approve-rev-user-8'
}
rv = flask_app.put(SUBMIT_REVIEW_API,
data=json.dumps(body_data),
headers=headers)
assert rv.status_code == 400
data = json.loads(rv.data.decode('utf-8'))
assert data['error'] == [
'unable to update case {0}, complete review process'.format(request_id)
]
def test_de_registration_request_info_requested(flask_app, db, app):
"""Verify that the system mark the request as information requested even when only one of the
sections is marked as information requested.
"""
headers = {'Content-Type': 'application/json'}
de_registration_data = {
'file': 'de-reg-test-file.txt',
'device_count': 1,
'user_id': 'dereg-req-approve-rev-user-12',
'user_name': 'dereg req approve rev user 12',
'reason': 'because we have to run tests successfully'
}
request = create_assigned_dummy_request(de_registration_data, 'De_Registration', 'dereg-req-approve-rev-user-12',
'dereg req approve rev user 12')
device_data = {
'devices': """[
{
"tac": "12000009",
"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=['120000091115009'],
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-req-approve-rev-user-12',
'dereg req approve rev user 12', 6, request_id)
DeRegComments.add('imei_classification', 'test comment on section', 'dereg-req-approve-rev-user-12',
'dereg req approve rev user 12', 5, request_id)
DeRegComments.add('imei_registration', 'test comment on section', 'dereg-req-approve-rev-user-12',
'dereg req approve rev user 12', 6, request_id)
DeRegComments.add('approval_documents', 'test comment on section', 'dereg-req-approve-rev-user-12',
'dereg req approve rev user 12', 6, request_id)
body_data = {
'request_id': request_id,
'request_type': 'de_registration_request',
'reviewer_id': 'dereg-req-approve-rev-user-12'
}
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['request_id'] == request_id
assert response['status'] == 5
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_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_de_registration_set_imei_report_permissions_assigned_request(flask_app, db): # pylint: disable=unused-argument
"""Verify that POST method to test dashboard reports for reviewer user"""
de_reg_request = create_assigned_dummy_request(DE_REG_REQUEST_DATA, 'De-Registration', USER_ID, USER_NAME)
url = IMEI_REPORT_PERMISSION
request_data = {
"request_type": "de_registration_request",
"request_id": "{0}".format(de_reg_request.id),
"user_type": "reviewer",
"user_id": "{0}".format(USER_ID)
}
headers = {'Content-Type': 'application/json'}
rv = flask_app.post(url, data=json.dumps(request_data), headers=headers)
assert rv.status_code == 200
def test_empty_classification_state(flask_app, db): # pylint: disable=unused-argument
"""Verify that the api responds properly if there is no summary in the summary column."""
# registration
registration_data = {
'device_count': 2,
'imei_per_device': 1,
'imeis': "[['86834403015010', '868344039012345']]",
'm_location': 'local',
'user_name': '3234323imei stat user 1',
'user_id': '434334imei-stat-user-1'
}
request = create_assigned_dummy_request(registration_data, 'Registration',
'434dev-descp-1', 'd4343ev descp')
rv = flask_app.get(
'{0}?request_id={1}&request_type=registration_request'.format(
CLASSIFICATION_API, request.id))
assert rv.status_code == 200
data = json.loads(rv.data.decode('utf-8'))
assert data == {}
# de-registration
# de-registration
data = {
'file': 'de-reg-test-file',
'device_count': 1,
'user_id': '2323323assign-rev-user-1',
'user_name': '3233assign rev user 1',
'reason': 'because we have to run tests successfully'
}
request = create_assigned_dummy_request(data, 'De-Registration',
'323dev-descp-1', '3233dev descp')
rv = flask_app.get(
'{0}?request_id={1}&request_type=de_registration_request'.format(
CLASSIFICATION_API, request.id))
assert rv.status_code == 200
data = json.loads(rv.data.decode('utf-8'))
assert data == {}
def test_review_sections_de_registration(flask_app, db): # pylint: disable=unused-argument
"""Verify that the api returns correct information of sections."""
# de-registration test
reviewer_id = 'section-rev-1-0'
reviewer_name = 'section rev0'
dereg_data = {
'file': 'de-reg-test-file',
'device_count': 1,
'user_id': 'assign-rev-user-1',
'user_name': 'assign rev user 1',
'reason': 'because we have to run tests successfully'
}
request = create_assigned_dummy_request(dereg_data, 'De-Registration',
reviewer_id, reviewer_name)
assert request
request_id = request.id
reviewer_id = 'section-rev-2'
reviewer_name = 'section rev 2'
section = 'device_description'
status = 7
comment = 'this is a test comment'
DeRegDetails.add_comment(section, comment, reviewer_id, reviewer_name,
status, request_id)
rv = flask_app.get(
'{0}?request_id={1}&request_type=de_registration_request'.format(
SECTIONS_API, request_id))
assert rv.status_code == 200
data = json.loads(rv.data.decode('utf-8'))['sections']
for sect in data:
if sect.get('comments'):
assert sect.get('section_type') == section
assert sect.get('section_status') == status
sect_comment = sect.get('comments')[0]
assert sect_comment.get('user_name') == reviewer_name
assert sect_comment.get('user_id') == reviewer_id
assert sect_comment.get('comment') == comment
assert sect_comment.get('datetime')
else:
assert sect.get('section_type') in [
'device_description', 'imei_classification',
'imei_registration', 'approval_documents'
]
assert sect.get('comments') is None
assert sect.get('section_status') is None
def test_review_sections_registration(flask_app, db): # pylint: disable=unused-argument
"""Verify that the api returns correct information of sections."""
# registration request
data = {
'device_count': 2,
'imei_per_device': 1,
'imeis': "[['86834403015010', '86834403015011']]",
'm_location': 'local',
'user_name': 'section rev user 1',
'user_id': 'section-rev-user-1'
}
reviewer_id = 'section-rev-1'
reviewer_name = 'section rev'
section = 'device_quota'
status = 6
comment = 'this is a test comment'
request = create_assigned_dummy_request(data, 'Registration', reviewer_id,
reviewer_name)
assert request
request_id = request.id
RegDetails.add_comment(section, comment, reviewer_id, reviewer_name,
status, request_id)
rv = flask_app.get(
'{0}?request_id={1}&request_type=registration_request'.format(
SECTIONS_API, request_id))
assert rv.status_code == 200
data = json.loads(rv.data.decode('utf-8'))['sections']
for sect in data:
if sect.get('comments'):
assert sect.get('section_type') == section
assert sect.get('section_status') == status
sect_comment = sect.get('comments')[0]
assert sect_comment.get('user_name') == reviewer_name
assert sect_comment.get('user_id') == reviewer_id
assert sect_comment.get('comment') == comment
assert sect_comment.get('datetime')
else:
assert sect.get('section_type') in [
'device_description', 'imei_classification',
'imei_registration', 'approval_documents'
]
assert sect.get('comments') is None
assert sect.get('section_status') is None
def test_valid_invalid_date(flask_app, db, app):
"""Search by date and return all result of current user and empty search result"""
de_registration_data = {
'file': 'de-reg-test-file.txt',
'device_count': 1,
'user_id': 'assign-rev-user-1',
'user_name': 'assign rev user 1',
'reason': 'because we have to run tests successfully'
}
request = create_assigned_dummy_request(de_registration_data,
'De_Registration', 'dereg-rev',
'de reg rev')
device_data = {
'devices': """[
{
"tac": "35732108",
"model_name": "Nokia 6",
"brand_name": "Nokia",
"model_num": "TA-1034",
"technology": "3G,4G",
"device_type": "Mobile Phone/Feature phone",
"count": 2,
"operating_system": "Android"
}
]""",
'dereg_id': request.id
}
documents = [
{
'label': 'shipment document',
'file_name': 'shipment.pdf'
},
{
'label': 'authorization document',
'file_name': 'authorize.pdf'
},
{
'label': 'certificate document',
'file_name': 'certf.pdf'
},
]
request = create_dummy_devices(
device_data,
'De_Registration',
request,
db,
file_content=['357321082345123', '357321082345124'],
file_path='{0}/{1}/{2}'.format(app.config['DRS_UPLOADS'],
request.tracking_id,
de_registration_data.get('file')))
request = create_dummy_documents(documents, 'De-Registration', request,
app)
assert request
request_id = request.id
rv = flask_app.get(
'{0}?request_id={1}&request_type=de_registration_request'.format(
DOCUMENTS_API, request_id))
assert rv.status_code == 200
headers = {'Content-type': 'application/json'}
body_data = {
"start": 1,
"limit": 10,
"search_specs": {
"group": "exporter",
"request_type": 2,
"user_id": "assign-rev-user-1"
},
"search_args": {}
}
# Valid Date Check
body_data['search_args']['created_at'] = \
request.created_at.strftime("%Y-%m-%d") + ',' + request.created_at.strftime("%Y-%m-%d")
rv = flask_app.post(SEARCH_API,
data=json.dumps(body_data),
headers=headers)
assert rv.status_code == 200
result = json.loads(rv.data.decode('utf-8'))
assert result['requests'] != []
body_data['search_args'] = {}
body_data['search_args']['created_at'] = request.created_at.strftime(
"%Y-%m-%d") + ',' + request.created_at.strftime("%Y-%m-%d")
body_data['search_args']['updated_at'] = request.updated_at.strftime(
"%Y-%m-%d") + ',' + request.updated_at.strftime("%Y-%m-%d")
rv = flask_app.post(SEARCH_API,
data=json.dumps(body_data),
headers=headers)
assert rv.status_code == 200
result = json.loads(rv.data.decode('utf-8'))
assert result['requests'] != []
# InValid Date Check
body_data['search_args'] = {}
body_data['search_args']['created_at'] = '2020-12-11' + ',' + '2018-12-11'
rv = flask_app.post(SEARCH_API,
data=json.dumps(body_data),
headers=headers)
assert rv.status_code == 200
result = json.loads(rv.data.decode('utf-8'))
assert result['requests'] == []
def test_technologies(flask_app, db, app):
"""Validate technologies input search parameter and respond with positive result and status code."""
de_registration_data = {
'file': 'de-reg-test-file.txt',
'device_count': 1,
'user_id': 'assign-rev-user-1',
'user_name': 'assign rev user 1',
'reason': 'because we have to run tests successfully'
}
request = create_assigned_dummy_request(de_registration_data,
'De_Registration', 'dereg-rev',
'de reg rev')
device_data = {
'devices': """[
{
"tac": "35732108",
"model_name": "Nokia 6",
"brand_name": "Nokia",
"model_num": "TA-1034",
"technology": "3G,4G",
"device_type": "Mobile Phone/Feature phone",
"count": 2,
"operating_system": "Android"
}
]""",
'dereg_id': request.id
}
documents = [
{
'label': 'shipment document',
'file_name': 'shipment.pdf'
},
{
'label': 'authorization document',
'file_name': 'authorize.pdf'
},
{
'label': 'certificate document',
'file_name': 'certf.pdf'
},
]
request = create_dummy_devices(
device_data,
'De_Registration',
request,
db,
file_content=['357321082345123', '357321082345124'],
file_path='{0}/{1}/{2}'.format(app.config['DRS_UPLOADS'],
request.tracking_id,
de_registration_data.get('file')))
request = create_dummy_documents(documents, 'De-Registration', request,
app)
assert request
request_id = request.id
rv = flask_app.get(
'{0}?request_id={1}&request_type=de_registration_request'.format(
DOCUMENTS_API, request_id))
assert rv.status_code == 200
headers = {'Content-type': 'application/json'}
body_data = {
"start": 1,
"limit": 10,
"search_specs": {
"group": "reviewer",
"request_type": 2,
"user_id": ""
},
"search_args": {
'technologies': ["3G"]
}
}
rv = flask_app.post(SEARCH_API,
data=json.dumps(body_data),
headers=headers)
assert rv.status_code == 200
result = json.loads(rv.data.decode('utf-8'))
assert result['requests'] != []
body_data['search_args']['technologies'] = ['3G', '4G']
body_data["search_args"]['brand'] = device_data['devices'][0]['brand_name']
body_data["search_args"]['model_name'] = device_data['devices'][0][
'model_name']
rv = flask_app.post(SEARCH_API,
data=json.dumps(body_data),
headers=headers)
assert rv.status_code == 200
result = json.loads(rv.data.decode('utf-8'))
assert result['requests'] != []
body_data['search_args']['technologies'] = ['3G']
body_data["search_args"]['brand'] = device_data['devices'][0]['brand_name']
body_data["search_args"]['model_name'] = device_data['devices'][0][
'model_name']
rv = flask_app.post(SEARCH_API,
data=json.dumps(body_data),
headers=headers)
assert rv.status_code == 200
result = json.loads(rv.data.decode('utf-8'))
assert result['requests'] != []
def test_search_invalid_parameters(flask_app):
"""Validate invalid seach specification input parameters and respond with proper status code."""
data = {
'device_count': 1,
'imei_per_device': 2,
'imeis': "[['86834403380268','86834403380269']]",
'm_location': 'local',
'user_name': 'Test_User',
'user_id': '800'
}
request = create_assigned_dummy_request(data, 'Registration',
'Test-Reviewer', 'reviewer-1')
assert request
device_data = {
'brand': 'Xiaomi',
'operating_system': 'android',
'model_name': 'Mi 8',
'model_num': 'Mi 8',
'device_type': 'Smartphone',
'technologies': ['2G', '3G', '4G'],
'reg_id': request.id
}
request = create_dummy_devices(device_data, 'Registration', request)
assert request
headers = {'Content-type': 'application/json'}
# Reviewer invalid request parameters
body_data = {
"start": 1,
"limit": 10,
"search_specs": {
"group": "reviewer",
"request_type": 1,
"user_id": ""
},
"search_args": {
"tracking_id": "string",
"created_at": "string",
"updated_at": "string",
"device_count": "string",
"status": "string",
"brand": "string",
"model_name": "string",
"operating_system": "string",
"device_type": "string",
"imeis": ["string", "string"]
}
}
rv = flask_app.post(SEARCH_API,
data=json.dumps(body_data),
headers=headers)
assert rv.status_code == 404
data = json.loads(rv.data.decode('utf-8'))
assert data['message'] == "Not Found"
# Individual user invalid parameters
body_data['search_specs']['group'] = "individual"
body_data['search_specs']['user_id'] = '800'
rv = flask_app.post(SEARCH_API,
data=json.dumps(body_data),
headers=headers)
assert rv.status_code == 404
data = json.loads(rv.data.decode('utf-8'))
assert data['message'] == "Not Found"
# importer user parameters
body_data['search_specs']['group'] = "importer"
body_data['search_specs']['user_id'] = '800'
rv = flask_app.post(SEARCH_API,
data=json.dumps(body_data),
headers=headers)
assert rv.status_code == 404
data = json.loads(rv.data.decode('utf-8'))
assert data['message'] == "Not Found"
assert data['requests'] == []
def test_imei_classification(flask_app, db): # pylint: disable=unused-argument
"""Verify that the api returns correct imei classification information."""
# registration request
registration_data = {
'device_count': 2,
'imei_per_device': 1,
'imeis': "[['86834403015010', '868344039012345']]",
'm_location': 'local',
'user_name': '4yyjhhkhkimei stat user 1',
'user_id': 'imeihfhdhhd-stat-user-1'
}
summary = {
"provisional_compliant": 0,
"non_complaint": 10,
"count_per_condition": {
"not_on_registration_list": 0,
"on_local_stolen_list": 0,
"gsma_not_found": 0,
"duplicate_compound": 0
},
"provisional_stolen": 0,
"compliant_report_name":
"compliant_report669f9938-1ffb-468e-b303-f73385a1b9e0.tsv",
"provisional_non_compliant": 0,
"complaint": 0,
"seen_on_network": 0,
"stolen": 0,
"verified_imei": 10
}
request = create_assigned_dummy_request(registration_data, 'Registration',
'23233eeedev-descp-1',
'3323eeedev descp')
request.update_summary(summary)
rv = flask_app.get(
'{0}?request_id={1}&request_type=registration_request'.format(
CLASSIFICATION_API, request.id))
assert rv.status_code == 200
data = json.loads(rv.data.decode('utf-8'))
assert data['lost_stolen_status']['provisional_stolen'] == 0
assert data['lost_stolen_status']['stolen'] == 0
assert data['seen_on_network'] == 0
assert data['imei_compliance_status']['compliant_imeis'] == 0
assert data['imei_compliance_status']['non_compliant_imeis'] == 10
assert data['imei_compliance_status']['provisional_non_compliant'] == 0
assert data['imei_compliance_status']['provisional_compliant'] == 0
assert data['per_condition_classification_state'][
'not_on_registration_list'] == 0
assert data['per_condition_classification_state'][
'on_local_stolen_list'] == 0
assert data['per_condition_classification_state']['gsma_not_found'] == 0
assert data['per_condition_classification_state'][
'duplicate_compound'] == 0
# de-registration
data = {
'file': 'de-reg-test-file',
'device_count': 1,
'user_id': 'avbvvssign-rev-user-1',
'user_name': 'avbvbbvssign rev user 1',
'reason': 'because we have to run tests successfully'
}
request = create_assigned_dummy_request(data, 'De-Registration',
'dew3223ev-descp-1',
'de322ev descp')
assert request
request.update_summary(summary)
rv = flask_app.get(
'{0}?request_id={1}&request_type=de_registration_request'.format(
CLASSIFICATION_API, request.id))
assert rv.status_code == 200
data = json.loads(rv.data.decode('utf-8'))
assert data['lost_stolen_status']['provisional_stolen'] == 0
assert data['lost_stolen_status']['stolen'] == 0
assert data['seen_on_network'] == 0
assert data['imei_compliance_status']['compliant_imeis'] == 0
assert data['imei_compliance_status']['non_compliant_imeis'] == 10
assert data['imei_compliance_status']['provisional_non_compliant'] == 0
assert data['imei_compliance_status']['provisional_compliant'] == 0
assert data['per_condition_classification_state'][
'not_on_registration_list'] == 0
assert data['per_condition_classification_state'][
'on_local_stolen_list'] == 0
assert data['per_condition_classification_state']['gsma_not_found'] == 0
assert data['per_condition_classification_state'][
'duplicate_compound'] == 0
def test_search_valid_parameters(flask_app):
"""Validate/Verifies valid search parameters all valid search inputs and respond with proper status code."""
data = {
'device_count': 1,
'imei_per_device': 2,
'imeis': "[['86834403380270','86834403380271']]",
'm_location': 'local',
'user_name': 'Test_User',
'user_id': '800'
}
request = create_assigned_dummy_request(data, 'Registration',
'Test-Reviewer', 'reviewer-1')
assert request
device_data = {
'brand': 'Xiaomi',
'operating_system': 'android',
'model_name': 'Mi 8',
'model_num': 'Mi 8',
'device_type': 'Smartphone',
'technologies': ['2G', '3G'],
'reg_id': request.id
}
request = create_dummy_devices(device_data, 'Registration', request)
assert request
headers = {'Content-type': 'application/json'}
# Reviewer Valid request parameters
body_data = {
"start": 1,
"limit": 10,
"search_specs": {
"group": "reviewer",
"request_type": 1,
"user_id": ""
},
"search_args": {
"id":
request.id,
"tracking_id":
request.tracking_id,
"brand":
device_data['brand'],
"created_at":
request.created_at.strftime("%Y-%m-%d") + ',' +
request.updated_at.strftime("%Y-%m-%d"),
"updated_at":
request.created_at.strftime("%Y-%m-%d") + ',' +
request.updated_at.strftime("%Y-%m-%d"),
"device_count":
request.device_count,
"model_name":
device_data['model_name'],
"operating_system":
device_data['operating_system'],
"device_type":
device_data['device_type'],
"imeis": ['86834403380270', '86834403380271'],
"technologies":
device_data['technologies']
}
}
rv = flask_app.post(SEARCH_API,
data=json.dumps(body_data),
headers=headers)
assert rv.status_code == 200
result = json.loads(rv.data.decode('utf-8'))
assert result['requests'] != []
body_data['search_args'] = {}
body_data['search_args']['imeis'] = ['86834403380270']
body_data['search_args']['device_count'] = request.device_count
rv = flask_app.post(SEARCH_API,
data=json.dumps(body_data),
headers=headers)
assert rv.status_code == 200
result = json.loads(rv.data.decode('utf-8'))
assert result['requests'] != []
body_data['search_args'] = {}
body_data['search_specs']['group'] = 'importer'
body_data['search_specs']['user_id'] = data['user_id']
rv = flask_app.post(SEARCH_API,
data=json.dumps(body_data),
headers=headers)
assert rv.status_code == 200
result = json.loads(rv.data.decode('utf-8'))
assert result['requests'] != []
body_data['search_args'] = {}
body_data['search_args']['status'] = "In Review"
rv = flask_app.post(SEARCH_API,
data=json.dumps(body_data),
headers=headers)
assert rv.status_code == 200
result = json.loads(rv.data.decode('utf-8'))
assert result['requests'] != []
def test_valid_invalid_date(flask_app):
"""Search by date and return all result of current user and empty search result"""
data = {
'device_count': 1,
'imei_per_device': 2,
'imeis': "[['86834403380270','86834403380271']]",
'm_location': 'local',
'user_name': 'Test_User',
'user_id': '800'
}
request = create_assigned_dummy_request(data, 'Registration',
'Test-Reviewer', 'reviewer-1')
assert request
device_data = {
'brand': 'Xiaomi',
'operating_system': 'android',
'model_name': 'Mi 8',
'model_num': 'Mi 8',
'device_type': 'Smartphone',
'technologies': ['2G', '3G'],
'reg_id': request.id
}
request = create_dummy_devices(device_data, 'Registration', request)
assert request
headers = {'Content-type': 'application/json'}
body_data = {
"start": 1,
"limit": 10,
"search_specs": {
"group": "importer",
"request_type": 1,
"user_id": "800"
},
"search_args": {}
}
# Valid Date Check
body_data['search_args']['created_at'] = \
request.created_at.strftime("%Y-%m-%d") + ',' + request.created_at.strftime("%Y-%m-%d")
rv = flask_app.post(SEARCH_API,
data=json.dumps(body_data),
headers=headers)
assert rv.status_code == 200
result = json.loads(rv.data.decode('utf-8'))
assert result['requests'] != []
body_data['search_args'] = {}
body_data['search_args']['created_at'] = request.created_at.strftime(
"%Y-%m-%d") + ',' + request.created_at.strftime("%Y-%m-%d")
body_data['search_args']['updated_at'] = request.updated_at.strftime(
"%Y-%m-%d") + ',' + request.updated_at.strftime("%Y-%m-%d")
rv = flask_app.post(SEARCH_API,
data=json.dumps(body_data),
headers=headers)
assert rv.status_code == 200
result = json.loads(rv.data.decode('utf-8'))
assert result['requests'] != []
# InValid Date Check
body_data['search_args'] = {}
body_data['search_args']['created_at'] = '2020-12-11' + ',' + '2018-12-11'
rv = flask_app.post(SEARCH_API,
data=json.dumps(body_data),
headers=headers)
assert rv.status_code == 200
result = json.loads(rv.data.decode('utf-8'))
assert result['requests'] == []
def test_de_registration_request_approval(flask_app, db, app):
"""Verify that the system approves the request when all the sections are approved
and de-register imeis successfully.
"""
headers = {'Content-Type': 'application/json'}
data = {
'device_count': 1,
'imei_per_device': 1,
'imeis': "[['121621090005119']]",
'm_location': 'local',
'user_name': 'reg req approve rev user 9',
'user_id': 'reg-req-approve-rev-user-9'
}
request = create_assigned_dummy_request(data, 'Registration',
'dereg-req-approve-rev-user-10', 'dereg req approve rev user 10')
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
de_registration_data = {
'file': 'de-reg-test-file.txt',
'device_count': 1,
'user_id': 'dereg-req-approve-rev-user-10',
'user_name': 'dereg req approve rev user 10',
'reason': 'because we have to run tests successfully'
}
request = create_assigned_dummy_request(de_registration_data, 'De_Registration', 'dereg-req-approve-rev-user-10',
'dereg req approve rev user 10')
device_data = {
'devices': """[
{
"tac": "12162109",
"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=['121621090005119'],
file_path='{0}/{1}/{2}'.format(app.config['DRS_UPLOADS'], request.tracking_id,
de_registration_data.get('file')))
assert request
request_id = request.id
# add imei to approvedimeis as whitelist to de register
approved_imei = ApprovedImeis.get_imei('12162109000511')
approved_imei.status = 'whitelist'
approved_imei.delta_status = 'update'
ApprovedImeis.bulk_insert_imeis([approved_imei])
DeRegComments.add('device_description', 'test comment on section', 'dereg-req-approve-rev-user-10',
'dereg req approve rev user 10', 6, request_id)
DeRegComments.add('imei_classification', 'test comment on section', 'dereg-req-approve-rev-user-10',
'dereg req approve rev user 10', 6, request_id)
DeRegComments.add('imei_registration', 'test comment on section', 'dereg-req-approve-rev-user-10',
'dereg req approve rev user 10', 6, request_id)
DeRegComments.add('approval_documents', 'test comment on section', 'dereg-req-approve-rev-user-10',
'dereg req approve rev user 10', 6, request_id)
body_data = {
'request_id': request_id,
'request_type': 'de_registration_request',
'reviewer_id': 'dereg-req-approve-rev-user-10'
}
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'))
imei = ApprovedImeis.get_imei('12162109000511')
assert response['request_type'] == 'de_registration_request'
assert response['status'] == 6
assert response['request_id'] == request_id
assert imei.status == 'removed'
def test_valid_invalid_imeis(flask_app, db, app):
"""Search by IMEI and return all result of current/reviewer user"""
de_registration_data = {
'file': 'de-reg-test-file.txt',
'device_count': 1,
'user_id': 'assign-rev-user-1',
'user_name': 'assign rev user 1',
'reason': 'because we have to run tests successfully'
}
request = create_assigned_dummy_request(de_registration_data,
'De_Registration', 'dereg-rev',
'de reg rev')
device_data = {
'devices': """[
{
"tac": "35732108",
"model_name": "Nokia 6",
"brand_name": "Nokia",
"model_num": "TA-1034",
"technology": "3G,4G",
"device_type": "Mobile Phone/Feature phone",
"count": 2,
"operating_system": "Android"
}
]""",
'dereg_id': request.id
}
documents = [
{
'label': 'shipment document',
'file_name': 'shipment.pdf'
},
{
'label': 'authorization document',
'file_name': 'authorize.pdf'
},
{
'label': 'certificate document',
'file_name': 'certf.pdf'
},
]
request = create_dummy_devices(
device_data,
'De_Registration',
request,
db,
file_content=['357321082345123', '357321082345224'],
file_path='{0}/{1}/{2}'.format(app.config['DRS_UPLOADS'],
request.tracking_id,
de_registration_data.get('file')))
request = create_dummy_documents(documents, 'De-Registration', request,
app)
assert request
request_id = request.id
rv = flask_app.get(
'{0}?request_id={1}&request_type=de_registration_request'.format(
DOCUMENTS_API, request_id))
assert rv.status_code == 200
sql = "Update deregimei set device_id=1, imei=357321082345123, norm_imei=3573210823451 where id =1"
db.session.execute(sql)
sql = "Insert into deregimei(imei, norm_imei, device_id) VALUES('357321082345224', '3573210823452', 1)"
db.session.execute(sql)
headers = {'Content-type': 'application/json'}
body_data = {
"start": 1,
"limit": 10,
"search_specs": {
"group": "reviewer",
"request_type": 2,
"user_id": ""
},
"search_args": {
"imeis": ['357321082345123', '357321082345224']
}
}
rv = flask_app.post(SEARCH_API,
data=json.dumps(body_data),
headers=headers)
assert rv.status_code == 200
result = json.loads(rv.data.decode('utf-8'))
assert result['requests'] != []
sql = "Update deregimei set device_id=1, imei=357321082345123, norm_imei=3573210823451 where id =1"
db.session.execute(sql)
sql = "Insert into deregimei(imei, norm_imei, device_id) VALUES('357321082345224', '3573210823452', 1)"
db.session.execute(sql)
body_data["search_args"]['imeis'] = ['357321082345123']
rv = flask_app.post(SEARCH_API,
data=json.dumps(body_data),
headers=headers)
assert rv.status_code == 200
result = json.loads(rv.data.decode('utf-8'))
assert result['requests'] != []
sql = "Update deregimei set device_id=1, imei=357321082345123, norm_imei=3573210823451 where id =1"
db.session.execute(sql)
sql = "Insert into deregimei(imei, norm_imei, device_id) VALUES('357321082345224', '3573210823452', 1)"
db.session.execute(sql)
body_data["search_specs"]['group'] = "exporter"
body_data["search_specs"]['user_id'] = de_registration_data['user_id']
body_data["search_args"]['imeis'] = ['357321082345123']
rv = flask_app.post(SEARCH_API,
data=json.dumps(body_data),
headers=headers)
assert rv.status_code == 200
result = json.loads(rv.data.decode('utf-8'))
assert result['requests'] != []
sql = "Update deregimei set device_id=1, imei=357321082345123, norm_imei=3573210823451 where id =1"
db.session.execute(sql)
sql = "Insert into deregimei(imei, norm_imei, device_id) VALUES('357321082345224', '3573210823452', 1)"
db.session.execute(sql)
body_data["search_specs"]['group'] = "exporter"
body_data["search_specs"]['user_id'] = de_registration_data['user_id']
body_data["search_args"]['imeis'] = ['357321082345123']
body_data["search_args"]['brand'] = device_data['devices'][0]['brand_name']
body_data["search_args"]['model_name'] = device_data['devices'][0][
'model_name']
rv = flask_app.post(SEARCH_API,
data=json.dumps(body_data),
headers=headers)
assert rv.status_code == 200
result = json.loads(rv.data.decode('utf-8'))
assert result['requests'] != []
sql = "Update deregimei set device_id=1, imei=357321082345123, norm_imei=3573210823451 where id =1"
db.session.execute(sql)
sql = "Insert into deregimei(imei, norm_imei, device_id) VALUES('357321082345224', '3573210823452', 1)"
db.session.execute(sql)
body_data["search_specs"]['group'] = "exporter"
body_data["search_specs"]['user_id'] = de_registration_data['user_id']
body_data["search_args"]['imeis'] = ['357321082345123', '357321082345224']
body_data["search_args"]['brand'] = device_data['devices'][0]['brand_name']
body_data["search_args"]['model_name'] = device_data['devices'][0][
'model_name']
rv = flask_app.post(SEARCH_API,
data=json.dumps(body_data),
headers=headers)
assert rv.status_code == 200
result = json.loads(rv.data.decode('utf-8'))
assert result['requests'] != []
def test_review_section(flask_app, db): # pylint: disable=unused-argument
"""Verify that if a request is in review already than a section of it can be reviewed."""
headers = {'Content-Type': 'application/json'}
# registration request
reviewer_id = 'section-rev-1'
reviewer_name = 'section rev'
data = {
'device_count': 2,
'imei_per_device': 1,
'imeis': "[['86834403015010', '86834403015011']]",
'm_location': 'local',
'user_name': 'section rev user 1',
'user_id': 'section-rev-user-1'
}
request = create_assigned_dummy_request(data, 'Registration', reviewer_id, reviewer_name)
assert request
request_id = request.id
# making api call
body = {
'section': 'device_quota',
'request_type': 'registration_request',
'status': 6,
'request_id': request_id,
'comment': 'this is a test comment',
'reviewer_id': reviewer_id,
'reviewer_name': reviewer_name
}
rv = flask_app.put(REVIEW_SECTION_API, data=json.dumps(body), headers=headers)
assert rv.status_code == 201
assert json.loads(rv.data.decode('utf-8'))['message'] == 'Comment on request added successfully'
# test with invalid reviewer_id
body['reviewer_id'] = 'abc-rev1'
rv = flask_app.put(REVIEW_SECTION_API, data=json.dumps(body), headers=headers)
assert rv.status_code == 400
assert json.loads(rv.data.decode('utf-8'))['error'] == ['invalid reviewer abc-rev1']
# de-registration test
data = {
'file': 'de-reg-test-file',
'device_count': 1,
'user_id': 'assign-rev-user-1',
'user_name': 'assign rev user 1',
'reason': 'because we have to run tests successfully'
}
request = create_assigned_dummy_request(data, 'De-Registration', reviewer_id, reviewer_name)
assert request
request_id = request.id
# make api call
body['request_type'] = 'de_registration_request'
body['request_id'] = request_id
body['reviewer_id'] = reviewer_id
rv = flask_app.put(REVIEW_SECTION_API, data=json.dumps(body), headers=headers)
assert rv.status_code == 201
assert json.loads(rv.data.decode('utf-8'))['message'] == 'Comment on request added successfully'
# test with invalid reviewer
body['reviewer_id'] = 'test-abc'
rv = flask_app.put(REVIEW_SECTION_API, data=json.dumps(body), headers=headers)
assert rv.status_code == 400
assert json.loads(rv.data.decode('utf-8'))['error'] == ['invalid reviewer test-abc']
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
