public async Task GetAndSetSessionStateTest(bool isSessionSpecified)
{
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 = "test-sessionId";
ServiceBusMessage message = GetMessage(sessionId);
await sender.SendAsync(message);
ServiceBusSessionReceiver receiver = await client.CreateSessionReceiverAsync(
scope.QueueName,
sessionId : isSessionSpecified?sessionId : null);
ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync();
Assert.AreEqual(message.MessageId, receivedMessage.MessageId);
Assert.AreEqual(message.SessionId, receivedMessage.SessionId);
var sessionStateString = "Received Message From Session!";
var sessionState = Encoding.UTF8.GetBytes(sessionStateString);
await receiver.SetSessionStateAsync(sessionState);
var returnedSessionState = await receiver.GetSessionStateAsync();
var returnedSessionStateString = Encoding.UTF8.GetString(returnedSessionState);
Assert.AreEqual(sessionStateString, returnedSessionStateString);
// Complete message using Session Receiver
await receiver.CompleteAsync(receivedMessage);
var peekedMessage = receiver.PeekAsync();
Assert.IsNull(peekedMessage.Result);
sessionStateString = "Completed Message On Session!";
sessionState = Encoding.UTF8.GetBytes(sessionStateString);
await receiver.SetSessionStateAsync(sessionState);
returnedSessionState = await receiver.GetSessionStateAsync();
returnedSessionStateString = Encoding.UTF8.GetString(returnedSessionState);
Assert.AreEqual(sessionStateString, returnedSessionStateString);
}
}
public async Task ReceiveFromSpecificSession()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
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 batch that we can send
ServiceBusMessageBatch messageBatch = await sender.CreateBatchAsync();
messageBatch.TryAdd(
new ServiceBusMessage(Encoding.UTF8.GetBytes("First"))
{
SessionId = "Session1"
});
messageBatch.TryAdd(
new ServiceBusMessage(Encoding.UTF8.GetBytes("Second"))
{
SessionId = "Session2"
});
// send the message batch
await sender.SendAsync(messageBatch);
#region Snippet:ServiceBusReceiveFromSpecificSession
// create a receiver specifying a particular session
ServiceBusSessionReceiver receiver = await client.CreateSessionReceiverAsync(
queueName,
sessionId : "Session2");
// the received message is a different type as it contains some service set properties
ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync();
Console.WriteLine(receivedMessage.SessionId);
#endregion
Assert.AreEqual(Encoding.UTF8.GetBytes("Second"), receivedMessage.Body.ToArray());
Assert.AreEqual("Session2", receivedMessage.SessionId);
}
}
public async Task ReceiverThrowsAfterSessionLockLost(bool isSessionSpecified)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true, lockDuration: TimeSpan.FromSeconds(5)))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
var sessionId1 = "sessionId1";
await sender.SendAsync(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"));
ServiceBusSessionReceiver receiver = await client.CreateSessionReceiverAsync(
scope.QueueName,
new ServiceBusSessionReceiverOptions
{
SessionId = isSessionSpecified ? sessionId1 : null
});
if (isSessionSpecified)
{
Assert.AreEqual(sessionId1, receiver.SessionId);
}
var message = await receiver.ReceiveAsync();
await Task.Delay((receiver.SessionLockedUntil - DateTime.UtcNow) + TimeSpan.FromSeconds(5));
Assert.That(async() => await receiver.ReceiveAsync(),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason))
.EqualTo(ServiceBusException.FailureReason.SessionLockLost));
Assert.That(async() => await receiver.SetSessionStateAsync(null),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason))
.EqualTo(ServiceBusException.FailureReason.SessionLockLost));
Assert.That(async() => await receiver.GetSessionStateAsync(),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason))
.EqualTo(ServiceBusException.FailureReason.SessionLockLost));
Assert.That(async() => await receiver.CompleteAsync(message),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason))
.EqualTo(ServiceBusException.FailureReason.SessionLockLost));
Assert.That(async() => await receiver.CompleteAsync(message),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason))
.EqualTo(ServiceBusException.FailureReason.SessionLockLost));
Assert.That(async() => await receiver.DeadLetterAsync(message),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason))
.EqualTo(ServiceBusException.FailureReason.SessionLockLost));
Assert.That(async() => await receiver.DeferAsync(message),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason))
.EqualTo(ServiceBusException.FailureReason.SessionLockLost));
Assert.That(async() => await receiver.AbandonAsync(message),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason))
.EqualTo(ServiceBusException.FailureReason.SessionLockLost));
}
}