Example #1
0
        public Task CreateActivities(int number)
        {
            var tasks = new Task[number];

            for (int i = 0; i < number; i++)
            {
                AccountCreatedMessage message = new AccountCreatedMessage(i, $"User {i}", "UserRef {i}");
                var messageContext            = new FakeMessage <AccountCreatedMessage>(message, Guid.NewGuid().ToString());

                MessageContextProvider.StoreMessageContext(messageContext);

                tasks[i] = ActivitySaver
                           .SaveActivity(message, ActivityType.AccountCreated)
                           .ContinueWith(t => CreatedActivities.Add(t.Result))
                           .ContinueWith(t => MessageContextProvider.ReleaseMessageContext(messageContext));
            }

            return(Task.WhenAll(tasks)
                   .ContinueWith(task =>
            {
                Assert.IsTrue(tasks.All(t => t.IsCompleted), "At least one creation task did not complete");

                var firstFaulted = tasks.FirstOrDefault(t => t.IsFaulted);
                if (firstFaulted != null)
                {
                    Assert.Fail($"At least one creation task faulted.{firstFaulted.Exception.Flatten().Message}");
                }

                Assert.AreEqual(number, CreatedActivities.Count, "Incorrect number of accounts created");
            }));
        }
        public async Task Should_Send_Message_Context_Correctly()
        {
            /* Setup */
            var subscriber = BusClientFactory.CreateDefault();

            var expectedId      = Guid.NewGuid();
            var subscribeTcs    = new TaskCompletionSource <Guid>();
            var contextProvider = new MessageContextProvider <MessageContext>(new JsonSerializer(), () => new MessageContext {
                GlobalRequestId = expectedId
            });
            var publisher = BusClientFactory.CreateDefault(collection => collection.AddSingleton <IMessageContextProvider <MessageContext> >(contextProvider));

            subscriber.SubscribeAsync <BasicMessage>((msg, c) =>
            {
                subscribeTcs.SetResult(c.GlobalRequestId);
                return(subscribeTcs.Task);
            });

            /* Test */
            publisher.PublishAsync <BasicMessage>();
            await subscribeTcs.Task;

            /* Assert */
            Assert.Equal(expected: expectedId, actual: subscribeTcs.Task.Result);
        }
Example #3
0
        public void Release_NullMessage_ShouldIgnoreNulls()
        {
            var mcp = new MessageContextProvider();

            mcp.ReleaseMessageContext((IMessage <object>)null);
            Assert.Pass("Did not get an exception thrown");
        }
Example #4
0
        public void GetContextForMessageBody_ValidMessageContent_ShouldBeAbleToHandleMultipleParallelMessages()
        {
            // Arrange
            var mcp = new MessageContextProvider();

            var messages = new List <Mock <IMessage <object> > >();

            for (int i = 0; i < 500; i++)
            {
                var messageMock    = new Mock <IMessage <object> >();
                var messageContent = new object();
                messageMock.Setup(mc => mc.Content).Returns(messageContent);
                messages.Add(messageMock);
            }

            Parallel.ForEach(messages, message =>
            {
                mcp.StoreMessageContext(message.Object);

                // Act
                var messageContext1 = mcp.GetContextForMessageBody(message.Object.Content);
                var messageContext2 = mcp.GetContextForMessageBody(message.Object.Content);

                // Assert
                Assert.AreEqual(message.Object.Content, messageContext1.MessageContent);
                Assert.AreEqual(messageContext1, messageContext2);
            });
        }
Example #5
0
        public void StoreMessageContext_NullMessageContent_ThrowsException()
        {
            var mcp     = new MessageContextProvider();
            var message = new Mock <IMessage <object> >();

            Assert.Throws <MessageContextException>(() => mcp.StoreMessageContext(message.Object));
        }
		public async Task Should_Send_Message_Context_Correctly()
		{
			/* Setup */

			var expectedId = Guid.NewGuid();
			var contextProvider = new MessageContextProvider<MessageContext>(new JsonSerializer(), () => new MessageContext { GlobalRequestId = expectedId });
			using (var subscriber = TestClientFactory.CreateNormal())
			using (var publisher = TestClientFactory.CreateNormal(collection => collection.AddSingleton<IMessageContextProvider<MessageContext>>(contextProvider)))
			{
				var subscribeTcs = new TaskCompletionSource<Guid>();

				subscriber.SubscribeAsync<BasicMessage>((msg, c) =>
				{
					subscribeTcs.SetResult(c.GlobalRequestId);
					return subscribeTcs.Task;
				});

				/* Test */
				publisher.PublishAsync<BasicMessage>();
				await subscribeTcs.Task;

				/* Assert */
				Assert.Equal(expected: expectedId, actual: subscribeTcs.Task.Result);
			}
		}
Example #7
0
        public void Release_ValidMessageContent_ShouldThrowExcptionIfContentNotCurrentlyStored()
        {
            // Arrange
            var mcp     = new MessageContextProvider();
            var message = new Mock <IMessage <object> >();

            message.Setup(mc => mc.Content).Returns(new object());

            // Act
            Assert.Throws <MessageContextException>(() => mcp.ReleaseMessageContext(message.Object));
        }
Example #8
0
        public void Release_ValidMessageContent_ShouldNotThrowExcptionIfContentIsReleasedOnce()
        {
            // Arrange
            var mcp     = new MessageContextProvider();
            var message = new Mock <IMessage <object> >();

            message.Setup(mc => mc.Content).Returns(new object());
            mcp.StoreMessageContext(message.Object);

            // Act
            mcp.ReleaseMessageContext(message.Object);
        }
Example #9
0
        public void Release_NullMessageContent_ShouldIgnoreNulls()
        {
            // Arrange
            var mcp     = new MessageContextProvider();
            var message = new Mock <IMessage <object> >();

            message.Setup(mc => mc.Content).Returns(null);

            // Act
            mcp.ReleaseMessageContext(message.Object);
            Assert.Pass("Did not get an exception thrown");
        }
Example #10
0
        public void StoreMessageContext_ValidMessageContent_ShouldNotThrowException()
        {
            // Arrange
            var mcp     = new MessageContextProvider();
            var message = new Mock <IMessage <object> >();

            message.Setup(mc => mc.Content).Returns(new object());

            // Act
            mcp.StoreMessageContext(message.Object);

            // Assert
            Assert.Pass("Did not get an exception");
        }
Example #11
0
        public void GetContextForMessageBody_ValidMessageContent_ShouldBeAvailableAfterStore()
        {
            // Arrange
            var mcp            = new MessageContextProvider();
            var message        = new Mock <IMessage <object> >();
            var messageContent = new object();

            message.Setup(mc => mc.Content).Returns(messageContent);
            mcp.StoreMessageContext(message.Object);

            // Act
            var messageContext = mcp.GetContextForMessageBody(messageContent);

            // Assert
            Assert.IsNotNull(messageContext);
        }
Example #12
0
        public void GetContextForMessageBody_ValidMessageContent_ShouldBeSameInstanceRetrievedWithEachCallForTheSameContent()
        {
            // Arrange
            var mcp            = new MessageContextProvider();
            var message        = new Mock <IMessage <object> >();
            var messageContent = new object();

            message.Setup(mc => mc.Content).Returns(messageContent);
            mcp.StoreMessageContext(message.Object);

            // Act
            var messageContext1 = mcp.GetContextForMessageBody(messageContent);
            var messageContext2 = mcp.GetContextForMessageBody(messageContent);

            // Assert
            Assert.AreEqual(messageContext1, messageContext2);
        }
		public async void Should_Send_Message_Context_Correctly()
		{
			/* Setup */
			var subscriber = BusClientFactory.CreateDefault();

			var expectedId = Guid.NewGuid();
			var subscribeTcs = new TaskCompletionSource<Guid>();
			var contextProvider = new MessageContextProvider<MessageContext>(() => Task.FromResult(new MessageContext {GlobalRequestId = expectedId}));
			var publisher = BusClientFactory.CreateDefault(collection => collection.AddInstance(typeof (IMessageContextProvider<MessageContext>), contextProvider));
			subscriber.SubscribeAsync<BasicMessage>((msg, c) =>
			{
				subscribeTcs.SetResult(c.GlobalRequestId);
				return subscribeTcs.Task;
			});

			/* Test */
			publisher.PublishAsync<BasicMessage>();
			await subscribeTcs.Task;

			/* Assert */
			Assert.Equal(subscribeTcs.Task.Result, expectedId);
		}
Example #14
0
        public void StoreMessageContext_NullMessage_ThrowsException()
        {
            var mcp = new MessageContextProvider();

            Assert.Throws <MessageContextException>(() => mcp.StoreMessageContext((IMessage <Object>)null));
        }
Example #15
0
        public void Constructor_Valid_Test()
        {
            var mcp = new MessageContextProvider();

            Assert.Pass("Did not throw exception");
        }
        /// <summary>
        /// Creates a default <see cref="IBusClient{TMessageContext}"/> according to config.
        /// </summary>
        /// <remarks>
        /// This component replaces RawRabbit.vNext.BusClientFactory in order to avoid heavy dependency "pollution", but at
        /// the cost of inflexible, hard-wired setup.
        /// </remarks>
        /// <typeparam name="TMessageContext">The type of the context.</typeparam>
        /// <param name="config">The raw rabbit configuration.</param>
        /// <returns>The bus client.</returns>
        public static IBusClient <TMessageContext> CreateDefault <TMessageContext>(RawRabbitConfiguration config)
            where TMessageContext : MessageContext
        {
            var namingConventions      = new NamingConventions();
            var configurationEvaluator = new ConfigurationEvaluator(config, namingConventions);
            var connectionFactory      = CreateConnectionFactory(config);


            var channelConfig    = new ChannelFactoryConfiguration();
            var channelFactory   = new ChannelFactory(connectionFactory, config, channelConfig);
            var consumerFactory  = new EventingBasicConsumerFactory();
            var topologyProvider = new TopologyProvider(channelFactory);
            var jsonSerializer   = new JsonSerializer();
            var serializer       = new MessageSerializer(jsonSerializer);
            IMessageContextProvider <TMessageContext> contextProvider =
                new MessageContextProvider <TMessageContext>(jsonSerializer);

            var contextEnhancer    = new ContextEnhancer(channelFactory, namingConventions);
            var propertiesProvider = new BasicPropertiesProvider(config);
            var errorHandling      = new DefaultStrategy(
                serializer,
                namingConventions,
                propertiesProvider,
                topologyProvider,
                channelFactory);
            ISubscriber <TMessageContext> subscriber = new Subscriber <TMessageContext>(
                channelFactory,
                consumerFactory,
                topologyProvider,
                serializer,
                contextProvider,
                contextEnhancer,
                errorHandling,
                config);

            var acknowledger = new NoAckAcknowledger();
            var publisher    = new Publisher <TMessageContext>(
                channelFactory,
                topologyProvider,
                serializer,
                contextProvider,
                acknowledger,
                propertiesProvider,
                config);
            var responder = new Responder <TMessageContext>(
                channelFactory,
                topologyProvider,
                consumerFactory,
                serializer,
                contextProvider,
                contextEnhancer,
                propertiesProvider,
                errorHandling,
                config);
            var requester = new Requester <TMessageContext>(
                channelFactory,
                consumerFactory,
                serializer,
                contextProvider,
                errorHandling,
                propertiesProvider,
                topologyProvider,
                config);
            var client = new BaseBusClient <TMessageContext>(
                configurationEvaluator,
                subscriber,
                publisher,
                responder,
                requester);

            return(client);
        }