public void RemoveDoesNotCrashOnMissingID()
        {
            var client = MockRepository.GenerateStub<IClient>();
            client.Expect(c => c.ID).Return("abc");

            var messageHandler = new MessageHandlerCache();
            messageHandler.Remove(client);
        }
        public void MessageHandlerCacheStoresMessageHandlers()
        {
            var client = MockRepository.GenerateStub<IClient>();
            client.Expect(c => c.ID).Return("abc");

            MessageHandler messageHandler = new MessageHandler(null);
            var messageHandlerCache = new MessageHandlerCache();
            messageHandlerCache[client] = messageHandler;
            Assert.AreEqual(messageHandler, messageHandlerCache[client]);
        }
        public void RemoveRemovesMessageHandlerFromCache()
        {
            var client = MockRepository.GenerateStub<IClient>();
            client.Expect(c => c.ID).Return("abc");

            var messageHandler = new MessageHandler(null);
            var messageHandlerCache = new MessageHandlerCache();
            messageHandlerCache[client] = messageHandler;
            messageHandlerCache.Remove(client);
            Assert.AreEqual(null, messageHandlerCache[client]);
        }
        public void RemoveMessageHandlerCallsOnDisconnect()
        {
            var mockRepository = new MockRepository();
            var client = mockRepository.Stub<IClient>();
            client.Expect(c => c.ID).Return("abc").Repeat.Any();

            var emptyMessageMap = new MessageMap(Enumerable.Empty<KeyValuePair<string, Type>>());
            var messageHandler = mockRepository.StrictMock<MessageHandler>(emptyMessageMap);
            messageHandler.Expect(h => h.HandleDisconnect(client));

            mockRepository.ReplayAll();
            var messageHandlerCache = new MessageHandlerCache();
            messageHandlerCache[client] = messageHandler;
            EventHub.Publish(new DisconnectedEvent(client));
            Assert.AreEqual(null, messageHandlerCache[client]);
            mockRepository.VerifyAll();
        }
        public void FindTranslatorObject_ReturnsExistingObject()
        {
            MockRepository mockRepository = new MockRepository();

            var clientRepository = mockRepository.Stub<IClientRepository>();
            var aClient = mockRepository.StrictMock<IClient>();
            clientRepository.Expect(repository => repository.GetByID("abc"))
                            .Return(aClient);

            Message message = new Message();
            message.clientId = "abc";

            var cache = new MessageHandlerCache();
            var translator = new TelnetProtocolTranslator(null, null, null);
            cache["abc"] = translator;

            Assert.AreEqual(translator, TelnetProtocolTranslator.FindTranslatorObject(cache, message, null));
        }
        public void FindTranslatorObject_MakesNewObjectIfNeeded()
        {
            MockRepository mockRepository = new MockRepository();

            var clientRepository = mockRepository.Stub<IClientRepository>();
            var aClient = mockRepository.StrictMock<IClient>();
            clientRepository.Expect(repository => repository.GetByID("abc"))
                            .Return(aClient);

            var message = new Message();
            message.clientId = "abc";

            var cache = new MessageHandlerCache();
            TelnetProtocolTranslator translator = new TelnetProtocolTranslator(null, null, null);

            Assert.AreEqual(translator, TelnetProtocolTranslator.FindTranslatorObject(cache, message, ()=>translator));
        }