From 89f3f86c92a3391a43bfecf1957f045a1bf283de Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Tue, 12 Dec 2017 18:33:52 -0500 Subject: [PATCH] SPARK-287 spreader_WAITING_FOR_CANCEL_ACK done --- .../sparkd/orderman/tests/spreader_tests.cpp | 336 +++++++----------- 1 file changed, 124 insertions(+), 212 deletions(-) diff --git a/src/server/sparkd/orderman/tests/spreader_tests.cpp b/src/server/sparkd/orderman/tests/spreader_tests.cpp index 59879d108..76de0714a 100644 --- a/src/server/sparkd/orderman/tests/spreader_tests.cpp +++ b/src/server/sparkd/orderman/tests/spreader_tests.cpp @@ -1846,8 +1846,6 @@ TEST_CASE ("spreader_WORKING", "[spreader]") LOG(OrderMan, Diag, "spreader_WORKING.on_quoter_order_error"); } } - - TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]") { ContractLeg leg_1, leg_2; @@ -1914,12 +1912,40 @@ TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]") spreader.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (45), Price (2001), nullptr); 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); - // std::vector& hedgers_leg_2 = leg_data_2.get_hedgers(); - // bts_assert (hedgers_leg_2.size() == 1); - // SingleFillHedger& hedger = hedgers_leg_2[0].hedger(); - // verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_FIRST_ACK, Price(1999), Quantity(20), Quantity(0), Price (1999), Quantity(20), Quantity (20)); - LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.initializing"); - + // send another fill on leg 2 (10) + spreader.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (55), Price (2001), nullptr); + 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 + bts_assert (leg_data_1.n_hedgers() == 3); + for (size_t i = 0; i < leg_data_1.n_hedgers(); i++) + spreader.on_child_update (leg_data_1.get_hedger(i).order_update_message().order_key, api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr); + for (size_t i = 0; i < leg_data_2.n_hedgers(); i++) + spreader.on_child_update (leg_data_2.get_hedger(i).order_update_message().order_key, api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr); + verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15)); + verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WORKING, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30)); + verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WORKING, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10)); + bts_assert (leg_data_2.n_hedgers () == 2); + verify_complete_hedger_state (leg_data_2.get_hedger (0).hedger(), HedgerState::WORKING, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20)); + verify_complete_hedger_state (leg_data_2.get_hedger (1).hedger(), 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 + spreader.on_cancel (bts::api::orderman::CancelSpreaderOrder()); + auto validate_state = [&]() -> void + { + verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity); + bts_assert (leg_data_1.n_hedgers () == 3); + bts_assert (leg_data_2.n_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 (0).hedger(), 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 (1).hedger(), 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 (2).hedger(), 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 (0).hedger(), 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 (1).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10)); + }; + validate_state (); SECTION("1. init") { } @@ -1930,250 +1956,136 @@ TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]") { spreader.on_disconnect (); verify_basic_spreader_state (spreader, SpreaderState::END, spreader_price, spreader_quantity); - // all spreaders should be in the end state - LOG(OrderMan, Diag, "spreader_WORKING.on_disconnect"); + // all quoters should go to end state + for (size_t i = 0; i < bookkeeping_data.count(); i++) + { + SpreaderLegData& leg_data = bookkeeping_data.get_leg_data (i); + bts_assert (leg_data.quoter()->test_only_func_quoter_state() == QuoterState::END); + // all hedgers should be in the end state + for (size_t h = 0; h < leg_data.n_hedgers(); h++) + bts_assert (leg_data.get_hedger (h).hedger().test_only_func_hedger_state() == HedgerState::END); + } + LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_disconnect"); } SECTION("4. on_update") { api::orderman::UpdateSpreaderOrder u; u.set_price(-0.05); u.set_quantity (200); spreader.on_update (u); - verify_basic_spreader_state (spreader, SpreaderState::WORKING, Price (-0.05), Quantity (200)); - // check spreader states - LOG(OrderMan, Diag, "spreader_WORKING.on_update"); + validate_state(); + // order changes dont go through + validate_state(); + LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_update"); } SECTION("5. on_cancel") { api::orderman::CancelSpreaderOrder c; spreader.on_cancel(c); - verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity); - // check spreader states - LOG(OrderMan, Diag, "spreader_WORKING.on_cancel"); + // already in cancel state, no change + validate_state(); + LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_cancel"); } SECTION("6. on_book") { - SpreaderBookkeepingData& bookkeeping_data = spreader.test_only_func_spreader_full_data (); - SpreaderLegData& leg_data_1 = bookkeeping_data.get_leg_data (0); - SpreaderLegData& leg_data_2 = bookkeeping_data.get_leg_data (1); - // send a book a on leg 1, this should make - // leg 2 send out an order - verify that - Book book_leg_1 = get_book (SecurityKey (leg_1.security().id()), 5, - new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {10, 10, 10, 10, 10}, - new double[5] {2000, 2001, 2002, 2003, 2004}, new uint16_t[5] {10, 15, 25, 50, 10}, true); - spreader.on_book (bts::orderman::NullTickToTradeCorID, book_leg_1); - validate_book (book_leg_1, leg_data_1.book()); - 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_FIRST_ACK, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false); - // send a book on leg 2, this should make - // leg 1 send out an order, so orders on - // both legs should be out there now - Book book_leg_2 = get_book (SecurityKey (leg_2.security().id()), 5, - 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] {10, 10, 10, 10, 10}, true); - spreader.on_book (bts::orderman::NullTickToTradeCorID, book_leg_2); - validate_book (book_leg_2, leg_data_2.book()); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_FIRST_ACK, 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::WAITING_FOR_FIRST_ACK, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false); - - bts_assert (leg_data_1.order_key().value() != leg_data_2.order_key().value()); - spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_NEW, - Quantity (0), Price (0), nullptr); - 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::WAITING_FOR_FIRST_ACK, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false); - - spreader.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_NEW, - Quantity (0), Price (0), nullptr); - 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); - - // change the books and make sure the quoter - // adjusts its order - book_leg_1 = get_book (SecurityKey (leg_1.security().id()), 5, - new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {10, 10, 10, 10, 10}, - new double[5] {2000, 2001, 2002, 2003, 2004}, new uint16_t[5] {10, 10, 10, 10, 10}, true); - spreader.on_book (bts::orderman::NullTickToTradeCorID, book_leg_1); - validate_book (book_leg_1, leg_data_1.book()); - 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(2003), Quantity(50), Quantity(100), false); - book_leg_2 = get_book (SecurityKey (leg_2.security().id()), 5, - new double[5] {2002, 2001, 2000, 1999, 1998}, new uint16_t[5] {1, 2, 10, 1, 1}, - new double[5] {2003, 2004, 2005, 2006, 2007}, new uint16_t[5] {10, 10, 10, 10, 10}, true); - spreader.on_book (bts::orderman::NullTickToTradeCorID, book_leg_2); - validate_book (book_leg_2, leg_data_2.book()); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(15), Quantity(100), false); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2003), Quantity(50), Quantity(100), false); - // remove the markets and the orders should be cancelled - book_leg_1 = get_book (SecurityKey (leg_1.security().id()), 5, - new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {0, 0, 0, 0, 0}, - new double[5] {2000, 2001, 2002, 2003, 2004}, new uint16_t[5] {0, 0, 0, 0, 0}, true); - book_leg_2 = get_book (SecurityKey (leg_2.security().id()), 5, - new double[5] {2002, 2001, 2000, 1999, 1998}, new uint16_t[5] {0, 0, 0, 0, 0}, - new double[5] {2003, 2004, 2005, 2006, 2007}, new uint16_t[5] {0, 0, 0, 0, 0}, true); - spreader.on_book (bts::orderman::NullTickToTradeCorID, book_leg_1); - spreader.on_book (bts::orderman::NullTickToTradeCorID, book_leg_2); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(15), Quantity(100), false); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2003), Quantity(50), Quantity(100), false); - LOG(OrderMan, Diag, "spreader_WORKING.on_book"); - + // like 4 and 5, should have no effect + set_spreader_orders (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}); + validate_state (); + LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_book"); } SECTION("7. on_time") { } SECTION("8. on_quoter_order_error") { - // get orders in working state - // and send an error - set_spreader_orders (spreader, new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {10, 10, 10, 10, 10}, - 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] {10, 10, 10, 10, 10}); - // verify working orders - SpreaderBookkeepingData& bookkeeping_data = spreader.test_only_func_spreader_full_data (); - 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::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 an error now, both quoters should - // go to cancel waiting std::string err_msg = "error"; - spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), &err_msg); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(100), Quantity(100), false); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false); - LOG(OrderMan, Diag, "spreader_WORKING.on_quoter_order_error"); + spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (30), Price (2000), &err_msg); + validate_state(); + LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_quoter_order_error"); } SECTION("9. on_quoter_order_fill") { - set_spreader_orders (spreader, new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {10, 10, 10, 10, 10}, - 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] {10, 10, 10, 10, 10}); - // verify working orders - SpreaderBookkeepingData& bookkeeping_data = spreader.test_only_func_spreader_full_data (); - 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::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); - // now send a 20 lot fill in leg 1, - // verify leg 1's order data - // verify leg 2's order data - // verify that there a hedging order is worked - spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (20), Price (2000), nullptr); - 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); - std::vector& hedgers_leg_2 = leg_data_2.get_hedgers(); - bts_assert (hedgers_leg_2.size() == 1); - SingleFillHedger& hedger = hedgers_leg_2[0].hedger(); - verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_FIRST_ACK, Price(1999), Quantity(20), Quantity(0), Price (1999), Quantity(20), Quantity (20)); - LOG(OrderMan, Diag, "spreader_WORKING.on_quoter_order_error"); + // send another fill on leg 1, this will update the filled + // state of leg 1, but no other action will take place + spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (40), Price (2000.5), nullptr); + verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity); + bts_assert (leg_data_1.n_hedgers () == 3); + bts_assert (leg_data_2.n_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 (0).hedger(), 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 (1).hedger(), 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 (2).hedger(), 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 (0).hedger(), 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 (1).hedger(), 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") { - // already done in 9 + // cancelled update + spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_CANCELED, Quantity (30), Price (2000), nullptr); + verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity); + bts_assert (leg_data_1.n_hedgers () == 3); + bts_assert (leg_data_2.n_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 (0).hedger(), 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 (1).hedger(), 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 (2).hedger(), 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 (0).hedger(), 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 (1).hedger(), 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") { - //create the same scenario as 9, but send an error on the hedger order - set_spreader_orders (spreader, new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {10, 10, 10, 10, 10}, - 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] {10, 10, 10, 10, 10}); - // verify working orders - SpreaderBookkeepingData& bookkeeping_data = spreader.test_only_func_spreader_full_data (); - 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::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); - spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (20), Price (2000), nullptr); - 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); - std::vector& hedgers_leg_2 = leg_data_2.get_hedgers(); - bts_assert (hedgers_leg_2.size() == 1); - SingleFillHedger& hedger = hedgers_leg_2[0].hedger(); - verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_FIRST_ACK, Price(1999), Quantity(20), Quantity(0), Price (1999), Quantity(20), Quantity (20)); - bts::orderman::OrderKey hedger_order_key = hedgers_leg_2[0].order_update_message().order_key; - spreader.on_child_update (hedger_order_key, api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr); - verify_complete_hedger_state (hedger, HedgerState::WORKING, Price(1999), Quantity(20), Quantity(0), Price (1999), Quantity(20), Quantity (20)); std::string err_msg = "error"; - spreader.on_child_update (hedger_order_key, api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), &err_msg); - verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (20), Quantity(0), Price(2000), Quantity(100), Quantity(80), false); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (0), Quantity(20), Price(2002), Quantity(80), Quantity(80), false); - verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_CANCEL_ACK, Price(1999), Quantity(20), Quantity(0), Price (1999), Quantity(20), Quantity (20)); - // verify that all quoter and hedgers should - LOG(OrderMan, Diag, "spreader_WORKING.on_hedger_order_error"); + spreader.on_child_update (leg_data_1.get_hedger (0).order_update_message().order_key, api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), &err_msg); + validate_state (); + LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_hedger_order_error"); } SECTION("12. on_hedger_order_update") { - //create the same scenario as 9, but send an error on the hedger order - set_spreader_orders (spreader, new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {10, 10, 10, 10, 10}, - 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] {10, 10, 10, 10, 10}); - // verify working orders - SpreaderBookkeepingData& bookkeeping_data = spreader.test_only_func_spreader_full_data (); - 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::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); - spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (20), Price (2000), nullptr); - 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); - std::vector& hedgers_leg_2 = leg_data_2.get_hedgers(); - bts_assert (hedgers_leg_2.size() == 1); - SingleFillHedger& hedger = hedgers_leg_2[0].hedger(); - verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_FIRST_ACK, Price(1999), Quantity(20), Quantity(0), Price (1999), Quantity(20), Quantity (20)); - // send fill on the hedger order - bts::orderman::OrderKey hedger_order_key = hedgers_leg_2[0].order_update_message().order_key; - spreader.on_child_update (hedger_order_key, api::orderman::OrderStatus::OS_NEW, Quantity (5), Price (2000), nullptr); - verify_complete_hedger_state (hedger, HedgerState::WORKING, Price(1999), Quantity(20), Quantity(5), Price (1999), Quantity(20), Quantity (15)); - // verify that all quoter and hedgers should - LOG(OrderMan, Diag, "spreader_WORKING.on_hedger_order_update"); + // send a fill + spreader.on_child_update (leg_data_1.get_hedger (0).order_update_message().order_key, api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (10), Price (2000), nullptr); + 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 (0).hedger(), 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 (1).hedger(), 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 (2).hedger(), 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 (0).hedger(), 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 (1).hedger(), 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("13. on_external_error") - { - SpreaderBookkeepingData& bookkeeping_data = spreader.test_only_func_spreader_full_data (); - SpreaderLegData& leg_data_1 = bookkeeping_data.get_leg_data (0); SpreaderLegData& leg_data_2 = bookkeeping_data.get_leg_data (1); - set_spreader_orders (spreader, new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {10, 10, 10, 10, 10}, - 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] {10, 10, 10, 10, 10}); - spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (20), Price (2000), nullptr); - SpreaderHedgerData& hedger_data = leg_data_2.get_hedgers()[0]; - spreader.on_child_update (hedger_data.order_update_message().order_key, api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr); - std::string err_msg = "external error"; + { + std::string err_msg = "error"; spreader.on_external_error (err_msg); - verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (20), Quantity(0), Price(2000), Quantity(100), Quantity(80), false); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (0), Quantity(20), Price(2002), Quantity(80), Quantity(80), false); - verify_complete_hedger_state (hedger_data.hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price(1999), Quantity(20), Quantity(0), Price (1999), Quantity(20), Quantity (20)); - LOG(OrderMan, Diag, "spreader_WORKING.on_external_error"); + validate_state (); + LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_external_error"); } SECTION("14. on_check_termination") { - // get active orders working, send a terminal - // status on each order and verify that the - // spreader reached a terminal state - SpreaderBookkeepingData& bookkeeping_data = spreader.test_only_func_spreader_full_data (); - SpreaderLegData& leg_data_1 = bookkeeping_data.get_leg_data (0); SpreaderLegData& leg_data_2 = bookkeeping_data.get_leg_data (1); - set_spreader_orders (spreader, new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {10, 10, 10, 10, 10}, - 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] {10, 10, 10, 10, 10}); - verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity); - // completely fill leg 1, this should cxl the leg 2 quoting order and send a hedge - // fill the hedge completely - // this should cause on_check_termination to return true - spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_FILLED, Quantity (100), Price (1999), nullptr); - // leg1's quoter should be in end state - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::END, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(0), Quantity(0), Quantity(0), true); - // leg 2 should cancel its order now - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, Quantity (100), Quantity (0), Quantity(100), Price(2002), Quantity(100), Quantity(0), true); - spreader.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_CANCELED, Quantity (0), Price (0), nullptr); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::END, false, spreader_price, Quantity (100), Quantity (0), Quantity(100), Price(0), Quantity(0), Quantity(0), true); - bts_assert (leg_data_2.get_hedgers().size() == 1); - SpreaderHedgerData leg_2_hedger_data = leg_data_2.get_hedgers()[0]; - verify_complete_hedger_state (leg_2_hedger_data.hedger(), HedgerState::WAITING_FOR_FIRST_ACK, Price(1998), Quantity(100), Quantity(0), Price (1998), Quantity(100), Quantity (100)); - verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity); - // send a fill, this should make the spreader go to end - spreader.on_child_update (leg_2_hedger_data.order_update_message().order_key, api::orderman::OrderStatus::OS_FILLED, Quantity (100), Price (1998), nullptr); - verify_complete_hedger_state (leg_2_hedger_data.hedger(), HedgerState::END, Price(1998), Quantity(100), Quantity(100), Price (0), Quantity(0), Quantity (0)); + // send cancel for orders, once all quoters and hedgers + // are cancelled, spreader should come to end + spreader.on_child_update (leg_data_1.order_update_message().order_key, api::orderman::OrderStatus::OS_CANCELED, Quantity (30), Price (2000), nullptr); + 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.on_child_update (leg_data_2.order_update_message().order_key, api::orderman::OrderStatus::OS_CANCELED, Quantity (55), Price (2000), nullptr); + 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, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity); + spreader.on_child_update (leg_data_1.get_hedger (0).order_update_message().order_key, api::orderman::OrderStatus::OS_CANCELED, Quantity (0), Price (0), nullptr); + verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::END, Price (2002), Quantity(15), Quantity (0), Price(0), Quantity (0), Quantity (15)); + spreader.on_child_update (leg_data_1.get_hedger (1).order_update_message().order_key, api::orderman::OrderStatus::OS_CANCELED, Quantity (0), Price (0), nullptr); + verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::END, Price (2002), Quantity(30), Quantity (0), Price(0), Quantity (0), Quantity (30)); + spreader.on_child_update (leg_data_1.get_hedger (2).order_update_message().order_key, api::orderman::OrderStatus::OS_CANCELED, Quantity (0), Price (0), nullptr); + verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::END, Price (2002), Quantity(10), Quantity (0), Price(0), Quantity (0), Quantity (10)); + spreader.on_child_update (leg_data_2.get_hedger (0).order_update_message().order_key, api::orderman::OrderStatus::OS_CANCELED, Quantity (0), Price (0), nullptr); + verify_complete_hedger_state (leg_data_2.get_hedger (0).hedger(), HedgerState::END, Price (1999), Quantity(20), Quantity (0), Price(0), Quantity (0), Quantity (20)); + verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity); + spreader.on_child_update (leg_data_2.get_hedger (1).order_update_message().order_key, api::orderman::OrderStatus::OS_CANCELED, Quantity (0), Price (0), nullptr); + verify_complete_hedger_state (leg_data_2.get_hedger (1).hedger(), HedgerState::END, Price (1999), Quantity(10), Quantity (0), Price(0), Quantity (0), Quantity (10)); verify_basic_spreader_state (spreader, SpreaderState::END, spreader_price, spreader_quantity); - LOG(OrderMan, Diag, "spreader_WORKING.on_quoter_order_error"); + LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_check_termination"); } }