private void CrashAndInitializeAgainWithSnapshot()
{
//crash
InputDisruptorPublisher.Shutdown();
OutputDisruptor.ShutDown();
_exchange.StopTimer();
inputEventStore.ShutDown();
outputEventStore.ShutDown();
inputJournaler.ShutDown();
outputJournaler.ShutDown();
ContextRegistry.Clear();
//initialize
inputEventStore = new RavenNEventStore(Constants.INPUT_EVENT_STORE);
outputEventStore = new RavenNEventStore(Constants.OUTPUT_EVENT_STORE);
inputJournaler = new Journaler(inputEventStore);
outputJournaler = new Journaler(outputEventStore);
_applicationContext = ContextRegistry.GetContext();
IList <CurrencyPair> currencyPairs = new List <CurrencyPair>();
currencyPairs.Add(new CurrencyPair("BTCUSD", "USD", "BTC"));
currencyPairs.Add(new CurrencyPair("BTCLTC", "LTC", "BTC"));
currencyPairs.Add(new CurrencyPair("BTCDOGE", "DOGE", "BTC"));
_exchange = new Exchange(currencyPairs, outputEventStore.LoadLastSnapshot());
InputDisruptorPublisher.InitializeDisruptor(new IEventHandler <InputPayload>[] { _exchange, inputJournaler });
OutputDisruptor.InitializeDisruptor(new IEventHandler <byte[]>[] { outputJournaler });
_exchange.InitializeExchangeAfterSnaphot();
LimitOrderBookReplayService service = new LimitOrderBookReplayService();
service.ReplayOrderBooks(_exchange, outputJournaler);
_exchange.EnableSnaphots(5000);
ManualResetEvent resetEvent = new ManualResetEvent(false);
resetEvent.WaitOne(20000);
}
public new void TearDown()
{
BeforeTearDown();
_databaseUtility.Create();
OutputDisruptor.ShutDown();
AfterTearDown();
}
//protected override System.Web.Http.Dependencies.IDependencyResolver BuildWebApiDependencyResolver()
//{
// //get the 'default' resolver, populated from the 'main' config metadata
// var resolver = base.BuildWebApiDependencyResolver();
// //check if its castable to a SpringWebApiDependencyResolver
// var springResolver = resolver as SpringWebApiDependencyResolver;
// //return the fully-configured resolver
// return springResolver;
//}
/// <summary>
/// Method for initializaing the single threaded application parts
/// </summary>
private void InitiliazeApplication()
{
InputDisruptorPublisher.Shutdown();
OutputDisruptor.ShutDown();
IEventStore inputEventStore = new RavenNEventStore(Constants.INPUT_EVENT_STORE);
IEventStore outputEventStore = new RavenNEventStore(Constants.OUTPUT_EVENT_STORE);
Journaler inputJournaler = new Journaler(inputEventStore);
Journaler outputJournaler = new Journaler(outputEventStore);
ExchangeEssentialsList exchangeEssentialsList=outputEventStore.LoadLastSnapshot();
ICurrencyPairRepository currencyPairRepository = (ICurrencyPairRepository) ContextRegistry.GetContext()["CurrencyPairRepository"];
IList<CurrencyPair> tradeableCurrencyPairs = currencyPairRepository.GetTradeableCurrencyPairs();
Exchange exchange;
if (exchangeEssentialsList != null)
{
//means snapshot found so initialize the exchange
exchange = new Exchange(tradeableCurrencyPairs, exchangeEssentialsList);
InputDisruptorPublisher.InitializeDisruptor(new IEventHandler<InputPayload>[] {exchange, inputJournaler});
OutputDisruptor.InitializeDisruptor(new IEventHandler<byte[]>[] {outputJournaler});
exchange.InitializeExchangeAfterSnaphot();
LimitOrderBookReplayService service = new LimitOrderBookReplayService();
service.ReplayOrderBooks(exchange, outputJournaler);
exchange.EnableSnaphots(Constants.SnaphsortInterval);
}
else
{
//no snapshot found
exchange = new Exchange(tradeableCurrencyPairs);
InputDisruptorPublisher.InitializeDisruptor(new IEventHandler<InputPayload>[] { exchange, inputJournaler });
OutputDisruptor.InitializeDisruptor(new IEventHandler<byte[]>[] { outputJournaler });
// check if there are events to replay
LimitOrderBookReplayService service = new LimitOrderBookReplayService();
service.ReplayOrderBooks(exchange, outputJournaler);
exchange.EnableSnaphots(Constants.SnaphsortInterval);
}
}
public new void TearDown()
{
_databaseUtility.Create();
InputDisruptorPublisher.Shutdown();
OutputDisruptor.ShutDown();
inputEventStore.RemoveAllEvents();
outputEventStore.RemoveAllEvents();
}
/// <summary>
/// Handles the OrderBook's event in case the state of an Order changes
/// </summary>
/// <param name="order"> </param>
public void OnOrderChanged(Order order)
{
OutputDisruptor.Publish(order);
// Raising Event to be handled by OrderEventListener
OrderEvent.Raise(order);
Log.Debug("Order change received and published. Order: " + order.ToString());
}
public new void TearDown()
{
BeforeTearDown();
_databaseUtility.Create();
OutputDisruptor.ShutDown();
_eventStore.RemoveAllEvents();
AfterTearDown();
}
public void Setup()
{
// NOTE: Passing in NULL as RavenDB event store is no longer operational
//IEventStore eventStore = new RavenNEventStore(Constants.OUTPUT_EVENT_STORE);
Journaler journaler = new Journaler(null);
// Initialize the output Disruptor and assign the journaler as the event handler
OutputDisruptor.InitializeDisruptor(new IEventHandler <byte[]>[] { journaler });
}
public void TearDown()
{
InputDisruptorPublisher.Shutdown();
OutputDisruptor.ShutDown();
ContextRegistry.Clear();
_databaseUtility.Create();
inputEventStore.RemoveAllEvents();
outputEventStore.RemoveAllEvents();
}
public void TearDown()
{
_exchange.StopTimer();
_databaseUtility.Create();
InputDisruptorPublisher.Shutdown();
OutputDisruptor.ShutDown();
inputEventStore.RemoveAllEvents();
outputEventStore.RemoveAllEvents();
}
public void OnTrade(Trade trade)
{
if (_trades == null)
{
_trades = new TradeList(trade.CurrencyPair);
}
_trades.Add(trade);
OutputDisruptor.Publish(trade);
Log.Debug("Trade received: " + trade.ToString());
}
public void SetUp()
{
//initialize journaler
_eventStore = new RavenNEventStore(Constants.OUTPUT_EVENT_STORE);
Journaler journaler = new Journaler(_eventStore);
//assign journaler to disruptor as its consumer
OutputDisruptor.InitializeDisruptor(new IEventHandler <byte[]>[] { journaler });
_manualResetEvent = new ManualResetEvent(false);
}
public void PublishOrderToOutputDisruptor_IfOrderIsConvertedToByteArray_ItShouldBeReceivedAndCastedToOrder()
{
Order order = OrderFactory.CreateOrder("1234", "XBTUSD", "market", "buy", 5, 0,
new StubbedOrderIdGenerator());
//byte[] array = ObjectToByteArray(order);
OutputDisruptor.Publish(order);
_manualResetEvent.WaitOne(3000);
Assert.NotNull(_receviedOrder);
Assert.AreEqual(_receviedOrder, order);
}
public void VerifyTickerInfoCalculations_WhenANewTradeIsArrived_NewUpdatedTickerInfoShouldGetSaved()
{
Order buyOrder = OrderFactory.CreateOrder("123", "XBTUSD", "limit", "buy", 10, 100,
new StubbedOrderIdGenerator());
Order sellOrder = OrderFactory.CreateOrder("1234", "XBTUSD", "limit", "sell", 10, 100,
new StubbedOrderIdGenerator());
DateTime dateTime = DateTime.Now.AddSeconds(-1 * DateTime.Now.Second);
Trade trade5 = new Trade(new TradeId("1"), "XBTUSD", new Price(2), new Volume(10), dateTime.AddDays(-1),
buyOrder, sellOrder);
Trade trade6 = new Trade(new TradeId("2"), "XBTUSD", new Price(3), new Volume(5), dateTime.AddDays(-1).AddMinutes(1),
buyOrder, sellOrder);
Trade trade1 = new Trade(new TradeId("3"), "XBTUSD", new Price(10), new Volume(10), dateTime.AddSeconds(10),
buyOrder, sellOrder);
Trade trade2 = new Trade(new TradeId("4"), "XBTUSD", new Price(15), new Volume(15), dateTime.AddSeconds(15),
buyOrder, sellOrder);
Trade trade3 = new Trade(new TradeId("5"), "XBTUSD", new Price(20), new Volume(5), dateTime.AddSeconds(20),
buyOrder, sellOrder);
Trade trade4 = new Trade(new TradeId("6"), "XBTUSD", new Price(5), new Volume(10), dateTime.AddSeconds(40),
buyOrder, sellOrder);
OutputDisruptor.Publish(trade5);
_manualResetEvent.WaitOne(4000);
OutputDisruptor.Publish(trade6);
_manualResetEvent.WaitOne(4000);
OutputDisruptor.Publish(trade1);
_manualResetEvent.WaitOne(4000);
OutputDisruptor.Publish(trade2);
_manualResetEvent.WaitOne(4000);
OutputDisruptor.Publish(trade3);
_manualResetEvent.WaitOne(4000);
OutputDisruptor.Publish(trade4);
_manualResetEvent.WaitOne(10000);
TickerInfoReadModel model = _tickerInfoRepository.GetTickerInfoByCurrencyPair("XBTUSD");
Assert.NotNull(model);
Assert.AreEqual(model.CurrencyPair, "XBTUSD");
Assert.AreEqual(model.TradePrice, 5);
Assert.AreEqual(model.TradeVolume, 10);
Assert.AreEqual(model.OpeningPrice, 10);
Assert.AreEqual(model.TodaysHigh, 20);
Assert.AreEqual(model.Last24HoursHigh, 20);
Assert.AreEqual(model.TodaysLow, 5);
Assert.AreEqual(model.Last24HoursLow, 3);
Assert.AreEqual(model.TodaysVolume, 40);
Assert.AreEqual(model.Last24HourVolume, 45);
Assert.AreEqual(model.TodaysTrades, 4);
Assert.AreEqual(model.Last24HourTrades, 5);
Assert.AreEqual(model.TodaysVolumeWeight, 11.875m);
Assert.AreEqual(model.Last24HourVolumeWeight, 10.88889m);
}
public void PublishDepthToDisruptor_IfDepthIsConvertedToByteArray_ItShouldBeReceivedAndCastedToDepth()
{
Depth depth = new Depth("XBTUSD", 3);
depth.AddOrder(new Price(490), new Volume(100), OrderSide.Buy);
depth.AddOrder(new Price(491), new Volume(100), OrderSide.Buy);
depth.AddOrder(new Price(492), new Volume(200), OrderSide.Buy);
//byte[] array = ObjectToByteArray(depth);
OutputDisruptor.Publish(depth);
_manualResetEvent.WaitOne(3000);
Assert.NotNull(_receivedDepth);
Assert.AreEqual(_receivedDepth.BidLevels[0].Price.Value, 492);
Assert.AreEqual(_receivedDepth.BidLevels[1].Price.Value, 491);
Assert.AreEqual(_receivedDepth.BidLevels[2].Price.Value, 490);
}
public void PublishOrderToOutputDisruptor_IfOrderListenerIsInitiated_ItShouldSaveInDatabase()
{
Order order = OrderFactory.CreateOrder("1234", "XBTUSD", "limit", "buy", 5, 10,
new StubbedOrderIdGenerator());
OutputDisruptor.Publish(order);
_manualResetEvent.WaitOne(5000);
OrderReadModel receivedOrder = _orderRepository.GetOrderById(order.OrderId.Id.ToString());
Assert.NotNull(receivedOrder);
Assert.AreEqual(receivedOrder.OrderId, order.OrderId.Id.ToString());
Assert.AreEqual(receivedOrder.Side, order.OrderSide.ToString());
Assert.AreEqual(receivedOrder.Type, order.OrderType.ToString());
Assert.AreEqual(receivedOrder.Price, order.Price.Value);
Assert.AreEqual(receivedOrder.CurrencyPair, order.CurrencyPair);
}
public void PublishOrderBookToDisruptor_IfOrderBookIsConvertedToByteArray_ItShouldBeReceivedAndCastedToOrderBook()
{
LimitOrderBook limitOrderBook = new LimitOrderBook("XBTUSD");
Order buyOrder = OrderFactory.CreateOrder("1234", "XBTUSD", "limit", "buy", 5, 10,
new StubbedOrderIdGenerator());
Order sellOrder = OrderFactory.CreateOrder("1234", "XBTUSD", "limit", "sell", 5, 11,
new StubbedOrderIdGenerator());
limitOrderBook.PlaceOrder(buyOrder);
limitOrderBook.PlaceOrder(sellOrder);
//byte[] array = ObjectToByteArray(limitOrderBook);
OutputDisruptor.Publish(limitOrderBook);
_manualResetEvent.WaitOne(3000);
Assert.NotNull(_receivedLimitOrderBook);
Assert.AreEqual(_receivedLimitOrderBook.AskCount, 1);
Assert.AreEqual(_receivedLimitOrderBook.BidCount, 1);
}
public void PublishTradeToOutputDisruptor_IfTradeIsConvertedToByteArray_ItShouldBeReceivedAndCastedToTrade()
{
Order buyOrder = OrderFactory.CreateOrder("1234", "XBTUSD", "market", "buy", 5, 0,
new StubbedOrderIdGenerator());
Order sellOrder = OrderFactory.CreateOrder("1234", "XBTUSD", "market", "sell", 5, 0,
new StubbedOrderIdGenerator());
//Trade trade=new Trade("XBTUSD",new Price(100),new Volume(10),DateTime.Now,buyOrder,sellOrder);
Trade trade = TradeFactory.GenerateTrade("XBTUSD", new Price(100), new Volume(10), buyOrder, sellOrder);
//byte[] array = ObjectToByteArray(trade);
OutputDisruptor.Publish(trade);
_manualResetEvent.WaitOne(3000);
Assert.NotNull(_receivedTrade);
Assert.AreEqual(_receivedTrade.TradeId.Id, trade.TradeId.Id);
Assert.AreEqual(_receivedTrade.BuyOrder, buyOrder);
Assert.AreEqual(_receivedTrade.SellOrder, sellOrder);
}
public void CheckBarFormation_WhenANewTradeIsArrived_NewUpdatedBarShouldGetSaved()
{
Order buyOrder = OrderFactory.CreateOrder("123", "XBTUSD", "limit", "buy", 10, 100,
new StubbedOrderIdGenerator());
Order sellOrder = OrderFactory.CreateOrder("1234", "XBTUSD", "limit", "sell", 10, 100,
new StubbedOrderIdGenerator());
DateTime dateTime = DateTime.Now.AddSeconds(-1 * DateTime.Now.Second);
Trade trade1 = new Trade(new TradeId("1"), "XBTUSD", new Price(10), new Volume(10), dateTime.AddSeconds(10), buyOrder, sellOrder);
Trade trade2 = new Trade(new TradeId("2"), "XBTUSD", new Price(15), new Volume(15), dateTime.AddSeconds(15), buyOrder, sellOrder);
Trade trade3 = new Trade(new TradeId("3"), "XBTUSD", new Price(20), new Volume(5), dateTime.AddSeconds(20), buyOrder, sellOrder);
Trade trade4 = new Trade(new TradeId("4"), "XBTUSD", new Price(5), new Volume(10), dateTime.AddSeconds(40), buyOrder, sellOrder);
Trade trade5 = new Trade(new TradeId("5"), "XBTUSD", new Price(2), new Volume(10), dateTime.AddMinutes(1), buyOrder, sellOrder);
Trade trade6 = new Trade(new TradeId("6"), "XBTUSD", new Price(10), new Volume(5), dateTime.AddMinutes(1.1), buyOrder, sellOrder);
OutputDisruptor.Publish(trade1);
OutputDisruptor.Publish(trade2);
OutputDisruptor.Publish(trade3);
OutputDisruptor.Publish(trade4);
OutputDisruptor.Publish(trade5);
OutputDisruptor.Publish(trade6);
_manualResetEvent.WaitOne(10000);
OhlcReadModel model = _ohlcRepository.GetOhlcByDateTime(dateTime.AddMinutes(1));
OhlcReadModel model2 = _ohlcRepository.GetOhlcByDateTime(dateTime.AddMinutes(2));
//bar 1 verification(will form from trade 1-4)
Assert.NotNull(model);
Assert.AreEqual(model.High, 20);
Assert.AreEqual(model.Open, 10);
Assert.AreEqual(model.Low, 5);
Assert.AreEqual(model.Close, 5);
Assert.AreEqual(model.Volume, 40);
Assert.AreEqual(model.TotalWeight, 475);
Assert.AreEqual(model.AveragePrice, 11.875);
//bar 2 verification(will form from trade 5-6)
Assert.NotNull(model2);
Assert.AreEqual(model2.High, 10);
Assert.AreEqual(model2.Open, 2);
Assert.AreEqual(model2.Low, 2);
Assert.AreEqual(model2.Close, 10);
Assert.AreEqual(model2.Volume, 15);
Assert.AreEqual(model2.TotalWeight, 70);
Assert.AreEqual(model2.AveragePrice, 4.66667);
}
public void PublishBboToDisruptor_IfBboIsConvertedToByteArray_ItShouldBeReceivedAndCastedToBbo()
{
DepthLevel askDepthLevel = new DepthLevel(new Price(491.32M));
bool addOrder1 = askDepthLevel.AddOrder(new Volume(2000));
bool addOrder2 = askDepthLevel.AddOrder(new Volume(1000));
DepthLevel bidDepthLevel = new DepthLevel(new Price(491.32M));
addOrder1 = bidDepthLevel.AddOrder(new Volume(2000));
addOrder2 = bidDepthLevel.AddOrder(new Volume(1000));
bool addOrder3 = bidDepthLevel.AddOrder(new Volume(3000));
BBO bbo = new BBO("BTCUSD", bidDepthLevel, askDepthLevel);
//byte[] array = ObjectToByteArray(bbo);
OutputDisruptor.Publish(bbo);
_manualResetEvent.WaitOne(3000);
Assert.NotNull(_receivedBbo);
Assert.AreEqual(_receivedBbo.BestAsk.OrderCount, 2);
Assert.AreEqual(_receivedBbo.BestBid.OrderCount, 3);
}
public new void SetUp()
{
BeforeSetup();
var connection = ConfigurationManager.ConnectionStrings["MySql"].ToString();
_databaseUtility = new DatabaseUtility(connection);
_databaseUtility.Create();
_databaseUtility.Populate();
//initialize journaler
_eventStore = new RavenNEventStore(Constants.OUTPUT_EVENT_STORE);
Journaler journaler = new Journaler(_eventStore);
//assign journaler to disruptor as its consumer
OutputDisruptor.InitializeDisruptor(new IEventHandler <byte[]>[] { journaler });
_manualResetEvent = new ManualResetEvent(false);
_listener = new OrderEventListener(_persistance, _balanceValidationService);
AfterSetup();
}
public new void SetUp()
{
BeforeSetup();
var connection = ConfigurationManager.ConnectionStrings["MySql"].ToString();
_databaseUtility = new DatabaseUtility(connection);
_databaseUtility.Create();
_databaseUtility.Populate();
//_persistance = ContextRegistry.GetContext()["PersistenceRepository"] as IPersistanceRepository;
//_orderRepository = ContextRegistry.GetContext()["OrderRepository"] as IOrderRepository;
//initialize journaler
_eventStore = new RavenNEventStore(Constants.OUTPUT_EVENT_STORE);
Journaler journaler = new Journaler(_eventStore);
//assign journaler to disruptor as its consumer
OutputDisruptor.InitializeDisruptor(new IEventHandler <byte[]>[] { journaler });
_manualResetEvent = new ManualResetEvent(false);
// _listener = new TradeEventListener(_persistance);
AfterSetup();
}
public void SetUp()
{
var connection = ConfigurationManager.ConnectionStrings["MySql"].ToString();
_databaseUtility = new DatabaseUtility(connection);
_databaseUtility.Create();
_databaseUtility.Populate();
inputEventStore = new RavenNEventStore(Constants.INPUT_EVENT_STORE);
outputEventStore = new RavenNEventStore(Constants.OUTPUT_EVENT_STORE);
inputJournaler = new Journaler(inputEventStore);
outputJournaler = new Journaler(outputEventStore);
IList <CurrencyPair> currencyPairs = new List <CurrencyPair>();
currencyPairs.Add(new CurrencyPair("BTCUSD", "USD", "BTC"));
currencyPairs.Add(new CurrencyPair("BTCLTC", "LTC", "BTC"));
currencyPairs.Add(new CurrencyPair("BTCDOGE", "DOGE", "BTC"));
_exchange = new Exchange(currencyPairs);
_exchange.EnableSnaphots(5000);
InputDisruptorPublisher.InitializeDisruptor(new IEventHandler <InputPayload>[] { _exchange, inputJournaler });
OutputDisruptor.InitializeDisruptor(new IEventHandler <byte[]>[] { outputJournaler });
}
public void PublishTradeToOutputDisruptor_IfTradeListenerIsInitiated_ItShouldSaveInDatabase()
{
Order buyOrder = OrderFactory.CreateOrder("123", "XBTUSD", "limit", "buy", 10, 100,
new StubbedOrderIdGenerator());
Order sellOrder = OrderFactory.CreateOrder("1234", "XBTUSD", "limit", "sell", 10, 100,
new StubbedOrderIdGenerator());
//Trade trade=new Trade("XBTUSD",new Price(100),new Volume(10),DateTime.Now,buyOrder,sellOrder);
Trade trade = TradeFactory.GenerateTrade("XBTUSD", new Price(1000), new Volume(10), buyOrder, sellOrder);
OutputDisruptor.Publish(trade);
_manualResetEvent.WaitOne(5000);
TradeReadModel model = _tradeRepository.GetById(trade.TradeId.Id.ToString());
Assert.NotNull(model);
Assert.AreEqual(model.BuyOrderId, buyOrder.OrderId.Id.ToString());
Assert.AreEqual(model.SellOrderId, sellOrder.OrderId.Id.ToString());
Assert.AreEqual(model.Price, 1000);
Assert.AreEqual(model.CurrencyPair, "XBTUSD");
Assert.AreEqual(model.BuyTraderId, "123");
Assert.AreEqual(model.SellTraderId, "1234");
Assert.AreEqual(model.Volume, 10);
}
//[Test]
public void PerformanceTest()
{
// Initialize the output Disruptor and assign the journaler as the event handler
IEventStore eventStore = new RavenNEventStore(Constants.OUTPUT_EVENT_STORE);
Journaler journaler = new Journaler(eventStore);
OutputDisruptor.InitializeDisruptor(new IEventHandler <byte[]>[] { journaler });
IList <CurrencyPair> currencyPairs = new List <CurrencyPair>();
currencyPairs.Add(new CurrencyPair("BTCUSD", "USD", "BTC"));
currencyPairs.Add(new CurrencyPair("BTCLTC", "LTC", "BTC"));
currencyPairs.Add(new CurrencyPair("BTCDOGE", "DOGE", "BTC"));
_exchange = new Exchange(currencyPairs);
List <OrderId> orderIds = new List <OrderId>();
// Create Orders
Order[] orders = new Order[10000];
Random random = new Random();
for (int i = 0; i < orders.Length; i++)
{
bool isBuy = ((i % 2) == 0);
decimal delta = isBuy ? 1880 : 1884;
Price price = new Price(random.Next(1, 10) + delta);
Volume volume = new Volume(random.Next() % 10 + 1 * 100);
OrderId orderId = new OrderId(random.Next(1, 100).ToString(CultureInfo.InvariantCulture));
orderIds.Add(orderId);
orders[i] = new Order(orderId, "BTCUSD", price, isBuy ? OrderSide.Buy :
OrderSide.Sell, OrderType.Limit, volume, new TraderId(random.Next(1, 100).ToString()));
}
JustAddOrdersToList(orders);
AddOrdersAndCancel(_exchange.ExchangeEssentials.First().LimitOrderBook, orders, orderIds);
}
public void TearDown()
{
OutputDisruptor.ShutDown();
}
public void OnDepthChanged(Depth depth)
{
//Publish to output disruptor
OutputDisruptor.Publish(depth);
Log.Debug("Depth changed for currency pair: " + depth.CurrencyPair);
}
/// <summary>
/// Handles the event that signifies that the OrderBook has changed
/// </summary>
public void OnOrderBookChanged(LimitOrderBook orderBook)
{
OutputDisruptor.Publish(orderBook);
Log.Debug("OrderBook changed for Currency pair: " + orderBook.CurrencyPair);
}
public void TearDown()
{
OutputDisruptor.ShutDown();
_eventStore.RemoveAllEvents();
}
/// <summary>
/// Handles the OrderBook's event in case the state of an Order changes
/// </summary>
/// <param name="order"> </param>
public void OnOrderChanged(Order order)
{
OutputDisruptor.Publish(order);
Log.Debug("Order change received and published. Order: " + order.ToString());
}
public void GetTradesForTraderBetweenTimeRangeTest_TestsTheMethodThatWillGetAllTradesForACurrencypair_AssertsTheValuesOfTheFetchedTrades()
{
// Get the context
IApplicationContext applicationContext = ContextRegistry.GetContext();
//Exchange exchange = new Exchange();
//IEventStore inputEventStore = new RavenNEventStore(Constants.INPUT_EVENT_STORE);
//IEventStore outputEventStore = new RavenNEventStore(Constants.OUTPUT_EVENT_STORE);
//Journaler inputJournaler = new Journaler(inputEventStore);
//Journaler outputJournaler = new Journaler(outputEventStore);
//InputDisruptorPublisher.InitializeDisruptor(new IEventHandler<InputPayload>[] { exchange, inputJournaler });
//OutputDisruptor.InitializeDisruptor(new IEventHandler<byte[]>[] { outputJournaler });
// Get the instance through Spring configuration
TradeController tradeController = (TradeController)applicationContext["TradeController"];
tradeController.Request = new HttpRequestMessage(HttpMethod.Post, "");
tradeController.Request.Headers.Add("Auth", "123456789");
// Get the instance through Spring configuration
OrderController orderController = (OrderController)applicationContext["OrderController"];
orderController.Request = new HttpRequestMessage(HttpMethod.Post, "");
orderController.Request.Headers.Add("Auth", "123456789");
ITradeRepository tradeRepository = (ITradeRepository)applicationContext["TradeRepository"];
ManualResetEvent manualResetEvent = new ManualResetEvent(false);
orderController.CreateOrder(new CreateOrderParam()
{
Pair = "BTCUSD",
Price = 491,
Volume = 100,
Side = "buy",
Type = "limit"
});
manualResetEvent.Reset();
manualResetEvent.WaitOne(2000);
orderController.CreateOrder(new CreateOrderParam()
{
Pair = "BTCUSD",
Price = 492,
Volume = 300,
Side = "buy",
Type = "limit"
});
manualResetEvent.Reset();
manualResetEvent.WaitOne(2000);
orderController.CreateOrder(new CreateOrderParam()
{
Pair = "BTCUSD",
Price = 493,
Volume = 1000,
Side = "buy",
Type = "limit"
});
orderController.CreateOrder(new CreateOrderParam()
{
Pair = "BTCUSD",
Price = 493,
Volume = 1000,
Side = "sell",
Type = "limit"
});
manualResetEvent.Reset();
manualResetEvent.WaitOne(2000);
orderController.CreateOrder(new CreateOrderParam()
{
Pair = "BTCUSD",
Price = 492,
Volume = 300,
Side = "sell",
Type = "limit"
});
manualResetEvent.Reset();
manualResetEvent.WaitOne(2000);
orderController.CreateOrder(new CreateOrderParam()
{
Pair = "BTCUSD",
Price = 491,
Volume = 100,
Side = "sell",
Type = "limit"
});
manualResetEvent.Reset();
manualResetEvent.WaitOne(4000);
IHttpActionResult httpActionResult = tradeController.GetTradeHistory(new TradeHistoryParams("2014/05/09", "2014/05/09"));
OkNegotiatedContentResult <object> okResponseObject = (OkNegotiatedContentResult <object>)httpActionResult;
IList <object> objectList = (IList <object>)okResponseObject.Content;
List <object[]> newObjectsList = new List <object[]>();
for (int i = 0; i < objectList.Count; i++)
{
object[] objects = objectList[i] as object[];
newObjectsList.Add(objects);
}
Assert.AreEqual(493, newObjectsList[0][2]);
Assert.AreEqual(1000, newObjectsList[0][3]);
Assert.AreEqual(492, newObjectsList[1][2]);
Assert.AreEqual(300, newObjectsList[1][3]);
Assert.AreEqual(491, newObjectsList[2][2]);
Assert.AreEqual(100, newObjectsList[2][3]);
InputDisruptorPublisher.Shutdown();
OutputDisruptor.ShutDown();
tradeRepository.RollBack();
}
