public SourcedProcessTest(ITestOutputHelper output)
        {
            var converter = new Converter(output);

            Console.SetOut(converter);

            _world = World.StartWithDefaults("five-step-process-test");

            var queue = new AsyncMessageQueue(null);

            _exchange   = new LocalExchange(queue);
            _dispatcher = new MockJournalDispatcher();
            _journal    = new InMemoryJournal <string>(_dispatcher, _world);

            _sourcedTypeRegistry = new SourcedTypeRegistry(_world);

            RegisterSourcedTypes <FiveStepSendingSourcedProcess>();
            RegisterSourcedTypes <FiveStepEmittingSourcedProcess>();

            _exchangeReceivers = new ExchangeReceivers();
            _exchangeSender    = new LocalExchangeSender(queue);

            var processTypeRegistry = new ProcessTypeRegistry(_world);

            processTypeRegistry.Register(new SourcedProcessInfo <FiveStepSendingSourcedProcess, PorcessObjectState>(nameof(FiveStepSendingSourcedProcess), _exchange, _sourcedTypeRegistry));
            processTypeRegistry.Register(new SourcedProcessInfo <FiveStepEmittingSourcedProcess, PorcessObjectState>(nameof(FiveStepEmittingSourcedProcess), _exchange, _sourcedTypeRegistry));

            RegisterExchangeCoveys();
        }
        public StatefulProcessTest(ITestOutputHelper output)
        {
            var converter = new Converter(output);
            Console.SetOut(converter);
            
            _world = World.StartWithDefaults("five-step-process-test");

            var queue = new AsyncMessageQueue(null);
            _exchange = new LocalExchange(queue);
            _dispatcher = new MockTextDispatcher();
            var stateStore = _world.ActorFor<IStateStore>(() => new InMemoryStateStoreActor<TextState>(new List<IDispatcher> {_dispatcher}));

            var statefulTypeRegistry = new StatefulTypeRegistry(_world);
            
            var stepCountStateInfo = new Vlingo.Xoom.Lattice.Model.Stateful.Info(stateStore, typeof(StepCountState), stateStore.GetType().Name);
            statefulTypeRegistry.Register(stepCountStateInfo);

            _exchangeReceivers = new ExchangeReceivers();
            _exchangeSender = new LocalExchangeSender(queue);

            var processTypeRegistry = new ProcessTypeRegistry(_world);
            processTypeRegistry.Register(new StatefulProcessInfo<FiveStepEmittingStatefulProcess, StepCountState>(nameof(FiveStepEmittingStatefulProcess), _exchange, statefulTypeRegistry));

            RegisterExchangeCoveys();
        }
Esempio n. 3
0
 public void BeginProcessingQueue()
 {
     using (var sut = AsyncMessageQueue.CreateMessageQueue(500))
     {
         sut.BeginProcessingQueue();
         sut.Enqueue(new AsyncMessage(12345, Request,
                                      OnCompletion));
         Thread.Sleep(3000);
     }
 }
        public AsyncMessageQueueTest()
        {
            deliveredMessages = new List <IMessage>();

            queue = new AsyncMessageQueue();
            queue.RegisterListener(new ExceptionThrowingListener(false, deliveredMessages));

            countingDeadLettersListener = new CountingDeadLettersListener();
            countingDeadLettersQueue    = new CountingDeadLettersQueue();
            countingDeadLettersQueue.RegisterListener(countingDeadLettersListener);

            exceptionsQueue = new AsyncMessageQueue(countingDeadLettersQueue);
            exceptionsQueue.RegisterListener(new ExceptionThrowingListener(true, deliveredMessages));
        }
Esempio n. 5
0
        internal Connection(string url, int delay, bool enqueueAsyncMessages, IConnectionTransport transport, ILoggerFactory loggerFactory = null)
        {
            LoggerFactory = loggerFactory ?? new LoggerFactory();
            Url           = url;
            Delay         = delay;
            Transport     = transport;

            _logger = LoggerFactory.CreateLogger <Connection>();

            Transport.MessageReceived += Transport_MessageReceived;
            Transport.Closed          += Transport_Closed;
            _callbacks     = new ConcurrentDictionary <int, MessageTask>();
            _sessions      = new ConcurrentDictionary <string, CDPSession>();
            MessageQueue   = new AsyncMessageQueue(enqueueAsyncMessages, _logger);
            _asyncSessions = new AsyncDictionaryHelper <string, CDPSession>(_sessions, "Session {0} not found");
        }
        public ObjectProcessTest(ITestOutputHelper output)
        {
            var converter = new Converter(output);

            Console.SetOut(converter);

            _world = World.StartWithDefaults("five-step-process-test");

            var queue = new AsyncMessageQueue(null);

            _exchange = new LocalExchange(queue);
            var adapter = new ProcessMessageTextAdapter();

            EntryAdapterProvider.Instance(_world).RegisterAdapter(adapter);

            var dispatcher  = new MockDispatcher();
            var objectStore = _world.ActorFor <IObjectStore>(() => new InMemoryObjectStoreActor <string>(dispatcher));

            var objectTypeRegistry = new ObjectTypeRegistry(_world);

            var stepCountStateInfo =
                new Info <StepCountObjectState>(
                    objectStore,
                    nameof(StepCountObjectState),
                    MapQueryExpression.Using <StepCountObjectState>("find", MapQueryExpression.Map("id", "id")),
                    StateObjectMapper.With <StepCountObjectState>(new object(), new object()));

            objectTypeRegistry.Register(stepCountStateInfo);

            _exchangeSender = new LocalExchangeSender(queue);

            var processTypeRegistry = new ProcessTypeRegistry(_world);

            processTypeRegistry.Register(new ObjectProcessInfo <FiveStepEmittingObjectProcess, StepCountObjectState>(nameof(FiveStepEmittingObjectProcess), _exchange, objectTypeRegistry));

            _exchangeReceivers = new ExchangeReceivers();

            RegisterExchangeCoveys();
        }
        public void TestThatExchangeSendsTyped()
        {
            var results = new ConcurrentQueue <object>();

            var logger         = ConsoleLogger.TestInstance();
            var queue          = new AsyncMessageQueue(null);
            var exchange       = new TestExchange(queue, logger);
            var accessExchange = exchange.AfterCompleting(2);

            var exchangeReceiver1       = new TestExchangeReceiver1(results, logger);
            var accessExchangeReceiver1 = exchangeReceiver1.AfterCompleting(1);
            var exchangeReceiver2       = new TestExchangeReceiver2(results, logger);
            var accessExchangeReceiver2 = exchangeReceiver2.AfterCompleting(1);

            exchange
            .Register(Covey <LocalType1, ExternalType1, ExchangeMessage> .Of(
                          new TestExchangeSender(queue, logger),
                          exchangeReceiver1,
                          new TestExchangeAdapter1()))
            .Register(Covey <LocalType2, ExternalType2, ExchangeMessage> .Of(
                          new TestExchangeSender(queue, logger),
                          exchangeReceiver2,
                          new TestExchangeAdapter2()));

            var local1 = new LocalType1("ABC", 123);

            exchange.Send(local1);

            var local2 = new LocalType2("DEF", 456);

            exchange.Send(local2);

            Assert.Equal(2, accessExchange.ReadFrom <int>("sentCount"));
            Assert.Equal(local1, accessExchangeReceiver1.ReadFrom <LocalType1>("getMessage"));
            Assert.Equal(local2, accessExchangeReceiver2.ReadFrom <LocalType2>("getMessage"));

            exchange.Close();
        }