private static AS4Message UserMessageWithAttachment(string argRefPModeId)
{
var user = new UserMessage(
Guid.NewGuid().ToString(),
HolodeckCollaboration(argRefPModeId),
new Party(Constants.Namespaces.EbmsDefaultFrom, new PartyId(Constants.Namespaces.EbmsDefaultFrom)),
new Party(HolodeckPartyRole, new PartyId(HolodeckBId, HolodeckBId)),
new[]
{
new PartInfo(
href: "cid:earth",
properties: new Dictionary <string, string>
{
["Part Property"] = "Some Holodeck required Part Property"
},
schemas: new Schema[0])
},
new Model.Core.MessageProperty[0]);
AS4Message userMessage = AS4Message.Create(user, new SendingProcessingMode {
MessagePackaging = { IsMultiHop = true }
});
userMessage.AddAttachment(ImageAttachment(id: "earth"));
return(userMessage);
}
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);
}
private static MessagingContext CreateDummyMessageWithAttachment()
{
AS4Message message = AS4Message.Empty;
message.AddAttachment(new Attachment(Stream.Null, "text/plain"));
return(new MessagingContext(message, MessagingContextMode.Unknown));
}
private static AS4Message AS4MessageWithTwoAttachments()
{
Attachment CreateAttachment()
{
return(new Attachment(
id: $"attachment{Guid.NewGuid()}",
content: new MemoryStream(Encoding.UTF8.GetBytes("Plain Dummy Text")),
contentType: "text/plain"));
}
AS4Message message = AS4Message.Empty;
message.AddAttachment(CreateAttachment());
message.AddAttachment(CreateAttachment());
return(message);
}
private static AS4Message CreateAnonymousMessage()
{
AS4Message message = AS4Message.Create(new UserMessage("message-id"));
message.AddAttachment(CreateEarthAttachment());
return(message);
}
private static async Task <AS4Message> SignedUserMessage(string messageId)
{
AS4Message userMessage = AS4Message.Create(new UserMessage(messageId));
userMessage.AddAttachment(new FilledAttachment());
userMessage = await SerializeDeserializeMime(userMessage);
return(AS4MessageUtils.SignWithCertificate(userMessage, new StubCertificateRepository().GetStubCertificate()));
}
public async Task TransformRemovesUnnecessaryAttachments()
{
// Arrange
const string expectedId = "usermessage-id";
const string expectedUri = "expected-attachment-uri";
var user = new UserMessage(expectedId, new PartInfo("cid:" + expectedUri));
AS4Message message = AS4Message.Create(user);
message.AddAttachment(FilledAttachment(expectedUri));
message.AddAttachment(FilledAttachment());
message.AddAttachment(FilledAttachment());
// Act
MessagingContext actualMessage = await ExerciseTransform(expectedId, message);
// Assert
Assert.Single(actualMessage.DeliverMessage.Attachments);
}
private static MessagingContext CompressedAS4Message()
{
const string attachmentId = "attachment-id";
AS4Message as4Message = AS4Message.Create(UserMessageWithCompressedInfo(attachmentId));
as4Message.AddAttachment(CompressedAttachment(attachmentId));
return(new MessagingContext(as4Message, MessagingContextMode.Unknown));
}
private static AS4Message CreateAS4Message()
{
byte[] attachmentContents = Encoding.UTF8.GetBytes("hi!");
var attachment = new Attachment("attachment-id", new MemoryStream(attachmentContents), "text/plain");
AS4Message as4Message = AS4Message.Create(pmode: null);
as4Message.AddAttachment(attachment);
return(as4Message);
}
private static AS4Message SignedUserMessage(string messageId, SendingProcessingMode nrrPMode, X509Certificate2 cert)
{
AS4Message userMessage = AS4Message.Create(new UserMessage(messageId), nrrPMode);
userMessage.AddAttachment(
new Attachment(
id: "payload",
content: new MemoryStream(Encoding.UTF8.GetBytes("some content!")),
contentType: "text/plain"));
return(AS4MessageUtils.SignWithCertificate(userMessage, cert));
}
private static async Task <MessagingContext> CreateAS4MessageWithAttachmentAsync()
{
const string attachmentId = "attachment-id";
var userMessage = new UserMessage(Guid.NewGuid().ToString(), new PartInfo("cid:" + attachmentId));
AS4Message as4Message = AS4Message.Create(userMessage);
as4Message.AddAttachment(new Attachment(attachmentId, Stream.Null, "text/plain"));
ReceivingProcessingMode pMode = CreateReceivingPModeWithPayloadMethod();
return(await PrepareAS4MessageForDeliveryAsync(as4Message, pMode));
}
private static MessagingContext AS4MessageContext(Attachment attachment, SendingProcessingMode pmode)
{
var userMessage = new UserMessage($"user-{Guid.NewGuid()}", PartInfo.CreateFor(attachment));
AS4Message as4Message = AS4Message.Create(userMessage, pmode);
as4Message.AddAttachment(attachment);
return(new MessagingContext(as4Message, MessagingContextMode.Unknown)
{
SendingPMode = pmode
});
}
public void ThenHasAttachmentsIsCorrectTrue()
{
// Arrange
AS4Message as4Message = AS4Message.Create(pmode: null);
as4Message.AddAttachment(new Attachment("attachment-id"));
var context = new MessagingContext(as4Message, MessagingContextMode.Unknown);
// Act
bool hasAttachments = context.AS4Message.HasAttachments;
// Assert
Assert.True(hasAttachments);
}
public void ThenSerializeWithAttachmentsReturnsMimeMessage(string messageContents)
{
// Arrange
var attachmentStream = new MemoryStream(Encoding.UTF8.GetBytes(messageContents));
var attachment = new Attachment("attachment-id", attachmentStream, "text/plain");
UserMessage userMessage = CreateUserMessage();
AS4Message message = AS4Message.Create(userMessage);
message.AddAttachment(attachment);
// Act
AssertMimeMessageIsValid(message);
}
/// <summary>
/// Tranform the Payload(s)
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
public async Task <MessagingContext> TransformAsync(ReceivedMessage message)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
Attachment attachment = CreateAttachmentFromReceivedMessage(message);
AS4Message as4Message = AS4Message.Empty;
as4Message.AddAttachment(attachment);
Logger.Info("Transform the given Payload to a AS4 Attachment");
return(await Task.FromResult(new MessagingContext(as4Message, MessagingContextMode.Submit)));
}
public async Task Deliver_Attachment_Only_If_Belong_To_UserMessage()
{
// Arrange
AS4Message as4Message = await CreateAS4MessageFrom(deliveragent_message);
as4Message.AddAttachment(StubAttachment());
FileSystemUtils.ClearDirectory(DeliveryRoot);
// Act
await InsertToBeDeliveredMessagesAsync(as4Message);
// Assert
AssertOnDeliveredAttachments(DeliveryRoot, files => Assert.True(files.Length == 1, "files.Length == 1"));
}
public void ThenMessageRemainsSoapAfterAttachmentsAreRemoved(NonEmptyArray <Guid> ids)
{
// Arrange
AS4Message sut = AS4Message.Empty;
IEnumerable <Attachment> attachments = ids.Get.Distinct().Select(i => new Attachment(i.ToString()));
// Act / Assert
Assert.All(attachments, a =>
{
sut.AddAttachment(a);
Assert.NotEqual(Constants.ContentTypes.Soap, sut.ContentType);
});
Assert.All(attachments, a => sut.RemoveAttachment(a));
Assert.Equal(Constants.ContentTypes.Soap, sut.ContentType);
}
private static async Task <AS4Message> CreateEncryptedAS4Message()
{
AS4Message message = AS4Message.Create(new UserMessage("somemessage"));
message.AddAttachment(
new Attachment(
"some-attachment",
Stream.Null,
"text/plain"));
AS4Message encryptedMessage =
AS4MessageUtils.EncryptWithCertificate(
message, new StubCertificateRepository().GetStubCertificate());
return(await AS4MessageUtils.SerializeDeserializeAsync(encryptedMessage));
}
public async Task ValidationFailure_IfNoAttachmentCanBeFoundForEachPartInfo()
{
// Arrange
var attachment = new Attachment("earth", Stream.Null, "text/plain");
var user = new UserMessage($"user-{Guid.NewGuid()}", new PartInfo("cid:some other href"));
AS4Message message = AS4Message.Create(user);
message.AddAttachment(attachment);
message = await SerializeDeserialize(message);
// Act
StepResult result = await ExerciseValidation(message);
// Assert
Assert.False(result.Succeeded);
Assert.Equal(ErrorCode.Ebms0009, result.MessagingContext.ErrorResult.Code);
}
public async Task ThenStepWillNotZipSingleAttachment()
{
// Arrange
const string contentType = "image/png";
AS4Message as4Message = AS4Message.Empty;
as4Message.AddAttachment(new Attachment("attachment-id", Stream.Null, contentType));
// Act
await new ZipAttachmentsStep().ExecuteAsync(
new MessagingContext(as4Message, MessagingContextMode.Unknown));
// Assert
Assert.Collection(
as4Message.Attachments,
a => Assert.Equal(contentType, a.ContentType));
}
public void CreatesExpectedMessageFromPMode(NonEmptyString id)
{
// Arrange
AS4Message message = AS4Message.Empty;
var attachment = new Attachment(id.Get);
message.AddAttachment(attachment);
var sut = new CreateDefaultAS4MessageStep(this);
// Act
StepResult result = sut.ExecuteAsync(
new MessagingContext(message, MessagingContextMode.Unknown)).GetAwaiter().GetResult();
// Assert
Assert.Collection(
result.MessagingContext.AS4Message.UserMessages,
m => Assert.Contains(attachment.Id, m.PayloadInfo.First().Href));
}
public async Task ValidationFailure_IfExternalPayloadReference()
{
// Arrange
var attachment = new Attachment("earth", Stream.Null, "text/plain");
var user = new UserMessage(
$"user-{Guid.NewGuid()}",
new PartInfo("earth"));
AS4Message message = AS4Message.Create(user);
message.AddAttachment(attachment);
message = await SerializeDeserialize(message);
// Act
StepResult result = await ExerciseValidation(message);
// Assert
Assert.False(result.Succeeded);
Assert.Equal(ErrorCode.Ebms0011, result.MessagingContext.ErrorResult.Code);
}
private static AS4Message SignedEncryptedAS4UserMessage(AS4Component msh, string ebmsMessageId)
{
string attachmentId = "attachment-" + Guid.NewGuid();
var user = new UserMessage(
ebmsMessageId,
new CollaborationInfo(
agreement: new AgreementReference(
value: "http://agreements.europa.org/agreement",
pmodeId: DefaultPModeId),
service: new Service(
value: "getting:started",
type: "eu:europa:services"),
action: "eu:sample:01",
conversationId: "eu:europe:conversation"),
Party.DefaultFrom,
Party.DefaultTo,
new [] { new PartInfo("cid:" + attachmentId) },
Enumerable.Empty <MessageProperty>());
AS4Message m = AS4Message.Create(user);
m.AddAttachment(
new Attachment(
id: attachmentId,
content: new MemoryStream(Properties.Resources.payload),
contentType: "image/jpg"));
var certRepo = new CertificateRepository(msh.GetConfiguration());
X509Certificate2 signingCert = certRepo.GetCertificate(X509FindType.FindBySubjectName, "AccessPointA");
m.Sign(new CalculateSignatureConfig(signingCert));
X509Certificate2 encryptCert = certRepo.GetCertificate(X509FindType.FindBySubjectName, "AccessPointB");
m.Encrypt(new KeyEncryptionConfiguration(encryptCert), DataEncryptionConfiguration.Default);
return(m);
}
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));
}
public async Task Retries_Uploading_When_Uploader_Returns_RetryableFail_Result(UploadRetry input)
{
// Arrange
string id = "deliver-" + Guid.NewGuid();
InMessage im = InsertInMessage(id);
var r = RetryReliability.CreateForInMessage(
refToInMessageId: im.Id,
maxRetryCount: input.MaxRetryCount,
retryInterval: default(TimeSpan),
type: RetryType.Delivery);
r.CurrentRetryCount = input.CurrentRetryCount;
GetDataStoreContext.InsertRetryReliability(r);
var a = new FilledAttachment();
var userMessage = new FilledUserMessage(id, a.Id);
AS4Message as4Msg = AS4Message.Create(userMessage);
as4Msg.AddAttachment(a);
MessagingContext fixture = await PrepareAS4MessageForDeliveryAsync(as4Msg, CreateReceivingPModeWithPayloadMethod());
IAttachmentUploader stub = CreateStubAttachmentUploader(fixture.DeliverMessage.Message.MessageInfo, input.UploadResult);
// Act
await CreateUploadStep(stub).ExecuteAsync(fixture);
// Assert
GetDataStoreContext.AssertInMessage(id, actual =>
{
Assert.NotNull(actual);
Assert.Equal(input.ExpectedStatus, actual.Status.ToEnum <InStatus>());
Assert.Equal(input.ExpectedOperation, actual.Operation);
});
}
public async Task ValidationFailure_IfUserMessageContainsDuplicatePayloadIds()
{
var user = new UserMessage(
$"user-{Guid.NewGuid()}",
CollaborationInfo.DefaultTest,
Party.DefaultFrom,
Party.DefaultTo,
new[]
{
new PartInfo("cid:earth1"),
new PartInfo("cid:earth2"),
},
new MessageProperty[0]);
AS4Message message = AS4Message.Create(user);
message.AddAttachment(new Attachment("earth1", Stream.Null, "text/plain"));
message = await SerializeDeserialize(message);
StepResult result = await ExerciseValidation(message);
Assert.False(result.Succeeded);
Assert.Equal(ErrorAlias.InvalidHeader, result.MessagingContext.ErrorResult.Alias);
}
private static void OverwriteAttachmentEntries(AS4Message message, Attachment zipAttachment)
{
message.RemoveAllAttachments();
message.AddAttachment(zipAttachment);
}
public async Task Create_DeliverMessages_From_UserMessages()
{
// Arrange
string partId1 = $"part-{Guid.NewGuid()}";
var userMessage1 = new UserMessage(
$"user-{Guid.NewGuid()}",
new CollaborationInfo(
new Service($"service-{Guid.NewGuid()}"),
$"action-{Guid.NewGuid()}"),
new Party("Sender", new PartyId($"id-{Guid.NewGuid()}")),
new Party("Receiver", new PartyId($"id-{Guid.NewGuid()}")),
new[] { new PartInfo($"cid:{partId1}") },
new MessageProperty[0]);
string partId2 = $"part-{Guid.NewGuid()}";
var userMessage2 = new UserMessage(
$"user-{Guid.NewGuid()}",
new CollaborationInfo(
new Service($"service-{Guid.NewGuid()}"),
$"action-{Guid.NewGuid()}"),
new Party("Sender", new PartyId($"id-{Guid.NewGuid()}")),
new Party("Receiver", new PartyId($"id-{Guid.NewGuid()}")),
new[] { new PartInfo($"cid:{partId2}") },
new MessageProperty[0]);
AS4Message as4Message = AS4Message.Create(new [] { userMessage1, userMessage2 });
as4Message.AddAttachment(new Attachment(partId1));
as4Message.AddAttachment(new Attachment(partId2));
var receivingPMode = new ReceivingProcessingMode {
Id = "deliver-pmode"
};
var entity1 = new InMessage(userMessage1.MessageId);
entity1.SetPModeInformation(receivingPMode);
var entity2 = new InMessage(userMessage2.MessageId);
entity2.SetPModeInformation(receivingPMode);
var sut = new DeliverMessageTransformer();
// Act
MessagingContext result1 =
await sut.TransformAsync(new ReceivedEntityMessage(entity1, as4Message.ToStream(), as4Message.ContentType));
MessagingContext result2 =
await sut.TransformAsync(new ReceivedEntityMessage(entity2, as4Message.ToStream(), as4Message.ContentType));
// Assert
IEnumerable <string> mappingFailures1 =
DeliverMessageOriginateFrom(
userMessage1,
receivingPMode,
result1.DeliverMessage.Message);
Assert.Empty(mappingFailures1);
IEnumerable <string> mappingFailures2 =
DeliverMessageOriginateFrom(
userMessage2,
receivingPMode,
result2.DeliverMessage.Message);
Assert.Empty(mappingFailures2);
}
