public void ProcessSessionMessageAsync_DoesNotSetSessionStateAndThrowsException()
{
// Arrange
var expectedBodyMessage = new ContractEvent();
var dummyMessage = GetDummyMessage(expectedBodyMessage);
var initialState = new SessionWorkflowState();
var mockSession = Mock.Of <IMessageSession>(MockBehavior.Strict);
var mockLogger = Mock.Of <IContractEventProcessorLogger <IContractEventSessionManager> >(MockBehavior.Strict);
var mockProcessLog = Mock.Of <IContractEventProcessLog>(MockBehavior.Strict);
Mock.Get(mockProcessLog)
.Setup(c => c.Initialise(It.IsAny <Message>(), It.IsAny <ContractEvent>()));
var mockContractService = Mock.Of <IContractService>(MockBehavior.Strict);
Mock.Get(mockContractService)
.Setup(c => c.ProcessMessage(expectedBodyMessage))
.Throws <Exception>();
var mockStateManager = Mock.Of <IWorkflowStateManager>(MockBehavior.Strict);
Mock.Get(mockStateManager)
.Setup(s => s.GetWorkflowStateAsync(mockSession))
.ReturnsAsync(initialState)
.Verifiable();
// Act
var sessionManager = new ContractEventSessionManager(mockStateManager, mockContractService, mockLogger, GetConfiguration(), mockProcessLog);
Func <Task <SessionWorkflowState> > act = async() => await sessionManager.ProcessSessionMessageAsync(mockSession, dummyMessage);
// Assert
act.Should().Throw <Exception>();
Mock.Get(mockSession).VerifyNoOtherCalls();
Mock.Get(mockStateManager).Verify();
Mock.Get(mockContractService).Verify();
}
public void ProcessSessionMessageAsync_SetsSessionStateAndThrowsException()
{
// Arrange
var expectedBodyMessage = new ContractEvent();
var dummyMessage = GetDummyMessage(expectedBodyMessage, 10);
var initialState = new SessionWorkflowState();
var mockSession = Mock.Of <IMessageSession>(MockBehavior.Strict);
Mock.Get(mockSession)
.SetupGet(s => s.SessionId)
.Returns("session-id")
.Verifiable();
var mockLogger = Mock.Of <IContractEventProcessorLogger <IContractEventSessionManager> >(MockBehavior.Strict);
Mock.Get(mockLogger)
.Setup(l => l.LogWarning(It.IsAny <string>()))
.Verifiable();
var mockProcessLog = Mock.Of <IContractEventProcessLog>(MockBehavior.Strict);
Mock.Get(mockProcessLog)
.Setup(c => c.Initialise(It.IsAny <Message>(), It.IsAny <ContractEvent>()));
var mockContractService = Mock.Of <IContractService>(MockBehavior.Strict);
Mock.Get(mockContractService)
.Setup(c => c.ProcessMessage(expectedBodyMessage))
.Throws <Exception>();
var mockStateManager = Mock.Of <IWorkflowStateManager>(MockBehavior.Strict);
Mock.Get(mockStateManager)
.Setup(s => s.GetWorkflowStateAsync(mockSession))
.ReturnsAsync(initialState)
.Verifiable();
Mock.Get(mockStateManager)
.Setup(s => s.SetWorkflowStateAsync(mockSession, It.Is <SessionWorkflowState>(s => s.IsFaulted && s.FailedMessageId == dummyMessage.MessageId)))
.Returns(Task.CompletedTask)
.Verifiable();
// Act
var sessionManager = new ContractEventSessionManager(mockStateManager, mockContractService, mockLogger, GetConfiguration(), mockProcessLog);
Func <Task <SessionWorkflowState> > act = async() => await sessionManager.ProcessSessionMessageAsync(mockSession, dummyMessage);
// Assert
act.Should().Throw <Exception>();
Mock.Get(mockSession).Verify();
Mock.Get(mockStateManager).Verify();
Mock.Get(mockContractService).Verify();
Mock.Get(mockLogger).Verify();
}
/// <inheritdoc/>
public async Task SetWorkflowStateAsync(IMessageSession session, SessionWorkflowState state)
{
byte[] bytes = null;
if (state != null)
{
var json = JsonConvert.SerializeObject(state);
bytes = Encoding.UTF8.GetBytes(json);
}
await session.SetStateAsync(bytes);
}
public void Run_DoesNotThrowException()
{
// Arrange
var state = new SessionWorkflowState();
var dummyMessage = new Message {
MessageId = "1"
};
// Workaround to set internal get properties
var systemProperties = new Message.SystemPropertiesCollection();
typeof(Message.SystemPropertiesCollection).GetProperty(nameof(systemProperties.SequenceNumber)).SetValue(systemProperties, 1);
typeof(Message.SystemPropertiesCollection).GetProperty(nameof(systemProperties.DeliveryCount)).SetValue(systemProperties, 1);
typeof(Message.SystemPropertiesCollection).GetProperty(nameof(systemProperties.EnqueuedTimeUtc)).SetValue(systemProperties, DateTime.Now);
typeof(Message.SystemPropertiesCollection).GetProperty(nameof(systemProperties.LockedUntilUtc)).SetValue(systemProperties, DateTime.Now);
typeof(Message).GetProperty(nameof(dummyMessage.SystemProperties)).SetValue(dummyMessage, systemProperties);
var mockSession = Mock.Of <IMessageSession>(MockBehavior.Strict);
Mock.Get(mockSession)
.SetupGet(s => s.SessionId)
.Returns("session-1");
var mockContractEventSessionManager = Mock.Of <IContractEventSessionManager>(MockBehavior.Strict);
Mock.Get(mockContractEventSessionManager)
.Setup(m => m.ProcessSessionMessageAsync(mockSession, dummyMessage))
.ReturnsAsync(state)
.Verifiable();
var mockLogger = Mock.Of <ILogger>(MockBehavior.Strict);
Mock.Get(mockLogger)
.Setup(l => l.Log(LogLevel.Information, It.IsAny <EventId>(), It.IsAny <It.IsAnyType>(), null, It.IsAny <Func <It.IsAnyType, Exception, string> >()));
Mock.Get(mockLogger)
.Setup(l => l.BeginScope(It.IsAny <string>()))
.Returns(It.IsAny <IDisposable>());
var function = new ContractEventProcessorFunction(mockContractEventSessionManager);
// Act
Func <Task> act = async() => { await function.Run(dummyMessage, mockSession, mockLogger); };
// Assert
act.Should().NotThrow();
Mock.Get(mockContractEventSessionManager).Verify();
Mock.Get(mockLogger).VerifyAll();
Mock.Get(mockSession)
.VerifyGet(s => s.SessionId, Times.Exactly(3));
}
/// <inheritdoc/>
public async Task <SessionWorkflowState> GetWorkflowStateAsync(IMessageSession session)
{
byte[] bytes = await session.GetStateAsync();
var state = new SessionWorkflowState();
if (bytes != null)
{
var json = Encoding.UTF8.GetString(bytes);
state = JsonConvert.DeserializeObject <SessionWorkflowState>(json);
}
return(state);
}
public async Task ProcessSessionMessageAsync_SessionStateIsFaultedAndIsFailedMessage_ResetsSessionStateTest()
{
// Arrange
var dummyMessage = GetDummyMessage();
var initialState = new SessionWorkflowState
{
IsFaulted = true,
FailedMessageId = dummyMessage.MessageId
};
var expectedState = new SessionWorkflowState();
var mockSession = Mock.Of <IMessageSession>(MockBehavior.Strict);
var mockLogger = Mock.Of <IContractEventProcessorLogger <IContractEventSessionManager> >(MockBehavior.Strict);
var mockProcessLog = Mock.Of <IContractEventProcessLog>(MockBehavior.Strict);
Mock.Get(mockProcessLog)
.Setup(c => c.Initialise(It.IsAny <Message>(), It.IsAny <ContractEvent>()));
var mockContractService = Mock.Of <IContractService>(MockBehavior.Strict);
Mock.Get(mockContractService)
.Setup(c => c.ProcessMessage(It.IsAny <ContractEvent>()))
.Returns(Task.CompletedTask)
.Verifiable();
var mockStateManager = Mock.Of <IWorkflowStateManager>(MockBehavior.Strict);
Mock.Get(mockStateManager)
.Setup(s => s.GetWorkflowStateAsync(mockSession))
.ReturnsAsync(initialState)
.Verifiable();
Mock.Get(mockStateManager)
.Setup(s => s.ResetWorkflowStateAsync(mockSession))
.ReturnsAsync(expectedState)
.Verifiable();
// Act
var sessionManager = new ContractEventSessionManager(mockStateManager, mockContractService, mockLogger, GetConfiguration(), mockProcessLog);
var actual = await sessionManager.ProcessSessionMessageAsync(mockSession, dummyMessage);
// Assert
actual.Should().Be(expectedState);
Mock.Get(mockSession).VerifyNoOtherCalls();
Mock.Get(mockStateManager).Verify();
Mock.Get(mockContractService).Verify();
}
private async Task SaveFailedState(IMessageSession session, Message message, SessionWorkflowState state, Exception ex, string reason)
{
state.FailedMessageId = message.MessageId;
state.IsFaulted = true;
state.FailedMessageReason = $"{reason} with error [{ex.Message}]";
await _stateManager.SetWorkflowStateAsync(session, state);
var logMessage = $"[{nameof(ContractEventSessionManager)}.{nameof(ProcessSessionMessageAsync)}] - {reason} saving workflow state as faulted with failed message : {message.MessageId} for session: {session.SessionId}.";
if (ex is ContractEventExpectationFailedException)
{
_logger.LogError(ex, logMessage);
}
else
{
_logger.LogWarning(logMessage);
}
}
public async Task ResetWorkflowStateAsync_ReturnsExpectedSessionStateTest()
{
// Arrange
var expected = new SessionWorkflowState();
var mockSession = Mock.Of <IMessageSession>(MockBehavior.Strict);
Mock.Get(mockSession)
.Setup(s => s.SetStateAsync(null))
.Returns(Task.CompletedTask)
.Verifiable();
var workflowStateManager = new WorkflowStateManager();
// Act
var actual = await workflowStateManager.ResetWorkflowStateAsync(mockSession);
// Assert
actual.Should().BeEquivalentTo(expected);
Mock.Get(mockSession).Verify();
}
public async Task GetWorkflowStateAsync_ReturnsEmptySessionStateTest()
{
// Arrange
var expected = new SessionWorkflowState();
var mockSession = Mock.Of <IMessageSession>(MockBehavior.Strict);
Mock.Get(mockSession)
.Setup(s => s.GetStateAsync())
.ReturnsAsync(default(byte[]))
.Verifiable();
var workflowStateManager = new WorkflowStateManager();
// Act
var actual = await workflowStateManager.GetWorkflowStateAsync(mockSession);
// Assert
actual.Should().BeEquivalentTo(expected);
Mock.Get(mockSession).Verify();
}
public async Task SetWorkflowStateAsync_SetsExpectedSessionStateTest()
{
// Arrange
var state = new SessionWorkflowState {
FailedMessageId = "test"
};
var expected = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(state));
var mockSession = Mock.Of <IMessageSession>(MockBehavior.Strict);
Mock.Get(mockSession)
.Setup(s => s.SetStateAsync(expected))
.Returns(Task.CompletedTask)
.Verifiable();
var workflowStateManager = new WorkflowStateManager();
// Act
await workflowStateManager.SetWorkflowStateAsync(mockSession, state);
// Assert
Mock.Get(mockSession).Verify();
}
public async Task GetWorkflowStateAsync_ReturnsExpectedResultTest()
{
// Arrange
var expected = new SessionWorkflowState {
FailedMessageId = "test"
};
var stateBytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(expected));
var mockSession = Mock.Of <IMessageSession>(MockBehavior.Strict);
Mock.Get(mockSession)
.Setup(s => s.GetStateAsync())
.ReturnsAsync(stateBytes)
.Verifiable();
var workflowStateManager = new WorkflowStateManager();
// Act
var actual = await workflowStateManager.GetWorkflowStateAsync(mockSession);
// Assert
actual.Should().BeEquivalentTo(expected);
Mock.Get(mockSession).Verify();
}
public async Task ProcessSessionMessageAsync_SessionStateIsFaultedAndNotFailedMessage_ForwardsMessageToDLQTest()
{
// Arrange
var dummyMessage = GetDummyMessage();
var initialState = new SessionWorkflowState
{
IsFaulted = true,
FailedMessageId = "Not-same-as-dummy-message"
};
var expectedState = new SessionWorkflowState
{
IsFaulted = true,
FailedMessageId = "Not-same-as-dummy-message",
PostponedMessages = new List <string> {
dummyMessage.MessageId
}
};
var mockSession = Mock.Of <IMessageSession>(MockBehavior.Strict);
Mock.Get(mockSession)
.Setup(s => s.DeadLetterAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.Returns(Task.CompletedTask)
.Verifiable();
Mock.Get(mockSession)
.SetupGet(s => s.SessionId)
.Returns("session-id")
.Verifiable();
var mockLogger = Mock.Of <IContractEventProcessorLogger <IContractEventSessionManager> >(MockBehavior.Strict);
Mock.Get(mockLogger)
.Setup(l => l.LogWarning(It.IsAny <string>()));
var mockProcessLog = Mock.Of <IContractEventProcessLog>(MockBehavior.Strict);
Mock.Get(mockProcessLog)
.Setup(c => c.Initialise(It.IsAny <Message>(), It.IsAny <ContractEvent>()));
var mockContractService = Mock.Of <IContractService>(MockBehavior.Strict);
var mockStateManager = Mock.Of <IWorkflowStateManager>(MockBehavior.Strict);
Mock.Get(mockStateManager)
.Setup(s => s.GetWorkflowStateAsync(mockSession))
.ReturnsAsync(initialState)
.Verifiable();
Mock.Get(mockStateManager)
.Setup(s => s.SetWorkflowStateAsync(mockSession, initialState))
.Returns(Task.CompletedTask)
.Verifiable();
// Act
var sessionManager = new ContractEventSessionManager(mockStateManager, mockContractService, mockLogger, GetConfiguration(), mockProcessLog);
var actual = await sessionManager.ProcessSessionMessageAsync(mockSession, dummyMessage);
// Assert
actual.Should().BeEquivalentTo(expectedState);
actual.PostponedMessages.Should().Contain(dummyMessage.MessageId);
Mock.Get(mockSession).Verify();
Mock.Get(mockStateManager).Verify();
Mock.Get(mockContractService)
.Verify(c => c.ProcessMessage(It.IsAny <ContractEvent>()), Times.Never());
}
