public void Check_Order_InitialMargin()
{
_bestPriceConsumer.SendEvent(this,
new BestPriceChangeEventArgs(
new InstrumentBidAskPair {
Instrument = "EURUSD", Ask = 1.3M, Bid = 1.2M
}));
_bestPriceConsumer.SendEvent(this,
new BestPriceChangeEventArgs(
new InstrumentBidAskPair {
Instrument = "CHFJPY", Ask = 2.5M, Bid = 2.3M
}));
_fxRateCacheService.SetQuote(new InstrumentBidAskPair {
Instrument = "EURUSD", Ask = 1.25M, Bid = 1.25M
});
_fxRateCacheService.SetQuote(new InstrumentBidAskPair {
Instrument = "EURJPY", Ask = 2.3M, Bid = 2.3M
});
var order1 = TestObjectsFactory.CreateNewOrder(OrderType.Market, "EURUSD", Accounts[1],
MarginTradingTestsUtils.TradingConditionId, 1000);
var order2 = TestObjectsFactory.CreateNewOrder(OrderType.Market, "CHFJPY", Accounts[1],
MarginTradingTestsUtils.TradingConditionId, -100);
Assert.AreEqual(10.4M, _fplService.GetInitMarginForOrder(order1));
Assert.AreEqual(10M, _fplService.GetInitMarginForOrder(order2));
}
public void Is_No_Quote()
{
var order = TestObjectsFactory.CreateNewOrder(OrderType.Market, "EURUSD", Accounts[0],
MarginTradingTestsUtils.TradingConditionId, 10);
var ex = Assert.Throws <QuoteNotFoundException>(() => _validateOrderService.MakePreTradeValidation(order, true, _me));
Assert.That(ex.InstrumentId == "EURUSD");
}
public async Task Is_Order_NoLiquidity_ByInstrument_Not_Matched()
{
var order = TestObjectsFactory.CreateNewOrder(OrderType.Market, "BTCUSD", Accounts[0],
MarginTradingTestsUtils.TradingConditionId, 10);
var matchedOrders = await _matchingEngine.MatchOrderAsync(order, false);
Assert.AreEqual(0, matchedOrders.Count);
}
public void Is_Frozen_Instrument_Valid_For_PositionClose_Pre_Traid()
{
const string instrument = "EURUSD";
SetupAssetPair(instrument, isFrozen: true);
var order = TestObjectsFactory.CreateNewOrder(OrderType.Market, instrument, Accounts[0],
MarginTradingTestsUtils.TradingConditionId, 10);
Assert.DoesNotThrow(() => _validateOrderService.MakePreTradeValidation(order, false, _me));
}
public void Is_Frozen_Instrument_Invalid_For_NewPosition_Pre_Traid()
{
const string instrument = "EURUSD";
SetupAssetPair(instrument, isFrozen: true);
var order = TestObjectsFactory.CreateNewOrder(OrderType.Market, instrument, Accounts[0],
MarginTradingTestsUtils.TradingConditionId, 10);
var ex = Assert.Throws <ValidateOrderException>(() =>
_validateOrderService.MakePreTradeValidation(order, true, _me));
Assert.That(ex.RejectReason == OrderRejectReason.InvalidInstrument);
}
public async Task Is_Buy_Fully_Matched()
{
var order = TestObjectsFactory.CreateNewOrder(OrderType.Market, "EURUSD", Accounts[0],
MarginTradingTestsUtils.TradingConditionId, 8);
var matchedOrders = await _matchingEngine.MatchOrderAsync(order, false);
var orderBooks = _matchingEngine.GetOrderBook("EURUSD");
Assert.AreEqual(2, matchedOrders.Count);
Assert.True(matchedOrders.Any(item => item.OrderId == "3"));
Assert.True(matchedOrders.Any(item => item.OrderId == "4"));
Assert.AreEqual(order.Volume, matchedOrders.SummaryVolume);
Assert.AreEqual(6, orderBooks.Sell[1.15M].First(item => item.Id == "4").GetRemainingVolume());
}
public void Is_TradingDisabled_Instrument_Invalid_Pre_Trade()
{
const string instrument = "EURUSD";
SetupAssetPair(instrument, tradingDisabled: true);
var order = TestObjectsFactory.CreateNewOrder(OrderType.Limit, instrument, Accounts[0],
MarginTradingTestsUtils.TradingConditionId, 10);
var ex = Assert.Throws <ValidateOrderException>(() =>
_validateOrderService.MakePreTradeValidation(order, true, _me, 0));
Assert.That(ex.RejectReason == OrderRejectReason.InvalidInstrument);
Assert.That(ex.Message.Contains(CommonErrorCodes.InstrumentTradingDisabled));
}
public async Task Is_Sell_Partial_Matched()
{
var order = TestObjectsFactory.CreateNewOrder(OrderType.Market, "EURUSD", Accounts[0],
MarginTradingTestsUtils.TradingConditionId, -13);
var matchedOrders = await _matchingEngine.MatchOrderAsync(order, false);
var orderBooks = _matchingEngine.GetOrderBook("EURUSD");
Assert.AreEqual(2, matchedOrders.Count);
Assert.True(matchedOrders.Any(item => item.OrderId == "1"));
Assert.True(matchedOrders.Any(item => item.OrderId == "2"));
Assert.AreEqual(2, Math.Abs(order.Volume) - matchedOrders.SummaryVolume);
Assert.IsFalse(orderBooks.Buy.ContainsKey(1.05M));
Assert.IsFalse(orderBooks.Buy.ContainsKey(1.04M));
}
public void Is_Not_Enough_Balance()
{
const string instrument = "EURUSD";
var quote = new InstrumentBidAskPair {
Instrument = instrument, Bid = 1.55M, Ask = 1.57M
};
_bestPriceConsumer.SendEvent(this, new BestPriceChangeEventArgs(quote));
var order = TestObjectsFactory.CreateNewOrder(OrderType.Market, instrument, Accounts[0],
MarginTradingTestsUtils.TradingConditionId, 150000);
var ex = Assert.Throws <ValidateOrderException>(() =>
_validateOrderService.MakePreTradeValidation(order, true, _me));
Assert.That(ex.RejectReason == OrderRejectReason.NotEnoughBalance);
}
public void Is_Enough_Balance_When_Additional_Margin_Exists()
{
const string instrument = "EURUSD";
var quote = new InstrumentBidAskPair {
Instrument = instrument, Bid = 1.55M, Ask = 1.57M
};
_bestPriceConsumer.SendEvent(this, new BestPriceChangeEventArgs(quote));
var order = TestObjectsFactory.CreateNewOrder(OrderType.Market, instrument, Accounts[0],
MarginTradingTestsUtils.TradingConditionId, 150000);
//account margin = 1000, margin requirement for order = 2355 => additional margin should be > 1355
Assert.DoesNotThrow(() =>
_validateOrderService.MakePreTradeValidation(order, true, _me, 1356));
}
public void Check_IsEnoughBalance()
{
//account have 1000
var me = new FakeMatchingEngine(10);
var order1 = TestObjectsFactory.CreateNewOrder(OrderType.Market, "EURUSD", Accounts[0],
MarginTradingTestsUtils.TradingConditionId, 96000);
Assert.DoesNotThrow(() => _accountUpdateService.CheckIsEnoughBalance(order1, me, 0));
var order2 = TestObjectsFactory.CreateNewOrder(OrderType.Market, "EURUSD", Accounts[0],
MarginTradingTestsUtils.TradingConditionId, 97000);
Assert.Throws <ValidateOrderException>(() =>
_accountUpdateService.CheckIsEnoughBalance(order2, me, 0));
var meWithSpread = new FakeMatchingEngine(10, closePrice: 1);
var order3 = TestObjectsFactory.CreateNewOrder(OrderType.Market, "EURUSD", Accounts[0],
MarginTradingTestsUtils.TradingConditionId, 96000);
Assert.Throws <ValidateOrderException>(
() => _accountUpdateService.CheckIsEnoughBalance(order3, meWithSpread, 0));
var meForLimitOk = new FakeMatchingEngine(999);
var limitOrderOk = TestObjectsFactory.CreateNewOrder(OrderType.Limit, "EURUSD", Accounts[0],
MarginTradingTestsUtils.TradingConditionId, 960, price: 1000);
Assert.DoesNotThrow(() => _accountUpdateService.CheckIsEnoughBalance(limitOrderOk, meForLimitOk, 0));
var limitOrderErr = TestObjectsFactory.CreateNewOrder(OrderType.Limit, "EURUSD", Accounts[0],
MarginTradingTestsUtils.TradingConditionId, 960, price: 1000);
var meWithHighPrice = new FakeMatchingEngine(1000, 10);
var ex = Assert.Throws <ValidateOrderException>(() =>
_accountUpdateService.CheckIsEnoughBalance(limitOrderErr, meWithHighPrice, 0));
Console.WriteLine(ex.Comment);
}
public void Is_Summary_Volume_Ivalid(decimal volume, bool isValid)
{
const string instrument = "BTCUSD";
var quote = new InstrumentBidAskPair {
Instrument = instrument, Bid = 1.55M, Ask = 1.57M
};
_bestPriceConsumer.SendEvent(this, new BestPriceChangeEventArgs(quote));
var existingLong = TestObjectsFactory.CreateOpenedPosition(instrument, Accounts[0],
MarginTradingTestsUtils.TradingConditionId, 110, 1.57M);
var existingShort = TestObjectsFactory.CreateOpenedPosition(instrument, Accounts[0],
MarginTradingTestsUtils.TradingConditionId, -12, 1.55M);
var existingOtherAcc = TestObjectsFactory.CreateOpenedPosition(instrument, Accounts[1],
MarginTradingTestsUtils.TradingConditionId, 49, 1.57M);
_ordersCache.Positions.Add(existingLong);
_ordersCache.Positions.Add(existingShort);
_ordersCache.Positions.Add(existingOtherAcc);
var order = TestObjectsFactory.CreateNewOrder(OrderType.Market, instrument, Accounts[0],
MarginTradingTestsUtils.TradingConditionId, volume);
if (isValid)
{
Assert.DoesNotThrow(() => _validateOrderService.MakePreTradeValidation(order, true, _me));
}
else
{
var ex = Assert.Throws <ValidateOrderException>(() =>
_validateOrderService.MakePreTradeValidation(order, true, _me));
Assert.That(ex.RejectReason == OrderRejectReason.MaxPositionLimit);
}
}
private Order CreatePendingOrder(OrderType orderType, OrderDirection direction, decimal?price, DateTime created)
{
return(TestObjectsFactory.CreateNewOrder(orderType, "AssetPair", new MarginTradingAccount(),
"TradingCondition", direction == OrderDirection.Buy ? 1 : -1, price: price, created: created));
}
public void Is_BaseOrder_Validated_Correctly_Against_Related_On_Change(
OrderDirection baseDirection, decimal newPrice, bool isValid)
{
const string instrument = "EURUSD";
var quote = new InstrumentBidAskPair {
Instrument = instrument, Bid = 1.55M, Ask = 1.57M
};
_bestPriceConsumer.SendEvent(this, new BestPriceChangeEventArgs(quote));
Order CreateOrder(OrderType type)
{
var order = TestObjectsFactory.CreateNewOrder(type, instrument, Accounts[0],
MarginTradingTestsUtils.TradingConditionId,
volume: baseDirection == OrderDirection.Buy ? 1 : -1,
price: baseDirection == OrderDirection.Buy ? 2 : 1);
_ordersCache.Active.Add(order);
var sl = TestObjectsFactory.CreateNewOrder(OrderType.StopLoss, instrument,
Accounts[0], MarginTradingTestsUtils.TradingConditionId,
volume: baseDirection == OrderDirection.Buy ? -1 : 1,
price: baseDirection == OrderDirection.Buy ? 0.5M : 3,
parentOrderId: order.Id);
var tp = TestObjectsFactory.CreateNewOrder(OrderType.TakeProfit, instrument,
Accounts[0], MarginTradingTestsUtils.TradingConditionId,
volume: baseDirection == OrderDirection.Buy ? -1 : 1,
price: baseDirection == OrderDirection.Buy ? 3 : 0.5M,
parentOrderId: order.Id);
order.AddRelatedOrder(sl);
order.AddRelatedOrder(tp);
_ordersCache.Inactive.Add(sl);
_ordersCache.Inactive.Add(tp);
return(order);
}
var limitOrder = CreateOrder(OrderType.Limit);
var stopOrder = CreateOrder(OrderType.Stop);
if (isValid)
{
Assert.DoesNotThrow(() =>
_validateOrderService.ValidateOrderPriceChange(limitOrder, newPrice));
Assert.DoesNotThrow(() =>
_validateOrderService.ValidateOrderPriceChange(stopOrder, newPrice));
}
else
{
var ex1 = Assert.Throws <ValidateOrderException>(() =>
_validateOrderService.ValidateOrderPriceChange(limitOrder, newPrice));
Assert.That(ex1.RejectReason == OrderRejectReason.InvalidExpectedOpenPrice);
StringAssert.Contains("against related", ex1.Message);
var ex2 = Assert.Throws <ValidateOrderException>(() =>
_validateOrderService.ValidateOrderPriceChange(stopOrder, newPrice));
Assert.That(ex2.RejectReason == OrderRejectReason.InvalidExpectedOpenPrice);
StringAssert.Contains("against related", ex1.Message);
}
}
