More tests for SpreaderWrapper

This commit is contained in:
Taha Afzal committed 2022-04-18 22:43:19 -04:00
1 parent bd39d407aa
commit 36bbcf849c
1 file changed
+775 -5
@@ -4218,6 +4218,466 @@ TEST_CASE("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]") {
"spreader_WAITING_FOR_CANCEL_ACK.on_check_termination");
}
}
TEST_CASE("spreader_standlone_WAITING_FOR_CANCEL_ACK", "[spreader]") {
bts::orderman::OrderKey order_key(0);
Price spreader_price = Price(1);
Quantity spreader_quantity = Quantity(100);
ContractLeg leg_1, leg_2;
fill_future_contract_leg(
leg_1, 2468, "ES", bts::api::Venue::VENUE_GLBX, 2017, 12, 15, 1.0, 1.0,
api::Side::SIDE_BUY, 1.0, 0.25);
fill_future_contract_leg(
leg_2, 13579, "ES", bts::api::Venue::VENUE_GLBX, 2018, 3, 15, -1.0, -1.0,
api::Side::SIDE_SELL, 1.0, 0.25);
std::vector<ContractLeg> contract_legs;
contract_legs.push_back(leg_1);
contract_legs.push_back(leg_2);
Security synthetic_security;
fill_synthetic_security(
synthetic_security, 2000, "synthetic_security", contract_legs);
// execution params/order def
LegSpreaderParams lsp_1, lsp_2, lsp_3;
fill_leg_spreader_params(lsp_1, 1.0, true, 1.0);
fill_leg_spreader_params(lsp_2, -1.0, true, 1.0);
// post hedge time out here
std::vector<LegSpreaderParams> spreader_params;
spreader_params.push_back(lsp_1);
spreader_params.push_back(lsp_2);
bts::api::orderman::OrderDefinition order_def;
fill_spreader_order_definition(
order_def, Side::SIDE_BUY, synthetic_security, spreader_params);
// putting it together in SpreaderBookkeepingData
SpreaderPreActivationOrderServices pao_services(synthetic_security);
std::vector<LegPropertyData> leg_props;
std::vector<bts::api::orderman::OrderDefinition> quoter_ord_defs,
hedger_ord_defs;
SpreaderUtils::resolve_synthetic_spread(
pao_services, order_def, leg_props, quoter_ord_defs, hedger_ord_defs);
SpreaderManagerForTest spreader_manager(
order_key, order_def, pao_services, leg_props, quoter_ord_defs,
hedger_ord_defs);
integration::SpreaderWrapper spreader_w(order_def, nullptr);
REQUIRE(spreader_w.spreader_state() == SpreaderState::START);
// on_init_new and activate
SpreaderOrderServices order_services(nullptr);
spreader_w.activate(spreader_price, spreader_quantity);
SpreaderBookkeepingData &bookkeeping_data = spreader_w.bookkeeping_data();
verify_basic_spreader_state(
spreader_w.spreader(), SpreaderState::WORKING, spreader_price,
spreader_quantity);
SpreaderLegData &leg_data_1 = bookkeeping_data.get_leg_data(0);
SpreaderLegData &leg_data_2 = bookkeeping_data.get_leg_data(1);
verify_complete_quoter_state(
leg_data_1.quoter(), QuoterState::WAITING_FOR_SIZE, false,
spreader_price, Quantity(100), Quantity(0), Quantity(0), Price(0),
Quantity(0), Quantity(100), false);
verify_complete_quoter_state(
leg_data_2.quoter(), QuoterState::WAITING_FOR_SIZE, false,
spreader_price, Quantity(100), Quantity(0), Quantity(0), Price(0),
Quantity(0), Quantity(100), false);
set_spreader_orders(
spreader_w.spreader(), new double[5]{1999, 1998, 1997, 1996, 1995},
new uint16_t[5]{50, 50, 10, 10, 30},
new double[5]{2000, 2001, 2002, 2003, 2004},
new uint16_t[5]{10, 15, 25, 50, 10},
new double[5]{2002, 2001, 2000, 1999, 1998},
new uint16_t[5]{20, 20, 20, 20, 20},
new double[5]{2003, 2004, 2005, 2006, 2007},
new uint16_t[5]{25, 25, 20, 20, 10}, 0, 0, 0, 0);
// verify working orders
verify_complete_quoter_state(
leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price,
Quantity(100), Quantity(0), Quantity(0), Price(1999), Quantity(100),
Quantity(100), false);
verify_complete_quoter_state(
leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price,
Quantity(100), Quantity(0), Quantity(0), Price(2002), Quantity(100),
Quantity(100), false);
// send fill on leg 1 (20)
spreader_w.on_order_update(
{leg_data_1.order_key(),
api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(20),
Price(2000)});
verify_complete_quoter_state(
leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price,
Quantity(100), Quantity(20), Quantity(0), Price(2000), Quantity(100),
Quantity(80), false);
verify_complete_quoter_state(
leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price,
Quantity(100), Quantity(0), Quantity(20), Price(2002), Quantity(80),
Quantity(80), false);
// send another fill on leg 1 (10)
spreader_w.on_order_update(
{leg_data_1.order_key(),
api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(30),
Price(2000)});
verify_complete_quoter_state(
leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price,
Quantity(100), Quantity(30), Quantity(0), Price(2000), Quantity(100),
Quantity(70), false);
verify_complete_quoter_state(
leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price,
Quantity(100), Quantity(0), Quantity(30), Price(2002), Quantity(70),
Quantity(70), false);
// send fill on leg 2 (15)
spreader_w.on_order_update(
{leg_data_2.order_key(),
api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(15),
Price(2001)});
verify_complete_quoter_state(
leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price,
Quantity(100), Quantity(30), Quantity(15), Price(2001), Quantity(85),
Quantity(55), false);
verify_complete_quoter_state(
leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price,
Quantity(100), Quantity(15), Quantity(30), Price(2002), Quantity(70),
Quantity(55), false);
// send another fill on leg 2 (30)
spreader_w.on_order_update(
{leg_data_2.order_key(),
api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(45),
Price(2001)});
verify_complete_quoter_state(
leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price,
Quantity(100), Quantity(30), Quantity(45), Price(2002), Quantity(55),
Quantity(25), false);
verify_complete_quoter_state(
leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price,
Quantity(100), Quantity(45), Quantity(30), Price(2000), Quantity(70),
Quantity(25), false);
// send another fill on leg 2 (10)
spreader_w.on_order_update(
{leg_data_2.order_key(),
api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(55),
Price(2001)});
verify_complete_quoter_state(
leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price,
Quantity(100), Quantity(30), Quantity(55), Price(2003), Quantity(45),
Quantity(15), false);
verify_complete_quoter_state(
leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price,
Quantity(100), Quantity(55), Quantity(30), Price(2000), Quantity(70),
Quantity(15), false);
// verify the hedgers
// leg 1 should have 3 hedgers, for each of the 3 fills
for (size_t i = 0; i < leg_data_1.n_active_hedgers(); i++)
spreader_w.on_order_update(
{leg_data_1.get_hedger_test_only(i).order_state().order_key(),
api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(0),
Price(0)});
for (size_t i = 0; i < leg_data_2.n_active_hedgers(); i++)
spreader_w.on_order_update(
{leg_data_2.get_hedger_test_only(i).order_state().order_key(),
api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(0),
Price(0)});
REQUIRE(leg_data_1.n_active_hedgers() == 3);
REQUIRE(leg_data_2.n_active_hedgers() == 2);
verify_complete_quoter_state(
leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price,
Quantity(100), Quantity(30), Quantity(55), Price(2003), Quantity(45),
Quantity(15), false);
verify_complete_quoter_state(
leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price,
Quantity(100), Quantity(55), Quantity(30), Price(2000), Quantity(70),
Quantity(15), false);
verify_complete_hedger_state(
leg_data_1.get_hedger_test_only(0), HedgerState::WORKING, Price(2002),
Quantity(15), Quantity(0), Price(2002), Quantity(15), Quantity(15));
verify_complete_hedger_state(
leg_data_1.get_hedger_test_only(1), HedgerState::WORKING, Price(2002),
Quantity(30), Quantity(0), Price(2002), Quantity(30), Quantity(30));
verify_complete_hedger_state(
leg_data_1.get_hedger_test_only(2), HedgerState::WORKING, Price(2002),
Quantity(10), Quantity(0), Price(2002), Quantity(10), Quantity(10));
verify_complete_hedger_state(
leg_data_2.get_hedger_test_only(0), HedgerState::WORKING, Price(1999),
Quantity(20), Quantity(0), Price(1999), Quantity(20), Quantity(20));
verify_complete_hedger_state(
leg_data_2.get_hedger_test_only(1), HedgerState::WORKING, Price(1999),
Quantity(10), Quantity(0), Price(1999), Quantity(10), Quantity(10));
LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.initializing");
// now cancel the spreader
bts::TimeStamp cancel_timestamp = std::chrono::system_clock::now();
// TODO
// speader_w.test_only_on_time(cancel_timestamp);
spreader_w.cancel();
auto validate_state = [&]() -> void {
verify_basic_spreader_state(
spreader_w.spreader(), SpreaderState::WAITING_FOR_CANCEL_ALL,
spreader_price, spreader_quantity);
REQUIRE(leg_data_1.n_active_hedgers() == 3);
REQUIRE(leg_data_2.n_active_hedgers() == 2);
verify_complete_quoter_state(
leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true,
spreader_price, Quantity(100), Quantity(30), Quantity(55),
Price(2003), Quantity(45), Quantity(15), false);
verify_complete_quoter_state(
leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true,
spreader_price, Quantity(100), Quantity(55), Quantity(30),
Price(2000), Quantity(70), Quantity(15), false);
verify_complete_hedger_state(
leg_data_1.get_hedger_test_only(0),
HedgerState::WAITING_FOR_CANCEL_ACK, Price(2002), Quantity(15),
Quantity(0), Price(2002), Quantity(15), Quantity(15));
verify_complete_hedger_state(
leg_data_1.get_hedger_test_only(1),
HedgerState::WAITING_FOR_CANCEL_ACK, Price(2002), Quantity(30),
Quantity(0), Price(2002), Quantity(30), Quantity(30));
verify_complete_hedger_state(
leg_data_1.get_hedger_test_only(2),
HedgerState::WAITING_FOR_CANCEL_ACK, Price(2002), Quantity(10),
Quantity(0), Price(2002), Quantity(10), Quantity(10));
verify_complete_hedger_state(
leg_data_2.get_hedger_test_only(0),
HedgerState::WAITING_FOR_CANCEL_ACK, Price(1999), Quantity(20),
Quantity(0), Price(1999), Quantity(20), Quantity(20));
verify_complete_hedger_state(
leg_data_2.get_hedger_test_only(1),
HedgerState::WAITING_FOR_CANCEL_ACK, Price(1999), Quantity(10),
Quantity(0), Price(1999), Quantity(10), Quantity(10));
};
validate_state();
SECTION("1. init") {}
SECTION("2. on_connect") {}
SECTION("4. on_update") {
spreader_w.update_spreader(Price(-0.05), Quantity(200));
validate_state();
// order changes dont go through
validate_state();
LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_update");
}
SECTION("5. on_cancel") {
spreader_w.cancel();
// already in cancel state, no change
validate_state();
LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_cancel");
}
SECTION("6. on_book") {
// like 4 and 5, should have no effect
set_spreader_orders(
spreader_w.spreader(), new double[5]{1999, 1998, 1997, 1996, 1995},
new uint16_t[5]{1, 0, 0, 0, 0},
new double[5]{2000, 2001, 2002, 2003, 2004},
new uint16_t[5]{1, 1, 2, 0, 0},
new double[5]{2002, 2001, 2000, 1999, 1998},
new uint16_t[5]{1, 0, 0, 0, 0},
new double[5]{2003, 2004, 2005, 2006, 2007},
new uint16_t[5]{1, 0, 0, 0, 0}, 30, 2000, 55, 2001);
validate_state();
LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_book");
}
SECTION("8. on_quoter_order_error") {
spreader_w.on_order_update(
{leg_data_1.order_key(),
bts::api::orderman::OrderStatus::ORDER_STATUS_DISCONNECTED,
Quantity(30), Price(2000)});
validate_state();
LOG(OrderMan, Diag,
"spreader_WAITING_FOR_CANCEL_ACK.on_quoter_order_error");
}
SECTION("9. on_quoter_order_fill") {
// send another fill on leg 1, this will update the filled
// state of leg 1, but no other action will take place
spreader_w.on_order_update(
{leg_data_1.order_key(),
bts::api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(40),
Price(2000.5)});
verify_basic_spreader_state(
spreader_w.spreader(), SpreaderState::WAITING_FOR_CANCEL_ALL,
spreader_price, spreader_quantity);
REQUIRE(leg_data_1.n_active_hedgers() == 3);
REQUIRE(leg_data_2.n_active_hedgers() == 2);
verify_complete_quoter_state(
leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true,
spreader_price, Quantity(100), Quantity(40), Quantity(55),
Price(2003), Quantity(45), Quantity(5), false);
verify_complete_quoter_state(
leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true,
spreader_price, Quantity(100), Quantity(55), Quantity(30),
Price(2000), Quantity(70), Quantity(15), false);
verify_complete_hedger_state(
leg_data_1.get_hedger_test_only(0),
HedgerState::WAITING_FOR_CANCEL_ACK, Price(2002), Quantity(15),
Quantity(0), Price(2002), Quantity(15), Quantity(15));
verify_complete_hedger_state(
leg_data_1.get_hedger_test_only(1),
HedgerState::WAITING_FOR_CANCEL_ACK, Price(2002), Quantity(30),
Quantity(0), Price(2002), Quantity(30), Quantity(30));
verify_complete_hedger_state(
leg_data_1.get_hedger_test_only(2),
HedgerState::WAITING_FOR_CANCEL_ACK, Price(2002), Quantity(10),
Quantity(0), Price(2002), Quantity(10), Quantity(10));
verify_complete_hedger_state(
leg_data_2.get_hedger_test_only(0),
HedgerState::WAITING_FOR_CANCEL_ACK, Price(1999), Quantity(20),
Quantity(0), Price(1999), Quantity(20), Quantity(20));
verify_complete_hedger_state(
leg_data_2.get_hedger_test_only(1),
HedgerState::WAITING_FOR_CANCEL_ACK, Price(1999), Quantity(10),
Quantity(0), Price(1999), Quantity(10), Quantity(10));
LOG(OrderMan, Diag,
"spreader_WAITING_FOR_CANCEL_ACK.on_quoter_order_fill");
}
SECTION("10. on_quoter_order_status_update") {
// cancelled update
spreader_w.on_order_update(
{leg_data_1.order_key(),
bts::api::orderman::OrderStatus::ORDER_STATUS_CANCELED, Quantity(30),
Price(2000)});
verify_basic_spreader_state(
spreader_w.spreader(), SpreaderState::WAITING_FOR_CANCEL_ALL,
spreader_price, spreader_quantity);
REQUIRE(leg_data_1.n_active_hedgers() == 3);
REQUIRE(leg_data_2.n_active_hedgers() == 2);
verify_complete_quoter_state(
leg_data_1.quoter(), QuoterState::END, true, spreader_price,
Quantity(100), Quantity(0), Quantity(55), Price(0), Quantity(0),
Quantity(15), false);
verify_complete_quoter_state(
leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true,
spreader_price, Quantity(100), Quantity(55), Quantity(30),
Price(2000), Quantity(70), Quantity(15), false);
verify_complete_hedger_state(
leg_data_1.get_hedger_test_only(0),
HedgerState::WAITING_FOR_CANCEL_ACK, Price(2002), Quantity(15),
Quantity(0), Price(2002), Quantity(15), Quantity(15));
verify_complete_hedger_state(
leg_data_1.get_hedger_test_only(1),
HedgerState::WAITING_FOR_CANCEL_ACK, Price(2002), Quantity(30),
Quantity(0), Price(2002), Quantity(30), Quantity(30));
verify_complete_hedger_state(
leg_data_1.get_hedger_test_only(2),
HedgerState::WAITING_FOR_CANCEL_ACK, Price(2002), Quantity(10),
Quantity(0), Price(2002), Quantity(10), Quantity(10));
verify_complete_hedger_state(
leg_data_2.get_hedger_test_only(0),
HedgerState::WAITING_FOR_CANCEL_ACK, Price(1999), Quantity(20),
Quantity(0), Price(1999), Quantity(20), Quantity(20));
verify_complete_hedger_state(
leg_data_2.get_hedger_test_only(1),
HedgerState::WAITING_FOR_CANCEL_ACK, Price(1999), Quantity(10),
Quantity(0), Price(1999), Quantity(10), Quantity(10));
LOG(OrderMan, Diag,
"spreader_WAITING_FOR_CANCEL_ACK.on_quoter_order_status_update");
}
SECTION("11. on_hedger_order_error") {
std::string err_msg = "error";
spreader_w.on_order_update(
{leg_data_1.get_hedger_test_only(0).order_state().order_key(),
bts::api::orderman::OrderStatus::ORDER_STATUS_DISCONNECTED,
Quantity(0), Price(0)});
validate_state();
LOG(OrderMan, Diag,
"spreader_WAITING_FOR_CANCEL_ACK.on_hedger_order_error");
}
SECTION("12. on_hedger_order_update") {
// send a fill
spreader_w.on_order_update(
{leg_data_1.get_hedger_test_only(0).order_state().order_key(),
bts::api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(10),
Price(2000)});
verify_complete_quoter_state(
leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true,
spreader_price, Quantity(100), Quantity(30), Quantity(55),
Price(2003), Quantity(45), Quantity(15), false);
verify_complete_quoter_state(
leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true,
spreader_price, Quantity(100), Quantity(55), Quantity(30),
Price(2000), Quantity(70), Quantity(15), false);
verify_complete_hedger_state(
leg_data_1.get_hedger_test_only(0),
HedgerState::WAITING_FOR_CANCEL_ACK, Price(2002), Quantity(15),
Quantity(10), Price(2002), Quantity(15), Quantity(5));
verify_complete_hedger_state(
leg_data_1.get_hedger_test_only(1),
HedgerState::WAITING_FOR_CANCEL_ACK, Price(2002), Quantity(30),
Quantity(0), Price(2002), Quantity(30), Quantity(30));
verify_complete_hedger_state(
leg_data_1.get_hedger_test_only(2),
HedgerState::WAITING_FOR_CANCEL_ACK, Price(2002), Quantity(10),
Quantity(0), Price(2002), Quantity(10), Quantity(10));
verify_complete_hedger_state(
leg_data_2.get_hedger_test_only(0),
HedgerState::WAITING_FOR_CANCEL_ACK, Price(1999), Quantity(20),
Quantity(0), Price(1999), Quantity(20), Quantity(20));
verify_complete_hedger_state(
leg_data_2.get_hedger_test_only(1),
HedgerState::WAITING_FOR_CANCEL_ACK, Price(1999), Quantity(10),
Quantity(0), Price(1999), Quantity(10), Quantity(10));
LOG(OrderMan, Diag,
"spreader_WAITING_FOR_CANCEL_ACK.on_hedger_order_update");
}
SECTION("14. on_check_termination") {
// send cancel for orders, once all quoters and hedgers
// are cancelled, spreader should come to end
spreader_w.on_order_update(
{leg_data_1.order_update_message().order_key(),
bts::api::orderman::OrderStatus::ORDER_STATUS_CANCELED, Quantity(30),
Price(2000)});
verify_complete_quoter_state(
leg_data_1.quoter(), QuoterState::END, true, spreader_price,
Quantity(100), Quantity(0), Quantity(55), Price(0), Quantity(0),
Quantity(15), false);
spreader_w.on_order_update(
{leg_data_2.order_update_message().order_key(),
bts::api::orderman::OrderStatus::ORDER_STATUS_CANCELED, Quantity(55),
Price(2000)});
verify_complete_quoter_state(
leg_data_2.quoter(), QuoterState::END, true, spreader_price,
Quantity(100), Quantity(0), Quantity(30), Price(0), Quantity(0),
Quantity(15), false);
verify_basic_spreader_state(
spreader_w.spreader(), SpreaderState::WAITING_FOR_CANCEL_ALL,
spreader_price, spreader_quantity);
spreader_w.on_order_update(
{leg_data_1.get_hedger_test_only(0).order_state().order_key(),
bts::api::orderman::OrderStatus::ORDER_STATUS_CANCELED, Quantity(0),
Price(0)});
verify_complete_hedger_state(
leg_data_1.get_hedger_test_only(0), HedgerState::END, Price(2002),
Quantity(15), Quantity(0), Price(0), Quantity(0), Quantity(15));
spreader_w.on_order_update(
{leg_data_1.get_hedger_test_only(1).order_state().order_key(),
bts::api::orderman::OrderStatus::ORDER_STATUS_CANCELED, Quantity(0),
Price(0)});
verify_complete_hedger_state(
leg_data_1.get_hedger_test_only(1), HedgerState::END, Price(2002),
Quantity(30), Quantity(0), Price(0), Quantity(0), Quantity(30));
spreader_w.on_order_update(
{leg_data_1.get_hedger_test_only(2).order_state().order_key(),
bts::api::orderman::OrderStatus::ORDER_STATUS_CANCELED, Quantity(0),
Price(0)});
verify_complete_hedger_state(
leg_data_1.get_hedger_test_only(2), HedgerState::END, Price(2002),
Quantity(10), Quantity(0), Price(0), Quantity(0), Quantity(10));
spreader_w.on_order_update(
{leg_data_2.get_hedger_test_only(0).order_state().order_key(),
bts::api::orderman::OrderStatus::ORDER_STATUS_CANCELED, Quantity(0),
Price(0)});
verify_complete_hedger_state(
leg_data_2.get_hedger_test_only(0), HedgerState::END, Price(1999),
Quantity(20), Quantity(0), Price(0), Quantity(0), Quantity(20));
verify_basic_spreader_state(
spreader_w.spreader(), SpreaderState::WAITING_FOR_CANCEL_ALL,
spreader_price, spreader_quantity);
spreader_w.on_order_update(
{leg_data_2.get_hedger_test_only(1).order_state().order_key(),
bts::api::orderman::OrderStatus::ORDER_STATUS_CANCELED, Quantity(0),
Price(0)});
verify_complete_hedger_state(
leg_data_2.get_hedger_test_only(1), HedgerState::END, Price(1999),
Quantity(10), Quantity(0), Price(0), Quantity(0), Quantity(10));
verify_basic_spreader_state(
spreader_w.spreader(), SpreaderState::END, spreader_price,
spreader_quantity);
LOG(OrderMan, Diag,
"spreader_WAITING_FOR_CANCEL_ACK.on_check_termination");
}
}
TEST_CASE("find_target_price_in_book", "[spreader]") {
SECTION("0.05") {
Quantity out_cum_qty;
@@ -4981,6 +5441,7 @@ TEST_CASE("spreader_perf_2legs", "[spreader]") {
<< " unit time(usecs):" << hedge_time << std::endl;
}
}
TEST_CASE("spreader_perf_4legs", "[spreader]") {
bool recomp = false; // gen_rand(0,10) > 5;
bts::orderman::OrderKey order_key(0);
@@ -5284,6 +5745,312 @@ TEST_CASE("spreader_perf_4legs", "[spreader]") {
REQUIRE(t_qty.value() == 10);
}
}
TEST_CASE("spreader_standalone_perf_4legs", "[spreader]") {
bool recomp = false; // gen_rand(0,10) > 5;
bts::orderman::OrderKey order_key(0);
Price spreader_price = Price(40);
Quantity spreader_quantity = Quantity(250);
ContractLeg leg_1, leg_2, leg_3, qleg_4;
fill_future_contract_leg(
leg_1, 2468, "SI", bts::api::Venue::VENUE_GLBX, 2019, 1, 15, 1.0, 1.0,
api::Side::SIDE_BUY, 1.0, 0.005);
fill_future_contract_leg(
leg_2, 2469, "SI", bts::api::Venue::VENUE_GLBX, 2019, 2, 15, 1.0, 1.0,
api::Side::SIDE_BUY, 1.0, 0.005);
fill_future_contract_leg(
leg_3, 2470, "SI", bts::api::Venue::VENUE_GLBX, 2019, 3, 15, 1.0, 1.0,
api::Side::SIDE_BUY, 1.0, 0.005);
fill_future_contract_leg(
qleg_4, 2471, "SI", bts::api::Venue::VENUE_GLBX, 2019, 4, 15, -1.0, -1.0,
api::Side::SIDE_SELL, 1.0, 0.005);
std::vector<ContractLeg> contract_legs;
contract_legs.push_back(leg_1);
contract_legs.push_back(leg_2);
contract_legs.push_back(leg_3);
contract_legs.push_back(qleg_4);
Security synthetic_security;
fill_synthetic_security(
synthetic_security, 2000, "synthetic_security", contract_legs);
// execution params/order def
LegSpreaderParams lsp_1, lsp_2, lsp_3, qlsp_4;
fill_leg_spreader_params(lsp_1, 1.0, false, 1.0);
fill_leg_spreader_params(lsp_2, 1.0, false, 1.0);
fill_leg_spreader_params(lsp_3, 1.0, false, 1.0);
fill_leg_spreader_params(qlsp_4, -1.0, true, 1.0);
std::vector<LegSpreaderParams> spreader_params;
spreader_params.push_back(lsp_1);
spreader_params.push_back(lsp_2);
spreader_params.push_back(lsp_3);
spreader_params.push_back(qlsp_4);
bts::api::orderman::OrderDefinition order_def;
fill_spreader_order_definition(
order_def, Side::SIDE_BUY, synthetic_security, spreader_params);
// putting it together in SpreaderBookkeepingData
SpreaderPreActivationOrderServices pao_services(synthetic_security);
std::vector<LegPropertyData> leg_props;
std::vector<bts::api::orderman::OrderDefinition> quoter_ord_defs,
hedger_ord_defs;
SpreaderUtils::resolve_synthetic_spread(
pao_services, order_def, leg_props, quoter_ord_defs, hedger_ord_defs);
SpreaderManagerForTest spreader_manager(
order_key, order_def, pao_services, leg_props, quoter_ord_defs,
hedger_ord_defs);
// SpreaderOrder spreader(spreader_manager.alt_order_gateway());
integration::SpreaderWrapper spreader_w(order_def, nullptr);
REQUIRE(spreader_w.spreader_state() == SpreaderState::START);
// on_init_new and activate
// spreader.test_only_on_init_new(order_def, pao_services);
SpreaderOrderServices order_services(nullptr);
spreader_w.activate(spreader_price, spreader_quantity);
SpreaderBookkeepingData &bookkeeping_data = spreader_w.bookkeeping_data();
verify_basic_spreader_state(
spreader_w.spreader(), SpreaderState::WORKING, spreader_price,
spreader_quantity);
SpreaderLegData &qleg_data_4 = bookkeeping_data.get_leg_data(3);
verify_complete_quoter_state(
qleg_data_4.quoter(), QuoterState::WAITING_FOR_SIZE, false,
spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0),
Quantity(0), spreader_quantity, false);
Book book_1 = get_book(
SecurityKey(leg_1.security().id()), 5,
new double[5]{20, 19.995, 19.990, 19.985, 19.980},
new uint16_t[5]{100, 50, 75, 150, 25},
new double[5]{20.005, 20.010, 20.015, 20.020, 20.025},
new uint16_t[5]{25, 125, 175, 225, 100}, true),
book_1_alt = get_book(
SecurityKey(leg_1.security().id()), 5,
new double[5]{20.005, 19.990, 19.890, 19.885, 19.780},
new uint16_t[5]{10, 25, 75, 15, 25},
new double[5]{20.010, 20.015, 20.025, 20.030, 20.035},
new uint16_t[5]{10, 25, 75, 15, 25}, true),
book_2 = get_book(
SecurityKey(leg_2.security().id()), 5,
new double[5]{20.030, 20.025, 20.020, 20.015, 20.010},
new uint16_t[5]{100, 100, 200, 250, 75},
new double[5]{20.035, 20.040, 20.045, 20.050, 20.055},
new uint16_t[5]{250, 275, 100, 5, 15}, true),
book_2_alt = get_book(
SecurityKey(leg_2.security().id()), 5,
new double[5]{20.050, 20.035, 20.030, 20.035, 20.030},
new uint16_t[5]{10, 10, 20, 250, 75},
new double[5]{20.055, 20.060, 20.065, 20.070, 20.085},
new uint16_t[5]{25, 275, 100, 5, 15}, true),
book_3 = get_book(
SecurityKey(leg_3.security().id()), 5,
new double[5]{19.985, 19.980, 19.975, 19.970, 19.965},
new uint16_t[5]{75, 250, 125, 100, 300},
new double[5]{19.990, 19.995, 20.000, 20.005, 20.010},
new uint16_t[5]{100, 150, 250, 25, 125}, true),
book_3_alt = get_book(
SecurityKey(leg_3.security().id()), 5,
new double[5]{19.885, 19.875, 19.870, 19.765, 19.760},
new uint16_t[5]{75, 25, 125, 100, 300},
new double[5]{19.890, 19.895, 19.900, 19.910, 19.915},
new uint16_t[5]{100, 50, 50, 125, 125}, true);
spreader_w.update_book(book_1);
spreader_w.update_book(book_2);
spreader_w.update_book(book_3);
verify_complete_quoter_state(
qleg_data_4.quoter(), QuoterState::WAITING_FOR_FIRST_ACK, false,
spreader_price, spreader_quantity, Quantity(0), Quantity(0),
Price(20.045), spreader_quantity, spreader_quantity, false);
spreader_w.on_order_update(
{qleg_data_4.order_key(),
api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(0),
Price(0)});
verify_complete_quoter_state(
qleg_data_4.quoter(), QuoterState::WORKING, false, spreader_price,
spreader_quantity, Quantity(0), Quantity(0), Price(20.045),
spreader_quantity, spreader_quantity, false);
SECTION("Testing Hedge Reuse") {
Quantity t_qty;
Price t_price;
// to keep the compiler warning happy
LOG(OrderMan, Info, "{} {} {}", book_1_alt.n_levels(),
book_2_alt.n_levels(), book_3_alt.n_levels());
// this sends fills, makes sure the hedgers are
// working, and on fill and recycled
// the hedge prices used are
// 20.015, 20.035 and 19.995
SpreaderLegData &qleg_data_4 = bookkeeping_data.get_leg_data(3);
// lets concentrate on the hedges sent on leg 1
SpreaderLegData &hleg_1 = bookkeeping_data.get_leg_data(0);
auto &hm_1 = hleg_1.hedger_manager();
REQUIRE(hm_1.n_active_hedgers() == 0);
// send a 1 lot quoter fill /////////
/////////////////////////////////////
spreader_w.on_order_update(
{qleg_data_4.order_key(),
api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(1),
Price(20.045)});
REQUIRE(hm_1.n_active_hedgers() == 1);
// legs 2 and 3
REQUIRE(securities::test_price_equality(
bookkeeping_data.get_leg_data(1)
.hedger_manager()
.test_only_get_hedger_at(0)
.order_state()
.out_price()
.value(),
20.035, 0.005));
REQUIRE(securities::test_price_equality(
bookkeeping_data.get_leg_data(2)
.hedger_manager()
.test_only_get_hedger_at(0)
.order_state()
.out_price()
.value(),
recomp ? 19.990 : 19.995, 0.005));
// back to leg1's hedger, this is what will
// be mainly tested here on
{
auto &hedger_1_1 = hm_1.test_only_get_hedger_at(0);
REQUIRE(hedger_1_1.order_state().out_quantity().value() == 1);
REQUIRE(securities::test_price_equality(
hedger_1_1.order_state().out_price().value(),
recomp ? 20.005 : 20.015, 0.005));
REQUIRE(hedger_1_1.state() == HedgerState::WAITING_FOR_FIRST_ACK);
spreader_w.on_order_update(
{hedger_1_1.order_state().order_key(),
api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(0),
Price(0)});
REQUIRE(hedger_1_1.state() == HedgerState::WORKING);
// fill h1 and it goes back to start ////
/////////////////////////////////////////
spreader_w.on_order_update(
{hedger_1_1.order_state().order_key(),
api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity(1),
Price(20.015)});
REQUIRE(hedger_1_1.state() == HedgerState::START);
}
REQUIRE(hm_1.n_active_hedgers() == 0);
hm_1.total_fills(t_qty, t_price);
REQUIRE(t_qty.value() == 1);
REQUIRE(securities::test_price_equality(t_price.value(), 20.015, 0.005));
////////////////////////////
// send another 1 lot q fill
spreader_w.on_order_update(
{qleg_data_4.order_key(),
api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(2),
Price(20.045)});
REQUIRE(hm_1.n_active_hedgers() == 1);
// since 2 and 3 were never filled, they should have 2 hedgers
REQUIRE(
bookkeeping_data.get_leg_data(1)
.hedger_manager()
.n_active_hedgers() == 2);
REQUIRE(
bookkeeping_data.get_leg_data(2)
.hedger_manager()
.n_active_hedgers() == 2);
{
auto &hedger_1_1 = hm_1.test_only_get_hedger_at(0);
REQUIRE(hedger_1_1.order_state().out_quantity().value() == 1);
REQUIRE(securities::test_price_equality(
hedger_1_1.order_state().out_price().value(),
recomp ? 20.005 : 20.015, 0.005));
REQUIRE(hedger_1_1.state() == HedgerState::WAITING_FOR_FIRST_ACK);
spreader_w.on_order_update(
{hedger_1_1.order_state().order_key(),
api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(0),
Price(0)});
REQUIRE(hedger_1_1.state() == HedgerState::WORKING);
// fill h1 ///////
//////////////////
spreader_w.on_order_update(
{hedger_1_1.order_state().order_key(),
api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity(1),
Price(20.025)});
REQUIRE(hedger_1_1.state() == HedgerState::START);
}
REQUIRE(hm_1.n_active_hedgers() == 0);
hm_1.total_fills(t_qty, t_price);
REQUIRE(t_qty.value() == 2);
REQUIRE(securities::test_price_equality(t_price.value(), 20.020, 0.005));
// send 4 more q fills /////////
////////////////////////////////
for (size_t f = 4; f <= 10; f += 2)
spreader_w.on_order_update(
{qleg_data_4.order_key(),
api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(f),
Price(20.045)});
REQUIRE(hm_1.n_active_hedgers() == 4);
REQUIRE(
bookkeeping_data.get_leg_data(1)
.hedger_manager()
.n_active_hedgers() == 6);
REQUIRE(
bookkeeping_data.get_leg_data(2)
.hedger_manager()
.n_active_hedgers() == 6);
REQUIRE(
bookkeeping_data.get_leg_data(3)
.hedger_manager()
.n_active_hedgers() == 0);
for (size_t i = 0; i < 4; i++) {
auto &h = hm_1.test_only_get_hedger_at(i);
REQUIRE(h.state() == HedgerState::WAITING_FOR_FIRST_ACK);
REQUIRE(h.order_state().out_quantity().value() == 2);
REQUIRE(securities::test_price_equality(
h.order_state().out_price().value(), recomp ? 20.005 : 20.015,
0.005));
}
// send order acks //////////
/////////////////////////////
for (size_t i = 0; i < 4; i++) {
auto &h = hm_1.test_only_get_hedger_at(i);
spreader_w.on_order_update(
{h.order_state().order_key(),
api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(0),
Price(0)});
REQUIRE(h.state() == HedgerState::WORKING);
REQUIRE(h.order_state().out_quantity().value() == 2);
REQUIRE(securities::test_price_equality(
h.order_state().out_price().value(), recomp ? 20.005 : 20.015,
0.005));
}
REQUIRE(hm_1.n_active_hedgers() == 4);
// fills 1 lot on each order //
///////////////////////////////
for (size_t i = 0; i < 4; i++) {
auto &h = hm_1.test_only_get_hedger_at(i);
// previous hedger fills were 20.015, 20.025
spreader_w.on_order_update(
{h.order_state().order_key(),
api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(1),
Price(20.035)});
REQUIRE(h.state() == HedgerState::WORKING);
REQUIRE(h.order_state().out_quantity().value() == 2);
REQUIRE(securities::test_price_equality(
h.order_state().out_price().value(), recomp ? 20.005 : 20.015,
0.005));
}
REQUIRE(hm_1.n_active_hedgers() == 4);
hm_1.total_fills(t_qty, t_price);
REQUIRE(securities::test_price_equality(t_price.value(), 20.03, 0.005));
REQUIRE(t_qty.value() == 6);
// fills additional 1 lot on each, ///////
// which should complete the orders //////
//////////////////////////////////////////
for (size_t i = 0; i < 4; i++) {
auto &h = hm_1.test_only_get_hedger_at(i);
// previous hedger fills were 20.015, 20.025
spreader_w.on_order_update(
{h.order_state().order_key(),
api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity(2),
Price(20.03)});
REQUIRE(h.state() == HedgerState::START);
REQUIRE(h.order_state().out_quantity().value() == 0);
}
REQUIRE(hm_1.n_active_hedgers() == 0);
hm_1.total_fills(t_qty, t_price);
REQUIRE(securities::test_price_equality(t_price.value(), 20.03, 0.005));
REQUIRE(t_qty.value() == 10);
}
}
TEST_CASE("simple book addition", "[spreader]") {
SECTION("direct, book") {
SecurityKey key(12345);
@@ -5817,8 +6584,8 @@ TEST_CASE("net_change_transformation", "[spreader]") {
b2_raw, bts::md::IntPrice_from_double<7>(settle2), tick2,
spark::LegSpreaderParams::MERGED,
bts::api::SyntheticContract::PRICECALC_NET_CHANGE, b2_ticks);
// generate the leg properties accordingly (notice the tick size is 1
// since the market is in ticks)
// generate the leg properties accordingly (notice the tick size is
// 1 since the market is in ticks)
const LegPropertyData lp1 = create_leg_property_data(
0, leg1_qty, leg1_pmult, api::Side::SIDE_BUY,
1, 0, true),
@@ -5892,17 +6659,20 @@ TEST_CASE("net_change_transformation", "[spreader]") {
// Book look_ahead_book = bk;
// // buy sweep
// bool res = SpreaderUtils::compute_book_from_sweep(
// bk, api::Side::SIDE_BUY, Price(80), Quantity(15), look_ahead_book);
// bk, api::Side::SIDE_BUY, Price(80), Quantity(15),
// look_ahead_book);
// REQUIRE(res);
// res = SpreaderUtils::compute_book_from_sweep(
// bk, api::Side::SIDE_BUY, Price(80), Quantity(16), look_ahead_book);
// bk, api::Side::SIDE_BUY, Price(80), Quantity(16),
// look_ahead_book);
// REQUIRE(!res);
// res = SpreaderUtils::compute_book_from_sweep(
// bk, api::Side::SIDE_BUY, Price(80.01), Quantity(16),
// look_ahead_book);
// REQUIRE(!res);
// res = SpreaderUtils::compute_book_from_sweep(
// bk, api::Side::SIDE_BUY, Price(80), Quantity(15), look_ahead_book);
// bk, api::Side::SIDE_BUY, Price(80), Quantity(15),
// look_ahead_book);
// REQUIRE(res);
// bts::securities::test_price_equality(
// look_ahead_book.bid()[0].price(), 80);