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')