def test_device_section_method_documents(flask_app, db, app):
""" To verify that registration section
method is working properly and response is correct"""
request_data = copy.deepcopy(REQUEST_DATA)
request_data['file'] = 'de-reg-test-file.txt'
de_registration = create_dummy_request(request_data, 'De-Registration', 'Awaiting Documents')
headers = {'Content-Type': 'multipart/form-data'}
documents = [
{'label': 'shipment document', 'file_name': 'shipment.pdf'},
{'label': 'authorization document', 'file_name': 'authorize.pdf'},
{'label': 'certificate document', 'file_name': 'certf.pdf'},
]
device_data = {
'devices': """[
{
"tac": "35700102",
"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': de_registration.id
}
de_registration = create_dummy_devices(device_data, 'De_Registration', de_registration, db,
file_content=['121621090005119'],
file_path='{0}/{1}/{2}'.format(app.config['DRS_UPLOADS'],
de_registration.tracking_id,
request_data['file']))
registration = create_dummy_documents(documents, 'De-Registration', de_registration, app)
rv = flask_app.get('{0}/{1}'.format(DEVICE_DE_REGISTRATION_SECTION_API, registration.id), headers=headers)
data = json.loads(rv.data.decode('utf-8'))
assert rv.status_code == 200
assert 'dereg_details' in data
assert data['dereg_details']
assert 'status_label' in data['dereg_details']
assert data['dereg_details']['status_label'] == 'Awaiting Documents'
assert 'dereg_device' in data
assert data['dereg_device']
assert 'tac' in data['dereg_device'][0]
assert 'model_name' in data['dereg_device'][0]
assert 'brand_name' in data['dereg_device'][0]
assert 'model_num' in data['dereg_device'][0]
assert 'technology' in data['dereg_device'][0]
assert 'device_type' in data['dereg_device'][0]
assert 'operating_system' in data['dereg_device'][0]
assert 'dereg_docs' in data
assert data['dereg_docs']
def test_registered_imeis_count(flask_app, app, db): # pylint: disable=unused-argument
"""Verify that the api returns correct count of registered imeis of a user."""
# registration request
registration_data = {
'device_count': 3,
'imei_per_device': 1,
'imeis': "[['86834403015010', '868344039012345', '868344039000011']]",
'm_location': 'local',
'user_name': 'usr-1-01-test-001',
'user_id': 'usr-1-01-test-001'
}
request = create_dummy_request(registration_data,
'Registration',
status='Approved')
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)
rv = flask_app.get(
'{0}?request_id={1}&request_type=registration_request'.format(
IMEIS_STATUS_API, request.id))
assert rv.status_code == 200
data = json.loads(rv.data.decode('utf-8'))
assert data['pending_registration'] == 0
assert data['registered'] == 3
assert data['not_registered'] == 0
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_device_section_method_devices(flask_app, db): # pylint: disable=unused-argument
""" To verify that registration section
method is working properly and response is correct"""
registration = create_registration(REQUEST_DATA, uuid.uuid4())
headers = {'Content-Type': 'multipart/form-data'}
device_data = {
'brand': 'samsung',
'operating_system': 'android',
'model_name': 's9',
'model_num': '30jjd',
'device_type': 'Smartphone',
'technologies': '2G,3G,4G',
'reg_id': registration.id
}
registration = create_dummy_devices(device_data, 'Registration', registration)
rv = flask_app.get('{0}/{1}'.format(DEVICE_REGISTRATION_SECTION_API, registration.id), headers=headers)
data = json.loads(rv.data.decode('utf-8'))
assert rv.status_code == 200
assert 'reg_details' in data
assert data['reg_details']
assert 'status_label' in data['reg_details']
assert data['reg_details']['status_label'] == 'New Request'
assert 'reg_device' in data
assert data['reg_device']
assert 'model_num' in data['reg_device']
assert 'technologies' in data['reg_device']
assert 'reg_docs' in data
assert not data['reg_docs']
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_request_status(flask_app):
"""Verify/Validate and return all approved and pending request."""
data = {
'device_count': 1,
'imei_per_device': 2,
'imeis': "[['86834403380270','86834403380271']]",
'm_location': 'local',
'user_name': 'Test_User',
'user_id': '800'
}
request = create_dummy_request(data, 'Registration', 'Approved')
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']['status'] = 'Approved'
rv = flask_app.post(SEARCH_API,
data=json.dumps(body_data),
headers=headers)
result = json.loads(rv.data.decode('utf-8'))
assert rv.status_code == 200
assert result['requests'] != []
# Invalid Result
body_data['search_args'] = {}
body_data['search_args']['status'] = 'Pending 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_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_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_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_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_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_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_invalid_imei_count(flask_app, app, db):
"""Verify that the api detects invalid imeis and create an invalid imei file."""
# de-registration request
de_registration_data = {
'file': 'de-reg-test-file.txt',
'device_count': 1,
'user_id': 'invalid-imei-stat-user-2',
'user_name': 'assign rev user 1',
'reason': 'because we have to run tests successfully'
}
request = create_dummy_request(de_registration_data, 'De_Registration')
tracking_id = request.tracking_id
device_data = {
'devices': """[
{
"tac": "35700102",
"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=['357001022345123'],
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(
IMEIS_STATUS_API, request.id))
assert rv.status_code == 200
data = json.loads(rv.data.decode('utf-8'))
assert data['invalid'] == 1
invalid_file_path = '{0}/{1}/invalid_imeis.txt'.format(
app.config['DRS_UPLOADS'], tracking_id)
assert os.path.exists(invalid_file_path)
# read file and check the content
with open(invalid_file_path, 'r') as f:
assert f.readline().split('\n')[0] == '35700102234512'
def test_update_devices_success(flask_app, app, db):
""" To verify that registration device
method is working properly and response is correct"""
request_data = copy.deepcopy(DE_REG_REQ_DATA)
request_data['file'] = 'de-reg-test-file.txt'
de_registration = create_dummy_request(request_data, 'De-Registration',
'Awaiting Documents')
headers = {'Content-Type': 'multipart/form-data'}
device_data = {
'devices': """[
{
"tac": "35700102",
"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': de_registration.id
}
de_registration = create_dummy_devices(device_data,
'De_Registration',
de_registration,
db,
file_content=['78788734563219'],
file_path='{0}/{1}/{2}'.format(
app.config['DRS_UPLOADS'],
de_registration.tracking_id,
request_data['file']))
rv = flask_app.get("{0}/{1}".format(DE_REGISTRATION_DEVICE_API,
de_registration.id),
data=request_data,
headers=headers)
data = json.loads(rv.data.decode('utf-8'))
assert rv.status_code == 200
assert 'model_num' in data[0] and data[0]['model_num'] == "TA-1034"
assert 'count' in data[0] and data[0]['count'] == 2
assert 'brand_name' in data[0] and data[0]['brand_name'] == "NOKIA"
assert 'device_type' in data[0] and data[0][
'device_type'] == "Mobile Phone/Feature phone"
def test_duplicated_imeis_count(flask_app, db, app): # pylint: disable=unused-argument
"""Verify that the system detects duplicate imeis and generated a related file."""
registration_data = {
'device_count': 3,
'imei_per_device': 1,
'imeis': "[['86800103015010', '8683342039012345', '868000039111111']]",
'm_location': 'local',
'user_name': 'usr-2-02-test-002',
'user_id': 'usr-2-02-test-002'
}
request = create_dummy_request(registration_data, 'Registration')
tracking_id = request.tracking_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)
# add an imei to approved imeis
approved_imei = ApprovedImeis('86800003911111', 332332332, 'whitelist',
'update')
approved_imei.add()
rv = flask_app.get(
'{0}?request_id={1}&request_type=registration_request'.format(
IMEIS_STATUS_API, request.id))
assert rv.status_code == 200
data = json.loads(rv.data.decode('utf-8'))
assert data['duplicated'] == 1
duplicated_file_path = '{0}/{1}/duplicated_imeis.txt'.format(
app.config['DRS_UPLOADS'], tracking_id)
assert os.path.exists(duplicated_file_path)
# read file and check the content
with open(duplicated_file_path, 'r') as f:
assert f.readline().split('\n')[0] == '86800003911111'
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_single_tac_device_description(flask_app, db, dirbs_core, app): # pylint: disable=unused-argument
"""Verify that the api responds properly with one tac in devices of a request."""
# registration request test
registration_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(registration_data, 'Registration',
'dev-descp-1', 'dev descp')
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)
rv = flask_app.get(
'{0}?request_id={1}&request_type=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('gsma_device_description')
assert data.get('user_device_description')
user_device_description = data['user_device_description']
assert user_device_description[0]['model_number'] == '30jjd'
assert user_device_description[0]['brand'] == 'samsung'
assert user_device_description[0]['model_name'] == 's9'
assert user_device_description[0]['device_type'] == 'Smartphone'
assert user_device_description[0]['operating_system'] == 'android'
# 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"
}
]""",
'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')
user_device_description = data['user_device_description']
assert user_device_description[0]['model_number'] == 'TA-1034'
assert user_device_description[0]['brand'] == 'NOKIA'
assert user_device_description[0]['model_name'] == 'TA-1034'
assert user_device_description[0][
'device_type'] == 'Mobile Phone/Feature phone'
assert user_device_description[0]['operating_system'] == 'N/A'
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_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_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_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 test_pending_registration_status(flask_app, db, app):
"""Verify that api returns correct imeis count."""
# registration request
registration_data = {
'device_count': 2,
'imei_per_device': 1,
'imeis': "[['86834403015010', '868344039012345']]",
'm_location': 'local',
'user_name': 'imei stat user 1',
'user_id': 'imei-stat-user-1'
}
request = create_assigned_dummy_request(registration_data, 'Registration',
'dev-descp-1', 'dev descp')
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)
rv = flask_app.get(
'{0}?request_id={1}&request_type=registration_request'.format(
IMEIS_STATUS_API, request.id))
assert rv.status_code == 200
data = json.loads(rv.data.decode('utf-8'))
assert data['not_registered'] == 0
assert data['pending_registration'] == 2
assert data['registered'] == 0
# de-registration request
de_registration_data = {
'file': 'de-reg-test-file.txt',
'device_count': 1,
'user_id': 'imei-stat-user-2',
'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"
}
]""",
'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')))
approved_imei = ApprovedImeis('35732108234512', 332332, 'whitelist',
'update')
approved_imei.add()
rv = flask_app.get(
'{0}?request_id={1}&request_type=de_registration_request'.format(
IMEIS_STATUS_API, request.id))
assert rv.status_code == 200
data = json.loads(rv.data.decode('utf-8'))
assert data['pending_registration'] == 2
assert data['not_registered'] == 0
assert data['registered'] == 0
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_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_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_document_api(flask_app, app, db):
"""Verify that the api responds with correct path and file name of a document."""
# registration request
data = {
'registration': {
'device_count': 2,
'imei_per_device': 1,
'imeis': "[['86834403015010', '868344039012345']]",
'm_location': 'local',
'user_name': 'imei stat user 1',
'user_id': 'imei-stat-user-1'
},
'devices': {
'brand': 'samsung',
'operating_system': 'android',
'model_name': 's9',
'model_num': '30jjd',
'device_type': 'Smartphone',
'technologies': '2G,3G,4G'
},
'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_request(data.get('registration'), 'Registration')
request = create_dummy_devices(data.get('devices'), 'Registration',
request)
request = create_dummy_documents(data.get('documents'), 'Registration',
request, app)
assert request
request_id = request.id
rv = flask_app.get(
'{0}?request_id={1}&request_type=registration_request'.format(
DOCUMENTS_API, request_id))
assert rv.status_code == 200
data = json.loads(rv.data.decode('utf-8'))['documents']
for document in data:
assert document.get('document_type') in [
'shipment document', 'authorization document',
'certificate document'
]
assert document.get('link')
# de registration
de_registration_data = {
'file': 'de-reg-test-file.txt',
'device_count': 1,
'user_id': 'imei-stat-user-2',
'user_name': 'assign rev user 1',
'reason': 'because we have to run tests successfully'
}
request = create_dummy_request(de_registration_data, 'De_Registration')
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"
}
]""",
'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'],
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
data = json.loads(rv.data.decode('utf-8'))['documents']
for document in data:
assert document.get('document_type') in [
'shipment document', 'authorization document',
'certificate document'
]
assert document.get('link')
