def test_get_ids_for_model_data():
GIVEN("a data handler with some data and two fixed probabilities")
GIVEN("a data handler and the directory and file name of a test file")
directory = "./data/29184567"
file_name = "1.156230797.txt"
file = HistoricalExternalAPIFileHander(directory=directory, file=file_name)
record = file.get_file_as_list()[0]
market_start_time = file.get_market_start_time()
adapter = ExternalAPIMarketRecordAdapter(
market_start_time=market_start_time)
mediator = MockMediator()
handler = DataHandler(
mediator=mediator,
adapter=adapter,
container=DataContainer(),
)
handler.process_data(record)
WHEN(
"we set the probabilities of two items and get the ids required for the next model run"
)
ids = handler.get_unique_ids()
for runner_id in ids[0:2]:
handler._set_probability(runner_id=runner_id, probability=0.1)
ids.pop(0)
THEN("the list omits the items which have fixed probabilities")
model_ids = handler._get_ids_for_model_data()
assert model_ids == ids
assert len(model_ids) < len(handler.get_unique_ids())
def test_calc_order_size():
GIVEN("a handler and a list of items with risk_percentages")
bank = 1000
mediator = MockMediator()
handler = OrdersHandler(mediator=mediator, bank=bank)
items = [
{
"id": 123,
"risk_percentage": -5
},
{
"id": 101,
"risk_percentage": 0.001
},
{
"id": 456,
"risk_percentage": 0.01
},
{
"id": 789,
"risk_percentage": 0.1
},
{
"id": 202,
"risk_percentage": 0.156788
},
]
WHEN("we calculate the size of the orders")
for item in items:
size = handler._calc_order_size(item=item)
THEN("the correct sizes are returned")
assert size == round(max(item.get("risk_percentage"), 0) * bank, 2)
def test_add_mixed_processed_orders():
GIVEN("a handler and a set of processed orders (2 valid, 1 invalid)")
mediator = MockMediator()
handler = OrdersHandler(mediator=mediator, bank=100000000000)
processed_orders = [
{
"id": 1234,
"probability": 0.2,
"type": "BUY",
"ex_price": 9.1,
"returns_price": 8.65,
"min_size": 5,
"size": 50000,
"risk_percentage": 0.05,
},
{
"id": 5678,
"probability": 0.26,
"type": "SELL",
"ex_price": 5,
"returns_price": 4.75,
"min_size": 5,
"size": 10000,
"risk_percentage": 0.01,
},
{},
]
WHEN("we add the orders to the handler")
handler.prevent_reorder(orders=processed_orders)
existing_orders = handler.get_orders()
THEN("the correct number of orders have been added to the handler")
assert len(existing_orders) == 2
THEN("the correct order data has been added to the handler")
assert existing_orders == processed_orders[0:2]
def test_post_order(mock_notify):
GIVEN("a file, a directory and a mock mediator")
directory = "./dev"
file = "1.163093692.bz2"
mediator = MockMediator()
WHEN("we instantiate the handler and post a valid order")
handler = HistoricalDownloadFileHandler(file=file, directory=directory)
handler.set_mediator(mediator)
runner_id = 2121212
orders = [{
"id": runner_id,
"type": "BUY",
"ex_price": 2.5,
"size": 1000000
}]
handler.post_order(orders)
THEN("the correct data is passed to the mediator")
args, kwargs = mock_notify.call_args
assert args == ()
data = kwargs.get("data")
assert data.get("response") == [{
"instruction": {
"selectionId": runner_id
},
"status": "SUCCESS"
}]
assert data.get("orders") == orders
def test_valid_and_invalid_orders():
GIVEN("a market handler two valid orders and two invalid orders")
market_handler = ExternalAPIMarketHandler(mediator=MockMediator(),
environment="Dev",
headers={},
market_id=123456)
orders = [
{
"id": 9999999,
"size": 100,
"ex_price": 2.0
},
{
"id": 8888888,
"type": "SELL",
"size": 6.18,
"ex_price": 75.0
},
{
"id": 7777777,
"type": "BUY",
"size": 5,
"ex_price": 12.6
},
{
"id": 7777777,
"type": "BUY",
"size": 5,
"ex_price": "THE BEST YOU HAVE"
},
]
valid_orders = market_handler._validate_orders(orders=orders)
THEN("the valid orders are returned")
assert valid_orders == orders[1:3]
def test_single_item(mock_notify):
GIVEN("an orders handler and some items")
mediator = MockMediator()
handler = OrdersHandler(mediator=mediator, bank=5000)
items = [{
"id": 16397186,
"probability": 0.19889500121124917,
"type": "BUY",
"ex_price": 6.4,
"returns_price": 6.13,
}]
WHEN("we call get_new_orders")
handler.get_new_orders(items=items)
THEN("the mediator's notify method is called with the correct paramaters")
args, kwargs = mock_notify.call_args
assert args == ()
assert kwargs.get("event") == "new orders"
new_orders = kwargs.get("data")
THEN("the correct order information is returned")
assert new_orders == [{
"id": 16397186,
"probability": 0.19889500121124917,
"type": "BUY",
"ex_price": 6.4,
"returns_price": 6.13,
"min_size": 5,
"size": 250.0,
"risk_percentage": 0.05,
}]
WHEN("we add the order to the handler (after processing)")
handler.prevent_reorder(orders=new_orders)
THEN("the correct information has been added to the handler")
assert handler.get_orders() == new_orders
WHEN("we try to add the order to the handler a second time")
handler.prevent_reorder(orders=new_orders)
THEN("the order has not been added again to the handler")
assert handler.get_orders() == new_orders
WHEN("we try to get new orders again using the same item")
handler.get_new_orders(items=items)
THEN("the mediator's notify method is called with the correct paramaters")
args, kwargs = mock_notify.call_args
assert args == ()
assert kwargs.get("event") == "finished processing"
new_orders = kwargs.get("data")
THEN("there are no new orders")
assert not new_orders
assert new_orders is None
def test_valid_orders():
GIVEN("a market handler and a set of valid orders")
market_handler = ExternalAPIMarketHandler(mediator=MockMediator(),
environment="Dev",
headers={},
market_id=123456)
orders = get_test_orders()
WHEN("we validate the orders")
valid_orders = market_handler._validate_orders(orders=orders)
THEN("all of the orders are shown to be valid")
assert valid_orders == orders
def test_calc_reduced_risk_percentage():
GIVEN(
"a set of risk percentages and an orders handler with an existing order"
)
items = [
{
"id": 123,
"risk_percentage": 0.01
},
{
"id": 456,
"risk_percentage": 0.01
},
{
"id": 789,
"risk_percentage": 0.02
},
{
"id": 101,
"risk_percentage": 0
},
]
mediator = MockMediator()
handler = OrdersHandler(mediator=mediator, bank=5000)
existing_orders = [{
"id": 999,
"probability": 0.26,
"type": "SELL",
"ex_price": 5,
"returns_price": 4.75,
"min_size": 5,
"size": 10000,
"risk_percentage": 0.03,
}]
handler.prevent_reorder(existing_orders)
WHEN("we calculate the reduced risk percentages")
reduced_risk_percentages = handler._calc_reduced_risk_percentage(
initial_risk_percentage=items)
THEN("the percentages have been reduced")
assert reduced_risk_percentages.get(
123) == 0.01 * (1 - 0.01) * (1 - 0.02) * (1 - 0.03)
assert reduced_risk_percentages.get(
456) == 0.01 * (1 - 0.01) * (1 - 0.02) * (1 - 0.03)
assert reduced_risk_percentages.get(
789) == 0.02 * (1 - 0.01) * (1 - 0.01) * (1 - 0.03)
assert reduced_risk_percentages.get(101) == 0
assert reduced_risk_percentages.get(999) is None
def test_calc_no_risk_percentage():
GIVEN("a handler, a probability and an equal price")
mediator = MockMediator()
handler = OrdersHandler(mediator=mediator, bank=1)
probability = 0.5
price = 2
WHEN("we calculate cap the risk percentage at 10%")
no_risk = handler._calc_risk_percentage(probability=probability,
price=price)
THEN("the correct risk percentage is returned")
assert no_risk == 0
GIVEN("a handler, a probability and a smaller price")
mediator = MockMediator()
handler = OrdersHandler(mediator=mediator, bank=1)
probability = 0.5
price = 1.5
WHEN("we calculate cap the risk percentage at 10%")
no_risk = handler._calc_risk_percentage(probability=probability,
price=price)
THEN("the correct risk percentage is returned")
assert no_risk == 0
GIVEN("a handler, a negative probability and negative price")
mediator = MockMediator()
handler = OrdersHandler(mediator=mediator, bank=1)
probability = -0.5
price = -2.1
WHEN("we calculate cap the risk percentage at 10%")
no_risk = handler._calc_risk_percentage(probability=probability,
price=price)
THEN("the correct risk percentage is returned")
assert no_risk == 0
def test_invalid_order():
GIVEN("a market handler and an invalid order")
market_handler = ExternalAPIMarketHandler(mediator=MockMediator(),
environment="Dev",
headers={},
market_id=123456)
orders = [
{
"type": "BUY",
"size": 100,
"ex_price": 2.0
},
]
valid_orders = market_handler._validate_orders(orders=orders)
THEN("the order is marked as invalid and omitted from the returned list")
assert not valid_orders
def test_empty_items(mock_notify):
GIVEN("an orders handler and some items")
mediator = MockMediator()
handler = OrdersHandler(mediator=mediator, bank=5000)
items = []
WHEN("we call get_new_orders")
handler.get_new_orders(items=items)
THEN("the mediator's notify method is called with the correct paramaters")
args, kwargs = mock_notify.call_args
assert args == ()
assert kwargs.get("event") == "finished processing"
new_orders = kwargs.get("data")
THEN("there are no new orders")
assert not new_orders
assert new_orders is None
def test_post_data(mock_call_exchange):
GIVEN("a market handler and some orders")
market_handler = ExternalAPIMarketHandler(mediator=MockMediator(),
environment="Dev",
headers={},
market_id=123456)
orders = get_test_orders()
WHEN("we post the orders")
market_handler.post_order(orders=orders)
THEN("the exchange was called with the correct request")
args, kwargs = mock_call_exchange.call_args
request = make_dict(kwargs.get("request"))
expected_request = get_expected_request()
assert args == ()
assert request.get("params").get("instructions") == expected_request.get(
"params").get("instructions")
def test_get_market(mock_notify):
GIVEN("a file and a directory with the correct market type")
directory = "./dev"
file = "1.163093692.bz2"
WHEN("we instantiate the handler")
handler = HistoricalDownloadFileHandler(file=file, directory=directory)
mediator = MockMediator()
handler.set_mediator(mediator)
WHEN("we call get market for every record in the file")
for record in handler.get_file_as_list():
handler.get_market()
THEN("the correct data is sent to the mediator")
args, kwargs = mock_notify.call_args
assert args == ()
data = kwargs.get("data")
assert data == record
def test_incorrect_type(mock_notify):
GIVEN("a file and in a directory which contains the incorrect market type")
directory = "./dev"
file = "1.156749791.bz2"
WHEN("we instantiate the handler")
handler = HistoricalDownloadFileHandler(file=file, directory=directory)
mediator = MockMediator()
handler.set_mediator(mediator)
THEN("it has loaded not loaded the file as an iterator")
assert handler.get_file_as_list() == []
WHEN("we call get_market")
market = handler.get_market()
THEN("no data is returned")
assert market is None
THEN("the mediator was not called")
assert mock_notify.call_args is None
def test_calc_risk_percentage():
GIVEN("a handler, a probability and price")
mediator = MockMediator()
handler = OrdersHandler(mediator=mediator, bank=1)
probability = 0.6
price = 2
WHEN("we calculate the uncapped risk percentage")
risk = handler._calc_risk_percentage(probability=probability,
price=price,
kelly_fraction=1,
cap=1)
THEN("the correct risk percentage is returned")
assert almost_equal(risk,
((probability * price) - (1 - probability)) / price)
WHEN("we calculate cap the risk percentage at 10%")
capped_risk = handler._calc_risk_percentage(probability=probability,
price=price,
kelly_fraction=1,
cap=0.1)
THEN("the correct risk percentage is returned")
assert capped_risk == 0.1
WHEN("we calculate the risk percentage based on a reduced kelly fraction")
fraction = 0.1
reduced_risk = handler._calc_risk_percentage(probability=probability,
price=price,
kelly_fraction=fraction,
cap=1)
THEN("the reduced risk is less than the original risk")
assert reduced_risk < risk
THEN("the correct risk percentage is returned")
assert almost_equal(
reduced_risk,
(((probability * price)**fraction - (1 - probability)**fraction) /
((price * probability)**fraction + (price *
(1 - probability))**fraction)),
)
def test_order_response(mock_notify, mock_open_url):
GIVEN("a market handler and some orders")
market_handler = ExternalAPIMarketHandler(mediator=MockMediator(),
environment="Dev",
headers={},
market_id=123456)
orders = get_test_orders()
mock_open_url.return_value = get_test_orders_post_response()
WHEN("we post the orders")
response = market_handler.post_order(orders=orders)
THEN("the notify method was called with the correct parameters")
args, kwargs = mock_notify.call_args
assert args == ()
data = kwargs.get("data")
assert data.get("orders") == orders
assert kwargs.get("event") == "orders posted"
response = data.get("response")
assert isinstance(response, list)
assert len(response) == 3
for order in response:
assert order.get("status") == "SUCCESS"
def test_confirm_market_closed():
GIVEN("a data handler and the directory and file name of a test file")
adapter = ExternalAPIMarketRecordAdapter(
market_start_time="2019-01-01T00:00:00.000Z")
mediator = MockMediator()
handler = DataHandler(mediator=mediator,
adapter=adapter,
container=DataContainer())
WHEN("we check if the market is closed")
closed = handler._confirm_market_closed()
THEN("it is not")
assert not closed
GIVEN("the handler's container has the required column" +
" but it does not indicate that the market is closed")
closed_record = handler._container.new(
data={("closed_indicator", ""): [0]})
handler._container.add_rows(container=closed_record)
WHEN("we check if the market is closed")
closed = handler._confirm_market_closed()
THEN("it is not")
assert not closed
GIVEN(
"the handler's container has the required column indicating that the market is closed"
)
closed_record = handler._container.new(
data={("closed_indicator", ""): [1]})
handler._container.add_rows(container=closed_record)
WHEN("we check if the market is closed")
closed = handler._confirm_market_closed()
THEN("it is")
assert closed
def test_get_data(mock_notify):
GIVEN(
"a schedule handler and a market handler connected to the dev environment"
)
schedule_handler = ExternalAPIScheduleHandler(environment="Dev")
headers = schedule_handler.get_headers()
markets = schedule_handler.get_schedule("7",
DateTime.utc_5_minutes_from_now())
WHEN(
"we create an instance of the market handler for each market and ask for data"
)
for market in markets:
market_id = market.get("marketId")
market_handler = ExternalAPIMarketHandler(
mediator=MockMediator(),
environment="Dev",
headers=headers,
market_id=market_id,
)
market_info = market_handler.get_market()
THEN("the notify method was called with the correct parameters")
args, kwargs = mock_notify.call_args
assert args == ()
assert kwargs.get("event") == "external data fetched"
market_info = kwargs.get("data")
assert isinstance(market_info, dict)
if market_info:
THEN("the dict contains a list of items")
items = market_info.get("runners")
assert isinstance(items, list)
THEN("the dict has an extract time")
process_time = market_info.get("process_time")
assert isinstance(process_time, str)
def test_removed_runner():
GIVEN(
"the directory and file name of a test file which contains a removed runner"
)
directory = "./data/29201704"
file_name = "1.156695742.txt"
file = HistoricalExternalAPIFileHander(directory=directory, file=file_name)
file_data = file.get_file_as_list()
market_start_time = file.get_market_start_time()
adapter = ExternalAPIMarketRecordAdapter(
market_start_time=market_start_time)
number_runners = __get_number_runners(data=file_data)
mediator = MockMediator()
WHEN("we feed the data into a handler one record at a time")
handler = DataHandler(
mediator=mediator,
adapter=adapter,
container=DataContainer(),
)
for i, record in enumerate(file_data):
handler.process_data(record)
THEN("the incoming record was processed")
number_records_processed = i + 1
THEN("the data container the correct number of records")
assert handler._container.get_row_count() == number_records_processed
WHEN("we have finished")
THEN("the data container has the correct number of columns")
assert handler._container.get_column_count() == __get_number_columns(
number_runners)
THEN("the data container has the same number of records as the raw data")
assert handler._container.get_row_count() == len(file_data)
THEN("the correct number of runners are contained in the object")
assert len(handler.get_unique_ids()) == number_runners
def test_place_order(mock_notify, mock_open_url):
GIVEN("a set of orders and a market handler")
orders = get_test_orders()
external_api = ExternalAPIMarketHandler(environment="Dev",
headers={},
market_id=123456)
handler = MarketHandler(
market_id=123456,
external_api=external_api,
market_start_time="2019-01-01T00:00:00.000Z",
)
external_api.set_mediator(mediator=MockMediator())
mock_open_url.return_value = get_test_orders_post_response()
WHEN("we place the orders")
handler.notify(event="new orders", data=orders)
THEN("the notify method was called with the correct parameters")
args, kwargs = mock_notify.call_args
assert args == ()
data = kwargs.get("data")
assert data.get("response") == get_test_orders_post_response().get(
"instructionReports")
assert data.get("orders") == orders
assert kwargs.get("event") == "orders posted"
def test_handler():
GIVEN("a file and a directory with the correct market type")
directory = "./dev"
file = "1.163093692.bz2"
WHEN("we instantiate the handler")
handler = HistoricalDownloadFileHandler(file=file, directory=directory)
mediator = MockMediator()
handler.set_mediator(mediator)
THEN("the first of the eligible records has a process" +
" time within 5 minutes of the market start time")
market_data = handler.get_file_as_list()
first_eligible = market_data[0]
assert first_eligible.get("extract_time") >= -60 * 5
THEN(
"the first eligible record does not have a closed indicator set to true"
)
assert first_eligible.get("closed_indicator") is False
THEN(
"the last of the eligible records has a process time after the market start time"
)
last_eligible = market_data[-2]
assert last_eligible.get("extract_time") > 0
THEN("the last eligible record has a closed indicator set to false")
assert last_eligible.get("closed_indicator") is False
THEN(
"the last of the records has a process time after the market start time"
)
last_record = market_data[-1]
assert last_record.get("extract_time") > last_eligible.get("extract_time")
THEN("the last eligible record has a closed indicator set to true")
assert last_record.get("closed_indicator") is True
THEN("the times in the list are unique")
assert len(handler._data._existing_times) == len(
set(handler._data._existing_times))
THEN("the extract times in the eligible records are unique")
extract_times = [record.get("extract_time") for record in market_data]
assert len(extract_times) == len(set(extract_times))
for index, record in enumerate(market_data):
THEN("each of the extract times is within the expected range")
extract_time = record.get("extract_time")
assert -5 * 60 <= extract_time < 60 * 60
THEN(
"the extract time is a single second after the previous extract time"
)
if index > 0:
assert extract_time == (
market_data[index - 1].get("extract_time") + 1)
THEN("each of the eligible records has a dict of items")
items = record.get("items")
assert isinstance(items, dict)
THEN("the keys of the items dict matches the ids of the items")
assert list(items.keys()) == __get_test_ids()
THEN(
"each of the items has no 0 value for each attribute and a starting price"
)
for runner_id in __get_test_ids():
assert items[runner_id]["sp"]["spn"]
assert 0 not in items[runner_id]["ex"]["atb"].values()
assert 0 not in items[runner_id]["ex"]["atl"].values()
assert 0 not in items[runner_id]["ex"]["trd"].values()
assert 0 not in items[runner_id]["sp"]["spb"].values()
assert 0 not in items[runner_id]["sp"]["spl"].values()
THEN(
"once the closed indicator becomes true is does not change back to false"
)
if index > 0 and market_data[index -
1].get("closed_indicator") is True:
assert record.get("closed_indicator") is True
WHEN("we call get_outcome")
result = handler.get_outcome()
THEN("the result is as expected")
assert result == 19795432
def test_fixed_probability(mock_notify):
GIVEN("a data handler and the directory and file name of a test file")
directory = "./data/29451865"
file_name = "1.162069495.txt"
file = HistoricalExternalAPIFileHander(directory=directory, file=file_name)
file_data = file.get_file_as_list()
market_start_time = file.get_market_start_time()
number_runners = __get_number_runners(data=file_data)
unfixed_items = number_runners
fixed_items = 0
adapter = ExternalAPIMarketRecordAdapter(
market_start_time=market_start_time)
pricer = PriceHandler()
metadata = MetadataHandler()
mediator = MockMediator()
correct_probability = 1
number_records_processed = 0
WHEN("we feed the data into a handler one record at a time")
handler = DataHandler(
mediator=mediator,
adapter=adapter,
container=DataContainer(),
)
for i, record in enumerate(file_data):
number_records_processed = i + 1
if number_records_processed % 10 == 0:
WHEN("we randomly fix the probability of an item")
id_to_fix = handler._get_ids_for_model_data()[0]
fixed_probability = round(
handler._container.get_last_column_entry(
name=("compositional_sp_probability", id_to_fix)),
4,
)
handler._set_probability(runner_id=id_to_fix,
probability=fixed_probability)
correct_probability -= fixed_probability
unfixed_items -= 1
fixed_items += 1
fixed_probability_ids = handler._get_fixed_probability_ids()
THEN("the list of fixed probability ids is the correct length")
assert len(fixed_probability_ids) == fixed_items
handler.process_data(record)
THEN("the handler's data has the correct number of records")
assert handler._container.get_row_count() == number_records_processed
THEN(
"the mediator's notify method was called with the correct parameters"
)
model_data = handler._get_model_data()
args, kwargs = mock_notify.call_args
assert args == ()
assert kwargs.get("data") == model_data
assert kwargs.get("event") == "data added to container"
THEN(
"there is a record in the model data for each of the unfixed items"
)
assert len(model_data) == unfixed_items
test_record = {
each.get("id"): each
for each in adapter.convert(record).get("items")
}
total_sp_probability = 0
total_ex_probability = 0
for data in model_data:
THEN("each of the items in the model data has an non-zero id")
runner_id = data.get("id")
assert isinstance(runner_id, int)
assert runner_id > 0
THEN("the items probability has not been fixed")
assert runner_id not in fixed_probability_ids
test_item = test_record.get(runner_id)
THEN("the data has the correct combined_back_size")
combined_back_size = data.get("combined_back_size" +
metadata.get_point_in_time_suffix())
assert combined_back_size == (test_item.get("sp_back_size") +
test_item.get("ex_back_size"))
THEN(
"the data contains the compositional sp probability which is between 0 and 1"
)
compositional_sp_probability = data.get(
"compositional_sp_probability" +
metadata.get_point_in_time_suffix())
total_sp_probability += compositional_sp_probability
assert 1 > compositional_sp_probability > 0
THEN(
"the data contains the compositional ex probability which is between 0 and 1"
)
compositional_ex_average_probability = data.get(
"compositional_ex_average_probability" +
metadata.get_point_in_time_suffix())
total_ex_probability += compositional_ex_average_probability
assert 1 > compositional_ex_average_probability > 0
THEN("the data contains the correct offered price")
offered_price = data.get("ex_offered_back_price" +
metadata.get_point_in_time_suffix())
assert offered_price > 0
assert offered_price == test_item.get("ex_offered_back_price")
THEN("the data contains the correct returns price")
returns_price = data.get("ex_offered_back_price_mc" +
metadata.get_point_in_time_suffix())
assert returns_price > 0
assert returns_price == pricer.remove_commission(
test_item.get("ex_offered_back_price"))
THEN(
"the sp back price time series data returned is of the correct length"
)
compositional_sp_back_price_ts = (
data.get("compositional_sp_back_price" +
metadata.get_time_series_suffix()) or [])
assert len(
compositional_sp_back_price_ts) == number_records_processed
THEN(
"the last record of the time series data matches the probability"
)
assert almost_equal(compositional_sp_back_price_ts[-1],
1 / compositional_sp_probability)
THEN(
"the extract time time series data returned is of the correct length"
)
extract_time_ts = (data.get("extract_time" +
metadata.get_time_series_suffix())
or [])
assert len(extract_time_ts) == number_records_processed
for j, extract_time in enumerate(extract_time_ts):
if j > 0:
THEN("the times in the series are ascending")
assert extract_time > extract_time_ts[j - 1]
THEN(
"the combined back size time series data returned is of the correct length"
)
combined_back_size_ts = (
data.get("combined_back_size" +
metadata.get_time_series_suffix()) or [])
assert len(combined_back_size_ts) == number_records_processed
THEN(
"the last entry in the time series is the same as point in time combined_back_size"
)
assert combined_back_size_ts[-1] == combined_back_size
for j, combined_back_size in enumerate(combined_back_size_ts):
if j > 0:
THEN("the sizes in the series are ascending")
assert combined_back_size >= combined_back_size_ts[j - 1]
THEN("the total ex and sp probabilities from the model_data sum to 1")
assert almost_equal(total_sp_probability, correct_probability)
assert almost_equal(total_ex_probability, correct_probability)
WHEN("we have finished")
THEN("the data container has the correct number of columns")
assert handler._container.get_column_count() == __get_number_columns(
number_runners)
THEN("the data container has the same number of records as the raw data")
assert handler._container.get_row_count() == len(file_data)
THEN("the correct number of runners are contained in the object")
assert len(handler.get_unique_ids()) == number_runners
THEN(
"the correct number of fixed probabilities are contained in the object"
)
assert len(handler._get_fixed_probability_ids()) == round_down(
number_records_processed / 10)
def test_add_invalid_processed_orders():
GIVEN("a handler and a set of valid processed orders")
mediator = MockMediator()
handler = OrdersHandler(mediator=mediator, bank=100000000000)
processed_orders = [
{
"probability": 0.5,
"type": "BUY",
"ex_price": 5,
"returns_price": 4.75,
"min_size": 5,
"size": 10000,
"risk_percentage": 0.01,
},
{
"id": "no probability",
"type": "BUY",
"ex_price": 5,
"returns_price": 4.75,
"min_size": 5,
"size": 10000,
"risk_percentage": 0.01,
},
{
"id": "negative probability",
"probability": -0.26,
"type": "BUY",
"ex_price": 5,
"returns_price": 4.75,
"min_size": 5,
"size": 10000,
"risk_percentage": 0.01,
},
{
"id": "wrong probability",
"probability": 1.26,
"type": "BUY",
"ex_price": 5,
"returns_price": 4.75,
"min_size": 5,
"size": 10000,
"risk_percentage": 0.01,
},
{
"id": "no type",
"probability": 0.26,
"ex_price": 5,
"returns_price": 4.75,
"min_size": 5,
"size": 10000,
"risk_percentage": 0.01,
},
{
"id": "wrong type",
"type": "FIXED",
"probability": 0.26,
"ex_price": 5,
"returns_price": 4.75,
"min_size": 5,
"size": 10000,
"risk_percentage": 0.01,
},
{
"id": "no buy price",
"probability": 0.26,
"type": "BUY",
"returns_price": 4.75,
"min_size": 5,
"size": 10000,
"risk_percentage": 0.01,
},
{
"id": "negative buy price",
"probability": 0.26,
"type": "BUY",
"ex_price": -5,
"returns_price": 4.75,
"min_size": 5,
"size": 10000,
"risk_percentage": 0.01,
},
{
"id": "no min size",
"probability": 0.26,
"type": "BUY",
"ex_price": 5,
"returns_price": 4.75,
"size": 10000,
"risk_percentage": 0.01,
},
{
"id": "0 min size",
"probability": 0.26,
"type": "BUY",
"ex_price": 5,
"returns_price": 4.75,
"min_size": 0,
"size": 10000,
"risk_percentage": 0.01,
},
{
"id": "no size",
"probability": 0.26,
"type": "BUY",
"ex_price": 5,
"returns_price": 4.75,
"min_size": 0,
"risk_percentage": 0.01,
},
{
"id": "size below min size",
"probability": 0.26,
"type": "BUY",
"ex_price": 5,
"returns_price": 4.75,
"min_size": 2,
"size": 1,
"risk_percentage": 0.01,
},
{
"id": "no risk percentage",
"probability": 0.26,
"type": "BUY",
"ex_price": 5,
"returns_price": 4.75,
"min_size": 2,
"size": 1,
},
{
"id": "negative risk percentage",
"probability": 0.26,
"type": "BUY",
"ex_price": 5,
"returns_price": 4.75,
"min_size": 2,
"size": 1,
"risk_percentage": -0.01,
},
]
WHEN("we try to add the orders to the handler")
handler.prevent_reorder(orders=processed_orders)
existing_orders = handler.get_orders()
THEN("no order data has been added to the handler")
assert not existing_orders