public void make_request_for_unfilled_limit_to_sell_order_when_current_price_near_take_profit()
{
Signal s1 = new Signal(this.strategyHeader, BrokerDateTime.Make(DateTime.Now), TradeAction.Sell, OrderType.Limit, 150000, 0, 150000);
this.tradingData.Get <ICollection <Signal> >().Add(s1);
Order o1 = new Order(s1);
this.tradingData.Get <ICollection <Order> >().Add(o1);
Assert.IsFalse(o1.IsFilled);
Assert.IsFalse(o1.IsFilledPartially);
double currentPrice = 149930;
DateTime date = BrokerDateTime.Make(DateTime.Now);
string description = String.Format("Текущая цена {0} на расстоянии одного шага от take profit цены {1} стратегии.", currentPrice, s1.Limit - this.tpSettings.Points);
IGenericFactory <OrderCancellationRequest> factory = new UnfilledOrderCancellationRequestFactory(currentPrice, o1, tradingData);
OrderCancellationRequest request = factory.Make();
Assert.IsTrue(request.Id > 0);
Assert.AreEqual(o1, request.Order);
Assert.AreEqual(o1.Id, request.OrderId);
Assert.IsTrue(request.DateTime >= date);
Assert.AreEqual(description, request.Description);
}
public void cancel_partially_filled_for_limit_to_buy_order_when_current_price_near_stop_loss()
{
Signal s1 = new Signal(this.strategyHeader, BrokerDateTime.Make(DateTime.Now), TradeAction.Buy, OrderType.Limit, 150000, 0, 150000);
this.tradingData.Get <ICollection <Signal> >().Add(s1);
Order o1 = new Order(s1);
this.tradingData.Get <ICollection <Order> >().Add(o1);
Trade t1 = new Trade(o1, this.strategyHeader.Portfolio, this.strategyHeader.Symbol, 150000, 3, BrokerDateTime.Make(DateTime.Now));
this.tradingData.Get <ICollection <Trade> >().Add(t1);
o1.FilledAmount = t1.Amount;
Assert.IsFalse(o1.IsFilled);
Assert.IsTrue(o1.IsFilledPartially);
double currentPrice = 149960;
DateTime date = BrokerDateTime.Make(DateTime.Now);
string description = String.Format("Текущая цена {0} на расстоянии одного шага от stop loss цены {1} стратегии.", currentPrice, s1.Limit - this.slSettings.Points);
IGenericFactory <OrderCancellationRequest> factory = new UnfilledOrderCancellationRequestFactory(currentPrice, o1, tradingData);
OrderCancellationRequest request = factory.Make();
Assert.IsTrue(request.Id > 0);
Assert.AreEqual(o1, request.Order);
Assert.AreEqual(o1.Id, request.OrderId);
Assert.IsTrue(request.DateTime >= date);
Assert.AreEqual(description, request.Description);
}
public void repeat_cancellation_request_if_previous_is_older_than_sixty_seconds_for_sell_test()
{
MockOrderManager mom = (MockOrderManager)this.orderManager;
Assert.AreEqual(0, mom.CancelCounter);
Assert.AreEqual(0, this.tradingData.Get <IEnumerable <Signal> >().Count());
Assert.AreEqual(0, this.tradingData.Get <IEnumerable <Order> >().Count());
Assert.AreEqual(0, this.tradingData.CancellationRequests.Count());
Signal signal = new Signal(this.strategyHeader,
BrokerDateTime.Make(DateTime.Now),
TradeAction.Sell,
OrderType.Limit,
145000,
0,
145100);
this.signalQueue.Enqueue(signal);
Order order = this.tradingData.Get <IEnumerable <Order> >().Last();
OrderCancellationRequest firstRequest = new OrderCancellationRequest(order, "First request");
firstRequest.DateTime = BrokerDateTime.Make(DateTime.Now.AddSeconds(-61));
this.tradingData.Get <ICollection <OrderCancellationRequest> >().Add(firstRequest);
OrderDeliveryConfirmation odc = new OrderDeliveryConfirmation(order, BrokerDateTime.Make(DateTime.Now));
this.tradingData.Get <ObservableHashSet <OrderDeliveryConfirmation> >().Add(odc);
this.quotesProvider.Update(0, this.strategyHeader.Symbol, 144800, 150, 144810, 150);
Assert.AreEqual(2, this.tradingData.CancellationRequests.Count());
Assert.AreEqual(1, mom.CancelCounter);
}
public void Handlers_cancel_stop_order_when_short_position_closed_by_limit()
{
Signal sl = new Signal(this.str2, BrokerDateTime.Make(DateTime.Now), TradeAction.Buy, OrderType.Stop, 33000, 33100, 0);
this.tradingData.Get <ICollection <Signal> >().Add(sl);
Order slo = new Order(sl);
this.tradingData.Get <ICollection <Order> >().Add(slo);
Signal tp = new Signal(this.str2, BrokerDateTime.Make(DateTime.Now), TradeAction.Buy, OrderType.Limit, 33000, 0, 32900);
this.tradingData.Get <ICollection <Signal> >().Add(tp);
Order tpo = new Order(tp);
this.tradingData.Get <ICollection <Order> >().Add(tpo);
Assert.AreEqual(-10, this.tradingData.GetAmount(this.str2));
Assert.AreEqual(2, this.tradingData.Get <ICollection <Order> >().GetUnfilled(this.str2).Count());
Assert.AreEqual(20, this.tradingData.Get <ICollection <Order> >().GetUnfilledSignedAmount(this.str2));
Assert.AreEqual(0, this.tradingData.Get <ObservableHashSet <OrderCancellationRequest> >().Count);
Trade t = new Trade(slo, this.str2.Portfolio, this.str2.Symbol, 33100, this.str1.Amount, BrokerDateTime.Make(DateTime.Now));
this.tradingData.Get <ObservableHashSet <Trade> >().Add(t);
Assert.AreEqual(1, this.tradingData.Get <ObservableHashSet <OrderCancellationRequest> >().Count);
OrderCancellationRequest request = this.tradingData.Get <ObservableHashSet <OrderCancellationRequest> >().Last();
Assert.AreEqual(tpo, request.Order);
Assert.AreEqual(tpo.Id, request.OrderId);
Assert.AreEqual(String.Format("Отменить заявку {0}, потому что позиция была закрыта заявкой {1}", tpo.ToString(), slo.ToString()), request.Description);
}
public void Handlers_cancel_partially_filled_outdated_strategy_order_to_open_short()
{
Signal signal = new Signal(this.strategyHeader, new DateTime(2013, 1, 1, 10, 0, 0), TradeAction.Sell, OrderType.Limit, 150000, 0, 150000);
this.tradingData.Get <ICollection <Signal> >().Add(signal);
Order order = new Order(1, new DateTime(2013, 1, 1, 10, 0, 0), this.strategyHeader.Portfolio, this.strategyHeader.Symbol, signal.TradeAction, signal.OrderType, signal.Amount, signal.Price, signal.Stop);
order.Signal = signal;
order.SignalId = signal.Id;
this.tradingData.Get <ICollection <Order> >().Add(order);
Trade t1 = new Trade(order, order.Portfolio, order.Symbol, order.Price, -2, new DateTime(2013, 1, 1, 10, 0, 1));
this.tradingData.Get <ObservableHashSet <Trade> >().Add(t1);
Assert.AreEqual(2, order.FilledAmount);
Assert.AreEqual(0, this.tradingData.Get <ICollection <OrderCancellationRequest> >().Count);
Tick tick = new Tick("RTS-9.13_FT", new DateTime(2013, 1, 1, 10, 0, 11), 150000, 10);
this.tradingData.Get <ObservableCollection <Tick> >().Add(tick);
Assert.AreEqual(1, this.tradingData.Get <ICollection <OrderCancellationRequest> >().Count);
OrderCancellationRequest request = this.tradingData.Get <ICollection <OrderCancellationRequest> >().Last();
Assert.AreEqual(order.Id, request.OrderId);
}
/// <summary>
/// Remove an outstanding order on the constellation exchange.
/// </summary>
/// <param name="orderId">Id of the order to cancel</param>
/// <returns></returns>
public async Task <QuantumResult> CancelOrder(ulong orderId)
{
var cancelOrderRequest = new OrderCancellationRequest {
OrderId = orderId
};
return(await Send(cancelOrderRequest));
}
public async Task <MessageEnvelope> CancelOrder(ulong orderId, bool waitForFinalize = true)
{
var order = new OrderCancellationRequest {
OrderId = orderId
};
var response = (CentaurusResponse)await connection.SendMessage(order.CreateEnvelope());
var result = await(waitForFinalize ? response.ResponseTask : response.AcknowledgmentTask);
return(result);
}
public void OrderCancellationRequest_constructor_test()
{
Order order = new Order {
Portfolio = "BP12345-RF-01", Symbol = "RTS-9.13_FT", TradeAction = TradeAction.Buy, OrderType = OrderType.Limit, Amount = 10
};
OrderCancellationRequest request = new OrderCancellationRequest(order, "Cигнал номер 3923");
Assert.IsTrue(request.Id > 0);
Assert.AreEqual(order.Id, request.OrderId);
Assert.AreEqual("Cигнал номер 3923", request.Description);
Assert.AreEqual(order, request.Order);
Assert.IsTrue(request.DateTime >= order.DateTime);
}
public void Handlers_Ignore_cancellation_confirmation_if_order_is_not_exists()
{
Order order = new Order(this.s1);
OrderCancellationRequest request = new OrderCancellationRequest(order, "Cancel order request");
this.tradingData.Get <ObservableHashSet <OrderCancellationRequest> >().Add(request);
Assert.IsFalse(order.IsCanceled);
OrderCancellationConfirmation confirmation = new OrderCancellationConfirmation(order, BrokerDateTime.Make(DateTime.Now), "Order canceled");
this.tradingData.Get <ObservableHashSet <OrderCancellationConfirmation> >().Add(confirmation);
Assert.IsFalse(order.IsCanceled);
}
public void OrderCancellationRequest_duplicates()
{
Order order = new Order {
Portfolio = "BP12345-RF-01", Symbol = "RTS-9.13_FT", TradeAction = TradeAction.Buy, OrderType = OrderType.Limit, Amount = 10
};
OrderCancellationRequest request = new OrderCancellationRequest(order, "Cигнал номер 3923");
HashSet <OrderCancellationRequest> collection = new HashSet <OrderCancellationRequest>(new IdentifiedComparer());
collection.Add(request);
Assert.AreEqual(1, collection.Count);
collection.Add(request);
Assert.AreEqual(1, collection.Count);
}
public MakeOrderCancellationRequestOnQuote(StrategyHeader strategyHeader,
double priceShiftPoints,
IQuoteProvider quotesProvider,
IDataContext tradingData,
ILogger logger)
: base(quotesProvider)
{
this.strategyHeader = strategyHeader;
this.priceShift = priceShiftPoints;
this.quotesProvider = quotesProvider;
this.tradingData = tradingData;
this.logger = logger;
this.bestPrice = 0;
this.request = null;
}
public void OrderCancellationRequest_ToString_test()
{
Order order = new Order(1,
BrokerDateTime.Make(DateTime.Now),
"BP12345-RF-01",
"RTS-12.13_FT",
TradeAction.Buy,
OrderType.Limit,
1,
150000,
0);
OrderCancellationRequest request = new OrderCancellationRequest(order, "Лучшая цена предложения ушла от цены заявки на 100 пунктов.");
string result = String.Format("Запрос на отмену заявки Id: {0}, DateTime: {1}, Description: {2}, OrderId: {3}", request.Id, request.DateTime, request.Description, request.OrderId);
Assert.AreEqual(result, request.ToString());
}
public void Handlers_CancelOrder_on_cancellation_request_arrival()
{
Signal signal = new Signal(this.st1, BrokerDateTime.Make(DateTime.Now), TradeAction.Buy, OrderType.Limit, 150000, 0, 120000);
this.tradingData.Get <ICollection <Signal> >().Add(signal);
Order order = new Order(signal);
this.tradingData.Get <ICollection <Order> >().Add(order);
Assert.AreEqual(0, this.manager.CancelCounter);
OrderCancellationRequest request = new OrderCancellationRequest(order, "Internally expired");
this.tradingData.Get <ObservableHashSet <OrderCancellationRequest> >().Add(request);
Assert.AreEqual(1, this.manager.CancelCounter);
}
public void Handlers_Cancel_order_on_cancellation_confirmation()
{
Order order = new Order(this.s3);
this.tradingData.Get <ICollection <Order> >().Add(order);
OrderCancellationRequest request = new OrderCancellationRequest(order, "Cancel order request");
this.tradingData.Get <ObservableHashSet <OrderCancellationRequest> >().Add(request);
Assert.IsFalse(order.IsCanceled);
OrderCancellationConfirmation confirmation = new OrderCancellationConfirmation(order, BrokerDateTime.Make(DateTime.Now), "Order canceled");
this.tradingData.Get <ObservableHashSet <OrderCancellationConfirmation> >().Add(confirmation);
Assert.IsTrue(order.IsCanceled);
Assert.AreEqual(confirmation.DateTime, order.CancellationDate);
Assert.AreEqual(confirmation.Description, order.CancellationReason);
}
public override void OnQuotesUpdate(string symbol)
{
if (!this.strategyHeader.Symbol.Equals(symbol))
{
return;
}
if (this.tradingData.GetAmount(this.strategyHeader) != 0)
{
return;
}
Order lastUnfilledOrder = GetLastUnfilledOrder();
if (lastUnfilledOrder == null)
{
return;
}
if (!lastUnfilledOrder.IsDelivered)
{
return;
}
if (!BestQuotePriceGoneOverTheLimit(lastUnfilledOrder))
{
return;
}
if (OrderCancellationRequstExists(lastUnfilledOrder))
{
return;
}
this.request = null;
this.request = MakeOrderCancellationRequest(lastUnfilledOrder);
this.logger.Log(String.Format("{0:dd/MM/yyyy H:mm:ss.fff}, {1}, запрос на снятие заявки {2}", DateTime.Now, this.GetType().Name, request.ToString()));
this.tradingData.Get <ObservableHashSet <OrderCancellationRequest> >().Add(request);
}
public void open_long_position_with_market_order_protect_it_with_stop_and_limit_and_close_with_limit()
{
// Сигнал на открытие позиции
Signal inputSignal = new Signal(this.strategyHeader, BrokerDateTime.Make(DateTime.Now), TradeAction.Buy, OrderType.Market, 150000, 0, 0);
EmulateTradeFor(inputSignal, 150050);
// Заявка исполнена, позиция открыта ровно на запрошенный в заявке объем
Assert.AreEqual(10, this.tradingData.GetAmount(this.strategyHeader));
// Для позиции созданы и отправлены брокеру защитные стоп и тейк профит приказы
Assert.AreEqual(3, this.tradingData.Get <IEnumerable <Signal> >().Count());
Assert.AreEqual(3, this.tradingData.Get <IEnumerable <Order> >().Count());
Signal slSignal = this.tradingData.Get <IEnumerable <Signal> >().Single(s => s.OrderType == OrderType.Stop && s.StrategyId == this.strategyHeader.Id);
Signal tpSignal = this.tradingData.Get <IEnumerable <Signal> >().Single(s => s.OrderType == OrderType.Limit && s.StrategyId == this.strategyHeader.Id);
// Цена защитных приказов установлена соответственно настройкам
Assert.AreEqual(149750, slSignal.Stop);
Assert.AreEqual(150550, tpSignal.Limit);
// Через некоторое время цена на рынке вырастает, срабатывает take profit приказ и исполняется одной сделкой
EmulateTradeFor(tpSignal, 145500);
Order slOrder =
this.tradingData.Get <IEnumerable <Order> >().Single(o => o.SignalId == slSignal.Id);
Order tpOrder =
this.tradingData.Get <IEnumerable <Order> >().Single(o => o.SignalId == tpSignal.Id);
Assert.IsTrue(tpOrder.IsFilled);
Assert.IsFalse(slOrder.IsFilled);
Assert.IsFalse(slOrder.IsCanceled);
// Позиция закрыта
Assert.AreEqual(0, this.tradingData.GetAmount(this.strategyHeader));
// Брокеру отправлен запрос на отмену stop loss приказа
Assert.AreEqual(1, this.tradingData.Get <IEnumerable <OrderCancellationRequest> >().Count());
OrderCancellationRequest slRequest = this.tradingData.Get <IEnumerable <OrderCancellationRequest> >().Single(r => r.OrderId == slOrder.Id);
Assert.IsNotNull(slRequest);
}
public override void OnItemAdded(Tick item)
{
//TODO здесь что-то очень медленно:
IEnumerable <Order> unfilled = this.tradingData.Get <ICollection <Order> >().GetUnfilled(item.Symbol);
if (unfilled == null)
{
return;
}
if (unfilled.Count() == 0)
{
return;
}
try
{
foreach (Order o in unfilled)
{
if (!this.tradingData.Get <ICollection <Position> >().Exists(o.Portfolio, o.Symbol))
{
IGenericFactory <OrderCancellationRequest> cancellationFactory = new UnfilledOrderCancellationRequestFactory(item.Price, o, (TradingDataContext)this.tradingData);
//cancellationFactory.currentPrice = item.Price;
//cancellationFactory.order = o;
//cancellationFactory.tradingData = (TradingDataContext)this.tradingData;
OrderCancellationRequest request = cancellationFactory.Make();
if (request != null)
{
this.logger.Log(String.Format("{0:dd/MM/yyyy H:mm:ss.fff}, {1}, сформирован новый запрос {2} на отмену заявки {3}.", DateTime.Now, this.GetType().Name, o.ToString(), request.Description));
this.tradingData.Get <ObservableHashSet <OrderCancellationRequest> >().Add(request);
}
}
}
}
catch
{
this.logger.Log(String.Format("{0:dd/MM/yyyy H:mm:ss.fff}, {1}, Ошибка в {2}.", DateTime.Now, this.GetType().Name, "OnItemAdded"));
}
}
public async Task OrderCancellationQuantumTest(int asset, int amount, OrderSide side, int apexMod, bool useFakeSigner, Type excpectedException)
{
var acc = context.AccountStorage.GetAccount(TestEnvironment.Client1KeyPair);
var order = new OrderRequest
{
Account = acc.Account.Id,
RequestId = 1,
Amount = amount,
Asset = asset,
Price = 100,
Side = side,
AccountWrapper = acc
};
var envelope = order.CreateEnvelope().Sign(useFakeSigner ? TestEnvironment.Client2KeyPair : TestEnvironment.Client1KeyPair);
if (!context.IsAlpha)
{
var quantum = new RequestQuantum {
Apex = context.QuantumStorage.CurrentApex + 1, RequestEnvelope = envelope, Timestamp = DateTime.UtcNow.Ticks
};
envelope = quantum.CreateEnvelope().Sign(TestEnvironment.AlphaKeyPair);
}
var submitResult = await AssertQuantumHandling(envelope, excpectedException);
if (excpectedException != null)
{
return;
}
var apex = ((Quantum)submitResult.OriginalMessage.Message).Apex + apexMod;
var orderCancellation = new OrderCancellationRequest
{
Account = acc.Account.Id,
RequestId = 2,
OrderId = OrderIdConverter.Encode((ulong)apex, asset, side),
AccountWrapper = context.AccountStorage.GetAccount(TestEnvironment.Client1KeyPair)
};
envelope = orderCancellation.CreateEnvelope().Sign(TestEnvironment.Client1KeyPair);
if (!context.IsAlpha)
{
var quantum = new RequestQuantum {
Apex = context.QuantumStorage.CurrentApex + 1, RequestEnvelope = envelope, Timestamp = DateTime.UtcNow.Ticks
};
envelope = quantum.CreateEnvelope().Sign(TestEnvironment.AlphaKeyPair);
}
var cancelResult = await AssertQuantumHandling(envelope, excpectedException);
if (excpectedException != null)
{
return;
}
var currentMarket = context.Exchange.GetMarket(asset);
Assert.IsTrue(currentMarket != null);
var requests = side == OrderSide.Buy ? currentMarket.Bids : currentMarket.Asks;
Assert.AreEqual(requests.Count, 0);
}
public void open_short_position_with_market_order_protect_it_with_stop_limit_rejected_close_with_emergency_market()
{
// Настройки для торгуемой стратегии
Symbol symbol = new Symbol("RTS-9.13_FT", 1, 8, 10, BrokerDateTime.Make(DateTime.Now));
this.tradingData.Get <ICollection <Symbol> >().Add(symbol);
StrategyHeader strategyHeader = new StrategyHeader(1, "strategyHeader", "BP12345-RF-01", "RTS-9.13_FT", 10);
this.tradingData.Get <ICollection <StrategyHeader> >().Add(strategyHeader);
StopPointsSettings slSettings = new StopPointsSettings(strategyHeader, 300, false);
this.tradingData.Get <ICollection <StopPointsSettings> >().Add(slSettings);
ProfitPointsSettings tpSettings = new ProfitPointsSettings(strategyHeader, 500, false);
this.tradingData.Get <ICollection <ProfitPointsSettings> >().Add(tpSettings);
StopLossOrderSettings slOrderSettings = new StopLossOrderSettings(strategyHeader, 3600);
this.tradingData.Get <ICollection <StopLossOrderSettings> >().Add(slOrderSettings);
TakeProfitOrderSettings tpOrderSettings = new TakeProfitOrderSettings(strategyHeader, 3600);
this.tradingData.Get <ICollection <TakeProfitOrderSettings> >().Add(tpOrderSettings);
StrategyStopLossByPointsOnTick stopLossHandler =
new StrategyStopLossByPointsOnTick(strategyHeader, this.tradingData, this.signalQueue, new NullLogger());
StrategyTakeProfitByPointsOnTick takeProfitHandler =
new StrategyTakeProfitByPointsOnTick(strategyHeader, this.tradingData, this.signalQueue, new NullLogger());
PlaceStrategyStopLossByPointsOnTrade placeStopOnTradeHandler =
new PlaceStrategyStopLossByPointsOnTrade(strategyHeader, this.tradingData, this.signalQueue, new NullLogger());
PlaceStrategyTakeProfitByPointsOnTrade placeTakeProfitOnTradeHandler =
new PlaceStrategyTakeProfitByPointsOnTrade(strategyHeader, this.tradingData, this.signalQueue, new NullLogger());
// Сигнал на открытие позиции
Signal inputSignal = new Signal(strategyHeader, BrokerDateTime.Make(DateTime.Now), TradeAction.Sell, OrderType.Market, 150000, 0, 0);
// Брокер исполнил заявку одной сделкой
Trade inputTrade = this.tradingData.AddSignalAndItsOrderAndTrade(inputSignal);
// Заявка исполнена, позиция открыта ровно на запрошенный в заявке объем
Assert.IsTrue(inputTrade.Order.IsFilled);
Assert.AreEqual(-10, this.tradingData.GetAmount(strategyHeader));
// Для позиции созданы и отправлены брокеру защитные стоп и тейк профит приказы
Assert.AreEqual(3, this.tradingData.Get <IEnumerable <Signal> >().Count());
Assert.AreEqual(3, this.tradingData.Get <IEnumerable <Order> >().Count());
Order slOrder = this.tradingData.Get <IEnumerable <Order> >().Single(o => o.OrderType == OrderType.Stop);
Order tpOrder = this.tradingData.Get <IEnumerable <Order> >().Single(o => o.OrderType == OrderType.Limit);
// Цена защитных приказов установлена соответственно настройкам
Assert.AreEqual(150300, slOrder.Stop);
Assert.AreEqual(149500, tpOrder.Price);
// Брокер подтверждает только получение стоп приказа и отклоняет тейк профит приказ
this.tradingData.Get <ObservableHashSet <OrderDeliveryConfirmation> >().Add(new OrderDeliveryConfirmation(slOrder, BrokerDateTime.Make(DateTime.Now)));
this.tradingData.Get <ObservableHashSet <OrderDeliveryConfirmation> >().Add(new OrderDeliveryConfirmation(tpOrder, BrokerDateTime.Make(DateTime.Now)));
this.tradingData.Get <ObservableHashSet <OrderRejection> >().Add(new OrderRejection(tpOrder, BrokerDateTime.Make(DateTime.Now), "заявка отклонена"));
Assert.IsTrue(slOrder.IsDelivered);
Assert.IsTrue(tpOrder.IsDelivered);
Assert.IsTrue(tpOrder.IsRejected);
// Тик не дошел до цены закрытия, поэтому сигнал экстренного закрытия по тейк профиту не срабатывает
this.tradingData.Get <ObservableCollection <Tick> >().Add(new Tick("RTS-9.13_FT", BrokerDateTime.Make(DateTime.Now), 149510, 100));
Assert.AreEqual(3, this.tradingData.Get <IEnumerable <Order> >().Count());
// Тик дошел до цены закрытия, поэтому срабатывает сигнал экстренного закрытия по тейк профиту
this.tradingData.Get <ObservableCollection <Tick> >().Add(new Tick("RTS-9.13_FT", BrokerDateTime.Make(DateTime.Now), 149500, 150));
Assert.AreEqual(4, this.tradingData.Get <IEnumerable <Order> >().Count());
// Извлекаем копию отправленной брокеру заявки чтобы убедиться в том, что отправлена нужная нам заявка
Order etpOrder = this.tradingData.Get <IEnumerable <Order> >().Last();
Assert.AreEqual(TradeAction.Buy, etpOrder.TradeAction);
Assert.AreEqual(OrderType.Market, etpOrder.OrderType);
Assert.AreEqual(Math.Abs(this.tradingData.GetAmount(strategyHeader)), etpOrder.Amount);
// Заявка экстренного закрытия исполняется одной сделкой
Trade outputTrade = this.tradingData.AddSignalAndItsOrderAndTrade(etpOrder.Signal);
// Приказ экстренного закрытия по тейк профиту исполнен
Assert.IsTrue(etpOrder.IsFilled);
// Стоп лосс приказ не исполнен
Assert.IsFalse(slOrder.IsFilled);
// Система автоматически сгенерировала и отправила заявку на отмену стоп лосс приказа
Assert.AreEqual(1, this.tradingData.Get <ObservableHashSet <OrderCancellationRequest> >().Count);
OrderCancellationRequest slOrderCancel = this.tradingData.Get <ObservableHashSet <OrderCancellationRequest> >().Last();
Assert.AreEqual(slOrder.Id, slOrderCancel.OrderId);
// Брокер присылает подтверждение отмены стоп лосс приказа
this.tradingData.Get <ObservableHashSet <OrderCancellationConfirmation> >().Add(new OrderCancellationConfirmation(slOrder, BrokerDateTime.Make(DateTime.Now), "Отмена приказа подтверждена"));
Assert.IsTrue(slOrder.IsCanceled);
// Позиция закрыта
Assert.AreEqual(0, this.tradingData.GetAmount(strategyHeader));
}
public void Handlers_cancel_short_position_stop_order_when_take_profit_order_begin_filling()
{
// Добавляем новую стратегию
StrategyHeader strategyHeader = new StrategyHeader(1, "Strategy 1", "BP12345-RF-01", "RTS-9.13_FT", 15);
this.tradingData.Get <ICollection <StrategyHeader> >().Add(strategyHeader);
// Добавляем настройки stop loss для стратегии
StopPointsSettings slSettings = new StopPointsSettings(strategyHeader, 900, false);
this.tradingData.Get <ICollection <StopPointsSettings> >().Add(slSettings);
// Добавляем настройки take profit для стратегии
ProfitPointsSettings tpSettings = new ProfitPointsSettings(strategyHeader, 1000, false);
this.tradingData.Get <ICollection <ProfitPointsSettings> >().Add(tpSettings);
// Имитируем генерацию сигнала на открытие позиции
Signal signal = new Signal(strategyHeader, BrokerDateTime.Make(DateTime.Now), TradeAction.Sell, OrderType.Limit, 150000, 0, 150000);
this.tradingData.Get <ICollection <Signal> >().Add(signal);
Order order = new Order(signal);
this.tradingData.Get <ICollection <Order> >().Add(order);
// Брокер исполнил заявку на открытие позиции одной сделкой
Trade trade = new Trade(order, order.Portfolio, order.Symbol, 150000, -order.Amount, BrokerDateTime.Make(DateTime.Now));
this.tradingData.Get <ObservableHashSet <Trade> >().Add(trade);
// Позиция существует и ее объем равен объему в исполненной сделке
Assert.AreEqual(1, this.tradingData.Get <IEnumerable <Position> >().Count());
Assert.AreEqual(-15, this.tradingData.GetAmount(strategyHeader));
// Имитируем автоматическую генерацию сигнала на установку stop loss заявки
Signal slSignal = new Signal(strategyHeader, BrokerDateTime.Make(DateTime.Now), TradeAction.Buy, OrderType.Stop, 150000, 150900, 0);
this.tradingData.Get <ICollection <Signal> >().Add(slSignal);
Order slOrder = new Order(slSignal);
this.tradingData.Get <ICollection <Order> >().Add(slOrder);
// Имитируем автоматическую генерацию сигнала на установку takep profit заявки
Signal tpSignal = new Signal(strategyHeader, BrokerDateTime.Make(DateTime.Now), TradeAction.Buy, OrderType.Limit, 150000, 0, 149000);
this.tradingData.Get <ICollection <Signal> >().Add(tpSignal);
Order tpOrder = new Order(tpSignal);
this.tradingData.Get <ICollection <Order> >().Add(tpOrder);
// Рынок дошел до take profit но заявка исполнилась лишь частично
Trade tpTrade = new Trade(tpOrder, tpOrder.Portfolio, tpOrder.Symbol, 149000, 8, BrokerDateTime.Make(DateTime.Now));
this.tradingData.Get <ObservableHashSet <Trade> >().Add(tpTrade);
// Объем позиции обновился
Assert.AreEqual(-7, this.tradingData.GetAmount(strategyHeader));
// Обработчик автоматически отправил запрос на отмену stop loss заявки как только начала исполняться лимитная заявка
Assert.AreEqual(1, this.tradingData.Get <ObservableHashSet <OrderCancellationRequest> >().Count);
OrderCancellationRequest request = this.tradingData.Get <ObservableHashSet <OrderCancellationRequest> >().Last();
Assert.AreEqual(slOrder, request.Order);
}
