public async Task ScheduleMessage()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
string connectionString = TestEnvironment.ServiceBusConnectionString;
string queueName = scope.QueueName;
// since ServiceBusClient implements IAsyncDisposable we create it with "await using"
await using var client = new ServiceBusClient(connectionString);
// get the sender
ServiceBusSender sender = client.GetSender(queueName);
// create a message that we can send
ServiceBusMessage message = new ServiceBusMessage(Encoding.Default.GetBytes("Hello world!"));
// schedule the message for tomorrow
// this prevents the message from being enqueued until tomorrow, but it can still be peeked
long seq = await sender.ScheduleMessageAsync(
message,
DateTimeOffset.Now.AddDays(1));
// get a receiver that we can use to peek the message
ServiceBusReceiver receiver = client.GetReceiver(queueName);
Assert.IsNotNull(await receiver.PeekAsync());
// cancel the scheduled messaged, thereby deleting from the service
await sender.CancelScheduledMessageAsync(seq);
Assert.IsNull(await receiver.PeekAsync());
}
}
public async Task ScheduleMessage()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
string connectionString = TestEnvironment.ServiceBusConnectionString;
string queueName = scope.QueueName;
// since ServiceBusClient implements IAsyncDisposable we create it with "await using"
await using var client = new ServiceBusClient(connectionString);
// create the sender
ServiceBusSender sender = client.CreateSender(queueName);
// create a message that we can send
ServiceBusMessage message = new ServiceBusMessage(Encoding.UTF8.GetBytes("Hello world!"));
#region Snippet:ServiceBusSchedule
long seq = await sender.ScheduleMessageAsync(
message,
DateTimeOffset.Now.AddDays(1));
#endregion
// create a receiver that we can use to peek the message
ServiceBusReceiver receiver = client.CreateReceiver(queueName);
Assert.IsNotNull(await receiver.PeekAsync());
// cancel the scheduled messaged, thereby deleting from the service
#region Snippet:ServiceBusCancelScheduled
await sender.CancelScheduledMessageAsync(seq);
#endregion
Assert.IsNull(await receiver.PeekAsync());
}
}
public async Task PeekIncrementsSequenceNumber(int messageCt)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
var sessionId = Guid.NewGuid().ToString();
// send the messages
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
ServiceBusMessageBatch messagebatch = AddMessages(batch, messageCt, sessionId);
await sender.SendAsync(messagebatch);
ServiceBusReceiver receiver = await client.CreateSessionReceiverAsync(scope.QueueName);
long seq = 0;
for (int i = 0; i < messageCt; i++)
{
ServiceBusReceivedMessage msg = await receiver.PeekAsync();
Assert.IsTrue(msg.SequenceNumber > seq);
if (seq > 0)
{
Assert.IsTrue(msg.SequenceNumber == seq + 1);
}
seq = msg.SequenceNumber;
}
}
}
public async Task SendAndPeekMessage()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
string connectionString = TestEnvironment.ServiceBusConnectionString;
string queueName = scope.QueueName;
await using var client = new ServiceBusClient(connectionString);
// create the sender
ServiceBusSender sender = client.CreateSender(queueName);
// create a message that we can send
ServiceBusMessage message = new ServiceBusMessage(Encoding.UTF8.GetBytes("Hello world!"));
// send the message
await sender.SendAsync(message);
// create a receiver that we can use to receive the message
ServiceBusReceiver receiver = client.CreateReceiver(queueName);
#region Snippet:ServiceBusPeek
ServiceBusReceivedMessage peekedMessage = await receiver.PeekAsync();
#endregion
// get the message body as a string
string body = Encoding.UTF8.GetString(peekedMessage.Body.ToArray());
Assert.AreEqual(Encoding.UTF8.GetBytes("Hello world!"), peekedMessage.Body.ToArray());
}
}
public void PeekMessageExceptionLogsEvents()
{
var mockLogger = new Mock <ServiceBusEventSource>();
var mockTransportReceiver = new Mock <TransportReceiver>();
var mockConnection = GetMockConnection(mockTransportReceiver);
mockTransportReceiver.Setup(
transportReceiver => transportReceiver.PeekBatchAtAsync(
It.IsAny <long?>(),
1,
It.IsAny <CancellationToken>()))
.Throws(new Exception());
var receiver = new ServiceBusReceiver(mockConnection.Object, "queueName", false, new ServiceBusReceiverOptions())
{
Logger = mockLogger.Object
};
Assert.That(
async() => await receiver.PeekAsync(),
Throws.InstanceOf <Exception>());
mockLogger
.Verify(
log => log.PeekMessageStart(
receiver.Identifier,
null,
1),
Times.Once);
mockLogger
.Verify(
log => log.PeekMessageException(
receiver.Identifier,
It.IsAny <string>()),
Times.Once);
}
public async Task RenewSessionLock(bool isSessionSpecified)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.GetSender(scope.QueueName);
var messageCount = 1;
var sessionId1 = "sessionId1";
ServiceBusMessage message = GetMessage(sessionId1);
// send another session message before the one we are interested in to make sure that when isSessionSpecified=true, it is being respected
await sender.SendAsync(GetMessage("sessionId2"));
await sender.SendAsync(message);
ServiceBusReceiver receiver = await client.GetSessionReceiverAsync(scope.QueueName, sessionId : isSessionSpecified?sessionId1 : null);
var session = receiver.GetSessionManager();
if (isSessionSpecified)
{
Assert.AreEqual(sessionId1, session.SessionId);
}
ServiceBusReceivedMessage[] receivedMessages = (await receiver.ReceiveBatchAsync(messageCount)).ToArray();
var receivedMessage = receivedMessages.First();
var firstLockedUntilUtcTime = session.LockedUntil;
// Sleeping for 10 seconds...
await Task.Delay(10000);
await session.RenewSessionLockAsync();
Assert.True(session.LockedUntil >= firstLockedUntilUtcTime + TimeSpan.FromSeconds(10));
// Complete Messages
await receiver.CompleteAsync(receivedMessage.LockToken);
Assert.AreEqual(messageCount, receivedMessages.Length);
if (isSessionSpecified)
{
Assert.AreEqual(message.MessageId, receivedMessage.MessageId);
}
var peekedMessage = receiver.PeekAsync();
Assert.IsNull(peekedMessage.Result);
}
}
public async Task PeekSingleMessageLogsEvents(bool specifySeqNumber)
{
var mockLogger = new Mock <ServiceBusEventSource>();
var mockTransportReceiver = new Mock <TransportReceiver>();
var mockConnection = GetMockConnection(mockTransportReceiver);
mockTransportReceiver.Setup(
transportReceiver => transportReceiver.PeekBatchAtAsync(
It.IsAny <long?>(),
It.IsAny <int>(),
It.IsAny <CancellationToken>()))
.Returns(
Task.FromResult((IList <ServiceBusReceivedMessage>)
new List <ServiceBusReceivedMessage> {
new ServiceBusReceivedMessage()
}));
var receiver = new ServiceBusReceiver(mockConnection.Object, "queueName", false, new ServiceBusReceiverOptions())
{
Logger = mockLogger.Object
};
var seqNumber = 5;
if (specifySeqNumber)
{
await receiver.PeekAtAsync(seqNumber);
}
else
{
await receiver.PeekAsync();
}
mockLogger
.Verify(
log => log.PeekMessageStart(
receiver.Identifier,
specifySeqNumber ? (long?)seqNumber : null,
1),
Times.Once);
mockLogger
.Verify(
log => log.PeekMessageComplete(
receiver.Identifier,
1),
Times.Once);
}
public async Task ReceiveMessagesInReceiveAndDeleteMode()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
var messageCount = 10;
var sessionId = "sessionId1";
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount, sessionId).AsEnumerable <ServiceBusMessage>();
await sender.SendAsync(batch);
var clientOptions = new ServiceBusReceiverOptions()
{
ReceiveMode = ReceiveMode.ReceiveAndDelete
};
ServiceBusReceiver receiver = await client.CreateSessionReceiverAsync(
scope.QueueName,
clientOptions,
sessionId);
var remainingMessages = messageCount;
var messageEnum = messages.GetEnumerator();
while (remainingMessages > 0)
{
foreach (var item in await receiver.ReceiveBatchAsync(remainingMessages))
{
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId);
remainingMessages--;
}
}
Assert.AreEqual(0, remainingMessages);
var peekedMessage = receiver.PeekAsync();
Assert.IsNull(peekedMessage.Result);
}
}
public async Task TransactionalCancelScheduleRollback()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
var options = new ServiceBusClientOptions();
options.RetryOptions.TryTimeout = TimeSpan.FromSeconds(5);
options.RetryOptions.MaxRetries = 0;
var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString, options);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
ServiceBusMessage message = GetMessage();
long seq = await sender.ScheduleMessageAsync(message, DateTimeOffset.UtcNow.AddMinutes(1));
using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
await sender.CancelScheduledMessageAsync(seq);
}
ServiceBusReceiver receiver = client.CreateReceiver(scope.QueueName);
ServiceBusReceivedMessage msg = await receiver.PeekAsync();
Assert.NotNull(msg);
};
}
public async Task CompleteMessages(bool useSpecificSession)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.GetSender(scope.QueueName);
var messageCount = 10;
var sessionId = "sessionId1";
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount, sessionId).AsEnumerable <ServiceBusMessage>();
await sender.SendBatchAsync(batch);
ServiceBusReceiver receiver = await client.GetSessionReceiverAsync(
scope.QueueName,
sessionId);
var receivedMessageCount = 0;
var messageEnum = messages.GetEnumerator();
foreach (var item in await receiver.ReceiveBatchAsync(messageCount))
{
receivedMessageCount++;
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId);
await receiver.CompleteAsync(item);
}
Assert.AreEqual(messageCount, receivedMessageCount);
var peekedMessage = receiver.PeekAsync();
Assert.IsNull(peekedMessage.Result);
}
}
