コード例 #1
0
        public void SerializerTest()
        {
            var stock1 = new ValuatedStock();
            var stock2 = new ValuatedStock();

            ValuatedStock[] stocks = { stock1, stock2 };
            string          date1  = "1990-02-20";

            MarketDay day1 = new MarketDay(date1, stocks);

            var recentHistory = new MarketSegment
            {
                day1
            };

            var stockStreamResponse = new StockHistoryResponseMessage
            {
                RecentHistory = recentHistory
            };

            var serializedMessage   = stockStreamResponse.Encode();
            var deserializedMessage = MessageFactory.GetMessage(serializedMessage, false) as StockHistoryResponseMessage;

            Assert.AreEqual(stockStreamResponse.RecentHistory[0].TradedCompanies.Count, deserializedMessage.RecentHistory[0].TradedCompanies.Count);
            Assert.AreEqual(stockStreamResponse.RecentHistory[0].TradedCompanies[0].Close, deserializedMessage.RecentHistory[0].TradedCompanies[0].Close);
            Assert.AreEqual(stockStreamResponse.RecentHistory[0].Date, deserializedMessage.RecentHistory[0].Date);
        }
コード例 #2
0
        public void InitializerTest()
        {
            var stock1 = new ValuatedStock();
            var stock2 = new ValuatedStock();

            ValuatedStock[] stocks = { stock1, stock2 };
            string          date1  = "1990-02-20";
            string          date2  = "1990-03-20";

            MarketDay day1 = new MarketDay(date1, stocks);
            MarketDay day2 = new MarketDay(date2, stocks);//not important that has same valuated stocks

            var recentHistory = new MarketSegment
            {
                day1,
                day2
            };

            var stockStreamResponse = new StockHistoryResponseMessage
            {
                RecentHistory = recentHistory
            };

            Assert.AreEqual(stockStreamResponse.RecentHistory[0].Date, date1);
            Assert.AreEqual(stockStreamResponse.RecentHistory[1].Date, date2);
            Assert.AreEqual(stockStreamResponse.RecentHistory.Count, 2);
            Assert.AreEqual(3, stockStreamResponse.RecentHistory[0].TradedCompanies.Count);
            Assert.AreEqual(3, stockStreamResponse.RecentHistory[1].TradedCompanies.Count);
        }
コード例 #3
0
        public void InheritsMessageTest()
        {
            var stockStreamResponse = new StockHistoryResponseMessage();

            Assert.IsNull(stockStreamResponse.ConversationID);
            Assert.IsNull(stockStreamResponse.MessageID);
            Assert.AreEqual(stockStreamResponse.SourceID, 0);
        }
コード例 #4
0
        public void RequestSingleTimeoutThenSucceed()
        {
            int processId = 1;
            var testStock = new Stock("TST", "Test Stock");
            var vStock    = new ValuatedStock(("1984-02-22,11.0289,11.0822,10.7222,10.7222,197402").Split(','), testStock);

            var conv     = new StockHistoryRequestConversation(processId);
            int requests = 0;

            //setup mock with response message
            var mock = new Mock <StockHistoryRequestState>(conv)
            {
                CallBase = true
            };

            mock.Setup(st => st.Send())
            .Callback(() =>
            {
                //Pretend message is sent and response comes back, but only after second request...
                if (++requests > 1)
                {
                    var responseMessage = new StockHistoryResponseMessage()
                    {
                        ConversationID = conv.Id,
                        MessageID      = "345-234-56"
                    };
                    var responseEnv = new Envelope(responseMessage);
                    ConversationManager.ProcessIncomingMessage(responseEnv);
                }
            });

            conv.SetInitialState(mock.Object as StockHistoryRequestState);

            Assert.IsTrue(conv.CurrentState is StockHistoryRequestState);
            mock.Verify(state => state.Prepare(), Times.Never);
            mock.Verify(state => state.Send(), Times.Never);
            Assert.IsFalse(ConversationManager.ConversationExists(conv.Id));

            ConversationManager.AddConversation(conv);

            Assert.IsTrue(conv.CurrentState is StockHistoryRequestState);
            mock.Verify(state => state.Prepare(), Times.Once);
            mock.Verify(state => state.Send(), Times.Once);
            mock.Verify(state => state.HandleTimeout(), Times.Never);
            Assert.IsTrue(ConversationManager.ConversationExists(conv.Id));

            Thread.Sleep((int)(Config.GetInt(Config.DEFAULT_TIMEOUT) * 1.5));

            Assert.IsFalse(conv.CurrentState is StockHistoryRequestState);
            Assert.IsTrue(conv.CurrentState is ConversationDoneState);
            mock.Verify(state => state.Prepare(), Times.Once);
            mock.Verify(state => state.Send(), Times.Exactly(2));
            mock.Verify(state => state.HandleTimeout(), Times.Exactly(1));
            Assert.IsTrue(ConversationManager.ConversationExists(conv.Id));
        }
コード例 #5
0
        public void DefaultConstructorTest()
        {
            var stockStreamResponse = new StockHistoryResponseMessage();

            Assert.AreEqual(stockStreamResponse.RecentHistory.Count, 0);
        }