private static async Task StoreToBeSentUserMessage(string mpc)
{
var submit = new SubmitMessage
{
MessageInfo = new MessageInfo(messageId: null, mpc: mpc),
Collaboration =
{
AgreementRef =
{
PModeId = "pullsendagent-pmode"
}
}
};
await SubmitMessageToSubmitAgent(AS4XmlSerializer.ToString(submit));
}
public async Task MultihopUserMessageStillContainsMultihopHeadersWhenSerializeDeserializedMessage()
{
// Arrange
var input = new MemoryStream(as4_multihop_usermessage);
const string contentType =
"multipart/related; boundary=\"=-AAB+iUI3phXyeG3w4aGnFA==\";\ttype=\"application/soap+xml\"";
ISerializer sut = SerializerProvider.Default.Get(contentType);
AS4Message deserialized = await sut.DeserializeAsync(input, contentType);
// Act
XmlDocument doc = AS4XmlSerializer.ToSoapEnvelopeDocument(deserialized, CancellationToken.None);
// Assert
AssertUserMessageMultihopHeaders(doc);
}
public async Task ReceiptMessageForNonMultiHopMessageIsNotMultiHop()
{
AS4Message as4Message = await CreateReceivedAS4Message(CreateNonMultiHopPMode());
var receipt = Receipt.CreateFor($"receipt-{Guid.NewGuid()}", as4Message.FirstUserMessage, as4Message.IsMultiHopMessage);
XmlDocument doc = AS4XmlSerializer.ToSoapEnvelopeDocument(AS4Message.Create(receipt), CancellationToken.None);
// No MultiHop related elements may be present:
// - No Action element in the wsa namespace
// - No UserElement in the multihop namespace.
// - No RoutingInput node
Assert.False(ContainsActionElement(doc));
Assert.False(ContainsUserMessageElement(doc));
Assert.Null(doc.UnsafeSelectEbmsNode("/s12:Envelope/s12:Header/mh:RoutingInput"));
}
private async Task <MessagingContext> OnMessageReceived(
ReceivedMessage receivedMessage,
CancellationToken cancellationToken)
{
var actualPMode = await AS4XmlSerializer.FromStreamAsync <SendingProcessingMode>(receivedMessage.UnderlyingStream);
Assert.Equal("01-pmode", actualPMode.Id);
if (_seriewatch.TrackSerie(maxSerieCount: 3))
{
Assert.True(_seriewatch.GetSerie(1) > _seriewatch.GetSerie(0));
_waitHandle.Set();
}
return(new EmptyMessagingContext());
}
private static string CreateErrorInformationString(Error error)
{
if (error.ErrorLines == null || error.ErrorLines.Any() == false)
{
return(null);
}
XmlDocument soapEnv =
AS4XmlSerializer.ToSoapEnvelopeDocument(
AS4Message.Create(error),
CancellationToken.None);
XmlNode signalNode = soapEnv.SelectSingleNode("//*[local-name()='SignalMessage']");
return(signalNode?.OuterXml);
}
private static async Task <SendingProcessingMode> ExerciseSerializeDeserialize(SendingProcessingMode pmode)
{
using (Stream str = await AS4XmlSerializer.ToStreamAsync(pmode))
using (var memoryStream = new MemoryStream())
{
str.CopyTo(memoryStream);
memoryStream.Position = 0;
using (var streamReader = new StringReader(Encoding.UTF8.GetString(memoryStream.ToArray())))
using (XmlReader reader = XmlReader.Create(streamReader))
{
var xmlSerializer = new XmlSerializer(typeof(SendingProcessingMode));
return(xmlSerializer.Deserialize(reader) as SendingProcessingMode);
}
}
}
public async Task OutMessageIsCreatedForPrimaryMessageUnitOfToBeForwardedAS4Message()
{
// Arrange
const string primaryMessageId = "primary-message-id";
const string secondMessageId = "secondary-message-id";
var primaryUserMessage = CreateForwardPushUserMessage(primaryMessageId);
var secondaryUserMessage = new UserMessage(secondMessageId);
var as4Message = AS4Message.Create(primaryUserMessage);
as4Message.AddMessageUnit(secondaryUserMessage);
// Act
InsertToBeForwardedInMessage(
pmodeId: "Forward_Push",
mep: MessageExchangePattern.Push,
tobeForwarded: as4Message);
// Assert: if an OutMessage is created with the correct status and operation.
InMessage primaryInMessage = await PollUntilPresent(
() => _databaseSpy.GetInMessageFor(
m => m.EbmsMessageId == primaryMessageId &&
m.Operation == Operation.Forwarded),
TimeSpan.FromSeconds(20));
Assert.NotNull(AS4XmlSerializer.FromString <ReceivingProcessingMode>(primaryInMessage.PMode));
await PollUntilPresent(
() => _databaseSpy.GetInMessageFor(m => m.EbmsMessageId == secondMessageId),
timeout : TimeSpan.FromSeconds(20));
Assert.Equal(Operation.Forwarded, primaryInMessage.Operation);
Assert.NotNull(AS4XmlSerializer.FromString <ReceivingProcessingMode>(primaryInMessage.PMode));
OutMessage primaryOutMessage = await PollUntilPresent(
() => _databaseSpy.GetOutMessageFor(m => m.EbmsMessageId == primaryMessageId),
timeout : TimeSpan.FromSeconds(5));
Assert.Equal(Operation.ToBeProcessed, primaryOutMessage.Operation);
Assert.NotNull(AS4XmlSerializer.FromString <SendingProcessingMode>(primaryOutMessage.PMode));
OutMessage secondaryOutMessage = _databaseSpy.GetOutMessageFor(m => m.EbmsMessageId == secondMessageId);
Assert.Null(secondaryOutMessage);
}
public async Task ThenBuildInMessageSucceedsWithAS4MessageAndMessageUnit()
{
// Arrange
AS4Message as4Message = AS4Message.Empty;
Receipt receipt = CreateReceiptMessageUnit();
// Act
InMessage inMessage =
InMessageBuilder.ForSignalMessage(receipt, as4Message, MessageExchangePattern.Push)
.WithPMode(new SendingProcessingMode())
.BuildAsToBeProcessed();
// Assert
Assert.NotNull(inMessage);
Assert.Equal(as4Message.ContentType, inMessage.ContentType);
Assert.Equal(await AS4XmlSerializer.ToStringAsync(new SendingProcessingMode()), inMessage.PMode);
Assert.Equal(MessageType.Receipt, inMessage.EbmsMessageType);
}
public void Then_Parties_Are_Filled_When_Defined()
{
// Arrange
var pmode = new PartyInfo {
FromParty = CreateFilledParty(), ToParty = CreateFilledParty()
};
// Act
string xml = AS4XmlSerializer.ToString(pmode);
// Assert
var doc = new XmlDocument();
doc.LoadXml(xml);
Assert.NotNull(doc.SelectSingleNode("/PartyInfo/FromParty"));
Assert.NotNull(doc.SelectSingleNode("/PartyInfo/ToParty"));
}
public async void ReceiptMessageForMultihopUserMessageIsMultihop()
{
AS4Message as4Message = await CreateReceivedAS4Message(CreateMultiHopPMode());
var receipt = Receipt.CreateFor($"receipt-{Guid.NewGuid()}", as4Message.FirstUserMessage, as4Message.IsMultiHopMessage);
XmlDocument doc = AS4XmlSerializer.ToSoapEnvelopeDocument(AS4Message.Create(receipt), CancellationToken.None);
// Following elements should be present:
// - To element in the wsa namespace
// - Action element in the wsa namespace
// - UserElement in the multihop namespace.
AssertToElement(doc);
Assert.True(ContainsActionElement(doc));
Assert.True(ContainsUserMessageElement(doc));
AssertUserMessageMessagingElement(as4Message, doc);
AssertIfSenderAndReceiverAreReversed(as4Message, doc);
}
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);
}
/// <summary>
/// Gets the name of the receiving by.
/// </summary>
/// <param name="name">The name.</param>
/// <returns></returns>
public Task <ReceivingBasePmode> GetReceivingByName(string name)
{
return(Task
.Factory
.StartNew(() =>
{
var pmode = SafeGetReceivingPMode(name);
if (pmode != null)
{
return new ReceivingBasePmode
{
Name = pmode.Id,
Type = PmodeType.Receiving,
Pmode = pmode,
Hash = AS4XmlSerializer.ToString(pmode).GetMd5Hash()
};
}
return null;
}));
}
public async Task ErrorMessageForMultihopUserMessageIsMultihop()
{
// Arrange
AS4Message expectedAS4Message = await CreateReceivedAS4Message(CreateMultiHopPMode());
var error = Error.CreateFor($"error-{Guid.NewGuid()}", expectedAS4Message.FirstUserMessage, userMessageSendViaMultiHop: true);
// Act
XmlDocument document = AS4XmlSerializer.ToSoapEnvelopeDocument(AS4Message.Create(error), CancellationToken.None);
// Following elements should be present:
// - To element in the wsa namespace
// - Action element in the wsa namespace
// - UserElement in the multihop namespace.
AssertToElement(document);
Assert.True(ContainsActionElement(document));
Assert.True(ContainsUserMessageElement(document));
AssertMessagingElement(document);
AssertIfSenderAndReceiverAreReversed(expectedAS4Message, document);
}
/// <summary>
/// Insert an <see cref="InException"/> based on an exception that occurred dring the incoming Submit operation.
/// </summary>
/// <param name="exception">The exception which message will be inserted.</param>
/// <param name="submit">The original message that caused the exception.</param>
/// <param name="pmode">The PMode that was being used during the Submit operation.</param>
public async Task <InException> InsertIncomingSubmitExceptionAsync(
Exception exception,
SubmitMessage submit,
ReceivingProcessingMode pmode)
{
Stream stream = await AS4XmlSerializer.ToStreamAsync(submit);
string location = await _bodyStore.SaveAS4MessageStreamAsync(
_config.InExceptionStoreLocation,
stream);
InException entity =
InException
.ForMessageBody(messageLocation: location, exception: exception)
.SetOperationFor(pmode?.ExceptionHandling);
await entity.SetPModeInformationAsync(pmode);
_repository.InsertInException(entity);
return(entity);
}
/// <summary>
/// Puts a message with a single payload to the Holodeck endpoint referencing the given <paramref name="pmodeId"/>.
/// </summary>
/// <param name="pmodeId">The pmode id the message should have as reference.</param>
public void PutMessageSinglePayloadToHolodeckB(string pmodeId)
{
var msg = new MessageMetaData
{
CollaborationInfo = new HolodeckCollaborationInfo
{
AgreementRef = new HolodeckAgreementRef {
PMode = pmodeId
},
ConversationId = "org:holodeckb2b:test:conversation"
},
PayloadInfo = new HolodeckPayloadInfo
{
PartInfo = new[] { SubmitImagePayload }
}
};
string xml = AS4XmlSerializer.ToString(msg);
string path = Path.Combine(HolodeckBLocations.OutputPath, $"{pmodeId}-sample.mmd");
File.WriteAllText(path, xml);
}
private async Task <NotifyMessageEnvelope> CreateMinderNotifyMessageEnvelope(
AS4Message as4Message, Type receivedEntityMessageType)
{
UserMessage userMessage = as4Message.FirstUserMessage;
SignalMessage signalMessage = as4Message.FirstSignalMessage;
if (userMessage == null && signalMessage != null)
{
userMessage = await RetrieveRelatedUserMessage(signalMessage);
}
if (userMessage == null)
{
Logger.Warn("The related usermessage for the received signalmessage could not be found");
userMessage = new UserMessage(IdentifierFactory.Instance.Create());
}
UserMessage minderUserMessage = CreateUserMessageFromMinderProperties(userMessage, signalMessage);
NotifyMessage notifyMessage =
AS4MessageToNotifyMessageMapper.Convert(
as4Message.FirstSignalMessage,
receivedEntityMessageType,
as4Message.EnvelopeDocument ?? AS4XmlSerializer.ToSoapEnvelopeDocument(as4Message));
// The NotifyMessage that Minder expects, is an AS4Message which contains the specific UserMessage.
var msg = AS4Message.Create(minderUserMessage, new SendingProcessingMode());
var serializer = SerializerProvider.Default.Get(msg.ContentType);
byte[] content;
using (var memoryStream = new MemoryStream())
{
serializer.Serialize(msg, memoryStream);
content = memoryStream.ToArray();
}
return(new NotifyMessageEnvelope(notifyMessage.MessageInfo, notifyMessage.StatusInfo.Status, content, msg.ContentType, receivedEntityMessageType));
}
public void DecorateMandatoryInfoToSendingPMode()
{
// Arrange
var smpResponse = new SmpConfiguration
{
PartyRole = "role",
Url = "http://some/url"
};
var doc = new XmlDocument();
doc.LoadXml(AS4XmlSerializer.ToString(smpResponse));
var pmode = new SendingProcessingMode();
var sut = new LocalDynamicDiscoveryProfile(GetDataStoreContext);
// Act
SendingProcessingMode actual = sut.DecoratePModeWithSmpMetaData(pmode, doc).CompletedSendingPMode;
// Assert
Assert.Equal(smpResponse.Url, actual.PushConfiguration.Protocol.Url);
}
public async Task SucceedsWithAValidPullConfiguration()
{
// Arrange
const string expectedMpc = "expected-mpc";
SendingProcessingMode expectedSendingPMode = CreateAnonymousSendingPModeWith(expectedMpc);
var receivedMessage = new ReceivedMessage(await AS4XmlSerializer.ToStreamAsync(expectedSendingPMode));
var transformer = new PModeToPullRequestTransformer();
// Act
using (MessagingContext context = await transformer.TransformAsync(receivedMessage))
{
// Assert
Assert.NotNull(context.AS4Message);
Assert.True(context.AS4Message.IsPullRequest);
var actualSignalMessage = context.AS4Message.FirstSignalMessage as PullRequest;
Assert.Equal(expectedMpc, actualSignalMessage?.Mpc);
Assert.Equal(expectedSendingPMode.Id, context.SendingPMode.Id);
Assert.Equal(MessagingContextMode.PullReceive, context.Mode);
}
}
private SendingProcessingMode RetrieveSendingPModeForMessageWithEbmsMessageId(string ebmsMessageId)
{
if (ebmsMessageId == null)
{
Logger.Debug("Can't retrieve SendingPMode because NotifyMessage.MessageInfo.RefToMessageId is not present");
return(null);
}
using (DatastoreContext context = _createContext())
{
var repository = new DatastoreRepository(context);
var outMessageData =
repository.GetOutMessageData(
where : m => m.EbmsMessageId == ebmsMessageId && m.Intermediary == false,
selection: m => new { m.PMode, m.ModificationTime })
.OrderByDescending(m => m.ModificationTime)
.FirstOrDefault();
if (outMessageData == null)
{
Logger.Debug(
"Can't retrieve SendingPMode because no matching stored OutMessage found "
+ $"for EbmsMessageId = {ebmsMessageId} AND Intermediary = false");
return(null);
}
var pmode = AS4XmlSerializer.FromString <SendingProcessingMode>(outMessageData.PMode);
if (pmode == null)
{
Logger.Debug(
"Can't use SendingPMode from matching OutMessage for NotifyMessage.MessageInfo.RefToMessageId "
+ $"{ebmsMessageId} because the PMode field can't be deserialized correctly to a SendingPMode");
}
return(pmode);
}
}
public async Task RetrieveSmpResponseFromDatastore()
{
// Arrange
var fixture = new Party("role", new PartyId(Guid.NewGuid().ToString(), "type"));
var expected = new SmpConfiguration
{
PartyRole = fixture.Role,
ToPartyId = fixture.PrimaryPartyId,
PartyType = "type"
};
InsertSmpResponse(expected);
var sut = new LocalDynamicDiscoveryProfile(GetDataStoreContext);
// Act
XmlDocument actualDoc = await sut.RetrieveSmpMetaDataAsync(fixture, properties : null);
// Assert
var actual = AS4XmlSerializer.FromString <SmpConfiguration>(actualDoc.OuterXml);
Assert.Equal(expected.ToPartyId, actual.ToPartyId);
}
public async Task Test_8_2_8_Send_AS4Message_To_Receiving_MSH_That_Cant_Find_PMode_Result_In_Notification_Error()
{
// Arrange
AS4Component.Start();
// Act
AS4Component.PutSubmitMessage("8.2.8-pmode", AS4Component.SubmitPayloadImage);
// Assert
IEnumerable <FileInfo> errors =
await PollingService.PollUntilPresentAsync(AS4Component.ErrorsPath);
string xml = File.ReadAllText(errors.First().FullName);
var notification = AS4XmlSerializer.FromString <NotifyMessage>(xml);
Assert.True(notification != null, "Found Error notification cannot be deserialized to a 'NotifyMessage'");
Assert.True(notification.StatusInfo != null, "Found Error notification doesn't hava a <StatusInfo/> element");
Assert.Equal(Status.Error, notification.StatusInfo.Status);
Assert.True(
notification.StatusInfo.Any.First().SelectSingleNode("//*[local-name()='ErrorDetail']")?.InnerText != null,
"Found Error notification doesn't have a <SignalMessage/> included");
}
public async Task Test_8_1_12_AS4Message_With_Single_Payload_Result_In_Notified_Signed_Non_Repudiation_Receipt()
{
// Arrange
AS4Component.Start();
Holodeck.CopyPModeToHolodeckB("8.1.12-pmode.xml");
// Act
AS4Component.PutSubmitMessageSinglePayload("8.1.12-pmode");
IEnumerable <FileInfo> receipts =
await PollingService.PollUntilPresentAsync(AS4Component.ReceiptsPath);
string xml = File.ReadAllText(receipts.First().FullName);
var notification = AS4XmlSerializer.FromString <NotifyMessage>(xml);
Assert.True(notification != null, "Found Receipt notification cannot be deserialized to a NotifyMessage");
Assert.True(notification.StatusInfo != null, "Found Receipt notification doesn't have a <StatusInfo/> element");
Assert.Equal(Status.Delivered, notification.StatusInfo.Status);
Assert.True(notification.StatusInfo.Any?.Any(), "Found Receipt notification doesn't have a <SignalMessage/> included");
Assert.True(
notification.StatusInfo.Any?.First()?.SelectSingleNode("//*[local-name()='NonRepudiationInformation']") != null,
"Found Receipt notification doesn't have a <NonRepudiationInformation/> element");
}
/// <summary>
/// Set the PMode that is used to process the message.
/// </summary>
/// <param name="pmode"></param>
public void SetPModeInformation(IPMode pmode)
{
if (pmode != null)
{
PModeId = pmode.Id;
// The Xml Serializer is not able to serialize an interface, therefore
// the argument must first be cast to a correct implementation.
if (pmode is SendingProcessingMode sp)
{
PMode = AS4XmlSerializer.ToString(sp);
}
else if (pmode is ReceivingProcessingMode rp)
{
PMode = AS4XmlSerializer.ToString(rp);
}
else
{
throw new NotImplementedException("Unable to serialize the the specified IPMode");
}
}
}
/// <summary>
/// Assigns the parent properties.
/// </summary>
/// <param name="messageUnit">The MessageUnit from which the properties must be retrieved..</param>
public void AssignAS4Properties(MessageUnit messageUnit)
{
if (messageUnit is UserMessage userMessage)
{
FromParty = userMessage.Sender.PartyIds.First().Id;
ToParty = userMessage.Receiver.PartyIds.First().Id;
Action = userMessage.CollaborationInfo.Action;
Service = userMessage.CollaborationInfo.Service.Value;
ConversationId = userMessage.CollaborationInfo.ConversationId;
Mpc = userMessage.Mpc;
IsTest = userMessage.IsTest;
IsDuplicate = userMessage.IsDuplicate;
SoapEnvelope = AS4XmlSerializer.ToString(UserMessageMap.Convert(userMessage));
}
else
{
if (messageUnit is SignalMessage signalMessage)
{
IsDuplicate = signalMessage.IsDuplicate;
Mpc = signalMessage.MultiHopRouting.Select(r => r.mpc).GetOrElse(Constants.Namespaces.EbmsDefaultMpc);
}
}
}
protected virtual async Task <NotifyMessageEnvelope> CreateNotifyMessageEnvelopeAsync(
AS4Message as4Message,
string receivedEntityMessageId,
Type receivedEntityType)
{
SignalMessage tobeNotifiedSignal =
as4Message.SignalMessages.FirstOrDefault(s => s.MessageId == receivedEntityMessageId);
NotifyMessage notifyMessage =
AS4MessageToNotifyMessageMapper.Convert(
tobeNotifiedSignal,
receivedEntityType,
as4Message.EnvelopeDocument ?? AS4XmlSerializer.ToSoapEnvelopeDocument(as4Message));
var serialized = await AS4XmlSerializer.ToStringAsync(notifyMessage).ConfigureAwait(false);
return(new NotifyMessageEnvelope(
notifyMessage.MessageInfo,
notifyMessage.StatusInfo.Status,
System.Text.Encoding.UTF8.GetBytes(serialized),
"application/xml",
receivedEntityType));
}
/// <summary>
/// Retrieves the SMP meta data <see cref="XmlDocument" /> for a given <paramref name="party" /> using a given
/// <paramref name="properties" />.
/// </summary>
/// <param name="party">The party identifier to select the right SMP meta-data.</param>
/// <param name="properties">The information properties specified in the <see cref="SendingProcessingMode"/> for this profile.</param>
public Task <XmlDocument> RetrieveSmpMetaDataAsync(Model.Core.Party party, IDictionary <string, string> properties)
{
if (party == null)
{
throw new ArgumentNullException(nameof(party));
}
if (party.PrimaryPartyId == null ||
party.PartyIds.FirstOrDefault()?.Type == null ||
party.Role == null)
{
throw new InvalidOperationException(
"Given invalid 'ToParty', requires 'Role', 'PartyId', and 'PartyType'");
}
SmpConfiguration configuration = FindSmpResponseForToParty(party);
string xml = AS4XmlSerializer.ToString(configuration);
var document = new XmlDocument();
document.LoadXml(xml);
return(Task.FromResult(document));
}
/// <summary>
/// Start receiving on a configured Target
/// Received messages will be send to the given Callback
/// </summary>
/// <param name="messageCallback"></param>
/// <param name="cancellationToken"></param>
/// <exception cref="Exception">A delegate callback throws an exception.</exception>
public override void StartReceiving(
Func <ReceivedMessage, CancellationToken, Task <MessagingContext> > messageCallback,
CancellationToken cancellationToken)
{
if (messageCallback == null)
{
throw new ArgumentNullException(nameof(messageCallback));
}
_messageCallback = async message =>
{
var receivedMessage = new ReceivedMessage(
underlyingStream: await AS4XmlSerializer.ToStreamAsync(message.PMode),
contentType: Constants.ContentTypes.Soap,
origin: message.PMode?.PushConfiguration?.Protocol?.Url ?? "unknown");
return(await messageCallback(receivedMessage, cancellationToken));
};
// Wait some time till the Kernel is fully started
Thread.Sleep(TimeSpan.FromSeconds(5));
StartInterval();
}
private static void TestConfigInitialization(
Action <Settings> alterSettings,
Action <Config> onInitialized)
{
string testSettingsFileName = Path.Combine(
Config.ApplicationPath, "config", "test-settings.xml");
string originalSettingsFileName = Path.Combine(
Config.ApplicationPath, "config", "settings.xml");
var settings = AS4XmlSerializer
.FromString <Settings>(File.ReadAllText(originalSettingsFileName));
alterSettings(settings);
File.WriteAllText(
testSettingsFileName,
AS4XmlSerializer.ToString(settings));
File.Copy(
originalSettingsFileName,
testSettingsFileName,
overwrite: true);
Directory.CreateDirectory(Path.Combine(Config.ApplicationPath, "config", "send-pmodes"));
Directory.CreateDirectory(Path.Combine(Config.ApplicationPath, "config", "receive-pmodes"));
// Act
Config.Instance.Initialize(testSettingsFileName);
// Assert
onInitialized(Config.Instance);
// TearDown
File.Delete(testSettingsFileName);
}
public void StartReceiver()
{
var stubConfig = new StubConfig(
sendingPModes: new Dictionary <string, SendingProcessingMode>
{
["01-send"] = AS4XmlSerializer.FromString <SendingProcessingMode>(Properties.Resources.send_01)
},
receivingPModes: new Dictionary <string, ReceivingProcessingMode>
{
["01-receive"] = AS4XmlSerializer.FromString <ReceivingProcessingMode>(Properties.Resources.receive_01)
});
// Arrange
var receiver = new PullRequestReceiver(stubConfig);
Setting receiverSetting = CreateMockReceiverSetting();
receiver.Configure(new[] { receiverSetting });
// Act
receiver.StartReceiving(OnMessageReceived, CancellationToken.None);
// Assert
Assert.True(_waitHandle.WaitOne(timeout: TimeSpan.FromMinutes(2)));
}
/// <summary>
/// Gets the sending processing mode of the child representation of an exception.
/// </summary>
public override SendingProcessingMode GetSendingPMode()
{
return(AS4XmlSerializer.FromString <SendingProcessingMode>(PMode));
}