public void SendMarketOrderAndEnsureItGetsFilled()
{
ManualResetEvent resetEvent = new ManualResetEvent(false);
bool executionArrived = false;
Execution receivedExecution = null;
MarketOrder marketOrder = OrderMessage.GenerateMarketOrder(new Security()
{
Symbol = "MSFT"
}, OrderSide.BUY, 1, "Tradier");
marketOrder.OrderTif = OrderTif.DAY;
_executionProvider.ExecutionArrived += delegate(Execution execution)
{
executionArrived = true;
receivedExecution = execution;
resetEvent.Set();
};
_executionProvider.SendMarketOrder(marketOrder);
resetEvent.WaitOne(10000);
Assert.True(executionArrived);
Assert.IsNotNull(receivedExecution);
Assert.Greater(receivedExecution.Fill.AverageExecutionPrice, 0);
Assert.Greater(receivedExecution.Fill.ExecutionPrice, 0);
Assert.AreEqual(receivedExecution.Fill.ExecutionSize, 1);
Assert.AreEqual(ExecutionType.Fill, receivedExecution.Fill.ExecutionType);
}
public void OverRideNewOrderEventTestCase()
{
_tradeHubStrategy.InitializeOrderExecutionServiceDisruptor(new IEventHandler <RabbitMqRequestMessage>[] { this });
_newOrderEventArrived = false;
_manualNewOrderEvent = new ManualResetEvent(false);
Thread.Sleep(5000);
_tradeHubStrategy.Run();
Thread.Sleep(1000);
Security security = new Security {
Symbol = "AAPL"
};
// Create new Market Order
MarketOrder marketOrder = OrderMessage.GenerateMarketOrder("1", security,
Common.Core.Constants.OrderSide.BUY, 100
, Common.Core.Constants.OrderExecutionProvider.Simulated);
// Send Market Order to OEE
_tradeHubStrategy.SendOrder(marketOrder);
_manualNewOrderEvent.WaitOne(30000, false);
Assert.AreEqual(true, _newOrderEventArrived, "New Order Event Arrived");
}
/// <summary>
/// Sends exit order to the Order Execution Service
/// </summary>
/// <param name="orderSide">Order side on which to open position</param>
/// <param name="symbol">Symbol on which to send order</param>
private void SendExitOrder(string orderSide, string symbol)
{
try
{
if (!orderSide.Equals(TradeHubConstants.OrderSide.NONE))
{
_exitOrderSent = true;
ConsoleWriter.WriteLine(ConsoleColor.Green, "Sending" + orderSide + " exit order.");
if (Logger.IsInfoEnabled)
{
Logger.Info("Sending" + orderSide + " exit order.", _type.FullName, "SendExitOrder");
}
// Get new unique ID
var id = (_orderId++).ToString("X");
Security security = new Security {
Symbol = symbol
};
// Create new Market Order
MarketOrder marketOrder = OrderMessage.GenerateMarketOrder(id, security, orderSide, 100, _orderExecutionProvider);
// Send Limit Order to OEE
SendOrder(marketOrder);
}
}
catch (Exception exception)
{
Logger.Error(exception, _type.FullName, "SendExitOrder");
}
}
/// <summary>
/// Sends a new market order to the server
/// </summary>
/// <param name="id">Unique ID to distinguish the order</param>
/// <param name="security">Contains symbol information</param>
/// <param name="orderSize">Trade size or lot</param>
/// <param name="orderSide">Side on which to send the order</param>
private void SendMarketOrder(string id, Security security, int orderSize, string orderSide = OrderSide.BUY)
{
// Create new Market Order
MarketOrder marketOrder = OrderMessage.GenerateMarketOrder(id, security, orderSide, orderSize, _orderExecutionProvider);
// Send market order
this.SendOrder(marketOrder);
}
public void CreateMarketOrder_IfSizeIsZero_ExceptionWillBeThrown()
{
MarketOrder marketOrder = OrderMessage.GenerateMarketOrder(new Security()
{
Symbol = "AAPL"
}, OrderSide.BUY, 0,
OrderExecutionProvider.SimulatedExchange);
}
public void SendOrderTest()
{
MarketOrder order = OrderMessage.GenerateMarketOrder(DateTime.Now.ToString("yyMMddHmsfff"), new Security()
{
Symbol = "TNA"
}, OrderSide.BUY, 3,
"WldxFix");
order.Exchange = "SMARTEDGEP";
bool logon = false;
ManualResetEvent resetEvent = new ManualResetEvent(false);
WldxFixOrderExecutionProvider provider = new WldxFixOrderExecutionProvider();
provider.LogonArrived += delegate(string dataProvider)
{
logon = true;
resetEvent.Set();
};
//start provider
provider.Start();
resetEvent.WaitOne(5000);
Assert.True(logon);
if (logon)
{
bool newArrived = false;
bool executionArrived = false;
provider.NewArrived += delegate(Order newOrder)
{
newArrived = true;
};
provider.ExecutionArrived += delegate(Execution execution)
{
executionArrived = true;
};
provider.SendMarketOrder(order);
resetEvent.Reset();
resetEvent.WaitOne(10000);
bool logout = false;
provider.LogoutArrived += delegate(string dataProvider)
{
logout = true;
resetEvent.Set();
};
resetEvent.Reset();
provider.Stop();
resetEvent.WaitOne(5000);
Assert.True(logout);
Assert.True(newArrived);
Assert.True(executionArrived);
}
}
/// <summary>
/// Sends a new Market Order Request to 'Order Execution Server'
/// </summary>
/// <param name="orderDetails">Contains market order information</param>
public void MarketOrderRequests(OrderDetails orderDetails)
{
// Get new Order ID
orderDetails.ID = _orderExecutionService.GetOrderId();
// Create Market Order object to be sent to 'Order Execution Service'
MarketOrder marketOrder = OrderMessage.GenerateMarketOrder(orderDetails.ID, orderDetails.Security, orderDetails.Side,
orderDetails.Quantity, orderDetails.Provider);
// Send Request to Server
_orderExecutionService.SendOrder(marketOrder);
}
public void CreateMarketOrder_IfAllParametersAreOk_VerifyMarketOrderIsCreated()
{
MarketOrder marketOrder = OrderMessage.GenerateMarketOrder(new Security()
{
Symbol = "AAPL"
}, OrderSide.BUY, 10,
OrderExecutionProvider.SimulatedExchange);
Assert.NotNull(marketOrder);
Assert.IsNotNullOrEmpty(marketOrder.OrderID);
Assert.AreEqual(marketOrder.OrderSide, OrderSide.BUY);
Assert.AreEqual(marketOrder.OrderSize, 10);
Assert.AreEqual(marketOrder.OrderExecutionProvider, OrderExecutionProvider.SimulatedExchange);
}
/// <summary>
/// Called when Order Execution is received
/// </summary>
/// <param name="execution">TradeHub Execution</param>
public override void OnExecutionArrived(Execution execution)
{
try
{
ConsoleWriter.WriteLine(ConsoleColor.Green, "Order Execution received : " + execution);
if (Logger.IsInfoEnabled)
{
Logger.Info("Order Execution received : " + execution, _type.FullName, "OnExecutionArrived");
}
// Resart trading algo on full fill
if (execution.Fill.LeavesQuantity.Equals(0))
{
if (_entryOrderSent)
{
_entryOrderSent = false;
// Get new unique ID
var id = (_orderId++).ToString("X");
Security security = new Security {
Symbol = execution.Order.Security.Symbol
};
var orderSide = execution.Fill.ExecutionSide.Equals(TradeHubConstants.OrderSide.BUY)
? TradeHubConstants.OrderSide.SELL
: TradeHubConstants.OrderSide.BUY;
// Create Market Order
MarketOrder marketOrder = OrderMessage.GenerateMarketOrder(id, security, orderSide, 10,
_orderExecutionProvider);
// Send Market Order
SendOrder(marketOrder);
}
}
}
catch (Exception exception)
{
Logger.Error(exception, _type.FullName, "OnExecutionArrived");
}
}
/// <summary>
/// Sends enrty order to the Order Execution Service
/// </summary>
/// <param name="orderSide">Order side on which to open position</param>
/// <param name="symbol">Symbol on which to send order</param>
private void SendBlackwoodEntryOrder(string orderSide, string symbol)
{
try
{
if (!orderSide.Equals(TradeHubConstants.OrderSide.NONE))
{
_entryOrderSent = true;
ConsoleWriter.WriteLine(ConsoleColor.Green, "Sending" + orderSide + " entry order.");
if (Logger.IsInfoEnabled)
{
Logger.Info("Sending" + orderSide + " entry order.", _type.FullName, "SendEntryOrder");
}
// Get new unique ID
var id = (_orderId++).ToString("X");
Security security = new Security {
Symbol = symbol
};
// Create new Limit Order
MarketOrder marketOrder = OrderMessage.GenerateMarketOrder(id, security, TradeHubConstants.OrderSide.SHORT, 100, _orderExecutionProvider);
// Set OPG Venue
marketOrder.Exchange = "SDOT";
// Set Order TIME_OUT
marketOrder.OrderTif = TradeHubConstants.OrderTif.DAY;
// Send Market Order to OEE
SendOrder(marketOrder);
}
}
catch (Exception exception)
{
Logger.Error(exception, _type.FullName, "SendEntryOrder");
}
}
public void MarketOrderTestCase()
{
MarketOrder order = OrderMessage.GenerateMarketOrder(DateTime.Now.ToString("yyMMddHmsfff"),
new Security()
{
Symbol = "EUR/USD"
}, OrderSide.BUY, 1000,
"Fxcm");
order.OrderCurrency = "EUR";
order.OrderTif = "GTC";
bool logon = false;
ManualResetEvent resetEvent = new ManualResetEvent(false);
_provider.LogonArrived += delegate(string dataProvider)
{
logon = true;
resetEvent.Set();
};
//start provider
_provider.Start();
resetEvent.WaitOne(5000);
Assert.True(logon, "Logon Arrived");
if (logon)
{
bool newArrived = false;
bool executionArrived = false;
_provider.NewArrived += delegate(Order newOrder)
{
newArrived = true;
};
_provider.ExecutionArrived += delegate(Execution execution)
{
executionArrived = true;
};
_provider.SendMarketOrder(order);
resetEvent.Reset();
resetEvent.WaitOne(10000);
bool logout = false;
_provider.LogoutArrived += delegate(string dataProvider)
{
logout = true;
resetEvent.Set();
};
resetEvent.Reset();
_provider.Stop();
resetEvent.WaitOne(5000);
Assert.True(logout, "Logout Arrived");
Assert.True(newArrived, "New Arrived");
Assert.True(executionArrived, "Execution Arrived");
}
}
public void MarketOrderCruld()
{
var ordersaved = new ManualResetEvent(false);
bool saved = false;
string id = DateTime.Now.ToString();
MarketOrder marketOrder = OrderMessage.GenerateMarketOrder(id,
new Security()
{
Isin = "123", Symbol = "AAPL"
}, OrderSide.SELL, 50, OrderExecutionProvider.Blackwood);
//adding order fills
Fill fill = new Fill(new Security()
{
Isin = "123", Symbol = "AAPL"
}, "BlackWood", id);
fill.ExecutionPrice = 100;
fill.CummalativeQuantity = 100;
fill.LeavesQuantity = 100;
fill.ExecutionSize = 100;
fill.ExecutionId = "asdfgfcx";
fill.OrderId = id;
fill.ExecutionType = ExecutionType.Fill;
List <Fill> fills = new List <Fill>();
fills.Add(fill);
Fill fill1 = new Fill(new Security()
{
Isin = "123", Symbol = "AAPL"
}, "BlackWood", id);
fill1.ExecutionPrice = 100;
fill1.CummalativeQuantity = 100;
fill1.LeavesQuantity = 100;
fill1.ExecutionSize = 100;
fill1.ExecutionId = "asdf";
fill1.OrderId = id;
fill1.ExecutionType = ExecutionType.Partial;
fills.Add(fill1);
marketOrder.Fills = fills;
//add market order to database
_orderRespository.AddUpdate(marketOrder);
//get the same order
MarketOrder getMarketOrder = _orderRespository.FindBy(id) as MarketOrder;
if (getMarketOrder.OrderID.Equals(id) && getMarketOrder.OrderSize == 50 && getMarketOrder.Fills.Count == 2)
{
saved = true;
ordersaved.Set();
}
ordersaved.WaitOne(30000);
//delete the order
_orderRespository.Delete(getMarketOrder);
//get ther order again to verify its deleted or not
getMarketOrder = _orderRespository.FindBy(id) as MarketOrder;
Assert.AreEqual(true, saved, "MarketOrderNotSaved");
Assert.IsNull(getMarketOrder, "Not deleted");
}