public async Task CanSendSequenceSection(IEnumerable <IList <object> > sequence)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
var sender = client.CreateSender(scope.QueueName);
var msg = new ServiceBusMessage();
msg.GetRawAmqpMessage().Body = AmqpMessageBody.FromSequence(sequence);
await sender.SendMessageAsync(msg);
var receiver = client.CreateReceiver(scope.QueueName);
var received = await receiver.ReceiveMessageAsync();
received.GetRawAmqpMessage().Body.TryGetSequence(out IEnumerable <IList <object> > receivedData);
var outerEnum = receivedData.GetEnumerator();
foreach (IList <object> seq in sequence)
{
outerEnum.MoveNext();
var innerEnum = outerEnum.Current.GetEnumerator();
foreach (object elem in seq)
{
innerEnum.MoveNext();
Assert.AreEqual(elem, innerEnum.Current);
}
}
Assert.That(
() => received.Body,
Throws.InstanceOf <NotSupportedException>());
}
}
public async Task CanRoundTripAbsoluteExpiryCreationTime()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
var message = new ServiceBusMessage();
var amqpMessage = message.GetRawAmqpMessage();
// body
amqpMessage.Body = AmqpMessageBody.FromValue("body");
// properties
var expiry = DateTimeOffset.Now.AddDays(1);
var creation = DateTimeOffset.Now.AddMinutes(1);
amqpMessage.Properties.AbsoluteExpiryTime = expiry;
amqpMessage.Properties.CreationTime = creation;
var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
var sender = client.CreateSender(scope.QueueName);
var now = DateTimeOffset.UtcNow;
await sender.SendMessageAsync(message);
var receiver = client.CreateReceiver(scope.QueueName);
var received = (await receiver.ReceiveMessageAsync()).GetRawAmqpMessage();
received.Body.TryGetValue(out var body);
Assert.AreEqual("body", body);
Assert.AreEqual(expiry.ToUnixTimeSeconds(), received.Properties.AbsoluteExpiryTime.Value.ToUnixTimeSeconds());
Assert.AreEqual(creation.ToUnixTimeSeconds(), received.Properties.CreationTime.Value.ToUnixTimeSeconds());
}
}
public async Task CanSendSequenceSection()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
var sender = client.CreateSender(scope.QueueName);
var msg = new ServiceBusMessage();
var sequence = new List <IList <object> >();
sequence.Add(new List <object> {
"first", 1
});
sequence.Add(new List <object> {
"second", 2
});
msg.GetRawAmqpMessage().Body = new AmqpMessageBody(sequence);
await sender.SendMessageAsync(msg);
var receiver = client.CreateReceiver(scope.QueueName);
var received = await receiver.ReceiveMessageAsync();
received.GetRawAmqpMessage().Body.TryGetSequence(out IEnumerable <IList <object> > receivedData);
var receivedSequence = receivedData.ToList();
Assert.AreEqual("first", receivedSequence[0][0]);
Assert.AreEqual(1, receivedSequence[0][1]);
Assert.AreEqual("second", receivedSequence[1][0]);
Assert.AreEqual(2, receivedSequence[1][1]);
Assert.That(
() => received.Body,
Throws.InstanceOf <NotSupportedException>());
}
}
public async Task CanSendValueSection(object value)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
var sender = client.CreateSender(scope.QueueName);
var msg = new ServiceBusMessage();
msg.GetRawAmqpMessage().Body = AmqpMessageBody.FromValue(value);
await sender.SendMessageAsync(msg);
var receiver = client.CreateReceiver(scope.QueueName);
var received = await receiver.ReceiveMessageAsync();
received.GetRawAmqpMessage().Body.TryGetValue(out var receivedData);
Assert.AreEqual(value, receivedData);
Assert.That(
() => received.Body,
Throws.InstanceOf <NotSupportedException>());
var sendable = new ServiceBusMessage(received);
sendable.GetRawAmqpMessage().Body.TryGetValue(out var sendData);
Assert.AreEqual(value, sendData);
}
}
public async Task CanSetMessageId()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
var sender = client.CreateSender(scope.QueueName);
var msg = new ServiceBusMessage();
msg.GetRawAmqpMessage().Body = new AmqpMessageBody(new ReadOnlyMemory <byte>[]
{
new ReadOnlyMemory <byte>(GetRandomBuffer(100)),
new ReadOnlyMemory <byte>(GetRandomBuffer(100))
});
Guid guid = Guid.NewGuid();
msg.GetRawAmqpMessage().Properties.MessageId = new AmqpMessageId(guid.ToString());
await sender.SendMessageAsync(msg);
var receiver = client.CreateReceiver(scope.QueueName);
var received = await receiver.ReceiveMessageAsync();
Assert.AreEqual(guid.ToString(), received.MessageId);
}
}
public async Task CanSendMultipleDataSections()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
var sender = client.CreateSender(scope.QueueName);
var msg = new ServiceBusMessage();
var amqp = new AmqpAnnotatedMessage(
new AmqpMessageBody(
new ReadOnlyMemory <byte>[]
{
new ReadOnlyMemory <byte>(GetRandomBuffer(100)),
new ReadOnlyMemory <byte>(GetRandomBuffer(100))
}));
msg.AmqpMessage = amqp;
await sender.SendMessageAsync(msg);
var receiver = client.CreateReceiver(scope.QueueName);
var received = await receiver.ReceiveMessageAsync();
received.GetRawAmqpMessage().Body.TryGetData(out var receivedData);
var bodyEnum = receivedData.GetEnumerator();
int ct = 0;
msg.GetRawAmqpMessage().Body.TryGetData(out var sentData);
foreach (ReadOnlyMemory <byte> data in sentData)
{
bodyEnum.MoveNext();
var bytes = data.ToArray();
Assert.AreEqual(bytes, bodyEnum.Current.ToArray());
if (ct++ == 0)
{
Assert.AreEqual(bytes, received.Body.ToMemory().Slice(0, 100).ToArray());
}
else
{
Assert.AreEqual(bytes, received.Body.ToMemory().Slice(100, 100).ToArray());
}
}
}
}
public async Task CreateFromReceivedMessageCopiesProperties()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: true, enableSession: true))
{
var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
var sender = client.CreateSender(scope.QueueName);
var msg = new ServiceBusMessage(new BinaryData(GetRandomBuffer(100)));
msg.ContentType = "contenttype";
msg.CorrelationId = "correlationid";
msg.Subject = "label";
msg.MessageId = "messageId";
msg.PartitionKey = "key";
msg.ApplicationProperties.Add("testProp", "my prop");
msg.ReplyTo = "replyto";
msg.ReplyToSessionId = "replytosession";
msg.ScheduledEnqueueTime = DateTimeOffset.Now;
msg.SessionId = "key";
msg.TimeToLive = TimeSpan.FromSeconds(60);
msg.To = "to";
await sender.SendMessageAsync(msg);
ServiceBusSessionReceiver receiver = await client.AcceptNextSessionAsync(scope.QueueName);
ServiceBusReceivedMessage received = await receiver.ReceiveMessageAsync();
AmqpAnnotatedMessage rawReceived = received.GetRawAmqpMessage();
Assert.IsNotNull(rawReceived.Header.DeliveryCount);
Assert.IsTrue(rawReceived.MessageAnnotations.ContainsKey(AmqpMessageConstants.LockedUntilName));
Assert.IsTrue(rawReceived.MessageAnnotations.ContainsKey(AmqpMessageConstants.SequenceNumberName));
Assert.IsTrue(rawReceived.MessageAnnotations.ContainsKey(AmqpMessageConstants.EnqueueSequenceNumberName));
Assert.IsTrue(rawReceived.MessageAnnotations.ContainsKey(AmqpMessageConstants.EnqueuedTimeUtcName));
AssertMessagesEqual(msg, received);
var toSend = new ServiceBusMessage(received);
AmqpAnnotatedMessage rawSend = toSend.GetRawAmqpMessage();
// verify that all system set properties have been cleared out
Assert.IsNull(rawSend.Header.DeliveryCount);
Assert.IsFalse(rawSend.MessageAnnotations.ContainsKey(AmqpMessageConstants.LockedUntilName));
Assert.IsFalse(rawSend.MessageAnnotations.ContainsKey(AmqpMessageConstants.SequenceNumberName));
Assert.IsFalse(rawSend.MessageAnnotations.ContainsKey(AmqpMessageConstants.DeadLetterSourceName));
Assert.IsFalse(rawSend.MessageAnnotations.ContainsKey(AmqpMessageConstants.EnqueueSequenceNumberName));
Assert.IsFalse(rawSend.MessageAnnotations.ContainsKey(AmqpMessageConstants.EnqueuedTimeUtcName));
Assert.IsFalse(rawSend.MessageAnnotations.ContainsKey(AmqpMessageConstants.DeadLetterSourceName));
Assert.IsFalse(toSend.ApplicationProperties.ContainsKey(AmqpMessageConstants.DeadLetterReasonHeader));
Assert.IsFalse(toSend.ApplicationProperties.ContainsKey(AmqpMessageConstants.DeadLetterErrorDescriptionHeader));
AssertMessagesEqual(toSend, received);
void AssertMessagesEqual(ServiceBusMessage sentMessage, ServiceBusReceivedMessage received)
{
Assert.IsTrue(received.Body.ToArray().SequenceEqual(sentMessage.Body.ToArray()));
Assert.AreEqual(received.ContentType, sentMessage.ContentType);
Assert.AreEqual(received.CorrelationId, sentMessage.CorrelationId);
Assert.AreEqual(received.Subject, sentMessage.Subject);
Assert.AreEqual(received.ContentType, sentMessage.ContentType);
Assert.AreEqual(received.CorrelationId, sentMessage.CorrelationId);
Assert.AreEqual(received.MessageId, sentMessage.MessageId);
Assert.AreEqual(received.PartitionKey, sentMessage.PartitionKey);
Assert.AreEqual((string)received.ApplicationProperties["testProp"], (string)sentMessage.ApplicationProperties["testProp"]);
Assert.AreEqual(received.ReplyTo, sentMessage.ReplyTo);
Assert.AreEqual(received.ReplyToSessionId, sentMessage.ReplyToSessionId);
Assert.AreEqual(received.ScheduledEnqueueTime.UtcDateTime.Second, sentMessage.ScheduledEnqueueTime.UtcDateTime.Second);
Assert.AreEqual(received.SessionId, sentMessage.SessionId);
Assert.AreEqual(received.TimeToLive, sentMessage.TimeToLive);
Assert.AreEqual(received.To, sentMessage.To);
Assert.AreEqual(received.TransactionPartitionKey, sentMessage.TransactionPartitionKey);
}
}
}
public async Task CanRoundTripAmqpProperties(bool enableSession)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: enableSession))
{
var message = new ServiceBusMessage();
var amqpMessage = message.GetRawAmqpMessage();
// body
amqpMessage.Body = AmqpMessageBody.FromValue("body");
// header
amqpMessage.Header.TimeToLive = TimeSpan.FromSeconds(50);
amqpMessage.Header.DeliveryCount = 3;
amqpMessage.Header.Durable = true;
amqpMessage.Header.FirstAcquirer = true;
amqpMessage.Header.Priority = 1;
// footer
amqpMessage.Footer.Add("footerKey1", "footerVal1");
amqpMessage.Footer.Add("footerKey2", "footerVal2");
// properties
amqpMessage.Properties.AbsoluteExpiryTime = DateTimeOffset.Now.AddDays(1);
amqpMessage.Properties.ContentEncoding = "compress";
amqpMessage.Properties.ContentType = "application/json";
amqpMessage.Properties.CorrelationId = new AmqpMessageId("correlationId");
amqpMessage.Properties.CreationTime = DateTimeOffset.Now.AddDays(1);
amqpMessage.Properties.GroupId = "groupId";
amqpMessage.Properties.GroupSequence = 5;
amqpMessage.Properties.MessageId = new AmqpMessageId("messageId");
amqpMessage.Properties.ReplyTo = new AmqpAddress("replyTo");
amqpMessage.Properties.ReplyToGroupId = "replyToGroupId";
amqpMessage.Properties.Subject = "subject";
amqpMessage.Properties.To = new AmqpAddress("to");
amqpMessage.Properties.UserId = new byte[] { 1, 2, 3 };
// application properties
amqpMessage.ApplicationProperties.Add("applicationKey1", "applicationVal1");
amqpMessage.ApplicationProperties.Add("applicationKey2", "applicationVal2");
// message annotations
amqpMessage.MessageAnnotations.Add("messageAnnotationKey1", "messageAnnotationVal1");
amqpMessage.MessageAnnotations.Add("messageAnnotationKey2", "messageAnnotationVal2");
// delivery annotations
amqpMessage.DeliveryAnnotations.Add("deliveryAnnotationKey1", "deliveryAnnotationVal1");
amqpMessage.DeliveryAnnotations.Add("deliveryAnnotationKey2", "deliveryAnnotationVal2");
var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
var sender = client.CreateSender(scope.QueueName);
var now = DateTimeOffset.UtcNow;
await sender.SendMessageAsync(message);
var receiver = enableSession ? await client.AcceptNextSessionAsync(scope.QueueName)
: client.CreateReceiver(scope.QueueName);
var received = (await receiver.ReceiveMessageAsync()).GetRawAmqpMessage();
received.Body.TryGetValue(out var body);
Assert.AreEqual("body", body);
Assert.AreEqual(TimeSpan.FromSeconds(50), received.Header.TimeToLive);
// the broker will disregard the value set for delivery count
Assert.AreEqual(1, received.Header.DeliveryCount);
Assert.IsTrue(received.Header.Durable);
Assert.IsTrue(received.Header.FirstAcquirer);
Assert.AreEqual(1, received.Header.Priority);
Assert.AreEqual("compress", received.Properties.ContentEncoding);
Assert.AreEqual("application/json", received.Properties.ContentType);
Assert.AreEqual(new AmqpMessageId("correlationId"), received.Properties.CorrelationId);
Assert.AreEqual("groupId", received.Properties.GroupId);
Assert.AreEqual(5, received.Properties.GroupSequence);
Assert.AreEqual(new AmqpMessageId("messageId"), received.Properties.MessageId);
Assert.AreEqual(new AmqpAddress("replyTo"), received.Properties.ReplyTo);
Assert.AreEqual("replyToGroupId", received.Properties.ReplyToGroupId);
Assert.AreEqual("subject", received.Properties.Subject);
Assert.AreEqual(new AmqpAddress("to"), received.Properties.To);
Assert.AreEqual(new byte[] { 1, 2, 3 }, received.Properties.UserId.Value.ToArray());
// since TTL was set these were overriden - provide some buffer since the Now time is
Assert.That(received.Properties.CreationTime, Is.EqualTo(now).Within(TimeSpan.FromSeconds(1)));
Assert.That(received.Properties.AbsoluteExpiryTime, Is.EqualTo(now.Add(TimeSpan.FromSeconds(50))).Within(TimeSpan.FromSeconds(1)));
// application properties
Assert.AreEqual(received.ApplicationProperties["applicationKey1"], "applicationVal1");
Assert.AreEqual(received.ApplicationProperties["applicationKey2"], "applicationVal2");
// message annotations
Assert.AreEqual(received.MessageAnnotations["messageAnnotationKey1"], "messageAnnotationVal1");
Assert.AreEqual(received.MessageAnnotations["messageAnnotationKey2"], "messageAnnotationVal2");
// delivery annotations
Assert.AreEqual(received.DeliveryAnnotations["deliveryAnnotationKey1"], "deliveryAnnotationVal1");
Assert.AreEqual(received.DeliveryAnnotations["deliveryAnnotationKey2"], "deliveryAnnotationVal2");
}
}