public async Task PeekRangeIncrementsSequenceNumber(int messageCt, int peekCt)
{
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 / peekCt; i++)
{
foreach (ServiceBusReceivedMessage msg in await receiver.PeekBatchAsync(
maxMessages: peekCt))
{
Assert.IsTrue(msg.SequenceNumber > seq);
if (seq > 0)
{
Assert.IsTrue(msg.SequenceNumber == seq + 1);
}
seq = msg.SequenceNumber;
}
}
}
}
public async Task AbandonMessages(bool useSpecificSession)
{
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);
ServiceBusReceiver receiver = await client.CreateSessionReceiverAsync(
scope.QueueName,
new ServiceBusSessionReceiverOptions
{
SessionId = useSpecificSession ? sessionId : null
});
var messageEnum = messages.GetEnumerator();
var remainingMessages = messageCount;
IList <ServiceBusReceivedMessage> receivedMessages = new List <ServiceBusReceivedMessage>();
while (remainingMessages > 0)
{
foreach (var msg in await receiver.ReceiveBatchAsync(remainingMessages))
{
remainingMessages--;
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, msg.MessageId);
Assert.AreEqual(messageEnum.Current.SessionId, msg.SessionId);
receivedMessages.Add(msg);
Assert.AreEqual(msg.DeliveryCount, 1);
}
}
Assert.AreEqual(0, remainingMessages);
// don't abandon in the receive loop
// as this would make the message available to be immediately received again
foreach (var msg in receivedMessages)
{
await receiver.AbandonAsync(msg);
}
messageEnum.Reset();
var receivedMessageCount = 0;
foreach (var item in await receiver.PeekBatchAsync(messageCount))
{
receivedMessageCount++;
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId);
}
Assert.AreEqual(messageCount, receivedMessageCount);
}
}
public async Task PeekBatchOfMessagesLogsEvents(bool specifySeqNumber)
{
var mockLogger = new Mock <ServiceBusEventSource>();
var maxMessages = 4;
var mockTransportReceiver = new Mock <TransportReceiver>();
var mockConnection = GetMockConnection(mockTransportReceiver);
mockTransportReceiver.Setup(
transportReceiver => transportReceiver.PeekBatchAtAsync(
It.IsAny <long?>(),
maxMessages,
It.IsAny <CancellationToken>()))
.Returns(
Task.FromResult((IList <ServiceBusReceivedMessage>)
new List <ServiceBusReceivedMessage> {
new ServiceBusReceivedMessage(),
new ServiceBusReceivedMessage()
}));
var receiver = new ServiceBusReceiver(mockConnection.Object, "queueName", false, new ServiceBusReceiverOptions())
{
Logger = mockLogger.Object
};
var seqNumber = 5;
IList <ServiceBusReceivedMessage> msgs;
if (specifySeqNumber)
{
msgs = await receiver.PeekBatchAtAsync(seqNumber, maxMessages);
}
else
{
msgs = await receiver.PeekBatchAsync(maxMessages : maxMessages);
}
mockLogger
.Verify(
log => log.PeekMessageStart(
receiver.Identifier,
specifySeqNumber ? (long?)seqNumber : null,
// the amount requested
maxMessages),
Times.Once);
mockLogger
.Verify(
log => log.PeekMessageComplete(
receiver.Identifier,
// the amount we actually received
msgs.Count),
Times.Once);
}
public async Task AbandonMessages(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 : useSpecificSession?sessionId : null);
var messageEnum = messages.GetEnumerator();
var remainingMessages = messageCount;
while (remainingMessages > 0)
{
foreach (var item in await receiver.ReceiveBatchAsync(remainingMessages))
{
remainingMessages--;
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId);
await receiver.AbandonAsync(item.LockToken);
Assert.AreEqual(item.DeliveryCount, 1);
}
}
Assert.AreEqual(0, remainingMessages);
messageEnum.Reset();
var receivedMessageCount = 0;
foreach (var item in await receiver.PeekBatchAsync(messageCount))
{
receivedMessageCount++;
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId);
}
Assert.AreEqual(messageCount, receivedMessageCount);
}
}
public async Task ReceiveMessagesInPeekLockMode()
{
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);
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);
Assert.AreEqual(item.DeliveryCount, 1);
}
Assert.AreEqual(messageCount, receivedMessageCount);
messageEnum.Reset();
foreach (var item in await receiver.PeekBatchAsync(messageCount))
{
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId);
}
}
}
