public void OrderIsNotPlacedWhenOrderIsLowerThanLotSize()
{
//Initializes the transaction handler
var transactionHandler = new BrokerageTransactionHandler();
transactionHandler.Initialize(_algorithm, new BacktestingBrokerage(_algorithm), new BacktestingResultHandler());
// Creates the order
var security = _algorithm.Securities[Ticker];
var orderRequest = new SubmitOrderRequest(OrderType.Market, security.Type, security.Symbol, 600, 0, 0, DateTime.Now, "");
// Mock the the order processor
var orderProcessorMock = new Mock <IOrderProcessor>();
orderProcessorMock.Setup(m => m.GetOrderTicket(It.IsAny <int>())).Returns(new OrderTicket(_algorithm.Transactions, orderRequest));
_algorithm.Transactions.SetOrderProcessor(orderProcessorMock.Object);
// Act
var orderTicket = transactionHandler.Process(orderRequest);
Assert.IsTrue(orderTicket.Status == OrderStatus.New);
transactionHandler.HandleOrderRequest(orderRequest);
// 600 after round off becomes 0 -> order is not placed
Assert.IsTrue(orderRequest.Response.IsProcessed);
Assert.IsTrue(orderRequest.Response.IsError);
Assert.IsTrue(orderTicket.Status == OrderStatus.Invalid);
}
public void OrderQuantityIsCeiledToNearestMultipleOfLotSizeWhenShortOrderIsRounded()
{
//Initializes the transaction handler
var transactionHandler = new BrokerageTransactionHandler();
transactionHandler.Initialize(_algorithm, new BacktestingBrokerage(_algorithm), new BacktestingResultHandler());
// Creates the order
var security = _algorithm.Securities[Ticker];
var orderRequest = new SubmitOrderRequest(OrderType.Market, security.Type, security.Symbol, -1600, 0, 0, DateTime.Now, "");
// Mock the the order processor
var orderProcessorMock = new Mock <IOrderProcessor>();
orderProcessorMock.Setup(m => m.GetOrderTicket(It.IsAny <int>())).Returns(new OrderTicket(_algorithm.Transactions, orderRequest));
_algorithm.Transactions.SetOrderProcessor(orderProcessorMock.Object);
// Act
var orderTicket = transactionHandler.Process(orderRequest);
Assert.IsTrue(orderTicket.Status == OrderStatus.New);
transactionHandler.HandleOrderRequest(orderRequest);
// Assert
Assert.IsTrue(orderRequest.Response.IsProcessed);
Assert.IsTrue(orderRequest.Response.IsSuccess);
Assert.IsTrue(orderTicket.Status == OrderStatus.Submitted);
// -1600 after round off becomes -1000
Assert.AreEqual(-1000, orderTicket.Quantity);
}
public void AddOrderWaitsForOrderToBeProcessed()
{
var algorithm = new QCAlgorithm();
algorithm.SubscriptionManager.SetDataManager(new DataManagerStub(algorithm));
var security = algorithm.AddSecurity(SecurityType.Equity, "SPY");
security.SetMarketPrice(new Tick {
Value = 150
});
algorithm.SetFinishedWarmingUp();
var transactionHandler = new BrokerageTransactionHandler();
transactionHandler.Initialize(algorithm, new BacktestingBrokerage(algorithm), new BacktestingResultHandler());
algorithm.Transactions.SetOrderProcessor(transactionHandler);
Task.Run(() => transactionHandler.Run());
var ticket = algorithm.LimitOrder(security.Symbol, 1, 100);
var openOrders = algorithm.Transactions.GetOpenOrders();
transactionHandler.Exit();
Assert.AreEqual(1, openOrders.Count);
Assert.IsTrue(ticket.HasOrder);
}
public void StopMarketOrderPriceIsRounded()
{
//Initializes the transaction handler
var transactionHandler = new BrokerageTransactionHandler();
transactionHandler.Initialize(_algorithm, new BacktestingBrokerage(_algorithm), new BacktestingResultHandler());
// Creates the order
var security = _algorithm.Securities[Ticker];
var price = 1.12129m;
security.SetMarketPrice(new Tick(DateTime.Now, security.Symbol, price, price, price));
var orderRequest = new SubmitOrderRequest(OrderType.StopMarket, security.Type, security.Symbol, 1600, 1.12131212m, 1.12131212m, DateTime.Now, "");
// Mock the the order processor
var orderProcessorMock = new Mock <IOrderProcessor>();
orderProcessorMock.Setup(m => m.GetOrderTicket(It.IsAny <int>())).Returns(new OrderTicket(_algorithm.Transactions, orderRequest));
_algorithm.Transactions.SetOrderProcessor(orderProcessorMock.Object);
// Act
var orderTicket = transactionHandler.Process(orderRequest);
Assert.IsTrue(orderTicket.Status == OrderStatus.New);
transactionHandler.HandleOrderRequest(orderRequest);
// Assert
Assert.IsTrue(orderRequest.Response.IsProcessed);
Assert.IsTrue(orderRequest.Response.IsSuccess);
Assert.IsTrue(orderTicket.Status == OrderStatus.Submitted);
// 1600 after round off becomes 1000
Assert.AreEqual(1000, orderTicket.Quantity);
// 1.12131212 after round becomes 1.12131
Assert.AreEqual(1.12131m, orderTicket.Get(OrderField.StopPrice));
}
public void UpdateOrderRequestShouldFailForInvalidOrderId()
{
// Initializes the transaction handler
var transactionHandler = new BrokerageTransactionHandler();
transactionHandler.Initialize(_algorithm, new BacktestingBrokerage(_algorithm), new BacktestingResultHandler());
var updateRequest = new UpdateOrderRequest(DateTime.Now, -10, new UpdateOrderFields());
transactionHandler.Process(updateRequest);
Assert.AreEqual(updateRequest.Status, OrderRequestStatus.Error);
Assert.IsTrue(updateRequest.Response.IsError);
Assert.IsTrue(_algorithm.OrderEvents.IsNullOrEmpty());
}
public void GetOpenOrdersWorksForCancelPendingCanceledStatus()
{
// Initializes the transaction handler
var transactionHandler = new BrokerageTransactionHandler();
transactionHandler.Initialize(_algorithm, new BacktestingBrokerage(_algorithm), new BacktestingResultHandler());
// Creates a limit order
var security = _algorithm.Securities[Ticker];
var price = 1.12m;
security.SetMarketPrice(new Tick(DateTime.Now, security.Symbol, price, price, price));
var orderRequest = new SubmitOrderRequest(OrderType.Limit, security.Type, security.Symbol, 1000, 0, 1.11m, DateTime.Now, "");
// Mock the the order processor
var orderProcessorMock = new Mock <IOrderProcessor>();
orderProcessorMock.Setup(m => m.GetOrderTicket(It.IsAny <int>())).Returns(new OrderTicket(_algorithm.Transactions, orderRequest));
_algorithm.Transactions.SetOrderProcessor(orderProcessorMock.Object);
Assert.AreEqual(transactionHandler.GetOpenOrders().Count, 0);
// Submit and process a limit order
var orderTicket = transactionHandler.Process(orderRequest);
transactionHandler.HandleOrderRequest(orderRequest);
Assert.IsTrue(orderTicket.Status == OrderStatus.Submitted);
var openOrders = transactionHandler.GetOpenOrders();
Assert.AreEqual(openOrders.Count, 1);
Assert.AreEqual(openOrders[0].Id, orderTicket.OrderId);
// Cancel the order
var cancelRequest = new CancelOrderRequest(DateTime.Now, orderTicket.OrderId, "");
transactionHandler.Process(cancelRequest);
Assert.IsTrue(orderTicket.Status == OrderStatus.CancelPending);
openOrders = transactionHandler.GetOpenOrders();
Assert.AreEqual(openOrders.Count, 1);
Assert.AreEqual(openOrders[0].Id, orderTicket.OrderId);
transactionHandler.HandleOrderRequest(cancelRequest);
Assert.IsTrue(orderTicket.Status == OrderStatus.Canceled);
Assert.AreEqual(transactionHandler.GetOpenOrders().Count, 0);
}
public void UpdateOrderRequestShouldFailForFilledOrder()
{
// Initializes the transaction handler
var transactionHandler = new BrokerageTransactionHandler();
var broker = new BacktestingBrokerage(_algorithm);
transactionHandler.Initialize(_algorithm, broker, new BacktestingResultHandler());
// Creates a limit order
var security = _algorithm.Securities[Ticker];
var price = 1.12m;
security.SetMarketPrice(new Tick(DateTime.Now, security.Symbol, price, price, price));
var orderRequest = new SubmitOrderRequest(OrderType.Market, security.Type, security.Symbol, 1000, 0, 1.11m, DateTime.Now, "");
// Mock the the order processor
var orderProcessorMock = new Mock <IOrderProcessor>();
orderProcessorMock.Setup(m => m.GetOrderTicket(It.IsAny <int>())).Returns(new OrderTicket(_algorithm.Transactions, orderRequest));
_algorithm.Transactions.SetOrderProcessor(orderProcessorMock.Object);
// Submit and process a limit order
var orderTicket = transactionHandler.Process(orderRequest);
transactionHandler.HandleOrderRequest(orderRequest);
Assert.IsTrue(orderRequest.Response.IsProcessed);
Assert.IsTrue(orderRequest.Response.IsSuccess);
Assert.AreEqual(orderTicket.Status, OrderStatus.Submitted);
broker.Scan();
Assert.AreEqual(orderTicket.Status, OrderStatus.Filled);
var updateRequest = new UpdateOrderRequest(DateTime.Now, orderTicket.OrderId, new UpdateOrderFields());
transactionHandler.Process(updateRequest);
Assert.AreEqual(updateRequest.Status, OrderRequestStatus.Error);
Assert.IsTrue(updateRequest.Response.IsError);
Assert.AreEqual(updateRequest.Response.ErrorCode, OrderResponseErrorCode.InvalidOrderStatus);
Assert.AreEqual(orderTicket.Status, OrderStatus.Filled);
Assert.AreEqual(_algorithm.OrderEvents.Count, 2);
Assert.AreEqual(_algorithm.OrderEvents.Count(orderEvent => orderEvent.Status == OrderStatus.Submitted), 1);
Assert.AreEqual(_algorithm.OrderEvents.Count(orderEvent => orderEvent.Status == OrderStatus.Filled), 1);
}
public void InvalidUpdateOrderRequestShouldNotInvalidateOrder()
{
// Initializes the transaction handler
var transactionHandler = new BrokerageTransactionHandler();
transactionHandler.Initialize(_algorithm, new BacktestingBrokerage(_algorithm), new BacktestingResultHandler());
_algorithm.SetBrokerageModel(new TestBrokerageModel());
// Creates a limit order
var security = _algorithm.Securities[Ticker];
var price = 1.12m;
security.SetMarketPrice(new Tick(DateTime.Now, security.Symbol, price, price, price));
var orderRequest = new SubmitOrderRequest(OrderType.Limit, security.Type, security.Symbol, 1000, 0, 1.11m, DateTime.Now, "");
// Mock the the order processor
var orderProcessorMock = new Mock <IOrderProcessor>();
orderProcessorMock.Setup(m => m.GetOrderTicket(It.IsAny <int>())).Returns(new OrderTicket(_algorithm.Transactions, orderRequest));
_algorithm.Transactions.SetOrderProcessor(orderProcessorMock.Object);
// Submit and process a limit order
var orderTicket = transactionHandler.Process(orderRequest);
transactionHandler.HandleOrderRequest(orderRequest);
Assert.IsTrue(orderRequest.Response.IsProcessed);
Assert.IsTrue(orderRequest.Response.IsSuccess);
Assert.AreEqual(orderTicket.Status, OrderStatus.Submitted);
var updateRequest = new UpdateOrderRequest(DateTime.Now, orderTicket.OrderId, new UpdateOrderFields());
transactionHandler.Process(updateRequest);
Assert.AreEqual(updateRequest.Status, OrderRequestStatus.Processing);
Assert.IsTrue(updateRequest.Response.IsSuccess);
Assert.AreEqual(orderTicket.Status, OrderStatus.Submitted);
transactionHandler.HandleOrderRequest(updateRequest);
Assert.IsFalse(updateRequest.Response.ErrorMessage.IsNullOrEmpty());
Assert.IsTrue(updateRequest.Response.IsError);
Assert.AreEqual(orderTicket.Status, OrderStatus.Submitted);
Assert.AreEqual(_algorithm.OrderEvents.Count, 2);
Assert.AreEqual(_algorithm.OrderEvents.Count(orderEvent => orderEvent.Message.Contains("unable to update order")), 1);
Assert.IsTrue(_algorithm.OrderEvents.TrueForAll(orderEvent => orderEvent.Status == OrderStatus.Submitted));
}
/// <summary>
/// Get an instance of the transaction handler set by the task.
/// </summary>
/// <param name="algorithm">Algorithm instance</param>
/// <param name="job">Algorithm job packet</param>
/// <param name="brokerage">Brokerage instance to avoid access token duplication</param>
/// <param name="results">Results array for sending order events.</param>
/// <returns>Class matching ITransactionHandler interface</returns>
private static ITransactionHandler GetTransactionHandler(IAlgorithm algorithm, IBrokerage brokerage, IResultHandler results, AlgorithmNodePacket job)
{
ITransactionHandler th;
switch (job.TransactionEndpoint)
{
case TransactionHandlerEndpoint.Brokerage:
th = new BrokerageTransactionHandler(algorithm, brokerage);
Log.Trace("Engine.GetTransactionHandler(): Selected Brokerage Transaction Models.");
break;
//Operation from local files:
default:
th = new BacktestingTransactionHandler(algorithm, brokerage as BacktestingBrokerage);
Log.Trace("Engine.GetTransactionHandler(): Selected Backtesting Transaction Models.");
break;
}
return(th);
}
public void SetHoldingsTakesIntoAccountPendingMarketOrders()
{
var algorithm = new QCAlgorithm();
algorithm.SubscriptionManager.SetDataManager(new DataManager());
var security = algorithm.AddEquity("SPY");
security.Exchange = new SecurityExchange(SecurityExchangeHours.AlwaysOpen(TimeZones.NewYork));
security.SetMarketPrice(new Tick {
Value = 270m
});
algorithm.SetFinishedWarmingUp();
var brokerage = new NullBrokerage();
var transactionHandler = new BrokerageTransactionHandler();
transactionHandler.Initialize(algorithm, brokerage, new LiveTradingResultHandler());
new Thread(transactionHandler.Run)
{
IsBackground = true
}.Start();
Thread.Sleep(2000);
algorithm.Transactions.SetOrderProcessor(transactionHandler);
var symbol = security.Symbol;
// this order should timeout (no fills received within 5 seconds)
algorithm.SetHoldings(symbol, 1m);
Thread.Sleep(2000);
var openOrders = algorithm.Transactions.GetOpenOrders();
Assert.AreEqual(1, openOrders.Count);
// this order should never be submitted because of the pending order
algorithm.SetHoldings(symbol, 1m);
Thread.Sleep(2000);
openOrders = algorithm.Transactions.GetOpenOrders();
Assert.AreEqual(1, openOrders.Count);
transactionHandler.Exit();
}
public void RoundOff_LessThanLotSize_Orders()
{
// Initializes the algorithm
var algo = GetAlgorithm();
// Sets the Security
var security = algo.AddSecurity(SecurityType.Forex, "EURUSD");
//Initializes the transaction handler
var transactionHandler = new BrokerageTransactionHandler();
transactionHandler.Initialize(algo, new BacktestingBrokerage(algo), new BacktestingResultHandler());
// Creates the order
var orderRequest = new SubmitOrderRequest(OrderType.Market, security.Type, security.Symbol, 600, 0, 0, DateTime.Now, "");
var order = Order.CreateOrder(orderRequest);
var actual = transactionHandler.RoundOffOrder(order, security);
// 600 after round off becomes 0
Assert.AreEqual(0, actual);
}
public void RoundOff_LessThanLotSize_Fractional_Orders()
{
var algo = new QCAlgorithm();
algo.SetBrokerageModel(BrokerageName.Default);
algo.SetCash(100000);
// Sets the Security
var security = algo.AddSecurity(SecurityType.Forex, "BTCUSD", Resolution.Hour, Market.Bitfinex, false, 3.3m, true);
//Initializes the transaction handler
var transactionHandler = new BrokerageTransactionHandler();
transactionHandler.Initialize(algo, new BacktestingBrokerage(algo), new BacktestingResultHandler());
// Creates the order
var orderRequest = new SubmitOrderRequest(OrderType.Market, security.Type, security.Symbol, 0.009m, 0, 0, DateTime.Now, "");
var order = Order.CreateOrder(orderRequest);
var actual = transactionHandler.RoundOffOrder(order, security);
Assert.AreEqual(0, actual);
}
public void RoundOff_Short_Fractional_Orders()
{
var algo = new QCAlgorithm();
algo.SubscriptionManager.SetDataManager(new DataManagerStub(algo));
algo.SetBrokerageModel(BrokerageName.Default);
algo.SetCash(100000);
// Sets the Security
var security = algo.AddSecurity(SecurityType.Crypto, "BTCUSD", Resolution.Hour, Market.GDAX, false, 3.3m, true);
//Initializes the transaction handler
var transactionHandler = new BrokerageTransactionHandler();
transactionHandler.Initialize(algo, new BacktestingBrokerage(algo), new BacktestingResultHandler());
// Creates the order
var orderRequest = new SubmitOrderRequest(OrderType.Market, security.Type, security.Symbol, -123.123456789m, 0, 0, DateTime.Now, "");
var order = Order.CreateOrder(orderRequest);
var actual = transactionHandler.RoundOffOrder(order, security);
Assert.AreEqual(-123.12345678m, actual);
}
public void WorksProperlyWithPyObjects()
{
var algorithm = new QCAlgorithm();
algorithm.SubscriptionManager.SetDataManager(new DataManagerStub(algorithm));
var spySecurity = algorithm.AddEquity("SPY");
var ibmSecurity = algorithm.AddEquity("IBM");
algorithm.SetTimeZone(TimeZones.NewYork);
spySecurity.SetMarketPrice(new Tick {
Value = 270m
});
ibmSecurity.SetMarketPrice(new Tick {
Value = 270m
});
algorithm.SetFinishedWarmingUp();
var transactionHandler = new BrokerageTransactionHandler();
transactionHandler.Initialize(algorithm, new BacktestingBrokerage(algorithm), _resultHandler);
algorithm.Transactions.SetOrderProcessor(transactionHandler);
var spy = spySecurity.Symbol;
var ibm = ibmSecurity.Symbol;
// this order should timeout (no fills received within 5 seconds)
algorithm.SetHoldings(spy, 0.5m);
algorithm.SetHoldings(ibm, 0.5m);
Func <Order, bool> basicOrderFilter = x => true;
Func <OrderTicket, bool> basicOrderTicketFilter = x => true;
using (Py.GIL())
{
var orders = algorithm.Transactions.GetOrders(basicOrderFilter.ToPython());
var orderTickets = algorithm.Transactions.GetOrderTickets(basicOrderTicketFilter.ToPython());
var openOrders = algorithm.Transactions.GetOpenOrders(basicOrderFilter.ToPython());
var openOrderTickets = algorithm.Transactions.GetOpenOrderTickets(basicOrderTicketFilter.ToPython());
var openOrdersRemaining = algorithm.Transactions.GetOpenOrdersRemainingQuantity(basicOrderTicketFilter.ToPython());
Assert.AreEqual(2, orders.Count());
Assert.AreEqual(2, orderTickets.Count());
Assert.AreEqual(2, openOrders.Count);
Assert.AreEqual(2, openOrderTickets.Count());
Assert.AreEqual(368, openOrdersRemaining);
var ibmOpenOrders = algorithm.Transactions.GetOpenOrders(ibm.ToPython()).Count;
var ibmOpenOrderTickets = algorithm.Transactions.GetOpenOrderTickets(ibm.ToPython()).Count();
var ibmOpenOrdersRemainingQuantity = algorithm.Transactions.GetOpenOrdersRemainingQuantity(ibm.ToPython());
var spyOpenOrders = algorithm.Transactions.GetOpenOrders(spy.ToPython()).Count;
var spyOpenOrderTickets = algorithm.Transactions.GetOpenOrderTickets(spy.ToPython()).Count();
var spyOpenOrdersRemainingQuantity = algorithm.Transactions.GetOpenOrdersRemainingQuantity(spy.ToPython());
Assert.AreEqual(1, ibmOpenOrders);
Assert.AreEqual(1, ibmOpenOrderTickets);
Assert.AreEqual(184, ibmOpenOrdersRemainingQuantity);
Assert.AreEqual(1, spyOpenOrders);
Assert.AreEqual(1, spyOpenOrderTickets);
Assert.AreEqual(184, spyOpenOrdersRemainingQuantity);
var defaultOrders = algorithm.Transactions.GetOrders();
var defaultOrderTickets = algorithm.Transactions.GetOrderTickets();
var defaultOpenOrders = algorithm.Transactions.GetOpenOrders();
var defaultOpenOrderTickets = algorithm.Transactions.GetOpenOrderTickets();
var defaultOpenOrdersRemaining = algorithm.Transactions.GetOpenOrdersRemainingQuantity();
Assert.AreEqual(2, defaultOrders.Count());
Assert.AreEqual(2, defaultOrderTickets.Count());
Assert.AreEqual(2, defaultOpenOrders.Count);
Assert.AreEqual(2, defaultOpenOrderTickets.Count());
Assert.AreEqual(368, defaultOpenOrdersRemaining);
}
transactionHandler.Exit();
}
