public async Task Updates_Status_Nack_Related_UserMessage_OutMessage()
{
// Arrange
string ebmsMessageId = "error-" + Guid.NewGuid();
GetDataStoreContext.InsertOutMessage(CreateOutMessage(ebmsMessageId));
var error = Error.FromErrorResult(
$"error-{Guid.NewGuid()}",
ebmsMessageId,
new ErrorResult("Some Error", ErrorAlias.ConnectionFailure));
// Act
await ExerciseUpdateReceivedMessage(
AS4Message.Create(error),
CreateNotifyAllSendingPMode(),
receivePMode : null);
// Assert
GetDataStoreContext.AssertOutMessage(
ebmsMessageId,
m =>
{
Assert.NotNull(m);
Assert.Equal(OutStatus.Nack, m.Status.ToEnum <OutStatus>());
});
}
public async Task Doesnt_Update_OutMessage_If_No_MessageLocation_Can_Be_Found()
{
// Arrange
string knownId = "known-id-" + Guid.NewGuid();
GetDataStoreContext.InsertOutMessage(
new OutMessage(knownId)
{
MessageLocation = null
});
var ctx = new MessagingContext(
AS4Message.Create(new FilledUserMessage(knownId)),
MessagingContextMode.Unknown)
{
SendingPMode = CreateNotifyAllSendingPMode()
};
var sut = new UpdateReceivedAS4MessageBodyStep(StubConfig.Default, GetDataStoreContext, _messageBodyStore);
// Act
await sut.ExecuteAsync(ctx);
// Assert
GetDataStoreContext.AssertOutMessage(knownId, m => Assert.Null(m.MessageLocation));
}
public async Task Updates_ToBeNotified_When_Specified_SendingPMode_And_Reference_InMessage()
{
// Arrange
string ebmsMessageId = Guid.NewGuid().ToString();
GetDataStoreContext.InsertOutMessage(new OutMessage(ebmsMessageId));
AS4Message receivedAS4Message =
AS4Message.Create(new Receipt($"receipt-{Guid.NewGuid()}", ebmsMessageId));
// Act
await ExerciseUpdateReceivedMessage(
receivedAS4Message,
CreateNotifyAllSendingPMode(),
receivePMode : null);
// Assert
GetDataStoreContext.AssertInMessageWithRefToMessageId(
ebmsMessageId,
m =>
{
Assert.NotNull(m);
Assert.Equal(Operation.ToBeNotified, m.Operation);
});
GetDataStoreContext.AssertOutMessage(
ebmsMessageId,
m =>
{
Assert.NotNull(m);
Assert.Equal(OutStatus.Ack, m.Status.ToEnum <OutStatus>());
});
}
public void Stores_Retry_Information_For_ToBePiggyBacked_SignalMessages(bool isEnabled, int maxRetryCount, TimeSpan retryInterval)
{
// Arrange
string userMessageId = $"user-{Guid.NewGuid()}";
GetDataStoreContext.InsertInMessage(
new InMessage(userMessageId)
{
MEP = MessageExchangePattern.Pull
});
var receipt = new Receipt($"receipt-{Guid.NewGuid()}", userMessageId);
var context = new MessagingContext(
AS4Message.Create(receipt),
MessagingContextMode.Receive)
{
SendingPMode = new SendingProcessingMode {
Id = "shortcut-send-pmode-retrieval"
},
ReceivingPMode = new ReceivingProcessingMode
{
ReplyHandling =
{
ReplyPattern = ReplyPattern.PiggyBack,
PiggyBackReliability = new AS4.Model.PMode.RetryReliability
{
IsEnabled = isEnabled,
RetryCount = maxRetryCount,
RetryInterval = retryInterval.ToString()
}
}
}
};
// Act
ExerciseStoreSignalMessageAsync(context)
.GetAwaiter()
.GetResult();
// Assert
GetDataStoreContext.AssertOutMessage(
receipt.MessageId,
m => GetDataStoreContext.AssertRetryRelatedOutMessage(
m.Id,
r =>
{
Assert.True(
isEnabled == (0 == r?.CurrentRetryCount),
$"Enabling PiggyBack Reliability should result in 0 = {r?.CurrentRetryCount}");
Assert.True(
isEnabled == (maxRetryCount == r?.MaxRetryCount),
$"Enabling PiggyBack Reliability should result in {maxRetryCount} = {r?.MaxRetryCount}");
Assert.True(
isEnabled == (retryInterval == r?.RetryInterval),
$"Enabling PiggyBack Reliability should result in {retryInterval} = {r?.RetryInterval}");
}));
}
public async Task Only_Unsigned_Signals_Are_PiggyBacked_For_SendingPModes_Where_Signing_Is_Not_Configured()
{
// Arrange
const string url = "http://localhost:8081/msh";
string mpc = $"mpc-{Guid.NewGuid()}";
var user = new UserMessage($"user-{Guid.NewGuid()}", mpc);
var unsignedReceipt = new Receipt($"receipt-{Guid.NewGuid()}", user.MessageId);
var signedReceipt = new Receipt($"receipt-{Guid.NewGuid()}", user.MessageId);
InsertUserMessage(user);
InsertReceipt(unsignedReceipt, Operation.ToBePiggyBacked, url, signed: false);
InsertReceipt(signedReceipt, Operation.ToBePiggyBacked, url, signed: true);
var pr = new PullRequest($"pr-{Guid.NewGuid()}", mpc);
var ctx = new MessagingContext(AS4Message.Create(pr), MessagingContextMode.PullReceive)
{
SendingPMode = new SendingProcessingMode
{
PushConfiguration = new PushConfiguration {
Protocol = { Url = url }
},
Security = { Signing = { IsEnabled = false } }
}
};
var sut = new BundleSignalMessageToPullRequestStep(GetDataStoreContext, _bodyStore);
// Act
StepResult result = await sut.ExecuteAsync(ctx);
// Assert
Assert.True(result.Succeeded);
Assert.Collection(
result.MessagingContext.AS4Message.MessageUnits,
u => Assert.IsType <PullRequest>(u),
u => Assert.Equal(unsignedReceipt.MessageId, Assert.IsType <Receipt>(u).MessageId));
GetDataStoreContext.AssertOutMessage(
signedReceipt.MessageId,
m => Assert.Equal(Operation.ToBePiggyBacked, m.Operation));
GetDataStoreContext.AssertOutMessage(
unsignedReceipt.MessageId,
m => Assert.Equal(Operation.Sending, m.Operation));
}
public async Task MessageGetsSavedWithOperationToBeProcessed()
{
// Arrange
string id = Guid.NewGuid().ToString();
var sut = new StoreAS4MessageStep(StubConfig.Default, GetDataStoreContext, _messageBodyStore);
// Act
await sut.ExecuteAsync(
new MessagingContext(AS4Message.Create(new FilledUserMessage(id)), MessagingContextMode.Submit));
// Assert
GetDataStoreContext.AssertOutMessage(
id,
async m =>
{
Assert.Equal(Operation.ToBeProcessed, m.Operation);
Assert.True(await _messageBodyStore.LoadMessageBodyAsync(m.MessageLocation) != Stream.Null);
});
}
public async Task After_Send_Updates_Request_Operation_And_Status_To_Sent_For_Exsiting_SendPMode()
{
// Arrange
string ebmsMessageId = $"user-{Guid.NewGuid()}";
AS4Message tobeSentMsg = AS4Message.Create(new FilledUserMessage(ebmsMessageId));
var inserted = new OutMessage(ebmsMessageId: ebmsMessageId);
GetDataStoreContext.InsertOutMessage(inserted);
var receivedMessage = new ReceivedEntityMessage(
inserted,
tobeSentMsg.ToStream(),
tobeSentMsg.ContentType);
var ctx = new MessagingContext(
tobeSentMsg,
receivedMessage,
MessagingContextMode.Send)
{
SendingPMode = CreateSendPModeWithPushUrl()
};
AS4Message receiptMessage =
AS4Message.Create(new Receipt($"receipt-{Guid.NewGuid()}", $"user-{Guid.NewGuid()}"));
// Act
IStep sut = CreateSendStepWithResponse(
StubHttpClient.ThatReturns(receiptMessage));
await sut.ExecuteAsync(ctx);
// Assert
GetDataStoreContext.AssertOutMessage(
ebmsMessageId,
message =>
{
Assert.Equal(OutStatus.Sent, message.Status.ToEnum <OutStatus>());
Assert.Equal(Operation.Sent, message.Operation);
});
}
public async Task Stores_SignalMessage_With_Expected_Operation_According_To_MEP_And_ReplyPattern(
MessageExchangePattern mep,
ReplyPattern reply,
Operation op)
{
// Arrange
string userMessageId = $"user-{Guid.NewGuid()}";
GetDataStoreContext.InsertInMessage(
new InMessage(userMessageId)
{
MEP = mep
});
var receipt = new Receipt($"receipt-{Guid.NewGuid()}", userMessageId);
var context = new MessagingContext(
AS4Message.Create(receipt),
MessagingContextMode.Receive)
{
SendingPMode = new SendingProcessingMode {
Id = "shortcut-send-pmode-retrieval"
},
ReceivingPMode = new ReceivingProcessingMode
{
ReplyHandling = { ReplyPattern = reply }
}
};
// Act
await ExerciseStoreSignalMessageAsync(context);
// Assert
GetDataStoreContext.AssertOutMessage(
receipt.MessageId,
m =>
{
Assert.NotNull(m);
Assert.Equal(op, m.Operation);
});
}
private async Task TestHandleExecutionException(
Operation expected,
MessagingContext context,
Func <IAgentExceptionHandler, Func <Exception, MessagingContext, Task <MessagingContext> > > getExercise)
{
var sut = new OutboundExceptionHandler(GetDataStoreContext, StubConfig.Default, new InMemoryMessageBodyStore());
Func <Exception, MessagingContext, Task <MessagingContext> > exercise = getExercise(sut);
// Act
await exercise(_expectedException, context);
// Assert
GetDataStoreContext.AssertOutMessage(_expectedId, m => Assert.Equal(OutStatus.Exception, m.Status.ToEnum <OutStatus>()));
GetDataStoreContext.AssertOutException(
_expectedId,
exception =>
{
Assert.True(exception.Exception.IndexOf(_expectedException.Message, StringComparison.CurrentCultureIgnoreCase) > -1, "Message does not contain expected message");
Assert.True(expected == exception.Operation, "Not equal 'Operation' inserted");
Assert.True(exception.MessageLocation == null, "Inserted exception body is not empty");
});
}
public async Task StepSetsMessageToBeSent()
{
// Assert
string messageId = Guid.NewGuid().ToString(),
expected = Guid.NewGuid().ToString();
var sut = new SetMessageToBeSentStep(GetDataStoreContext, _messageBodyStore);
var messagingContext = SetupMessagingContext(messageId, Operation.Processing, expected);
// Act
await sut.ExecuteAsync(messagingContext);
// Assert
GetDataStoreContext.AssertOutMessage(
messageId,
m =>
{
Assert.Equal(expected, m.MessageLocation);
Assert.Equal(Operation.ToBeSent, m.Operation);
});
}
