public async Task OutMessageIsCreatedForToBeForwardedMessage()
{
// Arrange
const string messageId = "message-id";
var as4Message = AS4Message.Create(CreateForwardPushUserMessage(messageId));
// Act
InsertToBeForwardedInMessage(
pmodeId: "Forward_Push",
mep: MessageExchangePattern.Push,
tobeForwarded: as4Message);
// Assert: if an OutMessage is created with the correct status and operation.
InMessage inMessage = await PollUntilPresent(
() => _databaseSpy.GetInMessageFor(
m => m.EbmsMessageId == messageId &&
m.Operation == Operation.Forwarded),
TimeSpan.FromSeconds(15));
Assert.NotNull(AS4XmlSerializer.FromString <ReceivingProcessingMode>(inMessage.PMode));
OutMessage outMessage = await PollUntilPresent(
() => _databaseSpy.GetOutMessageFor(m => m.EbmsMessageId == messageId),
timeout : TimeSpan.FromSeconds(5));
Assert.True(outMessage.Intermediary);
Assert.Equal(Operation.ToBeProcessed, outMessage.Operation);
Assert.NotNull(AS4XmlSerializer.FromString <SendingProcessingMode>(outMessage.PMode));
}
public async Task PiggyBack_PullRequest_With_Receipt_Operation_Becomes_DeadLettered_When_Retries_Are_Exhausted()
{
// Arrange
string pullSendUrl = RetrievePullingUrlFromConfig();
var user = new UserMessage($"user-{Guid.NewGuid()}", PullRequestMpc);
var receipt = new Receipt($"receipt-{Guid.NewGuid()}", user.MessageId);
InsertUserMessage(user);
long id = InsertReceipt(receipt, pullSendUrl, Operation.ToBePiggyBacked);
// Act
InsertRetryReliability(id, maxRetryCount: 1);
// Assert
await PollUntilPresent(
() => _databaseSpy.GetOutMessageFor(
m => m.EbmsMessageId == receipt.MessageId &&
m.Operation == Operation.DeadLettered),
timeout : TimeSpan.FromSeconds(40));
RetryReliability reliability = await PollUntilPresent(
() => _databaseSpy.GetRetryReliabilityFor(
r => r.RefToOutMessageId == id &&
r.Status == RetryStatus.Completed),
timeout : TimeSpan.FromSeconds(5));
Assert.True(
reliability.CurrentRetryCount > 0,
"RetryReliability.CurrentRetryCount should be greater then zero");
}
public async Task ThenAgentStoresOutMessageFoReceivedSubmitMessage()
{
// Arrange
string fixture = SubmitMessageFixture;
var submitMessage = AS4XmlSerializer.FromString <SubmitMessage>(fixture);
Assert.True(submitMessage?.MessageInfo?.MessageId != null, "Send SubmitMessage hasn't got a MessageInfo.MessageId element");
Assert.True(submitMessage?.Collaboration?.AgreementRef != null, "Send SubmitMessage hasn't got a Collaboration.AgreementRef element");
// Act
using (HttpResponseMessage response = await StubSender.SendRequest(HttpSubmitAgentUrl, Encoding.UTF8.GetBytes(fixture), "application/xml"))
{
Assert.Equal(HttpStatusCode.Accepted, response.StatusCode);
Assert.True(String.IsNullOrWhiteSpace(response.Content.Headers.ContentType?.ToString()));
}
// Assert
IConfig config = _as4Msh.GetConfiguration();
string pmodeId = submitMessage.Collaboration.AgreementRef.PModeId;
SendingProcessingMode usedSendingPMode = config.GetSendingPMode(pmodeId);
Assert.True(usedSendingPMode.PushConfiguration?.Protocol != null, "SendingPMode for SubmitMessage hasn't got PushConfiguration.Protocol element");
var databaseSpy = new DatabaseSpy(config);
OutMessage outMessage = databaseSpy.GetOutMessageFor(
m => m.EbmsMessageId == submitMessage.MessageInfo.MessageId);
Assert.True(outMessage != null, "No OutMessage was stored for send SubmitMessage");
Assert.Equal(usedSendingPMode.PushConfiguration.Protocol.Url, outMessage.Url);
}
public async Task OutMessage_Is_To_Notified_When_Retry_Happen_Withing_Allowed_MaxRetry(
HttpStatusCode secondAttemptStatusCode,
Operation expected)
{
await TestComponentWithSettings(
"outmessage_notify_reliability_settings.xml",
async (settings, as4Msh) =>
{
// Arrange
const string url = "http://localhost:7071/business/outmessage/";
string ebmsMessageId = $"error-{Guid.NewGuid()}";
var store = new AS4MessageBodyFileStore();
var om = new OutMessage(ebmsMessageId)
{
ContentType = Constants.ContentTypes.Soap,
MessageLocation = store.SaveAS4Message(
as4Msh.GetConfiguration().InMessageStoreLocation,
AS4Message.Create(
Error.FromErrorResult(
ebmsMessageId,
refToMessageId: $"user-{Guid.NewGuid()}",
result: new ErrorResult(
"Invalid header example description failure",
ErrorAlias.InvalidHeader))))
};
SendingProcessingMode pmode = NotifySendingPMode(url);
Entities.RetryReliability CreateRetry(long id)
=> Entities.RetryReliability.CreateForOutMessage(
refToOutMessageId: id,
maxRetryCount: pmode.ErrorHandling.Reliability.RetryCount,
retryInterval: pmode.ErrorHandling.Reliability.RetryInterval.AsTimeSpan(),
type: RetryType.Notification);
// Act
InsertMessageEntityWithRetry(om, as4Msh.GetConfiguration(), pmode, CreateRetry);
// Assert
SimulateNotifyFailureOnFirstAttempt(url, secondAttemptStatusCode);
var spy = new DatabaseSpy(as4Msh.GetConfiguration());
OutMessage notified = await PollUntilPresent(
() => spy.GetOutMessageFor(
m => m.Operation == expected),
timeout: TimeSpan.FromSeconds(10));
Assert.Equal(ebmsMessageId, notified.EbmsMessageId);
Entities.RetryReliability referenced = await PollUntilPresent(
() => spy.GetRetryReliabilityFor(r => r.RefToOutMessageId == notified.Id),
timeout: TimeSpan.FromSeconds(5));
Assert.Equal(RetryStatus.Completed, referenced.Status);
});
}
private async Task CorrectHandlingOnSynchronouslyReceivedMultiHopReceipt(
bool actAsIntermediaryMsh,
string receivePModeId,
OutStatus expectedOutStatus,
Operation expectedSignalOperation)
{
// Arrange
SendingProcessingMode pmode = CreateMultihopPMode(StubListenLocation);
UserMessage simpleUserMessage = CreateMultihopUserMessage(receivePModeId, pmode);
AS4Message as4Message = AS4Message.Create(simpleUserMessage, pmode);
var signal = new ManualResetEvent(false);
var serializer = new SoapEnvelopeSerializer();
StubHttpServer.StartServer(
StubListenLocation,
res =>
{
res.StatusCode = 200;
res.ContentType = Constants.ContentTypes.Soap;
var receipt = Receipt.CreateFor(
$"receipt-{Guid.NewGuid()}",
as4Message.FirstUserMessage,
userMessageSendViaMultiHop: true);
serializer.Serialize(AS4Message.Create(receipt), res.OutputStream);
},
signal);
// Act
PutMessageToSend(as4Message, pmode, actAsIntermediaryMsh);
// Assert
signal.WaitOne();
OutMessage sentMessage = await PollUntilPresent(
() => _databaseSpy.GetOutMessageFor(m => m.EbmsMessageId == simpleUserMessage.MessageId),
timeout : TimeSpan.FromSeconds(10));
Assert.Equal(expectedOutStatus, sentMessage.Status.ToEnum <OutStatus>());
InMessage receivedMessage = await PollUntilPresent(
() => _databaseSpy.GetInMessageFor(m => m.EbmsRefToMessageId == simpleUserMessage.MessageId),
timeout : TimeSpan.FromSeconds(10));
Assert.Equal(MessageType.Receipt, receivedMessage.EbmsMessageType);
Assert.Equal(expectedSignalOperation, receivedMessage.Operation);
}
private async Task <HttpResponseMessage> PiggyBacked_PullRequest_With_Bundled_Signal(
Func <string, SignalMessage> createSignal,
OutStatus expStatus)
{
// Arrange
OverridePullAuthorizationMap(
@".\config\componenttest-settings\security\pull_authorizationmap_allowed_facts.xml");
string userMessageId = $"user-{Guid.NewGuid()}";
StoreToBeAckOutMessage(userMessageId, CreateSendingPMode());
AS4Message pullRequest = CreateAllowedPullRequest();
SignalMessage extraSignalMessage = createSignal(userMessageId);
pullRequest.AddMessageUnit(extraSignalMessage);
AS4Message signedBundled = SignAS4MessageWithPullRequestCert(pullRequest);
// Act
HttpResponseMessage response = await StubSender.SendAS4Message(PullSendUrl, signedBundled);
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
OutMessage storedUserMesage =
_databaseSpy.GetOutMessageFor(m => m.EbmsMessageId == userMessageId);
Assert.Equal(expStatus, storedUserMesage.Status.ToEnum <OutStatus>());
InMessage storedSignalMessage =
_databaseSpy.GetInMessageFor(m => m.EbmsMessageId == extraSignalMessage.MessageId);
Assert.Equal(InStatus.Received, storedSignalMessage.Status.ToEnum <InStatus>());
return(response);
}
public async Task PiggyBack_Receipt_On_Next_PullRequest_Result_In_Acked_UserMessage()
{
// Arrange
OverrideServiceSettings("piggyback_service_settings.xml");
_windowsService.EnsureServiceIsStarted();
// Act
await SubmitMessageToSubmitAgent(pullsendagent_piggyback);
// Assert
var spy = new DatabaseSpy(_consoleHost.GetConfiguration());
InMessage receipt = await PollUntilPresent(
() => spy.GetInMessageFor(
m => m.EbmsMessageType == MessageType.Receipt),
timeout : TimeSpan.FromSeconds(30));
await PollUntilPresent(
() => spy.GetOutMessageFor(
m => m.EbmsMessageType == MessageType.UserMessage &&
m.EbmsMessageId == receipt.EbmsRefToMessageId &&
m.Status.ToEnum(OutStatus.NotApplicable) == OutStatus.Ack),
timeout : TimeSpan.FromSeconds(10));
}
public async Task ThenInMessageSignalIsStoredWithPModeUrl()
{
// Arrange
var userMessage = new UserMessage(
$"user-{Guid.NewGuid()}",
new CollaborationInfo(
new AgreementReference(
"http://eu.europe.agreements",
"callback-pmode")));
// Act
await StubSender.SendAS4Message(_receiveAgentUrl, AS4Message.Create(userMessage));
// Assert
OutMessage storedReceipt =
await PollUntilPresent(
() => _databaseSpy.GetOutMessageFor(m => m.EbmsRefToMessageId == userMessage.MessageId &&
m.EbmsMessageType == MessageType.Receipt),
timeout : TimeSpan.FromSeconds(20));
ReceivingProcessingMode pmode = _as4Msh.GetConfiguration().GetReceivingPModes().First(p => p.Id == "callback-pmode");
Assert.Equal(pmode.ReplyHandling.ResponseConfiguration.Protocol.Url, storedReceipt.Url);
}
