Esempio n. 1
0
        public void PopCallBackHandlerForSpecificCallbackKey_RemovesAllOtherHandlersForThisCallbackKey()
        {
            var promise = new Promise(Randomizer.Int64());
            var simpleMessageIdentifier   = MessageIdentifier.Create <SimpleMessage>();
            var messageHandlerIdentifiers = new[]
            {
                simpleMessageIdentifier,
                MessageIdentifier.Create <ExceptionMessage>()
            };

            callbackHandlerStack.Push(promise, messageHandlerIdentifiers);
            //
            var handler = callbackHandlerStack.Pop(new CallbackHandlerKey
            {
                Identity    = simpleMessageIdentifier.Identity,
                Version     = simpleMessageIdentifier.Version,
                Partition   = simpleMessageIdentifier.Partition,
                CallbackKey = promise.CallbackKey.Value
            });

            Assert.NotNull(handler);

            handler = callbackHandlerStack.Pop(new CallbackHandlerKey
            {
                Identity    = KinoMessages.Exception.Identity,
                Version     = KinoMessages.Exception.Version,
                CallbackKey = promise.CallbackKey.Value
            });
            Assert.Null(handler);
        }
Esempio n. 2
0
        public void WhenResultMessageIsDelivered_PromiseIsDisposedAndItsCallbackIsRemoved()
        {
            var callbackHandlerStack = new CallbackHandlerStack();
            var messageHub           = new MessageHub(callbackHandlerStack,
                                                      routerSocket.Object,
                                                      registrationSocket.Object,
                                                      localSocketFactory.Object,
                                                      scaleOutConfigurationProvider.Object,
                                                      securityProvider.Object,
                                                      logger);

            try
            {
                var message         = Message.CreateFlowStartMessage(new SimpleMessage());
                var callback        = CallbackPoint.Create <NullMessage>();
                var promise         = messageHub.EnqueueRequest(message, callback);
                var callbackMessage = Message.Create(new NullMessage()).As <Message>();
                callbackMessage.RegisterCallbackPoint(Guid.NewGuid().ToByteArray(),
                                                      Guid.NewGuid().ToByteArray(),
                                                      callback.MessageIdentifiers,
                                                      promise.CallbackKey.Value);
                receivingSocket.SetupMessageReceived(callbackMessage, ReceiveMessageDelay);
                //
                messageHub.Start();
                ReceiveMessageCompletionDelay.Sleep();
                //
                Assert.IsNull(callbackHandlerStack.Pop(new CallbackHandlerKey
                {
                    Version     = callback.MessageIdentifiers.Single().Version,
                    Identity    = callback.MessageIdentifiers.Single().Identity,
                    Partition   = callback.MessageIdentifiers.Single().Partition,
                    CallbackKey = promise.CallbackKey.Value
                }));
            }
            finally
            {
                messageHub.Stop();
            }
        }