// ReSharper disable once UnusedParameter.Local
private void AssertIfStatusOfOutMessageIs(string expectedId, OutStatus expectedStatus)
{
OutMessage outMessage = _databaseSpy.GetOutMessageFor(m => m.EbmsMessageId == expectedId);
Assert.NotNull(outMessage);
Assert.Equal(expectedStatus, outMessage.Status.ToEnum <OutStatus>());
}
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);
}
private void InsertOutMessageInDatastoreWith(Operation operation, OutStatus status)
{
using (var context = GetDataStoreContext())
{
var expectedMessage = new OutMessage("message-id")
{
MessageLocation = "ignored location"
};
expectedMessage.SetStatus(status);
expectedMessage.Operation = operation;
context.OutMessages.Add(expectedMessage);
context.SaveChanges();
}
}
private async Task <HttpResponseMessage> PiggyBacked_PullRequest_With_Bundled_Signal(
Func <string, SignalMessage> createSignal,
OutStatus expStatus)
{
// Arrange
OverridePullAuthorizationMap(
@".\config\componenttest-settings\security\pull_authorizationmap_allowed_facts.xml");
string userMessageId = $"user-{Guid.NewGuid()}";
StoreToBeAckOutMessage(userMessageId, CreateSendingPMode());
AS4Message pullRequest = CreateAllowedPullRequest();
SignalMessage extraSignalMessage = createSignal(userMessageId);
pullRequest.AddMessageUnit(extraSignalMessage);
AS4Message signedBundled = SignAS4MessageWithPullRequestCert(pullRequest);
// Act
HttpResponseMessage response = await StubSender.SendAS4Message(PullSendUrl, signedBundled);
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
OutMessage storedUserMesage =
_databaseSpy.GetOutMessageFor(m => m.EbmsMessageId == userMessageId);
Assert.Equal(expStatus, storedUserMesage.Status.ToEnum <OutStatus>());
InMessage storedSignalMessage =
_databaseSpy.GetInMessageFor(m => m.EbmsMessageId == extraSignalMessage.MessageId);
Assert.Equal(InStatus.Received, storedSignalMessage.Status.ToEnum <InStatus>());
return(response);
}
/// <summary>
/// Prepare an <see cref="OutMessage"/> to be picked or stored by a Sending operation.
/// </summary>
/// <param name="location"></param>
/// <param name="status"></param>
/// <param name="operation"></param>
/// <returns></returns>
public OutMessage BuildForSending(string location, OutStatus status, Operation operation)
{
if (String.IsNullOrWhiteSpace(location))
{
throw new ArgumentException(@"Value cannot be null or whitespace.", nameof(location));
}
OutMessage outMessage = Build();
if (_pmode is SendingProcessingMode sp)
{
outMessage.Url = sp.PushConfiguration?.Protocol?.Url;
}
else if (_pmode is ReceivingProcessingMode rp)
{
outMessage.Url = rp.ReplyHandling?.ResponseConfiguration?.Protocol?.Url;
}
outMessage.MessageLocation = location;
outMessage.SetStatus(status);
outMessage.Operation = operation;
return(outMessage);
}
private void DisplayMessage(String message, params Object[] args)
{
OutStatus.AppendText(String.Format(message, args) + "\r\n");
}
private void UpdateReferencedUserMessagesStatus(IEnumerable <SignalMessage> signalMessages, OutStatus outStatus)
{
string[] refToMessageIds = signalMessages.Select(r => r.RefToMessageId).Where(id => !String.IsNullOrEmpty(id)).ToArray();
if (refToMessageIds.Any())
{
_repository.UpdateOutMessages(
m => refToMessageIds.Contains(m.EbmsMessageId) && m.Intermediary == false,
m =>
{
m.SetStatus(outStatus);
Logger.Debug($"Update OutMessage UserMessage {m.EbmsMessageId} with Status={outStatus}");
});
}
}
public void SetStatus(OutStatus status)
{
Status = status.ToString();
}
