/// <summary>
/// Initializes a new instance of the <see cref="MessagingContext"/> class.
/// </summary>
public MessagingContext(ReceivedMessage receivedMessage, MessagingContextMode mode)
{
if (receivedMessage == null)
{
throw new ArgumentNullException(nameof(receivedMessage));
}
SubmitMessage = null;
ReceivedMessage = receivedMessage;
AS4Message = null;
DeliverMessage = null;
NotifyMessage = null;
Mode = mode;
if (receivedMessage is ReceivedEntityMessage rem)
{
MessageEntityId = rem.Entity?.Id;
switch (rem.Entity)
{
case MessageEntity me:
SendingPMode = me.GetSendingPMode();
ReceivingPMode = me.GetReceivingPMode();
break;
case ExceptionEntity ee:
ReceivingPMode = ee.GetReceivingPMode();
SendingPMode = ee.GetSendingPMode();
break;
}
}
}
public void ModifyContext(ReceivedMessage receivedMessage, MessagingContextMode mode)
{
if (receivedMessage == null)
{
throw new ArgumentNullException(nameof(receivedMessage));
}
PrepareContextChange();
ReceivedMessage = receivedMessage;
Mode = mode;
}
/// <summary>
/// Modifies the <see cref="MessagingContext"/>.
/// </summary>
/// <param name="as4Message">The as4 message.</param>
/// <param name="mode">The mode.</param>
public void ModifyContext(AS4Message as4Message, MessagingContextMode mode)
{
if (as4Message == null)
{
throw new ArgumentNullException(nameof(as4Message));
}
PrepareContextChange();
AS4Message = as4Message;
Mode = mode;
}
/// <summary>
/// Initializes a new instance of the <see cref="MessagingContext" /> class.
/// </summary>
/// <param name="as4Message"> </param>
/// <param name="mode">The <see cref="MessagingContextMode"/> in which the context is currently acting</param>
public MessagingContext(AS4Message as4Message, MessagingContextMode mode)
{
if (as4Message == null)
{
throw new ArgumentNullException(nameof(as4Message));
}
SubmitMessage = null;
ReceivedMessage = null;
AS4Message = as4Message;
DeliverMessage = null;
NotifyMessage = null;
Mode = mode;
}
/// <summary>
/// Initializes a new instance of the <see cref="MessagingContext"/> class.
/// </summary>
/// <param name="as4Message"></param>
/// <param name="receivedMessage"></param>
/// <param name="mode"></param>
public MessagingContext(
AS4Message as4Message,
ReceivedMessage receivedMessage,
MessagingContextMode mode) : this(receivedMessage, mode)
{
if (as4Message == null)
{
throw new ArgumentNullException(nameof(as4Message));
}
AS4Message = as4Message;
SubmitMessage = null;
DeliverMessage = null;
NotifyMessage = null;
}
public Property Resolve_Only_ToParty_From_AS4Message_If_UserMessage(
MessagingContextMode contextMode,
Maybe <SignalMessage> signalM)
{
return(Prop.ForAll(
GenAS4Party().ToArbitrary(),
receiver =>
{
var user = new UserMessage(
$"user-{Guid.NewGuid()}",
AS4Party.DefaultFrom,
receiver);
AS4Message message =
signalM.Select(s => AS4Message.Create(new MessageUnit[] { s, user }))
.GetOrElse(AS4Message.Create(user));
var context = new MessagingContext(message, contextMode)
{
SendingPMode = new SendingProcessingMode
{
DynamicDiscovery = new DynamicDiscoveryConfiguration()
}
};
var act = new Lazy <bool>(() =>
{
var spy = new SpyToPartyDynamicDiscoveryProfile();
var sut = new DynamicDiscoveryStep(_ => spy);
sut.ExecuteAsync(context)
.GetAwaiter()
.GetResult();
return spy.ToParty
.Equals(receiver)
.Equals(contextMode == MessagingContextMode.Forward &&
context.AS4Message.IsUserMessage);
});
return Prop.throws <InvalidOperationException, bool>(act)
.Label($"Throws {nameof(InvalidOperationException)}")
.Or(() => act.Value)
.Label("Resolved ToParty is UserMessge.ToParty");
}));
}
public Property Saves_Bundled_MessageUnits_As_InMessages(MessagingContextMode mode)
{
return(Prop.ForAll(
GenMessageUnits().ToArbitrary(),
messageUnits =>
{
// Arrange
AS4Message fixture = AS4Message.Create(messageUnits);
var stub = new ReceivedMessage(Stream.Null, Constants.ContentTypes.Soap);
var ctx = new MessagingContext(fixture, stub, mode);
// Act
Step.ExecuteAsync(ctx).GetAwaiter().GetResult();
// Assert
IEnumerable <InMessage> inserts =
GetDataStoreContext.GetInMessages(m => fixture.MessageIds.Contains(m.EbmsMessageId));
IEnumerable <string> expected = fixture.MessageIds.OrderBy(x => x);
IEnumerable <string> actual = inserts.Select(i => i.EbmsMessageId).OrderBy(x => x);
Assert.True(
expected.SequenceEqual(actual),
$"{String.Join(", ", expected)} != {String.Join(", ", actual)}");
Assert.All(
inserts, m =>
{
bool pushForNonPullReceive = m.MEP == MessageExchangePattern.Push && mode != MessagingContextMode.PullReceive;
bool pullForPullReceive = m.MEP == MessageExchangePattern.Pull && mode == MessagingContextMode.PullReceive;
Assert.True(
pushForNonPullReceive || pullForPullReceive,
mode == MessagingContextMode.PullReceive
? "MEP Binding should be Pull"
: "MEP Binding should be Push");
});
}));
}
public Property Returns_Empty_Soap_For_Signals_If_ReplyPattern_Is_Callback_Or_Mode_Is_PullReceive(
SignalMessage signal,
ReplyPattern pattern,
MessagingContextMode mode)
{
// Arrange
var context =
new MessagingContext(AS4Message.Create(signal), mode)
{
ReceivingPMode = new ReceivingProcessingMode {
ReplyHandling = { ReplyPattern = pattern }
},
SendingPMode = new SendingProcessingMode {
Id = "sending-pmode"
}
};
// Act
StepResult result = ExerciseStoreSignalMessageAsync(context).GetAwaiter().GetResult();
// Assert
AS4Message actual = result.MessagingContext.AS4Message;
AS4Message expected = context.AS4Message;
bool isCallback = pattern == ReplyPattern.Callback;
bool isResponse = pattern == ReplyPattern.Response;
bool isPullReceive = mode == MessagingContextMode.PullReceive;
bool isSignal = expected.Equals(actual);
return((actual.IsEmpty == (isCallback || isPullReceive))
.Label("Should be an empty SOAP envelope when configured Callback or in PullReceive mode")
.Or(isSignal == isResponse)
.Label("Should be a SignalMessage when configured Response")
.Classify(actual.IsEmpty, "Empty SOAP envelope response")
.Classify(isSignal, "SignalMessage response"));
}
