diff --git a/src/lib/orderman/orders/spreader_orders/tests/spreader_tests.cpp b/src/lib/orderman/orders/spreader_orders/tests/spreader_tests.cpp index fe10e9980..592061d10 100644 --- a/src/lib/orderman/orders/spreader_orders/tests/spreader_tests.cpp +++ b/src/lib/orderman/orders/spreader_orders/tests/spreader_tests.cpp @@ -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 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 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 leg_props; + std::vector 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 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 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 leg_props; + std::vector 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);