Files
spark/src/server/sparkd/risk_limits/tests/RiskLimitsTests.cpp
T

420 lines
15 KiB
C++

#include "catch/catch.hpp"
#include "../RiskLimitManager.h"
#include "../AccountRiskLimiter.h"
#include "../RiskLimiter.h"
#include "../RiskLimitState.h"
#include "../IRiskLimitObserver.h"
#include "../SymbolKey.h"
#include "server/sparkd/orderman/utils/orderman_utils.h"
#include "server/sparkd/user/AccountServiceServer.h"
#include "server/sparkd/user/UserServiceServer.h"
#include "lib/config/config.h"
#include "lib/api/public/ServiceContext.h"
#include "lib/api/services/AccountService.client.pb.h"
#include "lib/api/services/UserService.client.pb.h"
#include "lib/domain_model/Security.pb.h"
#include "lib/utils/helper_macros.h"
#include <future>
#include <memory>
#include <stdlib.h>
using namespace bts::orderman;
namespace bts
{
namespace risklimits
{
class RiskLimitsTests
{
std::unique_ptr<api::ServiceContext> context;
account::AccountServiceServer account_server;
user::UserServiceServer user_server;
api::user::UserService user_service;
api::account::AccountService account_service;
public:
RiskLimitsTests() : context(new api::ServiceContext()),
account_server(*context),
user_server(*context),
user_service(context->locate<api::user::UserService>()),
account_service(context->locate<api::account::AccountService>())
{
}
void initialize(RiskLimitManager& mgr)
{
auto uresp = user_service.get_users(api::user::GetUsersRequest());
auto aresp = account_service.get_accounts(api::account::GetAccountsRequest());
std::vector<api::user::User> users;
std::vector<api::account::Account> accounts;
const auto& uu = uresp.result()->users();
users.reserve(uu.size());
for(const auto& i : uu)
users.push_back(i);
const auto& aa = aresp.result()->accounts();
accounts.reserve(aa.size());
for(const auto& i : aa)
accounts.push_back(i);
mgr.initialize(accounts, users);
}
static void all_shared_limiters(RiskLimitManager& manager,
std::vector<std::shared_ptr<AccountRiskLimiter>>& shared_limiters)
{
return manager.all_shared_limiters(shared_limiters);
}
static AccountRiskLimiter& shared_limiter(RiskLimitManager& manager, const AccountName& acct, const api::Security& sec)
{
return manager.find_shared_limiter(acct, sec);
}
static const api::account::RiskLimit& risk_limit(AccountRiskLimiter& shared)
{
return shared.risk_limit();
}
static SharedLimiterData& shared_data(AccountRiskLimiter& shared)
{
return shared.shared_data();
}
static SharedLimiterData& shared_data(RiskLimiter& lim)
{
return lim.shared_data();
}
static void account_update(AccountRiskLimiter& shared, const api::account::Account& acct)
{
shared.on_account_update(acct);
}
static void operator_update(AccountRiskLimiter& shared, const api::user::Operator& oper)
{
shared.on_operator_update(oper);
}
static void risk_limit_update(AccountRiskLimiter& shared, const api::account::RiskLimit& risk)
{
shared.on_risk_limit_update(risk);
}
static void order_state_update(RiskLimiter& lim,api::Side side, Quantity quantity, Quantity filled_quantity)
{
lim.on_order_state(side,quantity,filled_quantity);
}
};
struct Observer : public IRiskLimitObserver
{
bool has_result;
RiskLimitState result;
Observer() : has_result(false), result() {}
virtual void on_limit_state(const RiskLimitState& state)
{
has_result = true;
result = state;
}
};
void setup_security(api::Security& sec, const SymbolKey& symbol)
{
sec.set_symbol(symbol.first);
if(symbol.second == api::Security::ContractCase::kFuture)
{
auto fut = sec.mutable_future();
fut->set_expiration_year(2018);
fut->set_expiration_month(12);
fut->set_expiration_day(15);
}
else
{
auto fut = sec.mutable_spread();
}
}
RiskLimiter& get_limiter(RiskLimitManager& manager, const std::string& acct, const std::string& oper,
const std::string& symbol, int order_key)
{
AccountName acctname = to<AccountName>(acct);
OperatorID oid = to<OperatorID>(oper);
api::Security sec = api::Security::default_instance();
setup_security(sec, SymbolKey(symbol, api::Security::ContractCase::kFuture));
OrderKey key(order_key);
RiskLimiter& lim = manager.find_limiter(acctname, oid, sec, key);
return lim;
}
TEST_CASE ("RiskLimits API", "[risklimits]")
{
RiskLimitManager _manager;
RiskLimitsTests init;
init.initialize(_manager);
SECTION("key_test")
{
RiskLimiter& limiter1 = get_limiter(_manager, "account1", "oper1", "symbol1", 111);
RiskLimiter& limiter2 = get_limiter(_manager, "account1", "oper1", "symbol1", 111);
RiskLimiter& limiter3 = get_limiter(_manager, "account1", "oper1", "symbol1", 112);
REQUIRE(&limiter1 == &limiter2);
REQUIRE(&limiter1 != &limiter3);
RiskLimiter& limiter4 = get_limiter(_manager, "account1", "oper1", "symbol1", 111);
RiskLimiter& limiter5 = get_limiter(_manager, "account2", "oper1", "symbol1", 111);
REQUIRE(&limiter4 == &limiter1);
REQUIRE(&limiter4 != &limiter5);
RiskLimiter& limiter6 = get_limiter(_manager, "account2", "oper2", "symbol2", 111);
RiskLimiter& limiter7 = get_limiter(_manager, "account2", "oper2", "symbol2", 111);
RiskLimiter& limiter8 = get_limiter(_manager, "account2", "oper3", "symbol3", 111);
REQUIRE(&limiter6 == &limiter7);
REQUIRE(&limiter7 != &limiter8);
}
SECTION("sub_test")
{
Observer obs;
RiskLimitManager observed_manager(&obs);
init.initialize(observed_manager);
REQUIRE(obs.has_result);
}
}
bool limits_ok(const Observer& state)
{
return state.result.limits_ok && state.has_result;
}
TEST_CASE ("RiskLimits Limits", "[risklimits]")
{
using namespace api;
RiskLimitManager& _manager = *new RiskLimitManager();
RiskLimitsTests init;
init.initialize(_manager);
SECTION("default_limiter_cant_trade")
{
RiskLimiter& lim = get_limiter(_manager, "rand1", "oper2", "somefuture", 919225);
auto res1 = lim.check(Quantity(1), SIDE_BUY);
REQUIRE(!res1.success);
auto res2 = lim.check(Quantity(1), SIDE_SELL);
REQUIRE(!res2.success);
}
SECTION("clip_size_and_permission_check")
{
Observer state;
RiskLimitManager observed_manager(&state);
init.initialize(observed_manager);
bool ok = limits_ok(state);
REQUIRE(ok);
std::vector<std::shared_ptr<AccountRiskLimiter>> limiters;
RiskLimitsTests::all_shared_limiters(observed_manager, limiters);
REQUIRE(limiters.size() > 0);
for(auto i : limiters)
{
std::vector<orderman::OperatorID> operators;
i->allowed_operators(operators);
const api::account::RiskLimit& limits = RiskLimitsTests::risk_limit(*i.get());
SharedLimiterData& data = RiskLimitsTests::shared_data(*i.get());
api::Security sec = api::Security::default_instance();
setup_security(sec, data.position_info.symbol);
OrderKey key(0);
RiskLimiter& lim = _manager.find_limiter(to<orderman::AccountName>(data.account_info.tag1()), operators[0], sec, key);
auto res = lim.check(Quantity(rand() % limits.max_order_size()), api::SIDE_BUY);
REQUIRE(res.success);
res = lim.check(Quantity(rand() % limits.max_order_size()), api::SIDE_SELL);
REQUIRE(res.success);
res = lim.check(Quantity(limits.max_order_size() + 1), api::SIDE_BUY);
REQUIRE(!res.success);
res = lim.check(Quantity(limits.max_order_size() + 1), api::SIDE_SELL);
REQUIRE(!res.success);
{
api::account::Account new_account = api::account::Account::default_instance();
new_account.set_tag1(data.account_info.tag1());
new_account.set_can_trade(false);
RiskLimitsTests::account_update(*i.get(), new_account);
bool ok = limits_ok(state);
REQUIRE(!ok);
new_account.set_can_trade(true);
RiskLimitsTests::account_update(*i.get(), new_account);
ok = limits_ok(state);
REQUIRE(ok);
}
{
api::user::Operator new_oper = api::user::Operator::default_instance();
auto id = to_str(operators[0]);
new_oper.mutable_operator_id()->set_tag50(id);
new_oper.set_can_trade(false);
RiskLimitsTests::operator_update(*i.get(), new_oper);
bool ok = limits_ok(state);
REQUIRE(!ok);
new_oper.set_can_trade(true);
RiskLimitsTests::operator_update(*i.get(), new_oper);
ok = limits_ok(state);
REQUIRE(ok);
}
}
}
SECTION("operators_share_account")
{
Observer state;
RiskLimitManager manager(&state);
init.initialize(manager);
bool ok = limits_ok(state);
REQUIRE(ok);
std::vector<std::shared_ptr<AccountRiskLimiter>> limiters;
RiskLimitsTests::all_shared_limiters(manager, limiters);
REQUIRE(limiters.size() > 1);
int lim_count = 0;
SharedLimiterData* data = nullptr;
api::account::RiskLimit limits;
std::vector<orderman::OperatorID> operators;
for(auto ii : limiters)
{
ii->allowed_operators(operators);
AccountRiskLimiter* sh = ii.get();
limits = RiskLimitsTests::risk_limit(*sh);
data = &RiskLimitsTests::shared_data(*sh);
lim_count++;
}
REQUIRE(operators.size() > 1);
api::Security sec = api::Security::default_instance();
setup_security(sec, data->position_info.symbol);
auto sym = data->position_info.symbol.first;
auto type = data->position_info.symbol.second;
auto secsym = sec.symbol();
auto sectype = sec.Contract_case();
REQUIRE(sym == secsym);
REQUIRE(type == sectype);
auto side = (api::Side)(api::SIDE_BUY + (rand() % 2));
auto other_side = (side == api::SIDE_BUY ? api::SIDE_SELL : api::SIDE_BUY);
auto maxpos = (side == api::SIDE_BUY ? (limits.max_position_long()) :
(limits.max_position_short()));
auto maxorder = limits.max_order_size();
OrderKey key1(0);
RiskLimiter& lim1 = manager.find_limiter(to<orderman::AccountName>(data->account_info.tag1()), operators[0], sec, key1);
OrderKey key2(1);
RiskLimiter& lim2 = manager.find_limiter(to<orderman::AccountName>(data->account_info.tag1()), operators[1], sec, key2);
lim1.on_order_state(side, Quantity(maxpos), Quantity(maxpos));
auto r1 = lim1.check(Quantity(maxorder), side);
REQUIRE(!r1.success);
auto r2 = lim2.check(Quantity(maxorder), side);
REQUIRE(!r2.success);
}
SECTION("position_and_working_order_check")
{
Observer state;
RiskLimitManager observed_manager(&state);
init.initialize(observed_manager);
bool ok = limits_ok(state);
REQUIRE(ok);
std::vector<std::shared_ptr<AccountRiskLimiter>> limiters;
RiskLimitsTests::all_shared_limiters(observed_manager, limiters);
REQUIRE(limiters.size() > 0);
int lim_count = 0;
for(auto ii : limiters)
{
std::vector<orderman::OperatorID> operators;
ii->allowed_operators(operators);
lim_count++;
AccountRiskLimiter* sh = ii.get();
const api::account::RiskLimit& limits = RiskLimitsTests::risk_limit(*sh);
SharedLimiterData& data = RiskLimitsTests::shared_data(*sh);
api::Security sec = api::Security::default_instance();
setup_security(sec, data.position_info.symbol);
auto sym = data.position_info.symbol.first;
auto type = data.position_info.symbol.second;
auto secsym = sec.symbol();
auto sectype = sec.Contract_case();
REQUIRE(sym == secsym);
REQUIRE(type == sectype);
auto side = (api::Side)(api::SIDE_BUY + (rand() % 2));
//auto side = api::SIDE_SELL;
auto other_side = (side == api::SIDE_BUY ? api::SIDE_SELL : api::SIDE_BUY);
auto maxpos = (side == api::SIDE_BUY ? (limits.max_position_long()) :
(limits.max_position_short()));
auto maxorder = limits.max_order_size();
OrderKey key(0);
int iters = 2;
for(int i = 0; i < iters; i++)
{
RiskLimiter& lim = observed_manager.find_limiter(to<orderman::AccountName>(data.account_info.tag1()), operators[0], sec, key);
SharedLimiterData& shared2 = RiskLimitsTests::shared_data(lim);
auto limsym = shared2.position_info.symbol.first;
auto limtype = shared2.position_info.symbol.second;
REQUIRE(limsym == secsym);
REQUIRE(type == sectype);
REQUIRE(shared2.account_info.tag1() == data.account_info.tag1());
REQUIRE(&shared2 == &data);
RiskLimiter::RiskLimitResult res;
if(i == 0)
{
res = lim.check(Quantity(rand() % maxorder), side);
REQUIRE(res.success);
}
int half_max = maxpos/2;
auto filled = rand() % half_max;
auto remaining = rand() % half_max;
auto tradeup = maxpos - (filled + remaining);
auto over = tradeup - tradeup % maxorder;
tradeup -= over;
filled += over;
if(i == 0)
RiskLimitsTests::order_state_update(lim, side, Quantity(remaining+filled), Quantity(filled));
else
RiskLimitsTests::order_state_update(lim, side, Quantity(remaining+filled), Quantity(remaining+filled));
res = lim.check(Quantity(tradeup), side);
if(!res.success)
std::cout << "";
REQUIRE(res.success);
res = lim.check( Quantity( tradeup + 1 + (rand() % (limits.max_order_size()-tradeup-1)) ), side);
if(res.success)
std::cout << "";
REQUIRE(!res.success);
res = lim.check( Quantity( tradeup + 1 + (rand() % (limits.max_order_size()-tradeup-1)) ), other_side);
if(!res.success)
std::cout << "";
REQUIRE(res.success);
}
}
}
delete &_manager;
}
}}