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); }