private void VerifyDepthBeforeAndAfterReplay(DepthTupleRepresentation beforeReplay,
                                                     DepthTupleRepresentation afterReplay)
        {
            for (int i = 0; i < 5; i++)
            {
                Assert.AreEqual(beforeReplay.BidDepth[i].Volume, afterReplay.BidDepth[i].Volume);
                Assert.AreEqual(beforeReplay.BidDepth[i].Price, afterReplay.BidDepth[i].Price);
                Assert.AreEqual(beforeReplay.BidDepth[i].OrderCount, afterReplay.BidDepth[i].OrderCount);

                Assert.AreEqual(beforeReplay.AskDepth[i].Volume, afterReplay.AskDepth[i].Volume);
                Assert.AreEqual(beforeReplay.AskDepth[i].Price, afterReplay.AskDepth[i].Price);
                Assert.AreEqual(beforeReplay.AskDepth[i].OrderCount, afterReplay.AskDepth[i].OrderCount);
            }
        }
        private void VerifyDepthWhenOrdersPublishedAfterReplayForScenario1(DepthTupleRepresentation representation)
        {
            //0 index
            Assert.AreEqual(representation.BidDepth[0].Price, 406);
            Assert.AreEqual(representation.BidDepth[0].Volume, 201);
            Assert.AreEqual(representation.BidDepth[0].OrderCount, 2);

            Assert.AreEqual(representation.AskDepth[0].Price, 407);
            Assert.AreEqual(representation.AskDepth[0].Volume, 202);
            Assert.AreEqual(representation.AskDepth[0].OrderCount, 2);

            //1 index
            Assert.AreEqual(representation.BidDepth[1].Price, 405);
            Assert.AreEqual(representation.BidDepth[1].Volume, 106);
            Assert.AreEqual(representation.BidDepth[1].OrderCount, 2);

            Assert.AreEqual(representation.AskDepth[1].Price, 409);
            Assert.AreEqual(representation.AskDepth[1].Volume, 205);
            Assert.AreEqual(representation.AskDepth[1].OrderCount, 2);

            //2 index
            Assert.AreEqual(representation.BidDepth[2].Price, 404);
            Assert.AreEqual(representation.BidDepth[2].Volume, 104);
            Assert.AreEqual(representation.BidDepth[2].OrderCount, 1);

            Assert.AreEqual(representation.AskDepth[2].Price, 410);
            Assert.AreEqual(representation.AskDepth[2].Volume, 100);
            Assert.AreEqual(representation.AskDepth[2].OrderCount, 1);

            //3 index
            Assert.AreEqual(representation.BidDepth[3].Price, 403);
            Assert.AreEqual(representation.BidDepth[3].Volume, 103);
            Assert.AreEqual(representation.BidDepth[3].OrderCount, 1);

            Assert.AreEqual(representation.AskDepth[3].Price, 411);
            Assert.AreEqual(representation.AskDepth[3].Volume, 105);
            Assert.AreEqual(representation.AskDepth[3].OrderCount, 1);

            //4 index
            Assert.AreEqual(representation.BidDepth[4].Price, 402);
            Assert.AreEqual(representation.BidDepth[4].Volume, 102);
            Assert.AreEqual(representation.BidDepth[4].OrderCount, 1);

            Assert.AreEqual(representation.AskDepth[4].Price, 412);
            Assert.AreEqual(representation.AskDepth[4].Volume, 106);
            Assert.AreEqual(representation.AskDepth[4].OrderCount, 1);
        }
        public void GetDepthFromControllerTest_TestsTheLinkBetweenMarketControllerAndMArketQueryService_ChecksTheOutputToBeAsExpected()
        {
            // Get the context
            //IApplicationContext applicationContext = ContextRegistry.GetContext();

            // Get the instance through Spring configuration
            MarketController marketController = (MarketController)_applicationContext["MarketController"];
            Depth            depth            = new Depth("XBTUSD", 3);

            depth.AddOrder(new Price(491), new Volume(100), OrderSide.Buy);
            depth.AddOrder(new Price(492), new Volume(100), OrderSide.Buy);
            depth.AddOrder(new Price(492), new Volume(200), OrderSide.Buy);

            depth.AddOrder(new Price(490), new Volume(100), OrderSide.Sell);
            depth.AddOrder(new Price(490), new Volume(100), OrderSide.Sell);
            depth.AddOrder(new Price(490), new Volume(200), OrderSide.Sell);

            DepthMemoryImage depthMemoryImage = (DepthMemoryImage)_applicationContext["DepthMemoryImage"];

            depthMemoryImage.OnDepthArrived(depth);

            IHttpActionResult httpActionResult = marketController.GetDepth("XBTUSD");

            OkNegotiatedContentResult <object> result =
                (OkNegotiatedContentResult <object>)httpActionResult;

            DepthTupleRepresentation returnedDepths = result.Content as DepthTupleRepresentation;

            Assert.IsNotNull(returnedDepths);
            // Bid Depth First Element represented as Item1
            Assert.AreEqual(300, returnedDepths.BidDepth.ToList()[0].Volume);   // Aggregated Volume
            Assert.AreEqual(492, returnedDepths.BidDepth.ToList()[0].Price);    // Price
            Assert.AreEqual(2, returnedDepths.BidDepth.ToList()[0].OrderCount); // OrderCount

            // Ask Depth First Element represented as Item2
            Assert.AreEqual(400, returnedDepths.AskDepth.ToList()[0].Volume);   // Aggregated Volume
            Assert.AreEqual(490, returnedDepths.AskDepth.ToList()[0].Price);    // Price
            Assert.AreEqual(3, returnedDepths.AskDepth.ToList()[0].OrderCount); // OrderCount
        }
        public void ReplayOrderBook_IfScenario2IsExecuted_VerifyTheWholeSystemState()
        {
            _applicationContext = ContextRegistry.GetContext();
            Scenario2();
            MarketController  marketController     = (MarketController)_applicationContext["MarketController"];
            IHttpActionResult marketDataHttpResult = marketController.GetOrderBook("XBTUSD");

            OkNegotiatedContentResult <object> okResponseMessage =
                (OkNegotiatedContentResult <object>)marketDataHttpResult;
            OrderBookRepresentation representation = okResponseMessage.Content as OrderBookRepresentation;
            Tuple <OrderRepresentationList, OrderRepresentationList> orderBooks = new Tuple <OrderRepresentationList, OrderRepresentationList>(representation.Bids, representation.Asks);

            marketDataHttpResult = marketController.GetDepth("XBTUSD");
            OkNegotiatedContentResult <object> okResponseMessageDepth = (OkNegotiatedContentResult <object>)marketDataHttpResult;
            DepthTupleRepresentation           beforeReplayDepth      = okResponseMessageDepth.Content as DepthTupleRepresentation;

            IOrderRepository      orderRepository = (IOrderRepository)_applicationContext["OrderRepository"];
            List <OrderReadModel> before          = orderRepository.GetAllOrderOfTrader("5555");

            before = before.Concat(orderRepository.GetAllOrderOfTrader("4444")).ToList();

            ITradeRepository       tradeRepository    = (ITradeRepository)_applicationContext["TradeRepository"];
            IList <TradeReadModel> beforeReplayTrades = tradeRepository.GetAll();
            IList <object>         beforeReplayEvents = outputEventStore.GetAllEvents();

            marketDataHttpResult = marketController.GetBbo("XBTUSD");
            OkNegotiatedContentResult <BBORepresentation> okResponseMessageBboBefore = (OkNegotiatedContentResult <BBORepresentation>)marketDataHttpResult;

            //down the exchange, make new exchange and reply
            CrashAndInitializeAgainWithSnapshot();

            marketController     = (MarketController)_applicationContext["MarketController"];
            marketDataHttpResult = marketController.GetOrderBook("XBTUSD");

            okResponseMessage =
                (OkNegotiatedContentResult <object>)marketDataHttpResult;
            representation = okResponseMessage.Content as OrderBookRepresentation;
            Tuple <OrderRepresentationList, OrderRepresentationList> orderBook1 = new Tuple <OrderRepresentationList, OrderRepresentationList>(representation.Bids, representation.Asks);

            //verify orderbook state
            VerifyOrderBookStateAfterReplay(orderBooks, orderBook1);

            List <OrderReadModel> after = orderRepository.GetAllOrderOfTrader("5555");

            after = after.Concat(orderRepository.GetAllOrderOfTrader("4444")).ToList();
            //verify order table in database
            VerifyDatabaseStateAfterReplay(before, after);
            IList <TradeReadModel> afterReplayTrades = tradeRepository.GetAll();

            //verify trades table in database
            VerifyDatabaseStateAfterReplay(beforeReplayTrades, afterReplayTrades);
            IList <object> afterReplayEvents = outputEventStore.GetAllEvents();

            //verify event store state
            VerifyEventStoreStateAfterReplay(beforeReplayEvents, afterReplayEvents);

            marketDataHttpResult   = marketController.GetDepth("XBTUSD");
            okResponseMessageDepth = (OkNegotiatedContentResult <object>)marketDataHttpResult;
            DepthTupleRepresentation afterReplayDepth = okResponseMessageDepth.Content as DepthTupleRepresentation;

            VerifyDepthBeforeAndAfterReplay(beforeReplayDepth, afterReplayDepth);

            marketDataHttpResult = marketController.GetBbo("XBTUSD");
            OkNegotiatedContentResult <BBORepresentation> okResponseMessageBboAfter = (OkNegotiatedContentResult <BBORepresentation>)marketDataHttpResult;

            VerifyBboAfterReplay(okResponseMessageBboBefore.Content, okResponseMessageBboAfter.Content);
        }
        public void SubmitOrdersAndGetDepthTest_SubmitsAnOrderAndGetsTheDepthAsTheResult_VerifiesIfDepthIsAsExpected()
        {
            // Get the instance through Spring configuration
            OrderController orderController = (OrderController)_applicationContext["OrderController"];

            orderController.Request = new HttpRequestMessage(HttpMethod.Post, "");
            orderController.Request.Headers.Add("Auth", "123456789");

            ManualResetEvent  manualResetEvent = new ManualResetEvent(false);
            IHttpActionResult orderHttpResult  = orderController.CreateOrder(new CreateOrderParam()
            {
                Pair   = "BTCUSD",
                Price  = 491,
                Volume = 100,
                Side   = "buy",
                Type   = "limit"
            });

            OkNegotiatedContentResult <NewOrderRepresentation> orderRepresentationContent = (OkNegotiatedContentResult <NewOrderRepresentation>)orderHttpResult;

            Assert.IsNotNull(orderRepresentationContent.Content);
            manualResetEvent.Reset();
            manualResetEvent.WaitOne(1000);
            orderController.CreateOrder(new CreateOrderParam()
            {
                Pair   = "BTCUSD",
                Price  = 491,
                Volume = 300,
                Side   = "buy",
                Type   = "limit"
            });

            manualResetEvent.Reset();
            manualResetEvent.WaitOne(1000);

            orderController.CreateOrder(new CreateOrderParam()
            {
                Pair   = "BTCUSD",
                Price  = 493,
                Volume = 1000,
                Side   = "buy",
                Type   = "limit"
            });

            orderController.CreateOrder(new CreateOrderParam()
            {
                Pair   = "BTCUSD",
                Price  = 498,
                Volume = 900,
                Side   = "sell",
                Type   = "limit"
            });

            manualResetEvent.Reset();
            manualResetEvent.WaitOne(1000);

            orderController.CreateOrder(new CreateOrderParam()
            {
                Pair   = "BTCUSD",
                Price  = 498,
                Volume = 800,
                Side   = "sell",
                Type   = "limit"
            });

            manualResetEvent.Reset();
            manualResetEvent.WaitOne(1000);

            orderController.CreateOrder(new CreateOrderParam()
            {
                Pair   = "BTCUSD",
                Price  = 497,
                Volume = 700,
                Side   = "sell",
                Type   = "limit"
            });

            manualResetEvent.Reset();
            manualResetEvent.WaitOne(2000);
            MarketController  marketController     = (MarketController)_applicationContext["MarketController"];
            IHttpActionResult marketDataHttpResult = marketController.GetDepth("BTCUSD");

            OkNegotiatedContentResult <object> okResponseMessage =
                (OkNegotiatedContentResult <object>)marketDataHttpResult;
            DepthTupleRepresentation returnedDepth = okResponseMessage.Content as DepthTupleRepresentation;

            Assert.AreEqual(1000, returnedDepth.BidDepth[0].Volume); // Volume of the first Bid DepthLevel
            Assert.AreEqual(493, returnedDepth.BidDepth[0].Price);   // Price of the first Bid DepthLevel
            Assert.AreEqual(400, returnedDepth.BidDepth[1].Volume);  // Volume of the second Bid DepthLevel
            Assert.AreEqual(491, returnedDepth.BidDepth[1].Price);   // Price of the second Bid DepthLevel

            Assert.AreEqual(700, returnedDepth.AskDepth[0].Volume);  // Volume of the first Ask DepthLevel
            Assert.AreEqual(497, returnedDepth.AskDepth[0].Price);   // Price of the first Ask DepthLevel
            Assert.AreEqual(1700, returnedDepth.AskDepth[1].Volume); // Volume of the second Ask DepthLevel
            Assert.AreEqual(498, returnedDepth.AskDepth[1].Price);   // Price of the second Ask DepthLevel
        }
        public void Scenario3Test_TestsScenario3AndItsOutcome_VerifiesThroughMarketDataOrderAndTradesResults()
        {
            // Get the context
            IApplicationContext applicationContext = ContextRegistry.GetContext();

            // Get the instance through Spring configuration
            OrderController  orderController  = (OrderController)applicationContext["OrderController"];
            TradeController  tradeController  = (TradeController)applicationContext["TradeController"];
            MarketController marketController = (MarketController)applicationContext["MarketController"];

            orderController.Request = new HttpRequestMessage(HttpMethod.Post, "");
            orderController.Request.Headers.Add("Auth", "123456789");
            tradeController.Request = new HttpRequestMessage(HttpMethod.Post, "");
            tradeController.Request.Headers.Add("Auth", "123456789");
            marketController.Request = new HttpRequestMessage(HttpMethod.Post, "");
            marketController.Request.Headers.Add("Auth", "123456789");
            Scenario3OrderCreation(orderController);

            // ------------------------------- Order Book ------------------------------
            IHttpActionResult orderBookResponse = marketController.GetOrderBook("BTCLTC");

            OkNegotiatedContentResult <object> okOrderBookResponse =
                (OkNegotiatedContentResult <object>)orderBookResponse;

            OrderBookRepresentation representation = okOrderBookResponse.Content as OrderBookRepresentation;
            Tuple <OrderRepresentationList, OrderRepresentationList> orderBook = new Tuple <OrderRepresentationList, OrderRepresentationList>(representation.Bids, representation.Asks);

            // Item1 = Bid Book, Item1[i].Item1 = Volume of 'i' Bid, Item1[i].Item2 = Price of 'i' Bid
            Assert.AreEqual(0, orderBook.Item1.Count());
            // Item2 = Bid Book, Item2[i].Item1 = Volume of Ask at index 'i', Item2[i].Item2 = Price of Bid at index 'i'
            Assert.AreEqual(0, orderBook.Item2.Count());
            // ------------------------------------------------------------------------

            // --------------------------------- Depth ---------------------------------
            IHttpActionResult depthResponse = marketController.GetDepth("BTCLTC");

            OkNegotiatedContentResult <object> okDepth
                = (OkNegotiatedContentResult <object>)depthResponse;

            DepthTupleRepresentation depth = okDepth.Content as DepthTupleRepresentation;

            // Item1 = Bid Book, Item1.Item1 = Aggregated Volume, Item1.Item2 = Price, Item1.Item3 = Number of Orders
            Assert.IsNull(depth.BidDepth[0]);
            Assert.IsNull(depth.BidDepth[1]);
            Assert.IsNull(depth.BidDepth[2]);
            Assert.IsNull(depth.BidDepth[3]);
            Assert.IsNull(depth.BidDepth[4]);

            // Item2 = Bid Book, Item2.Item1 = Aggregated Volume, Item2.Item2 = Price, Item2.Item3 = Number of Orders
            Assert.IsNull(depth.AskDepth[0]);
            Assert.IsNull(depth.AskDepth[1]);
            Assert.IsNull(depth.AskDepth[2]);
            Assert.IsNull(depth.AskDepth[3]);
            Assert.IsNull(depth.AskDepth[4]);

            // -----------------------------------------------------------------------

            //------------------------- Open Orders ----------------------------------
            IHttpActionResult openOrdersResponse = GetOpenOrders(orderController);
            OkNegotiatedContentResult <List <OrderReadModel> > okOpenOrdersResponse = (OkNegotiatedContentResult <List <OrderReadModel> >)openOrdersResponse;
            List <OrderReadModel> openOrders = okOpenOrdersResponse.Content;

            Assert.AreEqual(0, openOrders.Count);
            //---------------------------------------------------------------------

            //-------------------------- Closed Orders ----------------------------
            IHttpActionResult closedOrdersResponse = GetClosedOrders(orderController);
            OkNegotiatedContentResult <List <OrderReadModel> > okClosedOrdersResponse = (OkNegotiatedContentResult <List <OrderReadModel> >)closedOrdersResponse;
            List <OrderReadModel> closedOrders = okClosedOrdersResponse.Content;

            // Order List comes in descending order, so asserts are placed that way too
            Assert.AreEqual(252, closedOrders[8].Price);
            Assert.AreEqual(5, closedOrders[8].Volume);
            Assert.AreEqual(0, closedOrders[8].VolumeExecuted);
            Assert.AreEqual(5, closedOrders[8].OpenQuantity);
            Assert.AreEqual("Limit", closedOrders[8].Type);
            Assert.AreEqual("Sell", closedOrders[8].Side);
            Assert.AreEqual("Cancelled", closedOrders[8].Status);

            Assert.AreEqual(245, closedOrders[7].Price);
            Assert.AreEqual(8, closedOrders[7].Volume);
            Assert.AreEqual(0, closedOrders[7].VolumeExecuted);
            Assert.AreEqual(8, closedOrders[7].OpenQuantity);
            Assert.AreEqual("Limit", closedOrders[7].Type);
            Assert.AreEqual("Buy", closedOrders[7].Side);
            Assert.AreEqual("Cancelled", closedOrders[7].Status);

            Assert.AreEqual(250, closedOrders[6].Price);
            Assert.AreEqual(7, closedOrders[6].Volume);
            Assert.AreEqual(7, closedOrders[6].VolumeExecuted);
            Assert.AreEqual(0, closedOrders[6].OpenQuantity);
            Assert.AreEqual("Limit", closedOrders[6].Type);
            Assert.AreEqual("Buy", closedOrders[6].Side);
            Assert.AreEqual("Complete", closedOrders[6].Status);

            Assert.AreEqual(250, closedOrders[5].Price);
            Assert.AreEqual(3, closedOrders[5].Volume);
            Assert.AreEqual(2, closedOrders[5].VolumeExecuted);
            Assert.AreEqual(1, closedOrders[5].OpenQuantity);
            Assert.AreEqual("Limit", closedOrders[5].Type);
            Assert.AreEqual("Buy", closedOrders[5].Side);
            Assert.AreEqual("Cancelled", closedOrders[5].Status);

            Assert.AreEqual(253, closedOrders[4].Price);
            Assert.AreEqual(5, closedOrders[4].Volume);
            Assert.AreEqual(0, closedOrders[4].VolumeExecuted);
            Assert.AreEqual(5, closedOrders[4].OpenQuantity);
            Assert.AreEqual("Limit", closedOrders[4].Type);
            Assert.AreEqual("Sell", closedOrders[4].Side);
            Assert.AreEqual("Cancelled", closedOrders[4].Status);

            Assert.AreEqual(240, closedOrders[3].Price);
            Assert.AreEqual(8, closedOrders[3].Volume);
            Assert.AreEqual(0, closedOrders[3].VolumeExecuted);
            Assert.AreEqual(8, closedOrders[3].OpenQuantity);
            Assert.AreEqual("Limit", closedOrders[3].Type);
            Assert.AreEqual("Buy", closedOrders[3].Side);
            Assert.AreEqual("Cancelled", closedOrders[3].Status);

            Assert.AreEqual(245, closedOrders[2].Price);
            Assert.AreEqual(7, closedOrders[2].Volume);
            Assert.AreEqual(0, closedOrders[2].VolumeExecuted);
            Assert.AreEqual(7, closedOrders[2].OpenQuantity);
            Assert.AreEqual("Limit", closedOrders[2].Type);
            Assert.AreEqual("Buy", closedOrders[2].Side);
            Assert.AreEqual("Cancelled", closedOrders[2].Status);

            Assert.AreEqual(247, closedOrders[1].Price);
            Assert.AreEqual(3, closedOrders[1].Volume);
            Assert.AreEqual(0, closedOrders[1].VolumeExecuted);
            Assert.AreEqual(3, closedOrders[1].OpenQuantity);
            Assert.AreEqual("Limit", closedOrders[1].Type);
            Assert.AreEqual("Buy", closedOrders[1].Side);
            Assert.AreEqual("Cancelled", closedOrders[1].Status);

            Assert.AreEqual(0, closedOrders[0].Price);
            Assert.AreEqual(9, closedOrders[0].Volume);
            Assert.AreEqual(9, closedOrders[0].VolumeExecuted);
            Assert.AreEqual(0, closedOrders[0].OpenQuantity);
            Assert.AreEqual("Market", closedOrders[0].Type);
            Assert.AreEqual("Sell", closedOrders[0].Side);
            Assert.AreEqual("Complete", closedOrders[0].Status);
            //------------------------------------------------------------------------

            //------------------- Trades -------------------------

            IHttpActionResult tradesResponse = GetTrades(tradeController);
            OkNegotiatedContentResult <object> okTradeResponse = (OkNegotiatedContentResult <object>)tradesResponse;
            IList <object>   tradesintermediateList            = (IList <object>)okTradeResponse.Content;
            IList <object[]> trades = new List <object[]>();

            for (int i = 0; i < tradesintermediateList.Count; i++)
            {
                object[] objects = tradesintermediateList[i] as object[];
                trades.Add(objects);
            }

            // These trades execute simultaneously, so when queried from the database and sorted as per the time when
            // they were saved in the database, they can be queried out of the order as we expected because they have the
            // same time. So we check if one trade came before the other and place assertions for it then for the other and
            // vice versa
            if ((decimal)trades[1][3] == 7)
            {
                Assert.AreEqual(250, trades[1][2]);      // Price
                Assert.AreEqual(7, trades[1][3]);        // Volume
                Assert.AreEqual("BTCLTC", trades[1][4]); // CurrencyPair
            }
            else if ((decimal)trades[1][3] == 2)
            {
                Assert.AreEqual(250, trades[1][2]);
                Assert.AreEqual(2, trades[1][3]);
                Assert.AreEqual("BTCLTC", trades[1][4]);
            }
            else
            {
                throw new Exception("No assertions could be made on expected trade");
            }

            if ((decimal)trades[0][3] == 7)
            {
                Assert.AreEqual(250, trades[0][2]);      // Price
                Assert.AreEqual(7, trades[0][3]);        // Volume
                Assert.AreEqual("BTCLTC", trades[0][4]); // CurrencyPair
            }
            else if ((decimal)trades[0][3] == 2)
            {
                Assert.AreEqual(250, trades[0][2]);      // Price
                Assert.AreEqual(2, trades[0][3]);        // Volume
                Assert.AreEqual("BTCLTC", trades[0][4]); // CurrencyPair
            }
            else
            {
                throw new Exception("No assertions could be made on expected trade");
            }
            //-----------------------------------------------------------------------
        }
        public void Scenario1Test_TestsScenario1AndItsOutcome_VerifiesThroughMarketDataOrderAndTradesResults()
        {
            // Get the context
            IApplicationContext applicationContext = ContextRegistry.GetContext();

            // Get the instance through Spring configuration
            OrderController  orderController  = (OrderController)applicationContext["OrderController"];
            TradeController  tradeController  = (TradeController)applicationContext["TradeController"];
            MarketController marketController = (MarketController)applicationContext["MarketController"];

            orderController.Request = new HttpRequestMessage(HttpMethod.Post, "");
            orderController.Request.Headers.Add("Auth", "123456789");
            tradeController.Request = new HttpRequestMessage(HttpMethod.Post, "");
            tradeController.Request.Headers.Add("Auth", "123456789");
            marketController.Request = new HttpRequestMessage(HttpMethod.Post, "");
            marketController.Request.Headers.Add("Auth", "123456789");
            Scenario1OrderCreation(orderController);

            // ------------------------------- Order Book ------------------------------
            IHttpActionResult orderBookResponse = marketController.GetOrderBook("BTCLTC");

            OkNegotiatedContentResult <object> okOrderBookResponse =
                (OkNegotiatedContentResult <object>)orderBookResponse;
            OrderBookRepresentation representation = okOrderBookResponse.Content as OrderBookRepresentation;
            Tuple <OrderRepresentationList, OrderRepresentationList> orderBook = new Tuple <OrderRepresentationList, OrderRepresentationList>(representation.Bids, representation.Asks);

            // Item1 = Bid Book, Item1[i].Item1 = Volume of 'i' Bid, Item1[i].Item2 = Price of 'i' Bid
            Assert.AreEqual(5, orderBook.Item1.ToList()[0].Volume);
            Assert.AreEqual(250, orderBook.Item1.ToList()[0].Price);
            Assert.AreEqual(2, orderBook.Item1.ToList()[1].Volume);
            Assert.AreEqual(250, orderBook.Item1.ToList()[1].Price);

            // Item2 = Ask Book, Item2[i].Item1 = Volume of Ask at index 'i', Item2[i].Item2 = Price of Ask at index 'i'
            Assert.AreEqual(0, orderBook.Item2.Count());
            // ------------------------------- Order Book ------------------------------
            IHttpActionResult depthResponse = marketController.GetDepth("BTCLTC");

            OkNegotiatedContentResult <object> okDepth
                = (OkNegotiatedContentResult <object>)depthResponse;

            DepthTupleRepresentation depth = okDepth.Content as DepthTupleRepresentation;

            // Item1 = Bid Book, Item1.Item1 = Aggregated Volume, Item1.Item2 = Price, Item1.Item3 = Number of Orders
            Assert.AreEqual(7, depth.BidDepth[0].Volume);
            Assert.AreEqual(250, depth.BidDepth[0].Price);
            Assert.AreEqual(2, depth.BidDepth[0].OrderCount);
            Assert.IsNull(depth.BidDepth[1]);
            Assert.IsNull(depth.BidDepth[2]);
            Assert.IsNull(depth.BidDepth[3]);
            Assert.IsNull(depth.BidDepth[4]);

            // Item2 = Ask Book, Item2.Item1 = Aggregated Volume, Item2.Item2 = Price, Item2.Item3 = Number of Orders
            Assert.IsNull(depth.AskDepth[0]);
            Assert.IsNull(depth.AskDepth[1]);
            Assert.IsNull(depth.AskDepth[2]);
            Assert.IsNull(depth.AskDepth[3]);
            Assert.IsNull(depth.AskDepth[4]);

            //------------------- Open Orders -------------------------
            IHttpActionResult openOrdersResponse = GetOpenOrders(orderController);
            OkNegotiatedContentResult <List <OrderReadModel> > okOpenOrdersResponse = (OkNegotiatedContentResult <List <OrderReadModel> >)openOrdersResponse;
            List <OrderReadModel> openOrders = okOpenOrdersResponse.Content;

            Assert.AreEqual(2, openOrders.Count);
            // First Open Order
            Assert.AreEqual(250, openOrders[1].Price);
            Assert.AreEqual(10, openOrders[1].Volume);
            Assert.AreEqual(5, openOrders[1].VolumeExecuted);
            Assert.AreEqual(5, openOrders[1].OpenQuantity);
            Assert.AreEqual("Limit", openOrders[1].Type);
            Assert.AreEqual("Buy", openOrders[1].Side);
            Assert.AreEqual("PartiallyFilled", openOrders[1].Status);

            // Second Open Order
            Assert.AreEqual(250, openOrders[0].Price);
            Assert.AreEqual(2, openOrders[0].Volume);
            Assert.AreEqual(0, openOrders[0].VolumeExecuted);
            Assert.AreEqual(2, openOrders[0].OpenQuantity);
            Assert.AreEqual("Limit", openOrders[0].Type);
            Assert.AreEqual("Buy", openOrders[0].Side);
            Assert.AreEqual("Accepted", openOrders[0].Status);
            //------------------- Open Orders -------------------------

            //------------------- Closed Orders -------------------------
            IHttpActionResult closedOrdersResponse = GetClosedOrders(orderController);
            OkNegotiatedContentResult <List <OrderReadModel> > okClosedOrdersResponse = (OkNegotiatedContentResult <List <OrderReadModel> >)closedOrdersResponse;
            List <OrderReadModel> closedOrders = okClosedOrdersResponse.Content;

            Assert.AreEqual(252, closedOrders[3].Price);
            Assert.AreEqual(5, closedOrders[3].Volume);
            Assert.AreEqual(5, closedOrders[3].VolumeExecuted);
            Assert.AreEqual(0, closedOrders[3].OpenQuantity);
            Assert.AreEqual("Limit", closedOrders[3].Type);
            Assert.AreEqual("Sell", closedOrders[3].Side);
            Assert.AreEqual("Complete", closedOrders[3].Status);

            Assert.AreEqual(0, closedOrders[2].Price);
            Assert.AreEqual(3, closedOrders[2].Volume);
            Assert.AreEqual(3, closedOrders[2].VolumeExecuted);
            Assert.AreEqual(0, closedOrders[2].OpenQuantity);
            Assert.AreEqual("Market", closedOrders[2].Type);
            Assert.AreEqual("Buy", closedOrders[2].Side);
            Assert.AreEqual("Complete", closedOrders[2].Status);

            Assert.AreEqual(253, closedOrders[1].Price);
            Assert.AreEqual(2, closedOrders[1].Volume);
            Assert.AreEqual(2, closedOrders[1].VolumeExecuted);
            Assert.AreEqual(0, closedOrders[1].OpenQuantity);
            Assert.AreEqual("Limit", closedOrders[1].Type);
            Assert.AreEqual("Buy", closedOrders[1].Side);
            Assert.AreEqual("Complete", closedOrders[1].Status);

            Assert.AreEqual(0, closedOrders[0].Price);
            Assert.AreEqual(5, closedOrders[0].Volume);
            Assert.AreEqual(5, closedOrders[0].VolumeExecuted);
            Assert.AreEqual(0, closedOrders[0].OpenQuantity);
            Assert.AreEqual("Market", closedOrders[0].Type);
            Assert.AreEqual("Sell", closedOrders[0].Side);
            Assert.AreEqual("Complete", closedOrders[0].Status);
            //------------------- Closed Orders -------------------------

            //------------------- Trades -------------------------

            IHttpActionResult tradesResponse = GetTrades(tradeController);
            OkNegotiatedContentResult <object> okTradeResponse = (OkNegotiatedContentResult <object>)tradesResponse;
            IList <object>   tradesintermediateList            = (IList <object>)okTradeResponse.Content;
            IList <object[]> trades = new List <object[]>();

            for (int i = 0; i < tradesintermediateList.Count; i++)
            {
                object[] objects = tradesintermediateList[i] as object[];
                trades.Add(objects);
            }

            // This call return list of object, so we have to explicitly check values within elements
            Assert.AreEqual(252, trades[2][2]); // Price
            Assert.AreEqual(3, trades[2][3]);   // Volume
            Assert.AreEqual("BTCLTC", trades[2][4]);

            Assert.AreEqual(252, trades[1][2]);
            Assert.AreEqual(2, trades[1][3]);
            Assert.AreEqual("BTCLTC", trades[0][4]);

            Assert.AreEqual(250, trades[0][2]);
            Assert.AreEqual(5, trades[0][3]);
            Assert.AreEqual("BTCLTC", trades[0][4]);
            //------------------- Trades -------------------------
        }