public async Task ThenReceivedMultihopUserMessageIsSetAsIntermediaryAndForwarded() { // Arrange var userMessage = new UserMessage( "test-" + Guid.NewGuid(), new CollaborationInfo( agreement: new AgreementReference( value: "http://agreements.europa.org/agreement", pmodeId: "Forward_Push_Multihop"), service: new Service( value: "Forward_Push_Multihop_Service", type: "eu:europa:services"), action: "Forward_Push_Multihop_Action", conversationId: "eu:europe:conversation")); var multihopPMode = new SendingProcessingMode { MessagePackaging = { IsMultiHop = true } }; AS4Message multihopMessage = AS4Message.Create(userMessage, multihopPMode); // Act HttpResponseMessage response = await StubSender.SendAS4Message(_receiveAgentUrl, multihopMessage); // Assert Assert.Equal(HttpStatusCode.Accepted, response.StatusCode); InMessage inUserMessage = _databaseSpy.GetInMessageFor(m => m.EbmsMessageId == userMessage.MessageId); Assert.NotNull(inUserMessage); Assert.True(inUserMessage.Intermediary); Assert.Equal(Operation.ToBeForwarded, inUserMessage.Operation); }
public Property Then_Service_Has_Only_Type_When_Defined( Guid value, Maybe <Guid> type) { // Arrange var user = new UserMessage( $"user-{Guid.NewGuid()}", new AS4.Model.Core.CollaborationInfo( agreement: new AgreementReference("agreement"), service: new Service( value.ToString(), type.Select(t => t.ToString())), action: "action", conversationId: "conversation")); // Act XmlDocument doc = SerializeSoapMessage(AS4Message.Create(user)); // Assert XmlNode serviceNode = doc.UnsafeSelectEbmsNode( "/s12:Envelope/s12:Header/eb:Messaging/eb:UserMessage/eb:CollaborationInfo/eb:Service"); XmlAttribute serviceTypeAttr = serviceNode?.Attributes?["type"]; return((serviceNode?.FirstChild?.Value == value.ToString()) .Label("Equal value") .And(serviceTypeAttr == null && type == Maybe <Guid> .Nothing) .Label("No service type present") .Or(type.Select(t => t.ToString() == serviceTypeAttr?.Value).GetOrElse(false)) .Label("Equal service type")); }
public async Task ReturnsErrorMessageWhenDecryptionCertificateCannotBeFound() { var userMessage = new UserMessage( Guid.NewGuid().ToString(), new CollaborationInfo( agreement: new AgreementReference( value: "http://agreements.europa.org/agreement", pmodeId: "receiveagent-non_existing_decrypt_cert-pmode"), service: new Service( value: "errorhandling", type: "as4.net:receive_agent:componenttest"), action: "as4.net:receive_agent:decryption_failed", conversationId: "as4.net:receive_agent:conversation")); var as4Message = CreateAS4MessageWithAttachment(userMessage); var encryptedMessage = AS4MessageUtils.EncryptWithCertificate(as4Message, new StubCertificateRepository().GetStubCertificate()); // Act HttpResponseMessage response = await StubSender.SendAS4Message(_receiveAgentUrl, encryptedMessage); // Assert Assert.Equal(HttpStatusCode.OK, response.StatusCode); var contentType = response.Content.Headers.ContentType.MediaType; var result = await SerializerProvider.Default.Get(contentType) .DeserializeAsync(await response.Content.ReadAsStreamAsync(), contentType); Assert.True(result.IsSignalMessage); var errorMessage = result.FirstSignalMessage as Error; Assert.NotNull(errorMessage); Assert.Equal(ErrorCode.Ebms0102, errorMessage.ErrorLines.First().ErrorCode); }
private static Receipt CreateReceiptWithRelatedUserMessageInfo() { string ebmsMessageId = $"user-{Guid.NewGuid()}"; var userMessage = new UserMessage(ebmsMessageId); return(Receipt.CreateFor($"receipt-{Guid.NewGuid()}", userMessage)); }
private static AS4Message CreateAS4MessageWithAttachment(UserMessage msg) { var as4Message = AS4Message.Create(msg); // Arrange byte[] attachmentContents = Encoding.UTF8.GetBytes("some random attachment"); var attachment = new Attachment("attachment-id", new MemoryStream(attachmentContents), "text/plain"); as4Message.AddAttachment(attachment); return(as4Message); }
public async void ThenParseUserMessageSenderCorrectly() { using (var memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(Samples.UserMessage))) { // Act AS4Message message = await DeserializeAsSoap(memoryStream); // Assert UserMessage userMessage = message.UserMessages.First(); Assert.Equal("org:eu:europa:as4:example", userMessage.Sender.PartyIds.First().Id); Assert.Equal("Sender", userMessage.Sender.Role); } }
public async void ThenParseUserMessageReceiverCorrectly() { using (var memoryStream = new MemoryStream(Encoding.UTF32.GetBytes(Samples.UserMessage))) { // Act AS4Message message = await DeserializeAsSoap(memoryStream); // Assert UserMessage userMessage = message.UserMessages.First(); string receiverId = userMessage.Receiver.PartyIds.First().Id; Assert.Equal("org:holodeckb2b:example:company:B", receiverId); Assert.Equal("Receiver", userMessage.Receiver.Role); } }
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); }
public async void ThenParseUserMessageCollaborationInfoCorrectly() { using (var memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(Samples.UserMessage))) { // Act AS4Message message = await DeserializeAsSoap(memoryStream); // Assert UserMessage userMessage = message.UserMessages.First(); Assert.Equal(ServiceNamespace, userMessage.CollaborationInfo.Service.Value); Assert.Equal(ActionNamespace, userMessage.CollaborationInfo.Action); Assert.Equal("eu:edelivery:as4:sampleconversation", userMessage.CollaborationInfo.ConversationId); } }
public async Task ThenParseUserMessagePropertiesParsedCorrectlyAsync() { using (var memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(Samples.UserMessage))) { // Act AS4Message message = await DeserializeAsSoap(memoryStream); // Assert UserMessage userMessage = message.UserMessages.First(); Assert.NotNull(message); Assert.Single(message.UserMessages); Assert.Equal(1472800326948, userMessage.Timestamp.ToUnixTimeMilliseconds()); } }
/// <summary> /// Start determine the Receiving Processing Mode /// </summary> /// <param name="messagingContext"></param> /// <returns></returns> public async Task <StepResult> ExecuteAsync(MessagingContext messagingContext) { if (messagingContext == null) { throw new ArgumentNullException(nameof(messagingContext)); } if (messagingContext.AS4Message == null) { throw new InvalidOperationException( $"{nameof(DeterminePModesStep)} requires an AS4Message but no AS4Message is present in the MessagingContext"); } AS4Message as4Message = messagingContext.AS4Message; bool containsSignalThatNotPullRequest = as4Message.SignalMessages.Any(s => !(s is Model.Core.PullRequest)); if (containsSignalThatNotPullRequest && (as4Message.IsMultiHopMessage || messagingContext.SendingPMode == null)) { messagingContext.SendingPMode = await DetermineSendingPModeForSignalMessageAsync(as4Message); } if (messagingContext.ReceivingPMode != null) { Logger.Debug( $"Will not determine ReceivingPMode: incoming message has already a ReceivingPMode: {messagingContext.ReceivingPMode.Id} configured. " + $"{Environment.NewLine} This happens when the Receive Agent is configured as a \"Static Receive Agent\""); } else if (as4Message.HasUserMessage || as4Message.SignalMessages.Any(s => s.IsMultihopSignal)) { Logger.Trace("Incoming message hasn't yet a ReceivingPMode, will determine one"); UserMessage userMessage = GetUserMessageFromFirstMessageUnitOrRoutingInput(messagingContext.AS4Message); IEnumerable <ReceivePMode> possibilities = GetMatchingReceivingPModeForUserMessage(userMessage); if (possibilities.Any() == false) { return(NoMatchingPModeFoundFailure(messagingContext)); } if (possibilities.Count() > 1) { return(TooManyPossibilitiesFailure(messagingContext, possibilities)); } ReceivePMode pmode = possibilities.First(); Logger.Info($"Found ReceivingPMode \"{pmode.Id}\" to further process the incoming message"); messagingContext.ReceivingPMode = pmode; } return(StepResult.Success(messagingContext)); }
public void ThenSerializeWithoutAttachmentsReturnsSoapMessage(Guid mpc) { // Act UserMessage userMessage = CreateUserMessage(); AS4Message message = BuildAS4Message(mpc.ToString(), userMessage); using (var soapStream = new MemoryStream()) { XmlDocument document = SerializeSoapMessage(message, soapStream); XmlNode envelopeElement = document.DocumentElement; // Assert Assert.NotNull(envelopeElement); Assert.Equal(Constants.Namespaces.Soap12, envelopeElement.NamespaceURI); } }
public void ThenSaveToUserMessageCorrectlySerialized() { // Arrange UserMessage userMessage = CreateUserMessage(); AS4Message message = AS4Message.Create(userMessage); // Act using (var soapStream = new MemoryStream()) { XmlDocument document = SerializeSoapMessage(message, soapStream); // Assert Assert.NotNull(document.DocumentElement); Assert.Contains("Envelope", document.DocumentElement.Name); } }
public Property Then_AgreementReference_Is_Present_When_Defined( Maybe <Guid> value, Maybe <Guid> type) { // Arrange var a = value.Select(x => new AgreementReference( value: x.ToString(), type: type.Select(t => t.ToString()), pmodeId: Maybe <string> .Nothing)); var user = new UserMessage( $"user-{Guid.NewGuid()}", new AS4.Model.Core.CollaborationInfo( a, Service.TestService, Constants.Namespaces.TestAction, "1")); // Act XmlDocument doc = SerializeSoapMessage(AS4Message.Create(user)); // Assert XmlNode agreementNode = doc.UnsafeSelectEbmsNode( "/s12:Envelope/s12:Header/eb:Messaging/eb:UserMessage/eb:CollaborationInfo/eb:AgreementRef"); XmlAttribute agreementTypeAttr = agreementNode?.Attributes?["type"]; Property noAgreementTagProp = (agreementNode == null && value == Maybe <Guid> .Nothing) .Label("No agreement tag"); Property equalValueProp = value.Select(v => v.ToString() == agreementNode?.InnerText) .GetOrElse(false) .Label("Equal agreement value"); Property noTypeProp = (agreementTypeAttr == null && type == Maybe <Guid> .Nothing) .Label("No agreement type"); Property equalTypeProp = type.Select(t => t.ToString() == agreementTypeAttr?.Value) .GetOrElse(false) .Label("Equal agreement type"); return(noAgreementTagProp.Or(equalValueProp.And(noTypeProp).Or(equalTypeProp))); }
private IEnumerable <ReceivePMode> GetMatchingReceivingPModeForUserMessage(UserMessage userMessage) { IEnumerable <PModeParticipant> participants = _config.GetReceivingPModes() .Select(pmode => new PModeParticipant(pmode, userMessage)) .Select(PModeRuleEngine.ApplyRules); IEnumerable <int> scoresToConsider = participants.Select(p => p.Points).Where(p => p >= 10); if (scoresToConsider.Any() == false) { return(Enumerable.Empty <ReceivePMode>()); } int maxPoints = scoresToConsider.Max(); return(participants.Where(p => p.Points == maxPoints).Select(p => p.PMode)); }
public void ThenPullRequestCorrectlySerialized(Guid mpc) { // Arrange UserMessage userMessage = CreateUserMessage(); AS4Message message = BuildAS4Message(mpc.ToString(), userMessage); // Act using (var soapStream = new MemoryStream()) { XmlDocument document = SerializeSoapMessage(message, soapStream); // Assert XmlAttribute mpcAttribute = GetMpcAttribute(document); Assert.NotNull(mpcAttribute); Assert.Equal(mpc.ToString(), mpcAttribute.Value); } }
public void Then_PayloadInfo_Is_Present_When_Defined() { // Arrange var user = new UserMessage( $"user-{Guid.NewGuid()}", new AS4.Model.Core.PartInfo("cid:earth")); // Act XmlDocument doc = SerializeSoapMessage(AS4Message.Create(user)); // Assert XmlNode payloadInfoTag = doc.UnsafeSelectEbmsNode( "/s12:Envelope/s12:Header/eb:Messaging/eb:UserMessage/eb:PayloadInfo"); Assert.NotNull(payloadInfoTag); XmlNode partInfoTag = payloadInfoTag.FirstChild; Assert.Equal("cid:earth", partInfoTag.Attributes?["href"]?.Value); }
private static void AssertIfSenderAndReceiverAreReversed(AS4Message expectedAS4Message, XmlNode doc) { XmlNode routingInputNode = doc.UnsafeSelectEbmsNode("/s12:Envelope/s12:Header/mh:RoutingInput"); Assert.NotNull(routingInputNode); var routingInput = AS4XmlSerializer.FromString <RoutingInput>(routingInputNode.OuterXml); RoutingInputUserMessage actualUserMessage = routingInput.UserMessage; UserMessage expectedUserMessage = expectedAS4Message.FirstUserMessage; Assert.Equal(expectedUserMessage.Sender.Role, actualUserMessage.PartyInfo.To.Role); Assert.Equal( expectedUserMessage.Sender.PartyIds.First().Id, actualUserMessage.PartyInfo.To.PartyId.First().Value); Assert.Equal(expectedUserMessage.Receiver.Role, actualUserMessage.PartyInfo.From.Role); Assert.Equal( expectedUserMessage.Receiver.PartyIds.First().Id, actualUserMessage.PartyInfo.From.PartyId.First().Value); }
private static SignalMessage CreateMultihopSignalMessage(string refToMessageId, string pmodeId) { var userMessage = new UserMessage( refToMessageId, "some-mpc", new CollaborationInfo( new AgreementReference("http://agreements.europa.org/agreement", pmodeId), new Service("Forward_Push_Service", "eu:europe:services"), "Forward_Push_Action", CollaborationInfo.DefaultConversationId), new Party("Sender", new PartyId("org:eu:europa:as4:example:accesspoint:A")), new Party("Receiver", new PartyId("org:eu:europa:as4:example:accesspoint:B")), new PartInfo[0], new MessageProperty[0]); return(Receipt.CreateFor( $"receipt-{Guid.NewGuid()}", userMessage, userMessageSendViaMultiHop: true)); }
public void ThenMpcAttributeIsCorrectlySerialized() { var userMessage = new UserMessage("some-message-id", "the-specified-mpc"); var as4Message = AS4Message.Create(userMessage); using (var messageStream = new MemoryStream()) { var sut = new SoapEnvelopeSerializer(); // Act sut.Serialize(as4Message, messageStream); // Assert messageStream.Position = 0; var xmlDocument = new XmlDocument(); xmlDocument.Load(messageStream); var userMessageNode = xmlDocument.SelectSingleNode("//*[local-name()='UserMessage']"); Assert.NotNull(userMessageNode); Assert.Equal(userMessage.Mpc, userMessageNode.Attributes["mpc"].InnerText); } }
public async Task ThenReceivedMultihopUserMessageIsntSetToIntermediaryButDeliveredWithCorrespondingSentReceipt() { // Arrange var userMessage = new UserMessage( "test-" + Guid.NewGuid(), new CollaborationInfo( agreement: new AgreementReference( value: "http://agreements.europa.org/agreement", pmodeId: "ComponentTest_ReceiveAgent_Sample1"), service: new Model.Core.Service( value: "getting:started", type: "eu:europa:services"), action: "eu:sample:01", conversationId: "eu:europa:conversation")); var multihopPMode = new SendingProcessingMode { MessagePackaging = { IsMultiHop = true } }; AS4Message multihopMessage = AS4Message.Create(userMessage, multihopPMode); // Act HttpResponseMessage response = await StubSender.SendAS4Message(_receiveAgentUrl, multihopMessage); // Assert AS4Message responseReceipt = await response.DeserializeToAS4Message(); AssertMessageMultihopAttributes(responseReceipt.EnvelopeDocument); Assert.True(responseReceipt.IsMultiHopMessage); InMessage inUserMessage = _databaseSpy.GetInMessageFor(m => m.EbmsMessageId == userMessage.MessageId); Assert.NotNull(inUserMessage); Assert.False(inUserMessage.Intermediary); Assert.Equal(Operation.ToBeDelivered, inUserMessage.Operation); OutMessage outReceipt = _databaseSpy.GetOutMessageFor(m => m.EbmsRefToMessageId == userMessage.MessageId); Assert.Equal(OutStatus.Sent, outReceipt.Status.ToEnum <OutStatus>()); }
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 Received_Bundled_User_And_Receipt_Message_Should_Process_All_Messages() { // Arrange string ebmsMessageId = "test-" + Guid.NewGuid(); StoreToBeAckOutMessage(ebmsMessageId, CreateSendingPMode()); var userMessage = new UserMessage( "usermessage-" + Guid.NewGuid(), new CollaborationInfo( agreement: new AgreementReference( value: "http://agreements.europa.org/agreement", pmodeId: "receive_bundled_message_pmode"), service: new Service( value: "bundling", type: "as4.net:receive_agent:componenttest"), action: "as4.net:receive_agent:bundling", conversationId: "as4.net:receive_agent:conversation")); var receipt = new Receipt($"receipt-{Guid.NewGuid()}", ebmsMessageId); var bundled = AS4Message.Create(userMessage); bundled.AddMessageUnit(receipt); // Act HttpResponseMessage response = await StubSender.SendAS4Message(_receiveAgentUrl, bundled); // Assert AS4Message receivedReceipt = await response.DeserializeToAS4Message(); Assert.IsType <Receipt>(receivedReceipt.FirstSignalMessage); Assert.Equal(userMessage.MessageId, receivedReceipt.FirstSignalMessage.RefToMessageId); AssertIfInMessageExistsForSignalMessage(ebmsMessageId); AssertIfInMessageIsStoredFor(userMessage.MessageId, Operation.ToBeDelivered); }
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); }