Moving tests over to use SpreaderWrapper instead of SpreaderOrder

This commit is contained in:
Taha Afzal committed 2022-04-17 18:48:51 -04:00
1 parent 3f4a4fbac8
commit 81dde8e9df
6 files changed
+134 -24

No files matched your search

@@ -21,10 +21,6 @@ class SpreaderPreActivationOrderServices;
// each leg, 1 for the quoter and 1 for the hedger
// (cons'ed and housed in SpreaderBookKeepingData)
class SpreaderOrderBuilder {
private:
// const bool _is_live;
// bts::orderman::OrderBuilder _real_order_builder;
public:
SpreaderOrderBuilder(
OrderKey parent_key,
@@ -23,8 +23,8 @@ SpreaderPreActivationOrderServices::SpreaderPreActivationOrderServices(
const Security &s)
: _secs(_get_legs(s)), _pre_services(nullptr) {}
const Security *
SpreaderPreActivationOrderServices::resolve(SecurityKey key) const {
const Security *SpreaderPreActivationOrderServices::resolve(
SecurityKey key) const {
if (is_live())
return _pre_services->sec_db.resolve(key);
else {
@@ -39,10 +39,5 @@ bool SpreaderPreActivationOrderServices::is_live() const {
return _pre_services != nullptr;
}
OrderFactory &SpreaderPreActivationOrderServices::order_factory() const {
bts_assert(is_live());
return _pre_services->order_factory;
}
} // namespace orderman
} // namespace bts
@@ -23,7 +23,6 @@ class SpreaderPreActivationOrderServices {
// this is the main interface function
const bts::api::Security *resolve(SecurityKey key) const;
bool is_live() const;
bts::orderman::OrderFactory &order_factory() const;
};
} // namespace orderman
@@ -1,6 +1,8 @@
#include "SpreaderWrapper.h"
#include "lib/api/services/OrderService.pb.h"
#include "lib/domain_model/Security.pb.h"
#include "lib/orderman/orders/spreader_orders/SpreaderOrder.h"
#include "lib/orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderOrderServices.h"
#include "lib/orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderPreActivationOrderServices.h"
#include <memory>
@@ -9,22 +11,32 @@ namespace bts::integration {
using namespace bts::api;
struct SpreaderWrapper::PImpl {
const Security synthetic_security;
IOrderGateway &order_gateway;
const bts::api::orderman::OrderDefinition order_def;
IOrderGateway *order_gateway;
bts::orderman::SpreaderOrder spreader;
bts::orderman::SpreaderPreActivationOrderServices pre_activation_services;
bts::orderman::SpreaderOrderServices order_services;
PImpl(const Security &synthetic_security, IOrderGateway &order_gateway)
: synthetic_security(synthetic_security), order_gateway(order_gateway),
spreader(nullptr), pre_activation_services(synthetic_security) {}
PImpl(
const api::orderman::OrderDefinition &order_def,
IOrderGateway *order_gateway)
: order_def(order_def), order_gateway(order_gateway), spreader(nullptr),
pre_activation_services(order_def.custom_def().spreader().security()),
order_services(nullptr) {}
};
SpreaderWrapper::SpreaderWrapper(
const Security &synthetic_security, IOrderGateway &order_gateway)
: me(std::make_unique<PImpl>(synthetic_security, order_gateway)) {}
const api::orderman::OrderDefinition &order_def,
IOrderGateway *order_gateway)
: me(new PImpl(order_def, order_gateway)) {
me->spreader.test_only_on_init_new(order_def, me->pre_activation_services);
}
void SpreaderWrapper::activate(Price price, Quantity qty) {
me->spreader.test_only_on_activate(price, qty, me->order_services);
}
void SpreaderWrapper::on_order_update(const OrderUpdate &u) {
// TODO, pass it through the OrderServices
me->spreader.test_only_on_child_order_update(
u.key, u.status, u.filled_quantity, Price(u.avg_price));
}
@@ -32,4 +44,25 @@ void SpreaderWrapper::on_order_update(const OrderUpdate &u) {
void SpreaderWrapper::update_book(const bts::orderman::Book &book) {
me->spreader.test_only_on_book_update(book);
}
void SpreaderWrapper::update_spreader(Price price, Quantity qty) {
me->spreader.on_update(price, qty);
}
void SpreaderWrapper::cancel() { me->spreader.on_cancel(); }
// test only //////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
bts::orderman::SpreaderOrder &SpreaderWrapper::spreader() {
return me->spreader;
}
bts::orderman::SpreaderState SpreaderWrapper::spreader_state() const {
return me->spreader.test_only_func_spreader_state();
}
bts::orderman::SpreaderBookkeepingData &SpreaderWrapper::bookkeeping_data() {
return me->spreader.test_only_func_spreader_full_data();
}
} // namespace bts::integration
@@ -9,6 +9,7 @@
#include "lib/orderman/orderman_utils/Book.h"
#include "lib/orderman/orderman_utils/orderman_common.h"
#include "lib/orderman/orders/Order.h"
#include "lib/orderman/orders/spreader_orders/SpreaderOrder.h"
#include "lib/orderman/orders/spreader_orders/spreader/ISpreaderManager.h"
#include "lib/orderman/orders/spreader_orders/spreader/SpreaderBookkeepingData.h"
#include "lib/orderman/orders/spreader_orders/spreader/SpreaderCacheWarmingState.h"
@@ -23,10 +24,16 @@
#include "lib/utils/is_unittest_environment.h"
#include <memory>
namespace bts::orderman {
class SpreaderOrder;
}
namespace bts::integration {
// needs to be implemented by 3rd party
class IOrderGateway {
// OrderDefinition allows for a QHO to be sent (or do it some other way? not
// sure)
virtual bts::orderman::OrderKey send_order(
const bts::api::orderman::OrderDefinition &order_def) = 0;
virtual void report_spreader_state(
@@ -50,15 +57,22 @@ struct OrderUpdate {
class SpreaderWrapper : public IOrderSync {
private:
struct PImpl;
std::unique_ptr<PImpl> me;
// std::unique_ptr<PImpl> me;
PImpl *me;
public:
SpreaderWrapper(
const bts::api::Security &synthetic_security,
IOrderGateway &order_gateway);
void run();
const api::orderman::OrderDefinition &order_def,
IOrderGateway *order_gateway);
void activate(Price price, Quantity qty);
void on_order_update(const OrderUpdate &update) override;
void update_book(const bts::orderman::Book &book);
void update_spreader(Price price, Quantity qty);
void cancel();
// The above will be seperated into its own interface, ISpreader. The
// following are needed for testing mainly
bts::orderman::SpreaderOrder &spreader();
bts::orderman::SpreaderState spreader_state() const;
bts::orderman::SpreaderBookkeepingData &bookkeeping_data();
};
} // namespace bts::integration
@@ -1,5 +1,6 @@
#include "lib/io/websocket/WebsocketClient.h"
#include "lib/md/IMarketDataListener.h"
#include "lib/orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderWrapper.h"
#include "lib/orderman/orders/spreader_orders/tests/tests_common.h"
#include <boost/container/flat_set.hpp>
#include <stdio.h>
@@ -2410,6 +2411,78 @@ TEST_CASE("spreader_START", "[spreader]") {
LOG(OrderMan, Diag, "spreader_START.on_cancel");
}
}
TEST_CASE("spreader_standalone_START", "[spreader]") {
bts::orderman::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, 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);
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);
AltOrderGatewayForTest alt_order_gateway;
bts::integration::SpreaderWrapper spreader_w(order_def, nullptr);
REQUIRE(spreader_w.spreader_state() == SpreaderState::START);
SECTION("1. on_init_new.resolved") {
// spreader.test_only_on_init_new(order_def, pao_services);
REQUIRE(spreader_w.spreader_state() == SpreaderState::START);
const SpreaderBookkeepingData &bookkeeping_data =
spreader_w.bookkeeping_data();
REQUIRE(
bookkeeping_data.get_leg_data(0).leg_property_data().security_key() ==
2468);
REQUIRE(
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);
// REQUIRE(spreader.test_only_func_spreader_state() ==
// SpreaderState::END);
}
SECTION("2. on_activate") {
// spreader.test_only_on_init_new(order_def, pao_services);
// SpreaderOrderServices order_services(nullptr);
// spreader.test_only_on_activate(
// spreader_price, spreader_quantity, order_services);
// verify_basic_spreader_state(
// spreader, SpreaderState::WORKING, spreader_price,
// spreader_quantity);
spreader_w.activate(spreader_price, spreader_quantity);
verify_basic_spreader_state(
spreader_w.spreader(), SpreaderState::WORKING, spreader_price,
spreader_quantity);
}
SECTION("5. on_cancel") {
spreader_w.cancel();
REQUIRE(spreader_w.spreader_state() == SpreaderState::END);
LOG(OrderMan, Diag, "spreader_START.on_cancel");
}
}
TEST_CASE("spreader_WORKING", "[spreader]") {
bts::orderman::OrderKey order_key(0);
Price spreader_price = Price(1);