Python falcon.HTTP_OK Examples

def test_with_binary_file(client):
    here = os.path.dirname(os.path.realpath(__file__))
    filepath = os.path.join(here, 'image.jpg')
    image = open(filepath, 'rb')

    class Resource:

        def on_post(self, req, resp, **kwargs):
            resp.data = req.get_param('afile').file.read()
            resp.content_type = 'image/jpg'

    application.add_route('/route', Resource())

    resp = client.post('/route', data={'simple': 'ok'},
                       files={'afile': image})
    assert resp.status == falcon.HTTP_OK
    image.seek(0)
    assert resp.body == image.read() 

def test_parse_non_ascii_filename_in_headers(client):

    class Resource:

        def on_post(self, req, resp, **kwargs):
            assert req.get_param('afile').file.read() == b'name,code\nnom,2\n'
            assert req.get_param('afile').filename == 'Na%C3%AFve%20file.txt'
            resp.body = 'parsed'
            resp.content_type = 'text/plain'

    application.add_route('/route', Resource())

    # Simulate browser sending non ascii filename.
    body = ('--boundary\r\nContent-Disposition: '
            'form-data; name="afile"; filename*=utf-8\'\'Na%C3%AFve%20file.txt'
            '\r\nContent-Type: text/csv\r\n\r\nname,code\nnom,2\n\r\n'
            '--boundary--\r\n')
    headers = {'Content-Type': 'multipart/form-data; boundary=boundary'}
    resp = client.post('/route', body=body, headers=headers)
    assert resp.status == falcon.HTTP_OK
    assert resp.body == 'parsed' 

def test_with_binary_file(client):
    here = os.path.dirname(os.path.realpath(__file__))
    filepath = os.path.join(here, 'image.jpg')
    image = open(filepath, 'rb')

    class Resource:

        def on_post(self, req, resp, **kwargs):
            resp.data = req.get_param('afile').file.read()
            resp.content_type = 'image/jpg'

    application.add_route('/route', Resource())

    resp = client.post('/route', data={'simple': 'ok'},
                       files={'afile': image})
    assert resp.status == falcon.HTTP_OK
    image.seek(0)
    assert resp.body == image.read() 

def test_parse_form_as_params(client):

    class Resource:

        def on_post(self, req, resp, **kwargs):
            assert req.get_param('simple') == 'ok'
            assert req.get_param('afile').file.read() == b'filecontent'
            assert req.get_param('afile').filename == 'afile.txt'
            resp.body = 'parsed'
            resp.content_type = 'text/plain'

    application.add_route('/route', Resource())

    resp = client.post('/route', data={'simple': 'ok'},
                       files={'afile': ('filecontent', 'afile.txt')})
    assert resp.status == falcon.HTTP_OK
    assert resp.body == 'parsed' 

def test_parse_non_ascii_filename_in_headers(client):

    class Resource:

        def on_post(self, req, resp, **kwargs):
            assert req.get_param('afile').file.read() == b'name,code\nnom,2\n'
            assert req.get_param('afile').filename == 'Na%C3%AFve%20file.txt'
            resp.body = 'parsed'
            resp.content_type = 'text/plain'

    application.add_route('/route', Resource())

    # Simulate browser sending non ascii filename.
    body = ('--boundary\r\nContent-Disposition: '
            'form-data; name="afile"; filename*=utf-8\'\'Na%C3%AFve%20file.txt'
            '\r\nContent-Type: text/csv\r\n\r\nname,code\nnom,2\n\r\n'
            '--boundary--\r\n')
    headers = {'Content-Type': 'multipart/form-data; boundary=boundary'}
    resp = client.post('/route', body=body, headers=headers)
    assert resp.status == falcon.HTTP_OK
    assert resp.body == 'parsed' 

def test_parse_form_as_params(client):

    class Resource:

        def on_post(self, req, resp, **kwargs):
            assert req.get_param('simple') == 'ok'
            assert req.get_param('afile').file.read() == b'filecontent'
            assert req.get_param('afile').filename == 'afile.txt'
            resp.body = 'parsed'
            resp.content_type = 'text/plain'

    application.add_route('/route', Resource())

    resp = client.post('/route', data={'simple': 'ok'},
                       files={'afile': ('filecontent', 'afile.txt')})
    assert resp.status == falcon.HTTP_OK
    assert resp.body == 'parsed' 

def test_parse_multiple_values(client):

    class Resource:

        def on_post(self, req, resp, **kwargs):
            assert req.get_param_as_list('multi') == ['1', '2']
            resp.body = 'parsed'
            resp.content_type = 'text/plain'

    application.add_route('/route', Resource())

    resp = client.post('/route', data={'multi': ['1', '2']},
                       files={'afile': ('filecontent', 'afile.txt')})
    assert resp.status == falcon.HTTP_OK
    assert resp.body == 'parsed' 

def test_should_report_healthy_if_kafka_healthy(self, kafka_check):
        kafka_check.healthcheck.return_value = healthcheck.CheckResult(True,
                                                                       'OK')
        self.resource._kafka_check = kafka_check

        res = self.simulate_request(path=ENDPOINT,
                                    headers={
                                        'Content-Type': 'application/json'
                                    },
                                    method='GET')
        self.assertEqual(falcon.HTTP_OK, res.status)

        res = res.json
        self.assertIn('kafka', res)
        self.assertEqual('OK', res.get('kafka')) 

def test_should_report_healthy_if_all_services_healthy(self, kafka_check,
                                                           alarms_db_check,
                                                           metrics_db_check,
                                                           _):
        kafka_check.health_check.return_value = base.CheckResult(True, 'OK')
        alarms_db_check.health_check.return_value = base.CheckResult(True,
                                                                     'OK')
        metrics_db_check.health_check.return_value = base.CheckResult(True,
                                                                      'OK')
        self.resources._kafka_check = kafka_check
        self.resources._alarm_db_check = alarms_db_check
        self.resources._metrics_db_check = metrics_db_check

        response = self.simulate_request(path=ENDPOINT,
                                         headers={
                                             'Content-Type': 'application/json'
                                         },
                                         method='GET')
        self.assertEqual(falcon.HTTP_OK, response.status)

        response = response.json
        self.assertIn('kafka', response)
        self.assertIn('alarms_database', response)
        self.assertIn('metrics_database', response)
        self.assertEqual('OK', response.get('kafka'))
        self.assertEqual('OK', response.get('alarms_database'))
        self.assertEqual('OK', response.get('metrics_database')) 

def test_network_full(client, redis_my):
    setup_redis()
    response = client.simulate_get('/v1/network_full')
    assert len(response.json) == 1
    assert response.status == falcon.HTTP_OK
    verify_endpoints(response) 

def test_network(client, redis_my):
    setup_redis()
    response = client.simulate_get('/v1/network')
    assert len(response.json) == 2
    assert response.status == falcon.HTTP_OK
    verify_endpoints(response) 

def test_edit_user(client, user):
    doc = {"last_name": "changed"}
    with patch.object(UserMapper, "get", return_value=user):
        result = client.simulate_put("/users/".format(user.id), json=doc)

        assert result.status == falcon.HTTP_OK
        assert result.json["last_name"] == doc["last_name"]
        assert result.json["updated_at"] is not None 

def test_get_user(client, user):
    with patch.object(UserMapper, "get", return_value=user):
        result = client.simulate_get("/users/{}".format(user.id))

        assert result.status == falcon.HTTP_OK
        assert result.json["id"] == user.id.hex
        assert result.json["first_name"] == user.first_name
        assert result.json["last_name"] == user.last_name
        assert result.json["email"] == user.email 

def test_get_users(client):
    with patch.object(UserMapper, "get_all", return_value=[user1(), user2()]):
        result = client.simulate_get("/users")

        assert result.status == falcon.HTTP_OK
        assert len(result.json["users"]) == 2 

def test_get_returns_hello_name(client):
    doc = {"message": "Hello, Bob!"}
    result = client.simulate_get("/hello/bob")

    assert result.status == falcon.HTTP_OK
    assert result.json == doc 

def test_get_welcome_message(client):
    doc = {"message": "Hello, World!"}
    result = client.simulate_get("/")

    assert result.status == falcon.HTTP_OK
    assert result.json == doc 

def on_get(self, req, resp):
        response = list_servings(req.params['Authorization'])
        resp.status = falcon.HTTP_OK
        resp.body = json.dumps({'status': 'OK', 'data': response}) 

def test_parse_multiple_values(client):

    class Resource:

        def on_post(self, req, resp, **kwargs):
            assert req.get_param_as_list('multi') == ['1', '2']
            resp.body = 'parsed'
            resp.content_type = 'text/plain'

    application.add_route('/route', Resource())

    resp = client.post('/route', data={'multi': ['1', '2']},
                       files={'afile': ('filecontent', 'afile.txt')})
    assert resp.status == falcon.HTTP_OK
    assert resp.body == 'parsed' 

def test_endpoints_patch(mocker, client, functionality, method_name, body, expected_message,
                         expected_status):
    method_mock = mocker.patch('management_api.endpoints.endpoints.' + method_name)
    method_mock.return_value = "test"

    result = client.simulate_request(method='PATCH', path=f'/tenants/default/endpoints/test/'
                                                          f'{functionality}',
                                     headers={}, json=body)
    assert expected_status == result.status
    assert expected_message in result.text
    if result.status == falcon.HTTP_OK:
        method_mock.assert_called_once() 

def test_endpoints_delete(mocker, client):
    delete_endpoint_mock = mocker.patch('management_api.endpoints.endpoints.delete_endpoint')
    delete_endpoint_mock.return_value = "test"
    expected_status = falcon.HTTP_OK
    expected_message = {"status": "DELETED", "data": {"url": "test"}}
    body = {'endpointName': 'test'}

    result = client.simulate_request(method='DELETE', path='/tenants/default/endpoints', headers={},
                                     json=body)
    assert expected_status == result.status
    assert expected_message == json.loads(result.text)
    delete_endpoint_mock.assert_called_once() 

def test_endpoints_post(mocker, client, body, expected_message, expected_status,
                        model_availability):
    create_endpoint_mock = mocker.patch('management_api.endpoints.endpoints.create_endpoint')
    create_endpoint_mock.return_value = "test"
    check_model_mock = mocker.patch('management_api.endpoints.endpoints.check_endpoint_model')
    check_model_mock.return_value = model_availability

    result = client.simulate_request(method='POST', path='/tenants/default/endpoints', headers={},
                                     json=body)
    assert expected_status == result.status
    assert expected_message in result.text
    if not model_availability:
        assert "test model is not available on the platform" in result.text
    if result.status == falcon.HTTP_OK:
        create_endpoint_mock.assert_called_once() 

def test_models_delete(mocker, client):
    delete_model_mock = mocker.patch('management_api.models.models.delete_model')
    delete_model_mock.return_value = 'test'
    body = {'modelName': 'test', 'modelVersion': 1}
    expected_status = falcon.HTTP_OK

    result = client.simulate_request(method='DELETE', path='/tenants/default/models',
                                     headers={},
                                     json=body)

    assert expected_status == result.status
    delete_model_mock.assert_called_once() 

def test_token_post(mocker, client, body, expected_status):
    get_token_mock = mocker.patch('management_api.authenticate.authenticate.get_token')
    get_token_mock.return_value = "test"
    result = client.simulate_request(method='POST', json=body, path='/authenticate/token')
    assert expected_status == result.status
    if expected_status is falcon.HTTP_OK:
        get_token_mock.assert_called_once()
        assert 'token' in result.text 

def on_delete(self, req, resp, tenant_name):
        """Handles DELETE requests"""
        namespace = tenant_name
        body = req.media
        response = delete_model(body, namespace, req.params['Authorization'])
        resp.status = falcon.HTTP_OK
        resp.body = json.dumps({'status': 'DELETED', 'data': {'model_path': response}}) 

def on_get(self, req, resp, tenant_name):
        namespace = tenant_name
        response = list_models(namespace, req.params['Authorization'])
        resp.status = falcon.HTTP_OK
        resp.body = json.dumps({'status': 'OK', 'data': {'models': response}}) 

def on_get(self, req, resp, serving_name):
        response = get_serving(req.params['Authorization'], serving_name)
        resp.status = falcon.HTTP_OK
        resp.body = json.dumps({'status': 'OK', 'data': response})