public async Task PeekMultipleSessions_ShouldThrow()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var sender = new ServiceBusSenderClient(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);
await using var receiver1 = new SessionReceiverClient(sessionId, TestEnvironment.ServiceBusConnectionString, scope.QueueName);
await using var receiver2 = new SessionReceiverClient(sessionId, TestEnvironment.ServiceBusConnectionString, scope.QueueName);
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);
}
}
public async Task Peek_IncrementsSequenceNmber(int messageCt)
{
var sender = new ServiceBusSenderClient(ConnString, SessionQueueName);
var sessionId = Guid.NewGuid().ToString();
// send the messages
IEnumerable <ServiceBusMessage> sentMessages = GetMessages(messageCt, sessionId);
await sender.SendRangeAsync(sentMessages);
var receiver = new SessionReceiverClient(sessionId, ConnString, SessionQueueName);
long seq = 0;
for (int i = 0; i < messageCt; i++)
{
ServiceBusMessage msg = await receiver.PeekAsync();
Assert.IsTrue(msg.SystemProperties.SequenceNumber > seq);
if (seq > 0)
{
Assert.IsTrue(msg.SystemProperties.SequenceNumber == seq + 1);
}
seq = msg.SystemProperties.SequenceNumber;
}
}
public async Task PeekRange_IncrementsSequenceNmber(int messageCt, int peekCt)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
var sender = new ServiceBusSenderClient(TestEnvironment.ServiceBusConnectionString, scope.QueueName);
var sessionId = Guid.NewGuid().ToString();
// send the messages
IEnumerable <ServiceBusMessage> sentMessages = GetMessages(messageCt, sessionId);
await sender.SendRangeAsync(sentMessages);
await using var receiver = new SessionReceiverClient(sessionId, TestEnvironment.ServiceBusConnectionString, scope.QueueName);
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 Peek_IncrementsSequenceNmber(int messageCt)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var sender = new ServiceBusSenderClient(TestEnvironment.ServiceBusConnectionString, scope.QueueName);
var sessionId = Guid.NewGuid().ToString();
// send the messages
IEnumerable <ServiceBusMessage> sentMessages = GetMessages(messageCt, sessionId);
await sender.SendBatchAsync(sentMessages);
var options = new ServiceBusReceiverClientOptions()
{
SessionId = sessionId,
IsSessionEntity = true
};
var receiver = new ServiceBusReceiverClient(
TestEnvironment.ServiceBusConnectionString,
scope.QueueName,
options);
long seq = 0;
for (int i = 0; i < messageCt; i++)
{
ServiceBusMessage msg = await receiver.PeekAsync();
Assert.IsTrue(msg.SystemProperties.SequenceNumber > seq);
if (seq > 0)
{
Assert.IsTrue(msg.SystemProperties.SequenceNumber == seq + 1);
}
seq = msg.SystemProperties.SequenceNumber;
}
}
}
public void ClientProperties()
{
var sender = new ServiceBusSenderClient(ConnString, QueueName);
Assert.AreEqual(QueueName, sender.EntityName);
Assert.AreEqual(Endpoint, sender.FullyQualifiedNamespace);
}
public async Task Peek()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var sender = new ServiceBusSenderClient(TestEnvironment.ServiceBusConnectionString, scope.QueueName);
var messageCt = 10;
IEnumerable <ServiceBusMessage> sentMessages = GetMessages(messageCt);
await sender.SendBatchAsync(sentMessages);
await using var receiver = new ServiceBusReceiverClient(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));
}
var ct = 0;
foreach (ServiceBusMessage peekedMessage in await receiver.PeekBatchAsync(
maxMessages: messageCt))
{
var peekedText = Encoding.Default.GetString(peekedMessage.Body);
ct++;
}
Assert.AreEqual(messageCt, ct);
}
}
public async Task DeferMessages(bool isSessionSpecified)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var sender = new ServiceBusSenderClient(TestEnvironment.ServiceBusConnectionString, scope.QueueName);
var messageCount = 10;
var sessionId = "sessionId1";
IEnumerable <ServiceBusMessage> messages = GetMessages(messageCount, sessionId);
await sender.SendBatchAsync(messages);
var clientOptions = new ServiceBusReceiverClientOptions()
{
SessionId = isSessionSpecified ? sessionId : null,
IsSessionEntity = true,
};
var receiver = new ServiceBusReceiverClient(TestEnvironment.ServiceBusConnectionString, scope.QueueName, clientOptions);
var receivedMessageCount = 0;
var messageEnum = messages.GetEnumerator();
foreach (var item in await receiver.ReceiveBatchAsync(messageCount))
{
receivedMessageCount++;
messageEnum.MoveNext();
Assert.AreEqual(item.MessageId, messageEnum.Current.MessageId);
Assert.AreEqual(item.SessionId, messageEnum.Current.SessionId);
await receiver.DeferAsync(item.SystemProperties.LockToken);
}
Assert.AreEqual(receivedMessageCount, messageCount);
// TODO: Call ReceiveDeferredMessageAsync() to verify the messages
}
}
public async Task Peek()
{
var sender = new ServiceBusSenderClient(ConnString, QueueName);
var messageCt = 10;
IEnumerable <ServiceBusMessage> sentMessages = GetMessages(messageCt);
await sender.SendRangeAsync(sentMessages);
var receiver = new QueueReceiverClient(ConnString, 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 PeekMultipleSessions_ShouldThrow()
{
var sender = new ServiceBusSenderClient(ConnString, SessionQueueName);
var messageCt = 10;
var sessionId = Guid.NewGuid().ToString();
// send the messages
IEnumerable <ServiceBusMessage> sentMessages = GetMessages(messageCt, sessionId);
await sender.SendRangeAsync(sentMessages);
var receiver1 = new SessionReceiverClient(sessionId, ConnString, SessionQueueName);
var receiver2 = new SessionReceiverClient(sessionId, ConnString, SessionQueueName);
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();
try
{
await peekedMessages2.GetAsyncEnumerator().MoveNextAsync();
}
catch (Exception)
{
return;
}
Assert.Fail("No exception!");
}
public async Task ReceiveMessagesInReceiveAndDeleteMode()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var sender = new ServiceBusSenderClient(TestEnvironment.ServiceBusConnectionString, scope.QueueName);
var messageCount = 10;
IEnumerable <ServiceBusMessage> messages = GetMessages(messageCount);
await sender.SendBatchAsync(messages);
var clientOptions = new ServiceBusReceiverClientOptions()
{
ReceiveMode = ReceiveMode.ReceiveAndDelete,
};
var receiver = new ServiceBusReceiverClient(TestEnvironment.ServiceBusConnectionString, scope.QueueName, clientOptions);
var receivedMessageCount = 0;
var messageEnum = messages.GetEnumerator();
foreach (var item in await receiver.ReceiveBatchAsync(messageCount).ConfigureAwait(false))
{
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 CompleteMessages()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var sender = new ServiceBusSenderClient(TestEnvironment.ServiceBusConnectionString, scope.QueueName);
var messageCount = 10;
IEnumerable <ServiceBusMessage> messages = GetMessages(messageCount);
await sender.SendBatchAsync(messages);
var receiver = new ServiceBusReceiverClient(TestEnvironment.ServiceBusConnectionString, scope.QueueName);
var receivedMessageCount = 0;
var messageEnum = messages.GetEnumerator();
foreach (var item in await receiver.ReceiveBatchAsync(messageCount))
{
receivedMessageCount++;
messageEnum.MoveNext();
Assert.AreEqual(item.MessageId, messageEnum.Current.MessageId);
await receiver.CompleteAsync(item.SystemProperties.LockToken);
}
Assert.AreEqual(receivedMessageCount, messageCount);
var message = receiver.PeekAsync();
Assert.IsNull(message.Result);
}
}
public async Task Send_ConnString()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var sender = new ServiceBusSenderClient(TestEnvironment.ServiceBusConnectionString, scope.QueueName);
await sender.SendBatchAsync(GetMessages(10));
}
}
public async Task ClientProperties()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var sender = new ServiceBusSenderClient(TestEnvironment.ServiceBusConnectionString, scope.QueueName);
Assert.AreEqual(scope.QueueName, sender.EntityName);
Assert.AreEqual(TestEnvironment.FullyQualifiedNamespace, sender.FullyQualifiedNamespace);
}
}
public async Task Send_Token()
{
ClientSecretCredential credential = new ClientSecretCredential(
TenantId,
ClientId,
ClientSecret);
var sender = new ServiceBusSenderClient(Endpoint, QueueName, credential);
await sender.SendAsync(GetMessage());
}
public async Task Receive_StopProcessing(int numThreads)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(
enablePartitioning: false,
enableSession: false))
{
await using var sender = new ServiceBusSenderClient(
TestEnvironment.ServiceBusConnectionString,
scope.QueueName);
int numMessages = 50;
await sender.SendBatchAsync(GetMessages(numMessages));
await using var processor = new ServiceBusProcessorClient(
TestEnvironment.ServiceBusConnectionString,
scope.QueueName);
int messageProcessedCt = 0;
// stop processing halfway through
int stopAfterMessagesCt = numMessages / 2;
var options = new ProcessingOptions()
{
MaxConcurrentCalls = numThreads
};
TaskCompletionSource <bool> tcs = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously);
processor.ProcessMessageAsync += ProcessMessage;
processor.ProcessErrorAsync += ExceptionHandler;
await processor.StartProcessingAsync(options);
async Task ProcessMessage(ServiceBusMessage message, ServiceBusSession session)
{
Interlocked.Increment(ref messageProcessedCt);
if (messageProcessedCt == stopAfterMessagesCt)
{
await processor.StopProcessingAsync();
tcs.TrySetResult(true);
}
}
await tcs.Task;
var remainingCt = 0;
var receiver = new ServiceBusReceiverClient(TestEnvironment.ServiceBusConnectionString, scope.QueueName);
foreach (ServiceBusMessage message in await receiver.ReceiveBatchAsync(numMessages))
{
remainingCt++;
}
// can't assert on the exact amount processed due to threads that
// are already in flight when calling StopProcessingAsync, but we can at least verify that there are remaining messages
Assert.IsTrue(remainingCt > 0);
Assert.IsTrue(messageProcessedCt < numMessages);
}
}
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 ServiceBusSenderClient(connString, queueName);
Assert.AreEqual(queueName, sender.EntityName);
Assert.AreEqual(fullyQualifiedNamespace, sender.FullyQualifiedNamespace);
}
public async Task DeadLetterMessages(bool isSessionSpecified)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var sender = new ServiceBusSenderClient(TestEnvironment.ServiceBusConnectionString, scope.QueueName);
var messageCount = 10;
var sessionId = "sessionId1";
IEnumerable <ServiceBusMessage> messages = GetMessages(messageCount, sessionId);
await sender.SendBatchAsync(messages);
var clientOptions = new ServiceBusReceiverClientOptions()
{
SessionId = isSessionSpecified ? sessionId : null,
IsSessionEntity = true,
};
var receiver = new ServiceBusReceiverClient(TestEnvironment.ServiceBusConnectionString, scope.QueueName, clientOptions);
var receivedMessageCount = 0;
var messageEnum = messages.GetEnumerator();
foreach (var item in await receiver.ReceiveBatchAsync(messageCount))
{
receivedMessageCount++;
messageEnum.MoveNext();
Assert.AreEqual(item.MessageId, messageEnum.Current.MessageId);
Assert.AreEqual(item.SessionId, messageEnum.Current.SessionId);
await receiver.DeadLetterAsync(item.SystemProperties.LockToken);
}
Assert.AreEqual(receivedMessageCount, messageCount);
var message = receiver.PeekAsync();
Assert.IsNull(message.Result);
// TODO: System.InvalidOperationException : Cannot create a MessageSession for a sub-queue.
// messageEnum.Reset();
// receivedMessageCount = 0;
// string deadLetterQueuePath = EntityNameFormatter.FormatDeadLetterPath(scope.QueueName);
// var deadLetterReceiver = new ServiceBusReceiverClient(TestEnvironment.ServiceBusConnectionString, deadLetterQueuePath, sessionOptions);
// foreach (var item in await deadLetterReceiver.ReceiveBatchAsync(messageCount))
// {
// receivedMessageCount++;
// messageEnum.MoveNext();
// Assert.AreEqual(item.MessageId, messageEnum.Current.MessageId);
// Assert.AreEqual(item.SessionId, messageEnum.Current.SessionId);
// await deadLetterReceiver.CompleteAsync(item.SystemProperties.LockToken);
// }
// Assert.AreEqual(receivedMessageCount, messageCount);
// var deadLetterMessage = deadLetterReceiver.PeekAsync();
// Assert.IsNull(deadLetterMessage.Result);
}
}
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 ServiceBusSenderClient(TestEnvironment.ServiceBusConnectionString, scope.QueueName);
var messageCt = 10;
var sessionId = Guid.NewGuid().ToString();
// send the messages
IEnumerable <ServiceBusMessage> sentMessages = GetMessages(messageCt, sessionId, partitionKey);
await sender.SendBatchAsync(sentMessages);
Dictionary <string, ServiceBusMessage> sentMessageIdToMsg = new Dictionary <string, ServiceBusMessage>();
foreach (ServiceBusMessage message in sentMessages)
{
sentMessageIdToMsg.Add(message.MessageId, message);
}
var options = new ServiceBusReceiverClientOptions()
{
SessionId = sessionId,
IsSessionEntity = true
};
var receiver = new ServiceBusReceiverClient(
TestEnvironment.ServiceBusConnectionString,
scope.QueueName,
options);
sequenceNumber ??= 1;
// verify peeked == send
var ct = 0;
foreach (ServiceBusMessage peekedMessage in await receiver.PeekBatchBySequenceAsync(
fromSequenceNumber: (long)sequenceNumber,
maxMessages: messageCt))
{
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 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 ServiceBusSenderClient(TestEnvironment.FullyQualifiedNamespace, scope.QueueName, credential);
await sender.SendAsync(GetMessage());
}
}
public async Task Receive_Event(int numThreads)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(
enablePartitioning: false,
enableSession: false))
{
await using var sender = new ServiceBusSenderClient(
TestEnvironment.ServiceBusConnectionString,
scope.QueueName);
// use double the number of threads so we can make sure we test that we don't
// retrieve more messages than expected when there are more messages available
await sender.SendBatchAsync(GetMessages(numThreads * 2));
await using var receiver = new ServiceBusReceiverClient(
TestEnvironment.ServiceBusConnectionString,
scope.QueueName);
int messageCt = 0;
var options = new MessageHandlerOptions()
{
MaxConcurrentCalls = numThreads
};
TaskCompletionSource <bool>[] completionSources = Enumerable
.Range(0, numThreads)
.Select(index => new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously))
.ToArray();
var completionSourceIndex = -1;
receiver.ProcessMessageAsync += ProcessMessage;
receiver.ProcessErrorAsync += ExceptionHandler;
await receiver.StartReceivingAsync(options);
async Task ProcessMessage(ServiceBusMessage message)
{
await receiver.CompleteAsync(message.SystemProperties.LockToken);
Interlocked.Increment(ref messageCt);
var setIndex = Interlocked.Increment(ref completionSourceIndex);
completionSources[setIndex].TrySetResult(true);
}
await Task.WhenAll(completionSources.Select(source => source.Task));
// we complete each thread after one message being processed, so the total number of messages
// processed should equal the number of threads
Assert.AreEqual(numThreads, messageCt);
}
}
public async Task Schedule()
{
var sender = new ServiceBusSenderClient(ConnString, QueueName);
var scheduleTime = DateTimeOffset.UtcNow.AddHours(10);
var sequenceNum = await sender.ScheduleMessageAsync(GetMessage(), scheduleTime);
var receiver = new QueueReceiverClient(ConnString, 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 Peek_Session(long?sequenceNumber, string partitionKey)
{
var sender = new ServiceBusSenderClient(ConnString, SessionQueueName);
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 receiver = new SessionReceiverClient(sessionId, ConnString, SessionQueueName);
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 async Task Send_Connection_Topic()
{
var conn = new ServiceBusConnection(ConnString, TopicName);
var options = new ServiceBusSenderClientOptions
{
RetryOptions = new ServiceBusRetryOptions(),
ConnectionOptions = new ServiceBusConnectionOptions()
{
TransportType = ServiceBusTransportType.AmqpWebSockets,
Proxy = new WebProxy("localHost")
}
};
options.RetryOptions.Mode = ServiceBusRetryMode.Exponential;
var sender = new ServiceBusSenderClient(conn, options);
await sender.SendAsync(GetMessage());
}
public async Task RoundRobinSessions()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var sender = new ServiceBusSenderClient(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.SendBatchAsync(GetMessages(messageCt, session));
}
// create receiver not scoped to a specific session
for (int i = 0; i < 10; i++)
{
var options = new ServiceBusReceiverClientOptions()
{
IsSessionEntity = true
};
var receiver = new ServiceBusReceiverClient(
TestEnvironment.ServiceBusConnectionString,
scope.QueueName,
options);
foreach (ServiceBusMessage peekedMessage in await receiver.PeekBatchBySequenceAsync(
fromSequenceNumber: 1,
maxMessages: 10))
{
var sessionId = await receiver.Session.GetSessionIdAsync();
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 Send_Connection_Topic()
{
await using (var scope = await ServiceBusScope.CreateWithTopic(enablePartitioning: false, enableSession: false))
{
var options = new ServiceBusSenderClientOptions
{
RetryOptions = new ServiceBusRetryOptions(),
ConnectionOptions = new ServiceBusConnectionOptions()
{
TransportType = ServiceBusTransportType.AmqpWebSockets,
Proxy = WebRequest.DefaultWebProxy
}
};
options.RetryOptions.Mode = ServiceBusRetryMode.Exponential;
await using var sender = new ServiceBusSenderClient(TestEnvironment.ServiceBusConnectionString, scope.TopicName, options);
await sender.SendAsync(GetMessage());
}
}
public async Task Schedule()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var sender = new ServiceBusSenderClient(TestEnvironment.ServiceBusConnectionString, scope.QueueName);
var scheduleTime = DateTimeOffset.UtcNow.AddHours(10);
var sequenceNum = await sender.ScheduleMessageAsync(GetMessage(), scheduleTime);
await using var receiver = new ServiceBusReceiverClient(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 Send_Topic_Session()
{
var conn = new ServiceBusConnection(ConnString, "joshtopic");
var options = new ServiceBusSenderClientOptions
{
RetryOptions = new ServiceBusRetryOptions(),
ConnectionOptions = new ServiceBusConnectionOptions()
{
TransportType = ServiceBusTransportType.AmqpWebSockets,
Proxy = new WebProxy("localHost")
}
};
options.RetryOptions.Mode = ServiceBusRetryMode.Exponential;
var sender = new ServiceBusSenderClient(conn, options);
var message = GetMessage();
message.SessionId = "1";
await sender.SendAsync(message);
}
public async Task PeekMultipleSessions_ShouldThrow()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var sender = new ServiceBusSenderClient(TestEnvironment.ServiceBusConnectionString, scope.QueueName);
var messageCt = 10;
var sessionId = Guid.NewGuid().ToString();
// send the messages
IEnumerable <ServiceBusMessage> sentMessages = GetMessages(messageCt, sessionId);
await sender.SendBatchAsync(sentMessages);
var options = new ServiceBusReceiverClientOptions()
{
SessionId = sessionId,
IsSessionEntity = true
};
var receiver1 = new ServiceBusReceiverClient(
TestEnvironment.ServiceBusConnectionString,
scope.QueueName,
options);
var receiver2 = new ServiceBusReceiverClient(
TestEnvironment.ServiceBusConnectionString,
scope.QueueName,
options);
Dictionary <string, ServiceBusMessage> sentMessageIdToMsg = new Dictionary <string, ServiceBusMessage>();
// peek the messages
Assert.That(() => ScheduleTasksAsync(), Throws.Exception);
async Task ScheduleTasksAsync()
{
Task peek1 = receiver1.PeekBatchBySequenceAsync(
fromSequenceNumber: 1,
maxMessages: messageCt);
Task peek2 = receiver2.PeekBatchBySequenceAsync(
fromSequenceNumber: 1,
maxMessages: messageCt);
await Task.WhenAll(peek1, peek2);
}
}
}
public async Task Send_Topic_Session()
{
await using (var scope = await ServiceBusScope.CreateWithTopic(enablePartitioning: false, enableSession: false))
{
await using var conn = new ServiceBusConnection(TestEnvironment.ServiceBusConnectionString, scope.TopicName);
var options = new ServiceBusSenderClientOptions
{
RetryOptions = new ServiceBusRetryOptions(),
ConnectionOptions = new ServiceBusConnectionOptions()
{
TransportType = ServiceBusTransportType.AmqpWebSockets,
Proxy = new WebProxy("localHost")
}
};
options.RetryOptions.Mode = ServiceBusRetryMode.Exponential;
await using var sender = new ServiceBusSenderClient(conn, options);
var message = GetMessage();
message.SessionId = "1";
await sender.SendAsync(message);
}
}
public async Task ReceiveMessagesInPeekLockMode()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var sender = new ServiceBusSenderClient(TestEnvironment.ServiceBusConnectionString, scope.QueueName);
var messageCount = 10;
var sessionId = "sessionId1";
IEnumerable <ServiceBusMessage> messages = GetMessages(messageCount, sessionId);
await sender.SendBatchAsync(messages);
ServiceBusConnection conn = new ServiceBusConnection(TestEnvironment.ServiceBusConnectionString, scope.QueueName);
var options = new ServiceBusReceiverClientOptions()
{
SessionId = sessionId,
IsSessionEntity = true
};
var receiver = new ServiceBusReceiverClient(TestEnvironment.ServiceBusConnectionString, scope.QueueName, options);
var receivedMessageCount = 0;
var messageEnum = messages.GetEnumerator();
foreach (var item in await receiver.ReceiveBatchAsync(messageCount))
{
receivedMessageCount++;
messageEnum.MoveNext();
Assert.AreEqual(item.MessageId, messageEnum.Current.MessageId);
Assert.AreEqual(item.SessionId, messageEnum.Current.SessionId);
Assert.AreEqual(item.SystemProperties.DeliveryCount, 1);
}
Assert.AreEqual(receivedMessageCount, messageCount);
messageEnum.Reset();
foreach (var item in await receiver.PeekBatchAsync(messageCount))
{
messageEnum.MoveNext();
Assert.AreEqual(item.SessionId, messageEnum.Current.SessionId);
Assert.AreEqual(item.MessageId, messageEnum.Current.MessageId);
}
}
}