SPARK-331 spreader start state test

This commit is contained in:
Taha Afzal committed 2018-02-01 17:08:01 -05:00
1 parent 4e329d0baf
commit c968b46d83
13 files changed
+88 -58

No files matched your search

@@ -21,11 +21,11 @@ public:
virtual SpreaderState state() const = 0;
// 1. called once before the other calls. state should be
// constructed here
virtual void on_init_new(api::orderman2::OrderDefinition const&, const orderman2::PreActivationOrderServices&) = 0;
virtual void on_init_new(api::orderman2::OrderDefinition const&, const SpreaderPreActivationOrderServices&) = 0;
// 2. this is the end of the construction cycle. should happen
// after on_init_new and before all other calls. market data subs
// and quoter order creation happens here
virtual void on_activate(Price, Quantity, orderman2::OrderServices &) = 0;
virtual void on_activate(Price, Quantity, bts::orderman2::OrderServices &) = 0;
// 4. new on_update
virtual void on_update(Price, Quantity) = 0;
// 5. called when the user cancels an order
@@ -31,11 +31,12 @@ const api::orderman2::OrderDefinition& SpreaderOrder::definition()
bts_assert(_state_worker->state() != SpreaderState::START);
return _order_def;
}
void SpreaderOrder::on_init_new(const api::orderman2::OrderDefinition& order_def, const PreActivationOrderServices& pre_services)
void SpreaderOrder::on_init_new(const api::orderman2::OrderDefinition& order_def, const PreActivationOrderServices& pao_services)
{
if (!_active) return;
LOG(OrderMan, Diag, "SpreaderOrder.on_init_new key: {}", key().value());
_state_worker->on_init_new(order_def, pre_services);
SpreaderPreActivationOrderServices spreader_pao_services(&pao_services);
_on_init_new(order_def, spreader_pao_services);
}
void SpreaderOrder::on_activate(Price price, Quantity quantity, OrderServices& services)
{
@@ -174,6 +175,10 @@ void SpreaderOrder::_switch_state (ISpreaderStateWorker* new_state)
_state_worker = new_state;
_state_worker->build_once (this);
}
void SpreaderOrder::_on_init_new(const bts::api::orderman2::OrderDefinition& order_def, const SpreaderPreActivationOrderServices& spreader_pao_services)
{
_state_worker->on_init_new(order_def, spreader_pao_services);
}
void SpreaderOrder::_cancel_orders(bool cancel_quotes, bool cancel_hedges)
{
for (size_t q_idx = 0; q_idx < _bookkeeping_data().n_legs(); q_idx++)
@@ -55,9 +55,9 @@ public:
// if on_init_new has not been called yet
const api::orderman2::OrderDefinition& definition() override;
// this is the construction, can be slow
void on_init_new(api::orderman2::OrderDefinition const& order_def, const PreActivationOrderServices&) override;
void on_init_new(const bts::api::orderman2::OrderDefinition& order_def, const bts::orderman2::PreActivationOrderServices&) override;
// called when the order is recovered from disk
void on_init_recovered(api::orderman2::OrderRecord const&, const PreActivationOrderServices &) override {bts_assert (false);}
void on_init_recovered(bts::api::orderman2::OrderRecord const&, const bts::orderman2::PreActivationOrderServices&) override {bts_assert (false);}
// this is in the critical path, orders can be submitted now
// (this is only called once and after the on_init_new)
void on_activate(Price, Quantity, OrderServices&) override;
@@ -82,10 +82,8 @@ public:
SpreaderBookkeepingData& test_only_func_spreader_full_data () {return _bookkeeping_data();}
int64_t test_cancel_timeout () {return _cancel_timeout;}
void test_only_on_book_update(const bts::orderman2::BookUpdateEvent& b) {_on_book_update(b);}
void test_only_on_child_order_update (bts::orderman2::OrderKey order_key, bts::api::orderman2::OrderStatus status, Quantity filled_quantity, Price average_price)
{
_on_child_order_update(order_key, status, filled_quantity, average_price);
}
void test_only_on_child_order_update (bts::orderman2::OrderKey order_key, bts::api::orderman2::OrderStatus status, Quantity filled_quantity, Price average_price) {_on_child_order_update(order_key, status, filled_quantity, average_price);}
void test_only_on_init_new(const bts::api::orderman2::OrderDefinition& order_def, const SpreaderPreActivationOrderServices& pao_services) {_on_init_new(order_def, pao_services);}
private:
/**************************Event Handlers***********************************/
// events
@@ -101,6 +99,7 @@ private:
// swtches to the state passed in the arg
void _switch_state (ISpreaderStateWorker* new_state);
/***************************Misc***************************/
void _on_init_new(const bts::api::orderman2::OrderDefinition&, const SpreaderPreActivationOrderServices&);
// this calls the cancel on quoter and hedger orders
void _cancel_orders(bool cancel_quotes, bool cancel_hedges);
// iterates through all quoters and returns true if they
@@ -10,7 +10,7 @@ void SpreaderEndStateWorker::build_once (SpreaderOrder* spreader)
{
_spreader = spreader;
}
void SpreaderEndStateWorker::on_init_new(api::orderman2::OrderDefinition const&, const orderman2::PreActivationOrderServices&)
void SpreaderEndStateWorker::on_init_new(api::orderman2::OrderDefinition const&, const SpreaderPreActivationOrderServices&)
{
bts_assert_msg (false, "SpreaderEndStateWorker::on_init_new is an illegal operation");
}
@@ -14,7 +14,7 @@ public:
SpreaderEndStateWorker ();
void build_once (SpreaderOrder* spreader_order) override;
SpreaderState state() const override;
void on_init_new(api::orderman2::OrderDefinition const&, const orderman2::PreActivationOrderServices&) override;
void on_init_new(api::orderman2::OrderDefinition const&, const SpreaderPreActivationOrderServices&) override;
void on_activate(Price, Quantity, orderman2::OrderServices&) override;
void on_update(Price, Quantity) override;
void on_cancel() override;
@@ -13,10 +13,9 @@ void SpreaderStartStateWorker::build_once (SpreaderOrder* spreader)
{
_spreader = spreader;
}
void SpreaderStartStateWorker::on_init_new(const api::orderman2::OrderDefinition& order_def, const orderman2::PreActivationOrderServices& pao_services)
void SpreaderStartStateWorker::on_init_new(const api::orderman2::OrderDefinition& order_def, const SpreaderPreActivationOrderServices& pao_services)
{
const SpreaderPreActivationOrderServices spreader_pao_services (&pao_services);
_on_init_new_internal (order_def, spreader_pao_services);
_on_init_new_internal (order_def, pao_services);
}
void SpreaderStartStateWorker::on_activate(Price price, Quantity quantity, orderman2::OrderServices& order_services)
{
@@ -17,7 +17,7 @@ public:
SpreaderStartStateWorker ();
void build_once (SpreaderOrder* spreader_order) override;
SpreaderState state() const override;
void on_init_new(api::orderman2::OrderDefinition const&, const orderman2::PreActivationOrderServices&) override;
void on_init_new(api::orderman2::OrderDefinition const&, const SpreaderPreActivationOrderServices&) override;
void on_activate(Price, Quantity, orderman2::OrderServices&) override;
void on_update(Price, Quantity) override;
void on_cancel() override;
@@ -11,7 +11,7 @@ void SpreaderWaitingForCancelAllStateWorker::build_once (SpreaderOrder* spreader
_spreader = spreader;
_cancel_timestamp = _spreader->_curr_timestamp;
}
void SpreaderWaitingForCancelAllStateWorker::on_init_new(api::orderman2::OrderDefinition const&, const orderman2::PreActivationOrderServices&)
void SpreaderWaitingForCancelAllStateWorker::on_init_new(api::orderman2::OrderDefinition const&, const SpreaderPreActivationOrderServices&)
{
bts_assert_msg (false, "SpreaderWaitingForCancelAllStateWorker::on_init_new is an illegal operation");
}
@@ -15,7 +15,7 @@ public:
SpreaderWaitingForCancelAllStateWorker ();
void build_once (SpreaderOrder* spreader_order) override;
SpreaderState state() const override;
void on_init_new(api::orderman2::OrderDefinition const&, const orderman2::PreActivationOrderServices&) override;
void on_init_new(api::orderman2::OrderDefinition const&, const SpreaderPreActivationOrderServices&) override;
void on_activate(Price, Quantity, orderman2::OrderServices&) override;
void on_update(Price, Quantity) override;
void on_cancel() override;
@@ -10,7 +10,7 @@ void SpreaderWorkingStateWorker::build_once (SpreaderOrder* spreader)
{
_spreader = spreader;
}
void SpreaderWorkingStateWorker::on_init_new(api::orderman2::OrderDefinition const&, const orderman2::PreActivationOrderServices&)
void SpreaderWorkingStateWorker::on_init_new(api::orderman2::OrderDefinition const&, const SpreaderPreActivationOrderServices&)
{
bts_assert_msg (false, "SpreaderWorkingStateWorker::on_init_new is an illegal operation");
}
@@ -14,7 +14,7 @@ public:
SpreaderWorkingStateWorker ();
void build_once (SpreaderOrder* spreader_order) override;
SpreaderState state() const override;
void on_init_new(api::orderman2::OrderDefinition const&, const orderman2::PreActivationOrderServices&) override;
void on_init_new(api::orderman2::OrderDefinition const&, const SpreaderPreActivationOrderServices&) override;
void on_activate(Price, Quantity, orderman2::OrderServices&) override;
void on_update(Price, Quantity) override;
void on_cancel() override;
@@ -1431,11 +1431,11 @@ TEST_CASE ("hedger_WORKING", "[spreader]")
LOG(OrderMan, Diag, "hedger_WORKING.terminate");
}
}
// /************************************************************************************************************/
// /*********************************************Spreader State Tests*********************************************/
// /************************************************************************************************************/
// TEST_CASE ("spreader_START", "[spreader]")
// {
/************************************************************************************************************/
/*********************************************Spreader State Tests*********************************************/
/************************************************************************************************************/
TEST_CASE ("spreader_START", "[spreader]")
{
// ContractLeg leg_1, leg_2;
// fill_future_contract_leg (leg_1, 2468, "ES", bts::api::Venue::VENUE_GLBX, 2017, 12, 15, 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, api::Side::SIDE_SELL, 1.0, 0.25);
@@ -1470,35 +1470,56 @@ TEST_CASE ("hedger_WORKING", "[spreader]")
// // do_nothing,
// // do_nothing,
// // do_nothing);
// SECTION("1. init")
// {
// verify_basic_spreader_state (spreader, SpreaderState::START, spreader_price, spreader_quantity);
// spreader.init ();
// verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_FIRST_CONNECT, spreader_price, spreader_quantity);
// LOG(OrderMan, Diag, "spreader_START.init");
// }
// 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::START, Price (-0.05), Quantity (200));
// LOG(OrderMan, Diag, "spreader_START.init");
// }
// SECTION("5. on_cancel")
// {
// api::orderman::CancelSpreaderOrder c;
// spreader.on_cancel(c);
// verify_basic_spreader_state (spreader, SpreaderState::END, spreader_price, spreader_quantity);
// LOG(OrderMan, Diag, "spreader_START.on_cancel");
// }
// SECTION("13. on_external_error")
// {
// std::string err_msg = "stop and celebrate";
// spreader.on_external_error (err_msg);
// verify_basic_spreader_state (spreader, SpreaderState::END, spreader_price, spreader_quantity);
// LOG(OrderMan, Diag, "spreader_START.on_cancel");
// }
// }
bts::orderman2::OrderKey order_key(0);
//Price spreader_price = Price (0); 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, 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, 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);
std::vector<LegSpreaderParams> spreader_params;
spreader_params.push_back(lsp_1);spreader_params.push_back(lsp_2);
bts::api::orderman2::OrderDefinition order_def;
fill_spreader_order_definition(order_def, Side::SIDE_BUY, synthetic_security, spreader_params);
// putting it together in SpreaderBookkeepingData
TestOnlySpreaderPreActivationOrderServices testonly_spreader_pao_services = _create_spreader_pao_services(synthetic_security);
SpreaderPreActivationOrderServices pao_services (&testonly_spreader_pao_services);
std::vector<LegPropertyData> leg_props;
SpreaderUtils::resolve_synthetic_spread(pao_services, order_def, leg_props);
SpreaderManagerForTest spreader_manager (order_key, pao_services, leg_props);
SpreaderBookkeepingData& bookkeeping_data = spreader_manager.bookkeeping_data();
SpreaderOrder spreader;
bts_assert(spreader.test_only_func_spreader_state() == SpreaderState::START);
SECTION("1. on_init_new.resolved")
{
spreader.test_only_on_init_new (order_def, pao_services);
bts_assert(spreader.test_only_func_spreader_state() == SpreaderState::START);
SpreaderBookkeepingData& bookeeping_data = spreader.test_only_func_spreader_full_data();
bts_assert(bookkeeping_data.get_leg_data(0).leg_property_data().security_key() == 2468);
bts_assert(bookkeeping_data.get_leg_data(1).leg_property_data().security_key() == 13579);
}
SECTION("1. on_init_new.not_resolved")
{
testonly_spreader_pao_services.set_resolve_flag(false);
spreader.test_only_on_init_new (order_def, pao_services);
bts_assert(spreader.test_only_func_spreader_state() == SpreaderState::END);
}
SECTION("5. on_cancel")
{
spreader.on_cancel();
bts_assert(spreader.test_only_func_spreader_state() == SpreaderState::END);
LOG(OrderMan, Diag, "spreader_START.on_cancel");
}
}
// TEST_CASE ("spreader_WAITING_FOR_FIRST_CONNECT", "[spreader]")
// {
// ContractLeg leg_1, leg_2;
@@ -11,18 +11,24 @@ namespace orderman {
class TestOnlySpreaderPreActivationOrderServices
{
private:
bool _resolve;
const std::vector<bts::api::Security> _secs;
public:
TestOnlySpreaderPreActivationOrderServices (const std::vector<bts::api::Security>& secs)
: _secs(secs)
: _resolve(true),
_secs(secs)
{}
const bts::api::Security* resolve (SecurityKey key) const
{
for (size_t idx = 0; idx < _secs.size(); idx++)
if (_secs[idx].id() == key.value())
return &_secs[idx];
if (_resolve)
{
for (size_t idx = 0; idx < _secs.size(); idx++)
if (_secs[idx].id() == key.value())
return &_secs[idx];
}
return nullptr;
}
void set_resolve_flag (bool resolve) {_resolve = resolve;}
};
class SpreaderPreActivationOrderServices