public async Task WhenUsingExtendedCharacters_IsDecodedCorrectly()
{
var settings = TestHelpers.GetSettings();
var handlers = new Dictionary <string, IMessageHandler>();
handlers.Add(typeof(TestMessage1).FullName, new EncodingTestHandler());
var mhf = new GenericMessageHandlerFactory(handlers);
var container = TestHelpers.GetContainer(settings, mhf);
var factory = container.GetInstance <IMessagingFactory>();
var queueName = "my-first-queue";
var sender = factory.CreateMessageSender(queueName);
await sender.Send(new TestMessage1 { TestProperty = "巴黎" });
var handler = factory.MessageHandlerFactory.CreateMessageHandler(typeof(TestMessage1)) as EncodingTestHandler;
await TestHelpers.PumpQueueUntil(factory, queueName, () =>
{
return(handler.Calls.Count == 1);
}).ConfigureAwait(false);
Assert.AreEqual(1, handler.Calls.Count);
Assert.AreEqual(true, handler.ExpectedContentFound);
}
public async Task SendWithIMessageSenderFactory()
{
var settings = TestHelpers.GetSettings();
var queueName = "my-first-queue";
var tenantId = Guid.Parse("CDBFB8A7-FEFF-4559-BFFB-301A2CB4E0BE");
// Do a send using only the sending infrastucture
{
var sendOnlyContainer = TestHelpers.GetSendOnlyContainer(settings);
var senderFactory = sendOnlyContainer.GetInstance<IMessageSenderFactory>();
var sender = senderFactory.CreateMessageSender(queueName);
await sender.Send(new TestMessage1(), null, tenantId);
}
// Receive using the full infrastructure to test that the send worked
var handlers = new Dictionary<string, IMessageHandler>();
handlers.Add(typeof(TestMessage1).FullName, new MessageSenderTestMessageHandler());
var mhf = new GenericMessageHandlerFactory(handlers);
var container = TestHelpers.GetContainer(settings, mhf);
var factory = container.GetInstance<IMessagingFactory>();
var handler = factory.MessageHandlerFactory.CreateMessageHandler(typeof(TestMessage1)) as MessageSenderTestMessageHandler;
await TestHelpers.PumpQueueUntil(factory, queueName, () =>
{
return handler.Calls.Count == 1;
}).ConfigureAwait(false);
Assert.AreEqual(1, handler.Calls.Count);
Assert.AreEqual(true, handler.ExpectedTenantIdFound);
}
public async Task NonTransactionalHandlerSendsMessageToSameQueueOnFailure()
{
var settings = TestHelpers.GetSettings();
var handlers = new Dictionary <string, IMessageHandler>();
handlers.Add(typeof(TestMessage1).FullName, new NonTransactionalHandler());
handlers.Add(typeof(TestMessage2).FullName, new SecondStageHandler());
var mhf = new GenericMessageHandlerFactory(handlers);
var container = TestHelpers.GetContainer(settings, mhf);
var factory = container.GetInstance <IMessagingFactory>();
var nonTransactionalHandler = factory.MessageHandlerFactory.CreateMessageHandler(typeof(TestMessage1)) as NonTransactionalHandler;
var secondStageHandler = factory.MessageHandlerFactory.CreateMessageHandler(typeof(TestMessage2)) as SecondStageHandler;
var sender = factory.CreateMessageSender("my-first-queue");
await sender.Send(new TestMessage1 { TestProperty = "my-first-queue" });
await TestHelpers.PumpQueueUntil(factory, "my-first-queue", () =>
{
return(nonTransactionalHandler.Calls.Count == 2 &&
secondStageHandler.Calls.Count == 1);
});
Assert.AreEqual(2, nonTransactionalHandler.Calls.Count);
Assert.AreEqual(1, secondStageHandler.Calls.Count);
}
public async Task PeekMessagePump_WhenMessageWithTenantIdDoesNotExists_ReturnsFalse()
{
var settings = TestHelpers.GetSettings();
var handlers = new Dictionary <string, IMessageHandler>();
var mhf = new GenericMessageHandlerFactory(handlers);
var container = TestHelpers.GetContainer(settings, mhf);
var factory = container.GetInstance <IMessagingFactory>();
var queueName = "my-first-queue";
var sender = factory.CreateMessageSender(queueName);
var tenantId = Guid.Parse("CDBFB8A7-FEFF-4559-BFFB-301A2CB4E0BE");
await sender.Send(new TestMessage1(), null, tenantId);
var nonExistingTenantId = Guid.Parse("313E92AB-2719-4C6B-8BC4-4A88240E4FB8");
var messagePump = factory.CreatePeekMessagePump(queueName);
var hasMessage = await messagePump.PeekMessage(nonExistingTenantId, new CancellationToken());
Assert.IsFalse(hasMessage);
}
public async Task DuplicateMessageIdsAreReceivedWhenUsingANonDedupQueue()
{
var settings = TestHelpers.GetSettings();
var handlers = new Dictionary <string, IMessageHandler>();
handlers.Add(typeof(TestMessage1).FullName, new DeduplicationTestMessageHandler());
var mhf = new GenericMessageHandlerFactory(handlers);
var container = TestHelpers.GetContainer(settings, mhf);
var factory = container.GetInstance <IMessagingFactory>();
// "my-first-queue" has not been configured to deduplicate messages
var sender = factory.CreateMessageSender("my-first-queue");
var handler = factory.MessageHandlerFactory.CreateMessageHandler(typeof(TestMessage1)) as DeduplicationTestMessageHandler;
await sender.Send(new TestMessage1(), "1234");
await sender.Send(new TestMessage1(), "1234");
await sender.Send(new TestMessage1(), "1234");
await sender.Send(new TestMessage1(), "1234");
await TestHelpers.PumpQueueUntil(factory, "my-first-queue", () =>
{
return(handler.Calls.Count == 4);
}).ConfigureAwait(false);
Assert.AreEqual(4, handler.Calls.Count);
Assert.AreEqual(true, handler.ExpectedIdFound);
}
public async Task MessageSender_WhenTenantIdIsProvided_MessageContainsTenantIdProperty()
{
var settings = TestHelpers.GetSettings();
var handlers = new Dictionary <string, IMessageHandler>();
handlers.Add(typeof(TestMessage1).FullName, new MessageSenderTestMessageHandler());
var mhf = new GenericMessageHandlerFactory(handlers);
var container = TestHelpers.GetContainer(settings, mhf);
var factory = container.GetInstance <IMessagingFactory>();
var queueName = "my-first-queue";
var sender = factory.CreateMessageSender(queueName);
var tenantId = Guid.Parse("CDBFB8A7-FEFF-4559-BFFB-301A2CB4E0BE");
await sender.Send(new TestMessage1(), null, tenantId);
var handler = factory.MessageHandlerFactory.CreateMessageHandler(typeof(TestMessage1)) as MessageSenderTestMessageHandler;
await TestHelpers.PumpQueueUntil(factory, queueName, () =>
{
return(handler.Calls.Count == 1);
}).ConfigureAwait(false);
Assert.AreEqual(1, handler.Calls.Count);
Assert.AreEqual(true, handler.ExpectedTenantIdFound);
}
public async Task MessagesCanBeDeferred(int messageSizeKb, int timesToDefer, int timesToAbandon, bool complete, int expectedCalls)
{
var settings = TestHelpers.GetSettings();
var handlers = new Dictionary <string, IMessageHandler>();
handlers.Add(typeof(DeferralTestMessage).FullName, new DeferralTestMessageHandler());
var mhf = new GenericMessageHandlerFactory(handlers);
var container = TestHelpers.GetContainer(settings, mhf);
var factory = container.GetInstance <IMessagingFactory>();
var handler = factory.MessageHandlerFactory.CreateMessageHandler(typeof(DeferralTestMessage)) as DeferralTestMessageHandler;
var queueName = "my-first-queue";
var sender = factory.CreateMessageSender(queueName);
var message = new DeferralTestMessage()
{
NumberOfTimesToDefer = timesToDefer,
NumberOfTimesToAbandon = timesToAbandon,
Complete = complete,
};
// Pad the ALongString property out to meet the required message size
for (int i = 0; i < messageSizeKb * 16; ++i)
{
message.ALongString += "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
}
// Send a message to be deferred, then abandoned, then deadlettered or completed
await sender.Send(message).ConfigureAwait(false);
await TestHelpers.PumpQueueUntil(factory, queueName, async() =>
{
if (handler.Calls.Count != expectedCalls)
{
return(false);
}
// if we deferred any messages, there should be 2 raw messages in the DLQ - 1 actual message and 1 control message from the deferral
var expectedDeadLetteredItems = 0;
if (complete == false)
{
expectedDeadLetteredItems = timesToDefer > 0 ? 2 : 1;
}
var deadLetterQueue = EntityNameHelper.FormatDeadLetterPath(queueName);
var deadLetteredItems = await TestHelpers.GetAllRawMessagesByContextId(settings, deadLetterQueue).ConfigureAwait(false);
return(expectedDeadLetteredItems == deadLetteredItems.Count);
}).ConfigureAwait(false);
Assert.AreEqual(expectedCalls, handler.Calls.Count);
}
public async Task PerfTest()
{
ServicePointManager.DefaultConnectionLimit = 1000;
var settings = TestHelpers.GetSettings();
settings.PrefetchCount = 300;
var handlers = new Dictionary <string, IMessageHandler>();
handlers.Add(typeof(PerformanceTestMessage).FullName, new PerformanceTestMessageHandler());
var mhf = new GenericMessageHandlerFactory(handlers);
var container = TestHelpers.GetContainer(settings, mhf);
var factory = container.GetInstance <IMessagingFactory>();
var sender = factory.CreateMessageSender("my-first-queue");
using (var t1 = new Timer($"Send {totalMessageCount} messages"))
{
var sendTasks = new Task[totalMessageCount];
for (int i = 0; i < totalMessageCount; ++i)
{
sendTasks[i] = SendMessage(sender);
}
await Task.WhenAll(sendTasks);
}
Console.WriteLine($"Sent {smallMessageCount} {smallMessageSizeKb} KB messages, {mediumMessageCount} {mediumMessageSizeKb} KB messages and {largeMessageCount} {largeMessageSizeKb} KB messages.");
var pump = factory.CreateMessagePump("my-first-queue");
var handler = factory.MessageHandlerFactory.CreateMessageHandler(typeof(PerformanceTestMessage)) as PerformanceTestMessageHandler;
using (var t2 = new Timer($"Receive {totalMessageCount} messages"))
{
await pump.Start();
while (handler.Calls.Count < totalMessageCount)
{
await Task.Delay(1000);
}
await pump.Stop();
}
}
public async Task TransactionalHandlerDoesntSendMessageToDifferentQueueOnFailure()
{
var settings = TestHelpers.GetSettings();
var handlers = new Dictionary <string, IMessageHandler>();
handlers.Add(typeof(TestMessage1).FullName, new TransactionalHandler());
handlers.Add(typeof(TestMessage2).FullName, new SecondStageHandler());
var mhf = new GenericMessageHandlerFactory(handlers);
var container = TestHelpers.GetContainer(settings, mhf);
var factory = container.GetInstance <IMessagingFactory>();
var sender = factory.CreateMessageSender("my-first-queue");
var transactionalHandler = factory.MessageHandlerFactory.CreateMessageHandler(typeof(TestMessage1)) as TransactionalHandler;
// Send a message to the first queue, the handler will send a message to the second queue
// (but will throw an exception and abort the transaction, and the message to the second queue
// will not actually be sent)
await sender.Send(new TestMessage1 { TestProperty = "my-second-queue" });
await TestHelpers.PumpQueueUntil(factory, "my-first-queue", () =>
{
return(transactionalHandler.Calls.Count == 2);
});
// pump the second queue for 5 seconds and verify no message was received
var pump2 = factory.CreateMessagePump("my-second-queue");
await pump2.Start();
await Task.Delay(5000);
await pump2.Stop();
var secondStageHandler = factory.MessageHandlerFactory.CreateMessageHandler(typeof(TestMessage2)) as SecondStageHandler;
Assert.AreEqual(2, transactionalHandler.Calls.Count);
Assert.AreEqual(0, secondStageHandler.Calls.Count);
}
public async Task PeekMessagePump_WhenCanceled_ReturnsTrue()
{
var settings = TestHelpers.GetSettings();
var handlers = new Dictionary <string, IMessageHandler>();
var mhf = new GenericMessageHandlerFactory(handlers);
var container = TestHelpers.GetContainer(settings, mhf);
var factory = container.GetInstance <IMessagingFactory>();
var queueName = "my-first-queue";
var sender = factory.CreateMessageSender(queueName);
var tenantId = Guid.Parse("CDBFB8A7-FEFF-4559-BFFB-301A2CB4E0BE");
var messagePump = factory.CreatePeekMessagePump(queueName);
var cancelledToken = new CancellationToken(true);
var hasMessage = await messagePump.PeekMessage(tenantId, cancelledToken);
Assert.IsTrue(hasMessage);
}
public async Task ExceptionsDeadLetterMessagesWithUsefulDeadLetterFields()
{
var settings = TestHelpers.GetSettings();
var handlers = new Dictionary <string, IMessageHandler>();
handlers.Add(typeof(TestMessage1).FullName, new DeadLetterFieldTestHandler());
var mhf = new GenericMessageHandlerFactory(handlers);
var container = TestHelpers.GetContainer(settings, mhf);
var factory = container.GetInstance <IMessagingFactory>();
// "dedup-queue" has been configured to deduplicate messages
var sender = factory.CreateMessageSender("my-first-queue");
await sender.Send(new TestMessage1(), "1234");
var handler = factory.MessageHandlerFactory.CreateMessageHandler(typeof(TestMessage1)) as DeadLetterFieldTestHandler;
await TestHelpers.PumpQueueUntil(factory, "my-first-queue", () =>
{
return(handler.Calls.Count == 10);
}).ConfigureAwait(false);
Assert.AreEqual(10, handler.Calls.Count);
var deadLetterQueue = EntityNameHelper.FormatDeadLetterPath("my-first-queue");
var deadLetteredItems = await TestHelpers.GetAllRawMessagesByContextId(settings, deadLetterQueue).ConfigureAwait(false);
Assert.AreEqual(1, deadLetteredItems.Count);
Assert.AreEqual("System.ApplicationException: This is an exception that should cause the message to be dead-lettered eventually.", deadLetteredItems[0].UserProperties["DeadLetterReason"]);
var deadLetterErrorDescription = deadLetteredItems[0].UserProperties["DeadLetterErrorDescription"].ToString();
var expectedStartOfDeadLetterErrorDescription = "System.ApplicationException: This is an exception that should cause the message to be dead-lettered eventually.\r\n at RecordPoint.Messaging.AzureServiceBus.IntegrationTest.DeadLetterFieldTestHandler";
Assert.IsTrue(deadLetterErrorDescription.StartsWith(expectedStartOfDeadLetterErrorDescription));
Assert.IsTrue(deadLetterErrorDescription.Length <= 1024);
}
[Ignore] // hangs in the CI build
public async Task TransactionalHandlerFailsWithExplicitDbTransactions()
{
var settings = TestHelpers.GetSettings();
var handlers = new Dictionary <string, IMessageHandler>();
handlers.Add(typeof(TestMessage1).FullName, new TransactionalHandlerWithDbTransaction());
var mhf = new GenericMessageHandlerFactory(handlers);
var container = TestHelpers.GetContainer(settings, mhf);
var factory = container.GetInstance <IMessagingFactory>();
var sender = factory.CreateMessageSender("my-first-queue");
var transactionalHandler = factory.MessageHandlerFactory.CreateMessageHandler(typeof(TestMessage1)) as TransactionalHandlerWithDbTransaction;
await sender.Send(new TestMessage1());
await TestHelpers.PumpQueueUntil(factory, "my-first-queue", () =>
{
return(transactionalHandler.Calls.Count == 2);
});
Assert.AreEqual(0, transactionalHandler.CommittedTransactions.Count);
}
