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.SendMessageAsync(message);
ServiceBusSessionReceiver receiver = await client.CreateSessionReceiverAsync(
scope.QueueName,
new ServiceBusSessionReceiverOptions
{
SessionId = isSessionSpecified ? sessionId : null
});
ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync();
Assert.AreEqual(message.MessageId, receivedMessage.MessageId);
Assert.AreEqual(message.SessionId, receivedMessage.SessionId);
Assert.AreEqual(message.Body.ToBytes().ToArray(), receivedMessage.Body.ToBytes().ToArray());
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.CompleteMessageAsync(receivedMessage);
var peekedMessage = receiver.PeekMessageAsync();
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 TransactionalSetSessionState()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var client = CreateClient();
string queueName = scope.QueueName;
#region Snippet:ServiceBusTransactionalSetSessionState
//@@ string connectionString = "<connection_string>";
//@@ string queueName = "<queue_name>";
// since ServiceBusClient implements IAsyncDisposable we create it with "await using"
//@@ await using var client = new ServiceBusClient(connectionString);
ServiceBusSender sender = client.CreateSender(queueName);
await sender.SendMessageAsync(new ServiceBusMessage("my message") { SessionId = "sessionId" });
ServiceBusSessionReceiver receiver = await client.AcceptNextSessionAsync(queueName);
ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync();
var state = Encoding.UTF8.GetBytes("some state");
using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
await receiver.CompleteMessageAsync(receivedMessage);
await receiver.SetSessionStateAsync(new BinaryData(state));
ts.Complete();
}
#endregion
var bytes = await receiver.GetSessionStateAsync();
Assert.AreEqual(state, bytes.ToArray());
};
}
public async Task GetSessionStateLogsEvents()
{
var mockLogger = new Mock <ServiceBusEventSource>();
var mockTransportReceiver = new Mock <TransportReceiver>();
var mockConnection = GetMockConnection(mockTransportReceiver);
var receiver = new ServiceBusSessionReceiver(
mockConnection.Object,
"queueName",
new ServiceBusPlugin[] { },
new ServiceBusSessionReceiverOptions(),
cancellationToken: CancellationToken.None)
{
Logger = mockLogger.Object
};
await receiver.GetSessionStateAsync();
mockLogger
.Verify(
log => log.GetSessionStateStart(
receiver.Identifier,
It.IsAny <string>()),
Times.Once);
mockLogger
.Verify(
log => log.GetSessionStateComplete(
receiver.Identifier),
Times.Once);
}
public void GetSessionStateExceptionLogsEvents()
{
var mockLogger = new Mock <ServiceBusEventSource>();
var mockTransportReceiver = new Mock <TransportReceiver>();
var mockConnection = GetMockConnection(mockTransportReceiver);
mockTransportReceiver.Setup(
transportReceiver => transportReceiver.GetStateAsync(
It.IsAny <CancellationToken>()))
.Throws(new Exception());
var receiver = new ServiceBusSessionReceiver(mockConnection.Object, "queueName", new ServiceBusReceiverOptions())
{
Logger = mockLogger.Object
};
Assert.That(
async() => await receiver.GetSessionStateAsync(),
Throws.InstanceOf <Exception>());
mockLogger
.Verify(
log => log.GetSessionStateStart(
receiver.Identifier,
It.IsAny <string>()),
Times.Once);
mockLogger
.Verify(
log => log.GetSessionStateException(
receiver.Identifier,
It.IsAny <string>()),
Times.Once);
}
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);
await sender.SendMessagesAsync(ServiceBusTestUtilities.GetMessages(3, "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.SendMessagesAsync(ServiceBusTestUtilities.GetMessages(3, "sessionId2"));
ServiceBusSessionReceiver receiver = await client.AcceptSessionAsync(
scope.QueueName,
isSessionSpecified? "sessionId1" : null);
if (isSessionSpecified)
{
Assert.AreEqual("sessionId1", receiver.SessionId);
}
var message = await receiver.ReceiveMessageAsync();
Assert.AreEqual(receiver.SessionId, message.SessionId);
var sessionId = receiver.SessionId;
await Task.Delay((receiver.SessionLockedUntil - DateTime.UtcNow) + TimeSpan.FromSeconds(5));
Assert.IsTrue(receiver.IsClosed);
Assert.That(async() => await receiver.ReceiveMessageAsync(),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason))
.EqualTo(ServiceBusFailureReason.SessionLockLost));
Assert.That(async() => await receiver.SetSessionStateAsync(null),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason))
.EqualTo(ServiceBusFailureReason.SessionLockLost));
Assert.That(async() => await receiver.GetSessionStateAsync(),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason))
.EqualTo(ServiceBusFailureReason.SessionLockLost));
Assert.That(async() => await receiver.CompleteMessageAsync(message),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason))
.EqualTo(ServiceBusFailureReason.SessionLockLost));
Assert.That(async() => await receiver.CompleteMessageAsync(message),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason))
.EqualTo(ServiceBusFailureReason.SessionLockLost));
Assert.That(async() => await receiver.DeadLetterMessageAsync(message),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason))
.EqualTo(ServiceBusFailureReason.SessionLockLost));
Assert.That(async() => await receiver.DeferMessageAsync(message),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason))
.EqualTo(ServiceBusFailureReason.SessionLockLost));
}
}
/// <inheritdoc cref="ServiceBusSessionReceiver.GetSessionStateAsync(CancellationToken)"/>
public virtual async Task <BinaryData> GetSessionStateAsync(
CancellationToken cancellationToken = default)
{
if (_receiver != null)
{
return(await _receiver.GetSessionStateAsync(cancellationToken).ConfigureAwait(false));
}
else
{
return(await _eventArgs.GetSessionStateAsync(cancellationToken).ConfigureAwait(false));
}
}
public async Task SendAndReceiveSessionMessage()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
#region Snippet:ServiceBusSendAndReceiveSessionMessage
#if SNIPPET
string connectionString = "<connection_string>";
string queueName = "<queue_name>";
#else
string connectionString = TestEnvironment.ServiceBusConnectionString;
string queueName = scope.QueueName;
#endif
// 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 session message that we can send
ServiceBusMessage message = new ServiceBusMessage(Encoding.UTF8.GetBytes("Hello world!"))
{
SessionId = "mySessionId"
};
// send the message
await sender.SendMessageAsync(message);
// create a session receiver that we can use to receive the message. Since we don't specify a
// particular session, we will get the next available session from the service.
#region Snippet:ServiceBusReceiveNextSession
ServiceBusSessionReceiver receiver = await client.AcceptNextSessionAsync(queueName);
// the received message is a different type as it contains some service set properties
ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync();
Console.WriteLine(receivedMessage.SessionId);
#endregion
// we can also set arbitrary session state using this receiver
// the state is specific to the session, and not any particular message
await receiver.SetSessionStateAsync(new BinaryData("some state"));
// the state can be retrieved for the session as well
BinaryData state = await receiver.GetSessionStateAsync();
#endregion
Assert.AreEqual(Encoding.UTF8.GetBytes("Hello world!"), receivedMessage.Body.ToArray());
Assert.AreEqual("mySessionId", receivedMessage.SessionId);
Assert.AreEqual(Encoding.UTF8.GetBytes("some state"), state.ToArray());
}
}