420 lines
15 KiB
C++
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;
|
|
}
|
|
|
|
}}
|
|
|
|
|