def test_middleware_methods_are_called(api, client):
process_request_called = False
process_response_called = False
class CallMiddlewareMethods(Middleware):
def __init__(self, app):
super().__init__(app)
def process_request(self, request):
nonlocal process_request_called
process_request_called = True
def process_response(self, response):
nonlocal process_response_called
process_response_called = True
api.add_middleware(CallMiddlewareMethods)
@api.route('/')
def home(request, response):
response.text = 'hello'
return response
client.get(TEST_URL + '/')
assert process_request_called is True
assert process_response_called is True
def test_download_json(mocker):
download_parquet_data = mocker.patch(
'app.routers.downloads.download_parquet_data_v1')
download_parquet_data.return_value = ([{'data': 'data'}], HTTPStatus.OK)
get_guid_config = mocker.patch('app.routers.downloads.get_guid_config')
get_guid_config.return_value = 'INDEX', 'HORIZON'
response = client.get('/v1/12345/json',
headers={'Authorization': ACCESS_TOKEN},
params={
'from_date': '2021-01-01',
'to_date': '2021-01-02'
})
assert response.status_code == HTTPStatus.OK
assert download_parquet_data.called
assert download_parquet_data.await_args.args == ('12345', ACCESS_TOKEN,
'INDEX', 'HORIZON',
'2021-01-01',
'2021-01-02')
assert response.json() == [{'data': 'data'}]
response = client.get(
'/v1/12345/json',
headers={'Authorization': ACCESS_TOKEN},
)
assert response.status_code == HTTPStatus.OK
assert download_parquet_data.called
assert download_parquet_data.await_args.args == ('12345', ACCESS_TOKEN,
'INDEX', 'HORIZON', None,
None)
assert response.json() == [{'data': 'data'}]
def test_parametrized_route(api, client):
@api.route('/posts/{id}')
def posts(request, response, id):
response.text = f'post {id}'
return response
assert client.get(TEST_URL + '/posts/1').status_code == 200
assert client.get(TEST_URL + '/posts/1').text == 'post 1'
assert client.get(TEST_URL + '/posts/33').text == 'post 33'
def test_download_neptun(mocker):
import app.routers.neptun
download_parquet_data = mocker.patch('app.routers.neptun.download_parquet_data_v1')
download_parquet_data.return_value = ([{'data': 'data'}], HTTPStatus.OK)
get_guid_config = mocker.patch('app.routers.neptun.get_guid_config')
get_guid_config.return_value = 'INDEX', 'HORIZON'
app.routers.neptun.config = {'Neptun': {'daily_guid': 'daily_guid_1234',
'hourly_guid': 'hourly_guid_1234',
'minutely_guid': 'minutely_guid_1234'}}
response = client.get(
'/v1/neptun',
headers={'Authorization': ACCESS_TOKEN},
params={'horizon': 'DAILY', 'from_date': '2021-01-01', 'to_date': '2021-01-02', 'tags': 'TAG1, TAG2'}
)
assert response.status_code == HTTPStatus.OK
assert download_parquet_data.called
assert download_parquet_data.await_args.args == ('daily_guid_1234', ACCESS_TOKEN, 'INDEX', 'HORIZON',
'2021-01-01', '2021-01-02',
[[('Tag', '=', 'TAG1')], [('Tag', '=', ' TAG2')]])
assert response.json() == [{'data': 'data'}]
response = client.get(
'/v1/neptun',
headers={'Authorization': ACCESS_TOKEN},
params={'horizon': 'HOURLY', 'from_date': '2021-01-01', 'to_date': '2021-01-02'}
)
assert response.status_code == HTTPStatus.OK
assert download_parquet_data.called
assert download_parquet_data.await_args.args == ('hourly_guid_1234', ACCESS_TOKEN, 'INDEX', 'HORIZON',
'2021-01-01', '2021-01-02', None)
assert response.json() == [{'data': 'data'}]
response = client.get(
'/v1/neptun',
headers={'Authorization': ACCESS_TOKEN},
params={'horizon': 'MINUTELY', 'from_date': '2021-01-01', 'to_date': '2021-01-02'}
)
assert response.status_code == HTTPStatus.OK
assert download_parquet_data.called
assert download_parquet_data.await_args.args == ('minutely_guid_1234', ACCESS_TOKEN, 'INDEX', 'HORIZON',
'2021-01-01', '2021-01-02', None)
assert response.json() == [{'data': 'data'}]
response = client.get(
'/v1/neptun',
headers={'Authorization': ACCESS_TOKEN},
params={'horizon': 'YEARLY', 'from_date': '2021-01-01', 'to_date': '2021-01-02'}
)
assert response.status_code == HTTPStatus.BAD_REQUEST
assert response.json()['detail'] == '(ValueError) The horizon parameter must be Daily, Hourly or Minutely.'
def test_weather(client):
Config.WEATHER_API_KEY = "c376a81f73mshb9a443574833ecdp1bc627jsnc4245b06df70"
Config.WEATHER_API_URL = "https://community-open-weather-map.p.rapidapi.com/find"
Config.WEATHER_API_HOST = "community-open-weather-map.p.rapidapi.com"
response = client.get('/weather?city=London')
assert response.status_code == 200
response = client.get('/weather?city=Lviv,London')
assert response.status_code == 200
response = client.get('/weather?city=L')
assert response.status_code == 200
def test_search_weather(client):
Config.WEATHER_API_KEY = "53493f042amsh58b54fe3ed83e24p195f98jsnf109acbc59d2"
Config.WEATHER_API_URL = "https://community-open-weather-map.p.rapidapi.com/find"
Config.WEATHER_API_HOST = "community-open-weather-map.p.rapidapi.com"
response = client.get('/weather?city=Lviv')
assert response.status_code == 200
response = client.get('/weather?city=Paris,Barcelona')
assert response.status_code == 200
response = client.get('/weather?city=B')
assert response.status_code == 404
response = client.get('/weather?city=.')
assert response.status_code == 404
def test_class_based_view_get(api, client):
@api.route('/posts')
class PostsView:
def get(self, request, response):
id = request.GET.get('id')
if id is None:
response.text = 'posts'
else:
response.text = f'post {id}'
return response
assert client.get(TEST_URL + '/posts').text == 'posts'
assert client.get(TEST_URL + '/posts?id=5').text == 'post 5'
def test_download_dmi_list(mocker):
import app.routers.dmi
download_blob_to_stream = mocker.patch('app.routers.dmi.download_blob_to_stream')
test_df = pd.DataFrame({'lon': [1, 2], 'lat': [2, 3]})
bytes_io_file = BytesIO()
test_df.to_parquet(bytes_io_file, engine='pyarrow', compression='snappy')
bytes_io_file.seek(0)
download_blob_to_stream.return_value = bytes_io_file
app.routers.dmi.config = {'DMI': {'guid': 'dmi_guid'}}
response = client.get(
'/v1/dmi_list',
headers={'Authorization': ACCESS_TOKEN},
params={'from_date': '2021-01'}
)
path = 'dmi_guid/year=2021/month=01/data.parquet'
assert response.status_code == HTTPStatus.OK
assert download_blob_to_stream.called
assert download_blob_to_stream.await_args.args == (path, ACCESS_TOKEN)
assert response.json() == [{'lon': 1, 'lat': 2}, {'lon': 2, 'lat': 3}]
def test_templates(tmpdir_factory):
title = 'Microframework'
name = 'tiny-web'
template_content = f'<title>{title}</title><body>{name}</body>'
template_dir = tmpdir_factory.mktemp('./templates')
template = template_dir.join('index.html')
template.write(template_content)
api = Api(templates_dir=template_dir)
client = api.test_session()
@api.route('/')
def home(request, response):
context = {
'title': title,
'name': name,
}
response.html = api.template('index.html', context)
return response
response = client.get(TEST_URL + '/')
assert 'text/html' in response.headers['Content-Type']
assert title in response.text
assert name in response.text
def test_loan_endpoint_without_start_date(client):
rv = client.get('/loan-outstanding-percentages/500?end_date=2016-07-05')
assert rv.status_code == 200
assert rv.json == [{
'all_outstanding_shares': '100.0000',
'date': 'Mon, 04 Jul 2016 00:00:00 GMT',
'floating_shares': '100.0000',
'loan_outstanding_amount': '100.0000',
'loan_outstanding_shares': '100.0000',
'loan_utilization_percentage': '100.00',
'loan_utilization_percentage_amount': '100.00',
'loan_utilization_percentage_shares': '100.00',
'market_cap': '100.0000',
'prev_valid_free_floats': '100.0000',
'prev_valid_outstanding_shares': '100.0000',
'security_id': 500
}, {
'all_outstanding_shares': '100.0000',
'date': 'Tue, 05 Jul 2016 00:00:00 GMT',
'floating_shares': '100.0000',
'loan_outstanding_amount': '100.0000',
'loan_outstanding_shares': '100.0000',
'loan_utilization_percentage': '100.00',
'loan_utilization_percentage_amount': '100.00',
'loan_utilization_percentage_shares': '100.00',
'market_cap': '100.0000',
'prev_valid_free_floats': '100.0000',
'prev_valid_outstanding_shares': '100.0000',
'security_id': 500
}]
def test_get_ride(client):
rideId: int = 6
response = client.get("/rides/" + str(rideId))
assert response.status_code == 200
response_data = json.loads(response.get_data(as_text=True))
assert 'data' in response_data
assert isinstance(response_data['data'], dict)
def test_short_volume_endpoint(client):
rv = client.get('/short-volume-percentages/500?start_date=2016-07-04&end_date=2016-07-04')
assert rv.status_code == 200
assert rv.json == [{'date': 'Mon, 04 Jul 2016 00:00:00 GMT',
'security_id': 500,
'short_volume': '50.0000',
'short_volume_percentage': '50.00',
'trading_volume': '50.0000'}]
def test_get_ride_not_found(client, ride_id):
assert type(ride_id) is int
response = client.get("/rides/" + str(ride_id))
assert response.status_code == 404
if ride_id > 0:
response_data = json.loads(response.get_data(as_text=True))
assert 'message' in response_data
assert isinstance(response_data['message'], str)
def test_update(client):
update_data = {"text": "blablabla"}
response = client.put("/todos/1", json=update_data)
assert response.status_code == 200
get_response = client.get("/todos/1")
assert get_response.status_code == 200
assert get_response.json['1'] == "blablabla"
def test_alternative_add_route(api, client):
def home(request, response):
response.text = 'alternative'
return response
api.add_route('/home', home)
assert client.get(TEST_URL + '/home').status_code == 200
def test_api_test_client_works(api, client):
response_text = 'works'
@api.route('/foo')
def foo(request, response):
response.text = response_text
return response
assert client.get(TEST_URL + '/foo').text == response_text
def test_single_search_true(client):
rv = client.get('/search/삼성전자')
assert rv.status_code == 200
assert rv.json == [{
"id": 314,
"english_name": "SamsungElectronics",
"name": "삼성전자",
"ticker": "005930"
}]
def test_plain_response(api, client):
@api.route('/text')
def text_handler(request, response):
response.text = 'hello'
return response
response = client.get(TEST_URL + '/text')
assert response.headers['Content-Type'] == 'text/plain; charset=UTF-8'
assert response.text == 'hello'
def test_html_response(api, client):
@api.route('/html')
def html_handler(request, response):
response.html = '<h1>Hello</h1>'
return response
response = client.get(TEST_URL + '/html')
assert response.headers['Content-Type'] == 'text/html; charset=UTF-8'
assert response.text == '<h1>Hello</h1>'
def test_json_response(api, client):
@api.route('/json')
def json_handler(request, response):
response.json = {'message': 'hello'}
return response
response = client.get(TEST_URL + '/json')
assert response.headers['Content-Type'] == 'application/json'
assert response.json()['message'] == 'hello'
def test_static_is_served(tmpdir_factory):
static_dir = tmpdir_factory.mktemp('static')
_create_static(static_dir)
api = Api(static_dir=str(static_dir))
client = api.test_session()
response = client.get(TEST_URL + f'/static/{FILE_DIR}/{FILE_NAME}')
assert response.status_code == 200
assert response.text == FILE_CONTENTS
def test_loan_endpoint_without_end_date(client):
rv = client.get('/days-to-covers/631?start_date=2016-07-04')
assert rv.status_code == 200
assert rv.json == [{
"date":
"Mon, 04 Jul 2016 00:00:00 GMT",
"days_to_cover_in_amount":
"0.39",
"days_to_cover_in_shares":
"0.39",
"security_id":
631,
"short_outstanding_amount":
"35931975000.0000",
"short_outstanding_shares":
"49425.0000",
"twenty_days_moving_average_trading_amount":
"91136813750.0000",
"twenty_days_moving_average_trading_volume":
"127226.0000"
}, {
"date":
"Tue, 05 Jul 2016 00:00:00 GMT",
"days_to_cover_in_amount":
"0.34",
"days_to_cover_in_shares":
"0.32",
"security_id":
631,
"short_outstanding_amount":
"30985500000.0000",
"short_outstanding_shares":
"41314.0000",
"twenty_days_moving_average_trading_amount":
"92378772400.0000",
"twenty_days_moving_average_trading_volume":
"128596.2500"
}, {
"date":
"Wed, 06 Jul 2016 00:00:00 GMT",
"days_to_cover_in_amount":
"0.32",
"days_to_cover_in_shares":
"0.31",
"security_id":
631,
"short_outstanding_amount":
"30047340000.0000",
"short_outstanding_shares":
"40332.0000",
"twenty_days_moving_average_trading_amount":
"92924194100.0000",
"twenty_days_moving_average_trading_volume":
"129156.6500"
}]
def test_allowed_method_for_func_based_views(api, client):
@api.route('/', allowed_methods=['get', 'post'])
def home(request, response):
response.text = 'hello'
return response
assert client.get(TEST_URL + '/').status_code == 200
assert client.post(TEST_URL + '/').status_code == 200
with pytest.raises(AttributeError):
client.delete(TEST_URL + '/')
def test_connection_missing_headers(mocker):
directory_client = mocker.patch(
'app.routers.grafana_json.__get_directory_client')
check_directory_exist = mocker.patch(
'app.routers.grafana_json.check_directory_exist')
response = client.get('v1/grafana/12345')
assert response.status_code == HTTPStatus.BAD_REQUEST
assert not directory_client.called
assert not check_directory_exist.called
def test_short_volume_endpoint_without_end_date(client):
rv = client.get('/short-volume-percentages/500?start_date=2016-07-05')
assert rv.json == [{'date': 'Tue, 05 Jul 2016 00:00:00 GMT',
'security_id': 500,
'short_volume': '50.0000',
'short_volume_percentage': '50.00',
'trading_volume': '50.0000'},
{'date': 'Wed, 06 Jul 2016 00:00:00 GMT',
'security_id': 500,
'short_volume': '50.0000',
'short_volume_percentage': '50.00',
'trading_volume': '50.0000'}]
def test_short_out_with_all(client):
rv = client.get(
'/short-outstanding-percentages/500?start_date=2016-07-04&end_date=2016-07-04'
)
assert rv.status_code == 200
assert rv.json == [{
"date": "Mon, 04 Jul 2016 00:00:00 GMT",
"floating_shares": "100.0000",
"security_id": 500,
"short_outstanding_percentage": "100.00",
"short_outstanding_shares": "100.0000"
}]
def test_exception_handler(api, client):
def on_exception(request, response, exception_class):
response.text = 'Attribute error'
return response
api.add_custom_exception_handler(on_exception)
@api.route('/')
def home(request, response):
raise AttributeError()
response = client.get(TEST_URL + '/')
assert response.text == 'Attribute error'
def test_multiple_search_true(client):
rv = client.get('/search/삼성')
assert rv.status_code == 200
assert rv.json == [{
"english_name": "SamsungFire&MarineInsurance",
"id": 51,
"name": "삼성화재",
"ticker": "000810"
}, {
"id": 314,
"english_name": "SamsungElectronics",
"name": "삼성전자",
"ticker": "005930"
}]
def test_connection(mocker):
directory_client = mocker.patch(
'app.routers.grafana_json.__get_directory_client')
check_directory_exist = mocker.patch(
'app.routers.grafana_json.check_directory_exist')
response = client.get('v1/grafana/12345',
headers={
'client-id': 'mr_test',
'client-secret': 'secret'
})
assert response.status_code == HTTPStatus.OK
assert directory_client.called
assert directory_client.call_args.args == ('12345', 'mr_test', 'secret')
assert check_directory_exist.called
def test_retrieve_state(mocker):
directory_client = mocker.patch(
'app.routers.uploads.DataLakeDirectoryClient')
download_file = mocker.patch('app.routers.uploads.__download_file')
buffered_file = mocker.patch('_io.BufferedRandom')
json_data = {'test1': 'test2'}
download_file.return_value = buffered_file
buffered_file.readall.return_value = json.dumps(json_data)
response = client.get('/12345/retrieve_state',
headers={'Authorization': ACCESS_TOKEN})
assert directory_client.called
assert response.status_code == HTTPStatus.FOUND
assert response.json() == json_data
