protected MessagingContext CreateEncryptedAS4Message()
{
Stream attachmentStream = new MemoryStream(Encoding.UTF8.GetBytes("Hello, encrypt me"));
var attachment = new Attachment("attachment-id", attachmentStream, "text/plain");
AS4Message as4Message = AS4Message.Empty;
as4Message.AddMessageUnit(new UserMessage($"user-{Guid.NewGuid()}"));
as4Message.AddAttachment(attachment);
var message = new MessagingContext(as4Message, MessagingContextMode.Unknown)
{
SendingPMode = new SendingProcessingMode()
};
message.SendingPMode.Security.Encryption.IsEnabled = true;
message.SendingPMode.Security.Encryption.Algorithm = "http://www.w3.org/2009/xmlenc11#aes128-gcm";
message.SendingPMode.Security.Encryption.CertificateType = PublicKeyCertificateChoiceType.CertificateFindCriteria;
message.SendingPMode.Security.Encryption.EncryptionCertificateInformation = new CertificateFindCriteria()
{
CertificateFindType = X509FindType.FindBySerialNumber,
CertificateFindValue = "some dummy value"
};
return(message);
}
public async Task Received_Bundled_Response_Should_Process_All_Messages()
{
// Arrange
string pullSenderUrl = RetrievePullingUrlFromConfig();
string storedMessageId = "stored-" + Guid.NewGuid();
StoreToBeAckOutMessage(storedMessageId);
AS4Message bundled = CreateBundledMultipleUserMessagesWithRefTo();
bundled.AddMessageUnit(new Receipt($"receipt-{Guid.NewGuid()}", storedMessageId));
// Act
await RespondToPullRequestAsync(
pullSenderUrl,
response =>
{
response.ContentType = bundled.ContentType;
response.StatusCode = 200;
using (Stream output = response.OutputStream)
{
SerializerProvider.Default
.Get(bundled.ContentType)
.Serialize(bundled, output);
}
});
// Assert
IEnumerable <InMessage> storedBundled =
await PollUntilPresent(
() => _databaseSpy.GetInMessages(bundled.UserMessages.Select(u => u.MessageId).ToArray())
.Where(m => m.Operation == Operation.ToBeDelivered),
timeout : TimeSpan.FromSeconds(20));
Assert.Collection(
storedBundled,
userMessage1 =>
{
Assert.Equal(MessageExchangePattern.Pull, userMessage1.MEP);
Assert.Equal(InStatus.Received, userMessage1.Status.ToEnum <InStatus>());
Assert.Equal(Operation.ToBeDelivered, userMessage1.Operation);
},
userMessage2 =>
{
Assert.Equal(MessageExchangePattern.Pull, userMessage2.MEP);
Assert.Equal(InStatus.Received, userMessage2.Status.ToEnum <InStatus>());
Assert.Equal(Operation.ToBeDelivered, userMessage2.Operation);
});
Assert.Collection(
_databaseSpy.GetInMessages(bundled.SignalMessages.Select(s => s.MessageId).ToArray()),
signal =>
{
Assert.Equal(MessageExchangePattern.Pull, signal.MEP);
Assert.Equal(InStatus.Received, signal.Status.ToEnum <InStatus>());
Assert.Equal(Operation.ToBeNotified, signal.Operation);
});
Assert.Collection(
_databaseSpy.GetOutMessages(storedMessageId),
stored => Assert.Equal(OutStatus.Ack, stored.Status.ToEnum <OutStatus>()));
}
protected AS4Message BuildAS4Message(string mpc, UserMessage userMessage)
{
AS4Message as4Message = AS4Message.Create(userMessage);
as4Message.AddMessageUnit(new PullRequest($"pr-{Guid.NewGuid()}", mpc));
return(as4Message);
}
public async Task ThenTransformFailsWithInvalidUserMessageWithSoapAS4StreamAsync()
{
// Arrange
AS4Message as4Message = CreateAS4MessageWithoutAttachments();
as4Message.AddMessageUnit(new UserMessage("message-id"));
MemoryStream memoryStream = as4Message.ToStream();
var receivedMessage = new ReceivedMessage(memoryStream, Constants.ContentTypes.Mime);
// Act / Assert
await Assert.ThrowsAnyAsync <Exception>(() => Transform(receivedMessage));
}
/// <summary>
/// It is only executed when the external message (received) is an AS4 UserMessage
/// </summary>
/// <param name="messagingContext"></param>
public async Task <StepResult> ExecuteAsync(MessagingContext messagingContext)
{
if (messagingContext == null)
{
throw new ArgumentNullException(nameof(messagingContext));
}
if (messagingContext.AS4Message == null)
{
throw new InvalidOperationException(
$"{nameof(CreateAS4ReceiptStep)} requires an AS4Message to create ebMS Receipts but no AS4Message is present in the MessagingContext");
}
bool receiptSigning = messagingContext.ReceivingPMode?.ReplyHandling?.ResponseSigning?.IsEnabled ?? false;
bool useNRRFormat = messagingContext.ReceivingPMode?.ReplyHandling?.ReceiptHandling?.UseNRRFormat ?? false;
if (!receiptSigning && useNRRFormat)
{
Logger.Error(
"Cannot create Non-Repudiation Receipts that aren\'t signed, please change either the "
+ $"ReceivingPMode {messagingContext.ReceivingPMode.Id} ReplyHandling.ReceiptHandling.UseNRRFormat or the ReplyHandling.ResponseSigning");
messagingContext.ErrorResult = new ErrorResult(
"Cannot create Non-Repudiation Receipts that aren't signed",
ErrorAlias.InvalidReceipt);
return(StepResult.Failed(messagingContext));
}
AS4Message receivedMessage = messagingContext.AS4Message;
AS4Message receiptMessage = AS4Message.Empty;
receiptMessage.SigningId = receivedMessage.SigningId;
foreach (UserMessage userMessage in receivedMessage.UserMessages)
{
Receipt receipt = CreateReferencedReceipt(userMessage, receivedMessage, messagingContext.ReceivingPMode);
receiptMessage.AddMessageUnit(receipt);
}
if (Logger.IsInfoEnabled && receiptMessage.MessageUnits.Any())
{
Logger.Info($"{messagingContext.LogTag} {receiptMessage.MessageUnits.Count()} Receipt message(s) has been created for received AS4 UserMessages");
}
messagingContext.ModifyContext(receiptMessage);
return(await StepResult.SuccessAsync(messagingContext));
}
public void Bundled_UserMessage_With_Signal_Gets_Decompressed(SignalMessage signal)
{
// Arrange
string attachmentId = $"attachment-{Guid.NewGuid()}";
UserMessage user = UserMessageWithCompressedInfo(attachmentId);
Attachment attachment = CompressedAttachment(attachmentId);
AS4Message as4Message = AS4Message.Create(user);
as4Message.AddMessageUnit(signal);
as4Message.AddAttachment(attachment);
// Act
StepResult result = ExerciseDecompress(as4Message);
// Assert
Assert.All(
result.MessagingContext.AS4Message.Attachments,
a => Assert.NotEqual("application/gzip", a.ContentType));
Assert.All(
result.MessagingContext.AS4Message.UserMessages.SelectMany(u => u.PayloadInfo),
p => Assert.Equal("application/gzip", p.CompressionType));
}
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);
}
