def test_pending_review_request(flask_app, db): # pylint: disable=unused-argument
"""Verify that a pending request sections can not 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_dummy_request(data, 'Registration')
assert request
request_id = request.id
# make 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 == 400
assert json.loads(rv.data.decode('utf-8'))['error'] == [
'request {0} should be in-review'.format(request_id)
]
# 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_dummy_request(data, 'De-Registration')
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 == 400
assert json.loads(rv.data.decode('utf-8'))['error'] == [
'request {0} should be in-review'.format(request_id)
]
def test_already_assigned_request(flask_app, db): # pylint: disable=unused-argument
"""Verify that the api do not reassign an already assigned request and respond accordingly."""
# make dummy registration request, assign it and then try to reassign it
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'
}
# registration request test, creating dummy request
request = create_dummy_request(data, 'Registration')
assert request
request_id = request.id
# make api request
reviewer_id = 'assign-rev-1'
request_data = {
'request_id': request_id,
'reviewer_id': reviewer_id,
'reviewer_name': 'assign rev',
'request_type': 'registration_request'
}
rv = flask_app.put(ASSIGN_REVIEWER_API, data=json.dumps(request_data), headers=headers)
assert rv.status_code == 201
# try to reassign
request_data['reviewer_id'] = 'reassign-rev-1'
request_data['reviewer_name'] = 'reassign rev'
rv = flask_app.put(ASSIGN_REVIEWER_API, data=json.dumps(request_data), headers=headers)
assert rv.status_code == 400
# 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_dummy_request(data, 'De-Registration')
request_id = request.id
# make api call
request_data['request_id'] = request_id
request_data['request_type'] = 'de_registration_request'
rv = flask_app.put(ASSIGN_REVIEWER_API, data=json.dumps(request_data), headers=headers)
assert rv.status_code == 201
# try to reassign
request_data['reviewer_id'] = 'rev-2'
request_data['reviewer_name'] = 'rev2'
rv = flask_app.put(ASSIGN_REVIEWER_API, data=json.dumps(request_data), headers=headers)
assert rv.status_code == 400
def test_incomplete_request(flask_app, db): # pylint: disable=unused-argument
"""Verify that the api do not assign an incomplete request and respond accordingly."""
# 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_dummy_request(data, 'Registration', 'In Review')
assert request
request_id = request.id
# make api call
reviewer_id = 'assign-rev-1'
request_data = {
'request_id': request_id,
'reviewer_id': reviewer_id,
'reviewer_name': 'assign rev',
'request_type': 'registration_request'
}
rv = flask_app.put(ASSIGN_REVIEWER_API,
data=json.dumps(request_data),
headers=headers)
assert rv.status_code == 400
data = json.loads(rv.data.decode('utf-8'))
assert data['error'] == [
'incomplete request {0} can not be assigned/reviewed'.format(
request_id)
]
# 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_dummy_request(data, 'De-Registration', 'In Review')
request_id = request.id
# make api call
request_data['request_id'] = request_id
request_data['request_type'] = 'de_registration_request'
rv = flask_app.put(ASSIGN_REVIEWER_API,
data=json.dumps(request_data),
headers=headers)
assert rv.status_code == 400
data = json.loads(rv.data.decode('utf-8'))
assert data['error'] == [
'incomplete request {0} can not be assigned/reviewed'.format(
request_id)
]
def test_assign_reviewer(flask_app, db): # pylint: disable=unused-argument
"""Verify that the assign reviewer api assigns a reviewer to a
request in pending review status.
"""
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'
}
# registration request test, creating dummy request
request = create_dummy_request(data, 'Registration')
assert request
request_id = request.id
# make api request
reviewer_id = 'assign-rev-1'
request_data = {
'request_id': request_id,
'reviewer_id': reviewer_id,
'reviewer_name': 'assign rev',
'request_type': 'registration_request'
}
rv = flask_app.put(ASSIGN_REVIEWER_API,
data=json.dumps(request_data),
headers=headers)
assert rv.status_code == 201
rv_data = json.loads(rv.data.decode('utf-8'))
assert rv_data['message'] == 'reviewer {0} assigned to request {1}'.format(
reviewer_id, request_id)
# de-registration request test, creating dummy 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_dummy_request(data, 'De-Registration')
request_id = request.id
# make api call
request_data['request_id'] = request_id
request_data['request_type'] = 'de_registration_request'
rv = flask_app.put(ASSIGN_REVIEWER_API,
data=json.dumps(request_data),
headers=headers)
assert rv.status_code == 201
data = json.loads(rv.data.decode('utf-8'))
assert data['message'] == 'reviewer {0} assigned to request {1}'.format(
reviewer_id, request_id)
def test_restart_process_invalid_request(flask_app, db): # pylint: disable=unused-argument
""" unittest for registration restart process."""
request_data = copy.deepcopy(REG_REQ_DATA)
create_dummy_request(request_data, "Registration", 'New Request')
url = "{0}/{1}".format(DEVICE_REGISTRATION_RESTART_API, 'abcd')
rv = flask_app.post(url, data=request_data)
assert rv.status_code == 422
data = json.loads(rv.data.decode('utf-8'))
assert data['message'][0] == 'Registration Request not found.'
def test_devices_invalid_status(flask_app, app, db): # pylint: disable=unused-argument
""" To verify that de_registration device fails
with restricted status"""
headers = {'Content-Type': 'multipart/form-data'}
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')
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
}
rv = flask_app.post(DE_REGISTRATION_DEVICE_API,
data=device_data,
headers=headers)
data = json.loads(rv.data.decode('utf-8'))
assert rv.status_code == 422
assert 'status' in data
assert data['status'][
0] == 'This step can only be performed for New Request'
def test_devices_creating_invalid_resp(flask_app, app, db): # pylint: disable=unused-argument
""" To verify that de_registration device fails
when invalid"""
headers = {'Content-Type': 'multipart/form-data'}
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',
'New Request')
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,
'user_id': '17102'
}
rv = flask_app.post(DE_REGISTRATION_DEVICE_API,
data=device_data,
headers=headers)
data = json.loads(rv.data.decode('utf-8'))
# This requires a code change.
assert rv.status_code == 500
assert 'message' in data
assert data['message'][
0] == 'Failed to retrieve response, please try later'
def test_required_documents_missing_docs(flask_app, app, db): # pylint: disable=unused-argument
""" unittest for one missing document."""
headers = {'Content-Type': 'multipart/form-data'}
request = create_dummy_request(DE_REG_REQ_DATA,
'De-Registration',
status='Awaiting Documents')
document_obj = dict()
request_data = copy.deepcopy(REQUEST_DATA)
request_data['dereg_id'] = request.id
file_path = '{0}/{1}'.format('tests/unittest_data', 'shipment.pdf')
with open(file_path, 'rb') as read_file:
document_obj['shipment document'] = read_file
document_obj['dereg_id'] = request.id
rv = flask_app.post(DEVICE_REGISTRATION_DOC_API,
data=document_obj,
headers=headers)
data = json.loads(rv.data.decode('utf-8'))
assert rv.status_code == 422
assert 'authorization document' in data
assert 'certificate document' in data
assert data['authorization document'][
0] == 'This is a required Document'
assert data['certificate document'][0] == 'This is a required Document'
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"""
request_data = copy.deepcopy(REQUEST_DATA)
request_data['file'] = 'dummy_file.txt'
de_registration = create_dummy_request(request_data, 'De-Registration',
'Awaiting Documents')
headers = {'Content-Type': 'multipart/form-data'}
rv = flask_app.get('{0}/{1}'.format(DEVICE_DE_REGISTRATION_SECTION_API,
de_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_docs' in data
assert not data['dereg_docs']
def test_devices_update_creating_missing_model_name(flask_app, app, db): # pylint: disable=unused-argument
""" To verify that registration device
method fails with missing model name"""
headers = {'Content-Type': 'multipart/form-data'}
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',
'Pending Review')
device_data = {
'devices':
"""[{"tac":"35700102","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,
'user_id': '17102'
}
rv = flask_app.put(DE_REGISTRATION_DEVICE_API,
data=device_data,
headers=headers)
data = json.loads(rv.data.decode('utf-8'))
assert rv.status_code == 422
assert 'devices' in data
assert data['devices']['0']['model_name'][
0] == 'model_name is a required field'
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_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_devices_update_invalid_status(flask_app, app, db): # pylint: disable=unused-argument
""" 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',
'New Request')
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
}
rv = flask_app.put(DE_REGISTRATION_DEVICE_API,
data=device_data,
headers=headers)
data = json.loads(rv.data.decode('utf-8'))
assert rv.status_code == 422
assert 'status' in data
assert data['status'][
0] == 'Update is restricted for request in status New Request'
def test_documents_get_empty_list(flask_app, db): # pylint: disable=unused-argument
""" unittest for registration documents all missing"""
request = create_dummy_request(DE_REG_REQ_DATA, 'De-Registration', status='Awaiting Documents')
rv = flask_app.get("{0}/{1}".format(DEVICE_REGISTRATION_DOC_API, request.id))
data = json.loads(rv.data.decode('utf-8'))
assert rv.status_code == 200
assert not data
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_device_put_method(flask_app, db): # pylint: disable=unused-argument
""" To verify that registration post
method is working properly and response is correct"""
headers = {'Content-Type': 'multipart/form-data'}
request = create_dummy_request(REQUEST_DATA, 'Registration', status='New Request')
request_data = copy.deepcopy(REQUEST_DATA)
request_data['reg_id'] = request.id
rv = flask_app.put(DEVICE_REGISTRATION_REQ_API, data=request_data, headers=headers)
assert rv.status_code == 422
def test_large_invalid_imei_per_device_update(flask_app, db): # pylint: disable=unused-argument
request = create_dummy_request(REQUEST_DATA, 'Registration', status='New Request')
request_data = copy.deepcopy(REQUEST_DATA)
request_data['reg_id'] = request.id
request_data['imei_per_device'] = 20000
headers = {'Content-Type': 'multipart/form-data'}
rv = flask_app.put(DEVICE_REGISTRATION_REQ_API, data=request_data, headers=headers)
assert rv.status_code == 422
def test_request_get_single(flask_app, app, db, dirbs_core): # pylint: disable=unused-argument
""" unittest for de-registration request"""
request = create_dummy_request(REQUEST_DATA, 'De-Registration', status='Awaiting Documents')
rv = flask_app.get("{0}/{1}".format(DEVICE_DE_REGISTRATION_REQ_API, request.id))
data = json.loads(rv.data.decode('utf-8'))
assert data
assert 'report' in data
assert 'reason' in data
assert data['status_label'] == 'Awaiting Documents'
def test_invalid_string_in_manufacturing_locations_update(flask_app, db): # pylint: disable=unused-argument
request = create_dummy_request(REQUEST_DATA, 'Registration', status='New Request')
request_data = copy.deepcopy(REQUEST_DATA)
request_data['reg_id'] = request.id
request_data['m_location'] = 'abcd'
headers = {'Content-Type': 'multipart/form-data'}
rv = flask_app.put(DEVICE_REGISTRATION_REQ_API, data=request_data, headers=headers)
assert rv.status_code == 422
def test_restart_process_closed_request(flask_app, db): # pylint: disable=unused-argument
""" unittest for registration restart process."""
request_data = copy.deepcopy(REG_REQ_DATA)
request = create_dummy_request(request_data, "Registration", 'Closed')
url = "{0}/{1}".format(DEVICE_REGISTRATION_RESTART_API, request.id)
rv = flask_app.post(url, data=request_data)
assert rv.status_code == 200
data = json.loads(rv.data.decode('utf-8'))
assert data['message'] == 'This request cannot be processed'
def test_missing_user_id_update(flask_app, db): # pylint: disable=unused-argument
""" To verify that request fails incase of
missing user id"""
request = create_dummy_request(REQUEST_DATA, 'Registration', status='New Request')
request_data = copy.deepcopy(REQUEST_DATA)
request_data['reg_id'] = request.id
request_data['user_id'] = ''
headers = {'Content-Type': 'multipart/form-data'}
rv = flask_app.put(DEVICE_REGISTRATION_REQ_API, data=request_data, headers=headers)
assert rv.status_code == 422
def test_request_closed(flask_app, app, db, dirbs_core): # pylint: disable=unused-argument
""" unittest for de-registration request"""
headers = {'Content-Type': 'multipart/form-data'}
request_data = copy.deepcopy(REQUEST_DATA)
request_data['file'] = 'dummy-file.txt'
request = create_dummy_request(request_data, 'De-Registraiton', 'New Request')
data = {'close_request': True, 'dereg_id': request.id, 'user_id': USER_ID}
rv = flask_app.put(DEVICE_DE_REGISTRATION_REQ_API,
data=data, headers=headers)
data = json.loads(rv.data.decode('utf-8'))
assert rv.status_code == 200
assert data['status_label'] == 'Closed'
def test_de_registration_set_imei_report_permissions_report_not_found(flask_app, db): # pylint: disable=unused-argument
"""Verify that POST method to test dashboard reports for reviewer user"""
reg_request = create_dummy_request(DE_REG_REQUEST_DATA, 'De-Registration')
url = IMEI_REPORT_PERMISSION
request_data = {
"request_type": "de_registration_request",
"request_id": "{0}".format(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 == 422
def test_request_update_failed(flask_app, app, db, dirbs_core): # pylint: disable=unused-argument
""" unittest for de-registration request"""
headers = {'Content-Type': 'multipart/form-data'}
request_data = copy.deepcopy(REQUEST_DATA)
request_data['file'] = 'dummy-file.txt'
request = create_dummy_request(request_data, 'De-Registraiton', 'New Request')
data = {'reason': 'updating the request', 'dereg_id': request.id, 'user_id': USER_ID}
rv = flask_app.put(DEVICE_DE_REGISTRATION_REQ_API,
data=data, headers=headers)
data = json.loads(rv.data.decode('utf-8'))
assert rv.status_code == 422
assert 'reason' in data
assert data['reason'][0] == 'The request status is New Request, which cannot be updated'
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_devices_update_missing_devices(flask_app, app, db): # pylint: disable=unused-argument
""" To verify that registration device
method fails with missing devices"""
headers = {'Content-Type': 'multipart/form-data'}
request_data = copy.deepcopy(DE_REG_REQ_DATA)
request_data['file'] = 'de-reg-test-file.txt'
request_data['user_id'] = '17102'
de_registration = create_dummy_request(request_data, 'De-Registration', 'Pending Review')
device_data = {'dereg_id': de_registration.id}
rv = flask_app.put(DE_REGISTRATION_DEVICE_API, data=device_data, headers=headers)
data = json.loads(rv.data.decode('utf-8'))
assert rv.status_code == 422
assert 'devices' in data
assert data['devices'][0] == 'Missing data for required field.'
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_required_documents_all_missing(flask_app, db): # pylint: disable=unused-argument
""" unittest for registration documents all missing"""
headers = {'Content-Type': 'multipart/form-data'}
request = create_dummy_request(DE_REG_REQ_DATA, 'De-Registration', status='Awaiting Documents')
request_data = copy.deepcopy(REQUEST_DATA)
request_data['dereg_id'] = request.id
rv = flask_app.post(DEVICE_REGISTRATION_DOC_API, data=request_data, headers=headers)
data = json.loads(rv.data.decode('utf-8'))
assert rv.status_code == 422
assert 'authorization document' in data
assert 'certificate document' in data
assert 'shipment document' in data
assert data['authorization document'][0] == 'This is a required Document'
assert data['certificate document'][0] == 'This is a required Document'
assert data['shipment document'][0] == 'This is a required Document'
def test_request_file_update_invalid_device(flask_app, app, db, dirbs_core): # pylint: disable=unused-argument
""" unittest for de-registration request"""
headers = {'Content-Type': 'multipart/form-data'}
request_data = copy.deepcopy(REQUEST_DATA)
request_data['file'] = 'dummy-file.txt'
request = create_dummy_request(request_data, 'De-Registraiton', 'New Request')
request_data['device_count'] = 90
request_data['dereg_id'] = request.id
request_file = dict(request_data)
file_path = '{0}/{1}'.format('tests/unittest_data/de-registration', 'request_file.txt')
with open(file_path, 'rb') as read_file:
request_file['file'] = read_file
rv = flask_app.put(DEVICE_DE_REGISTRATION_REQ_API, data=request_file, headers=headers)
data = json.loads(rv.data.decode('utf-8'))
assert rv.status_code == 422
assert data['status'][0] == 'The request status is New Request, which cannot be updated'
def test_request_file_update(flask_app, app, db, dirbs_core): # pylint: disable=unused-argument
""" unittest for de-registration request"""
headers = {'Content-Type': 'multipart/form-data'}
request_data = copy.deepcopy(REQUEST_DATA)
request_data['file'] = 'dummy-file.txt'
request = create_dummy_request(request_data, 'De-Registraiton', 'Pending Review')
request_data['device_count'] = 9
request_data['dereg_id'] = request.id
request_file = dict(request_data)
file_path = '{0}/{1}'.format('tests/unittest_data/de-registration', 'request_file.txt')
with open(file_path, 'rb') as read_file:
request_file['file'] = read_file
rv = flask_app.put(DEVICE_DE_REGISTRATION_REQ_API, data=request_file, headers=headers)
# code change required
assert rv.status_code == 500
