#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 #include #include using namespace bts::orderman; namespace bts { namespace risklimits { class RiskLimitsTests { std::unique_ptr 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()), account_service(context->locate()) { } void initialize(RiskLimitManager& mgr) { auto uresp = user_service.get_users(api::user::GetUsersRequest()); auto aresp = account_service.get_accounts(api::account::GetAccountsRequest()); std::vector users; std::vector 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>& 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(acct); OperatorID oid = to(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> limiters; RiskLimitsTests::all_shared_limiters(observed_manager, limiters); REQUIRE(limiters.size() > 0); for(auto i : limiters) { std::vector 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(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> limiters; RiskLimitsTests::all_shared_limiters(manager, limiters); REQUIRE(limiters.size() > 1); int lim_count = 0; SharedLimiterData* data = nullptr; api::account::RiskLimit limits; std::vector 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(data->account_info.tag1()), operators[0], sec, key1); OrderKey key2(1); RiskLimiter& lim2 = manager.find_limiter(to(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> limiters; RiskLimitsTests::all_shared_limiters(observed_manager, limiters); REQUIRE(limiters.size() > 0); int lim_count = 0; for(auto ii : limiters) { std::vector 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(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; } }}