public async Task ReceiveMessagesInReceiveAndDeleteMode()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var sender = new QueueSenderClient(TestEnvironment.ServiceBusConnectionString, scope.QueueName);
var messageCount = 10;
IEnumerable <ServiceBusMessage> messages = GetMessages(messageCount);
await sender.SendRangeAsync(messages);
var clientOptions = new QueueReceiverClientOptions()
{
ReceiveMode = ReceiveMode.ReceiveAndDelete,
};
var receiver = new QueueReceiverClient(TestEnvironment.ServiceBusConnectionString, scope.QueueName, clientOptions);
var receivedMessageCount = 0;
var messageEnum = messages.GetEnumerator();
await foreach (var item in receiver.ReceiveBatchAsync(messageCount))
{
messageEnum.MoveNext();
Assert.AreEqual(item.MessageId, messageEnum.Current.MessageId);
receivedMessageCount++;
}
Assert.AreEqual(receivedMessageCount, messageCount);
var message = receiver.PeekAsync();
Assert.IsNull(message.Result);
}
}
public async Task Peek()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var sender = new QueueSenderClient(TestEnvironment.ServiceBusConnectionString, scope.QueueName);
var messageCt = 10;
IEnumerable <ServiceBusMessage> sentMessages = GetMessages(messageCt);
await sender.SendRangeAsync(sentMessages);
await using var receiver = new QueueReceiverClient(TestEnvironment.ServiceBusConnectionString, scope.QueueName);
Dictionary <string, string> sentMessageIdToLabel = new Dictionary <string, string>();
foreach (ServiceBusMessage message in sentMessages)
{
sentMessageIdToLabel.Add(message.MessageId, Encoding.Default.GetString(message.Body));
}
IAsyncEnumerable <ServiceBusMessage> peekedMessages = receiver.PeekRangeAsync(
maxMessages: messageCt);
var ct = 0;
await foreach (ServiceBusMessage peekedMessage in peekedMessages)
{
var peekedText = Encoding.Default.GetString(peekedMessage.Body);
//var sentText = sentMessageIdToLabel[peekedMessage.MessageId];
//sentMessageIdToLabel.Remove(peekedMessage.MessageId);
//Assert.AreEqual(sentText, peekedText);
TestContext.Progress.WriteLine($"{peekedMessage.Label}: {peekedText}");
ct++;
}
Assert.AreEqual(messageCt, ct);
}
}
public async Task ReceiveMessagesInPeekLockMode()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var sender = new QueueSenderClient(TestEnvironment.ServiceBusConnectionString, scope.QueueName);
var messageCount = 10;
IEnumerable <ServiceBusMessage> messages = GetMessages(messageCount);
await sender.SendRangeAsync(messages);
var receiver = new QueueReceiverClient(TestEnvironment.ServiceBusConnectionString, scope.QueueName);
var receivedMessageCount = 0;
var messageEnum = messages.GetEnumerator();
await foreach (var item in receiver.ReceiveBatchAsync(messageCount))
{
receivedMessageCount++;
messageEnum.MoveNext();
Assert.AreEqual(item.MessageId, messageEnum.Current.MessageId);
Assert.AreEqual(item.SystemProperties.DeliveryCount, 1);
}
Assert.AreEqual(receivedMessageCount, messageCount);
messageEnum.Reset();
IAsyncEnumerable <ServiceBusMessage> peekMessages = receiver.PeekRangeAsync(messageCount);
await foreach (var item in peekMessages)
{
messageEnum.MoveNext();
Assert.AreEqual(item.MessageId, messageEnum.Current.MessageId);
}
}
}
public async Task Send_ConnString()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var sender = new QueueSenderClient(TestEnvironment.ServiceBusConnectionString, scope.QueueName);
await sender.SendRangeAsync(GetMessages(10));
}
}
public async Task ClientProperties()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var sender = new QueueSenderClient(TestEnvironment.ServiceBusConnectionString, scope.QueueName);
Assert.AreEqual(scope.QueueName, sender.EntityName);
Assert.AreEqual(TestEnvironment.FullyQualifiedNamespace, sender.FullyQualifiedNamespace);
}
}
public async Task Peek_Session(long?sequenceNumber, string partitionKey)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var sender = new QueueSenderClient(TestEnvironment.ServiceBusConnectionString, scope.QueueName);
var messageCt = 10;
var sessionId = Guid.NewGuid().ToString();
// send the messages
IEnumerable <ServiceBusMessage> sentMessages = GetMessages(messageCt, sessionId, partitionKey);
await sender.SendRangeAsync(sentMessages);
Dictionary <string, ServiceBusMessage> sentMessageIdToMsg = new Dictionary <string, ServiceBusMessage>();
foreach (ServiceBusMessage message in sentMessages)
{
sentMessageIdToMsg.Add(message.MessageId, message);
}
// peek the messages
var sessionSettings = new SessionOptions()
{
Connection = new ServiceBusConnection(
TestEnvironment.ServiceBusConnectionString,
scope.QueueName),
SessionId = sessionId
};
var receiver = new QueueReceiverClient(
TestEnvironment.ServiceBusConnectionString,
scope.QueueName,
sessionSettings);
sequenceNumber ??= 1;
IAsyncEnumerable <ServiceBusMessage> peekedMessages = receiver.PeekRangeBySequenceAsync(
fromSequenceNumber: (long)sequenceNumber,
maxMessages: messageCt);
// verify peeked == send
var ct = 0;
await foreach (ServiceBusMessage peekedMessage in peekedMessages)
{
var peekedText = Encoding.Default.GetString(peekedMessage.Body);
var sentMsg = sentMessageIdToMsg[peekedMessage.MessageId];
sentMessageIdToMsg.Remove(peekedMessage.MessageId);
Assert.AreEqual(Encoding.Default.GetString(sentMsg.Body), peekedText);
Assert.AreEqual(sentMsg.PartitionKey, peekedMessage.PartitionKey);
Assert.IsTrue(peekedMessage.SystemProperties.SequenceNumber >= sequenceNumber);
TestContext.Progress.WriteLine($"{peekedMessage.Label}: {peekedText}");
ct++;
}
if (sequenceNumber == 1)
{
Assert.AreEqual(messageCt, ct);
}
}
}
public void ClientProperties()
{
var account = Encoding.Default.GetString(GetRandomBuffer(12));
var fullyQualifiedNamespace = new UriBuilder($"{account}.servicebus.windows.net/").Host;
var connString = $"Endpoint=sb://{fullyQualifiedNamespace};SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey={Encoding.Default.GetString(GetRandomBuffer(64))}";
var queueName = Encoding.Default.GetString(GetRandomBuffer(12));
var sender = new QueueSenderClient(connString, queueName);
Assert.AreEqual(queueName, sender.EntityName);
Assert.AreEqual(fullyQualifiedNamespace, sender.FullyQualifiedNamespace);
}
public async Task Send_Token()
{
ClientSecretCredential credential = new ClientSecretCredential(
TestEnvironment.ServiceBusTenant,
TestEnvironment.ServiceBusClient,
TestEnvironment.ServiceBusSecret);
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var sender = new QueueSenderClient(TestEnvironment.FullyQualifiedNamespace, scope.QueueName, credential);
await sender.SendAsync(GetMessage());
}
}
public async Task RoundRobinSessions()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var sender = new QueueSenderClient(TestEnvironment.ServiceBusConnectionString, scope.QueueName);
var messageCt = 10;
HashSet <string> sessions = new HashSet <string>()
{
"1", "2", "3"
};
// send the messages
foreach (string session in sessions)
{
await sender.SendRangeAsync(GetMessages(messageCt, session));
}
// create receiver not scoped to a specific session
for (int i = 0; i < 10; i++)
{
var sessionSettings = new SessionOptions()
{
Connection = new ServiceBusConnection(
TestEnvironment.ServiceBusConnectionString,
scope.QueueName),
SessionId = null
};
var receiver = new QueueReceiverClient(
TestEnvironment.ServiceBusConnectionString,
scope.QueueName,
sessionSettings);
IAsyncEnumerable <ServiceBusMessage> peekedMessages = receiver.PeekRangeBySequenceAsync(
fromSequenceNumber: 1,
maxMessages: 10);
await foreach (ServiceBusMessage peekedMessage in peekedMessages)
{
var sessionId = await receiver.Session.GetSessionId();
Assert.AreEqual(sessionId, peekedMessage.SessionId);
}
// Close the receiver client when we are done with it. Since the sessionClient doesn't own the underlying connection, the connection remains open, but the session link will be closed.
await receiver.CloseAsync();
}
}
}
public async Task PeekRange_IncrementsSequenceNumber(int messageCt, int peekCt)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
var sender = new QueueSenderClient(
TestEnvironment.ServiceBusConnectionString,
scope.QueueName);
var sessionId = Guid.NewGuid().ToString();
// send the messages
IEnumerable <ServiceBusMessage> sentMessages = GetMessages(messageCt, sessionId);
await sender.SendRangeAsync(sentMessages);
var sessionSettings = new SessionOptions()
{
Connection = new ServiceBusConnection(
TestEnvironment.ServiceBusConnectionString,
scope.QueueName),
SessionId = sessionId
};
var receiver = new QueueReceiverClient(
TestEnvironment.ServiceBusConnectionString,
scope.QueueName,
sessionSettings);
long seq = 0;
for (int i = 0; i < messageCt / peekCt; i++)
{
IAsyncEnumerable <ServiceBusMessage> peekedMessages = receiver.PeekRangeAsync(
maxMessages: peekCt);
await foreach (ServiceBusMessage msg in peekedMessages)
{
Assert.IsTrue(msg.SystemProperties.SequenceNumber > seq);
if (seq > 0)
{
Assert.IsTrue(msg.SystemProperties.SequenceNumber == seq + 1);
}
seq = msg.SystemProperties.SequenceNumber;
}
}
}
}
public async Task Schedule()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var sender = new QueueSenderClient(TestEnvironment.ServiceBusConnectionString, scope.QueueName);
var scheduleTime = DateTimeOffset.UtcNow.AddHours(10);
var sequenceNum = await sender.ScheduleMessageAsync(GetMessage(), scheduleTime);
await using var receiver = new QueueReceiverClient(TestEnvironment.ServiceBusConnectionString, scope.QueueName);
ServiceBusMessage msg = await receiver.PeekBySequenceAsync(sequenceNum);
Assert.AreEqual(0, Convert.ToInt32(new TimeSpan(scheduleTime.Ticks - msg.ScheduledEnqueueTimeUtc.Ticks).TotalSeconds));
await sender.CancelScheduledMessageAsync(sequenceNum);
msg = await receiver.PeekBySequenceAsync(sequenceNum);
Assert.IsNull(msg);
}
}
public async Task PeekMultipleSessions_ShouldThrow()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var sender = new QueueSenderClient(TestEnvironment.ServiceBusConnectionString, scope.QueueName);
var messageCt = 10;
var sessionId = Guid.NewGuid().ToString();
// send the messages
IEnumerable <ServiceBusMessage> sentMessages = GetMessages(messageCt, sessionId);
await sender.SendRangeAsync(sentMessages);
var sessionSettings = new SessionOptions()
{
Connection = new ServiceBusConnection(
TestEnvironment.ServiceBusConnectionString,
scope.QueueName),
SessionId = sessionId
};
var receiver1 = new QueueReceiverClient(
TestEnvironment.ServiceBusConnectionString,
scope.QueueName,
sessionSettings);
var receiver2 = new QueueReceiverClient(
TestEnvironment.ServiceBusConnectionString,
scope.QueueName,
sessionSettings);
Dictionary <string, ServiceBusMessage> sentMessageIdToMsg = new Dictionary <string, ServiceBusMessage>();
// peek the messages
IAsyncEnumerable <ServiceBusMessage> peekedMessages1 = receiver1.PeekRangeBySequenceAsync(
fromSequenceNumber: 1,
maxMessages: messageCt);
IAsyncEnumerable <ServiceBusMessage> peekedMessages2 = receiver2.PeekRangeBySequenceAsync(
fromSequenceNumber: 1,
maxMessages: messageCt);
await peekedMessages1.GetAsyncEnumerator().MoveNextAsync();
Assert.That(async() => await peekedMessages2.GetAsyncEnumerator().MoveNextAsync(), Throws.Exception);
}
}
