private static async void ReceiveEntity(Entity entity, Function messageCallback, CancellationToken token)
{
var message = new ReceivedEntityMessage(entity);
MessagingContext result = await messageCallback(message, token).ConfigureAwait(false);
result?.Dispose();
}
public static void CleanupTestTrack()
{
int deleteResult = -1;
MessagingContext context = null;
#region Clean database of records added during test
try
{
using (context = new MessagingContext(connectionStringName))
{
MessagePing recordToDelete = context.FindOne(new object[] { recordId });
bool recordIsNotAvailable = null != recordToDelete;
if (recordIsNotAvailable)
{
context.Remove(recordToDelete);
deleteResult = context.SaveChanges();
}
}
}
catch { }
finally
{
if (null != context)
{
context.Dispose();
}
}
#endregion
}
public void Cleanup()
{
context.Dispose();
if (File.Exists(dbFullPath))
{
File.Delete(dbFullPath);
}
}
public async Task ThenTransfromSuceedsWithAS4Message()
{
// Arrange
const string contentType = "multipart/related; boundary=\"=-PHQq1fuE9QxpIWax7CKj5w==\"; type=\"application/soap+xml\"; charset=\"utf-8\"";
// Act
MessagingContext context = await ExerciseTransform(as4_single_payload, contentType);
// Assert
Assert.NotNull(context?.AS4Message);
// TearDown
context.Dispose();
}
/// <summary>
/// <paramref name="intervalPullRequest" /> is received.
/// </summary>
/// <param name="intervalPullRequest"></param>
/// <returns></returns>
/// <exception cref="Exception">A delegate callback throws an exception.</exception>
protected override async Task <Interval> OnRequestReceived(PModePullRequest intervalPullRequest)
{
MessagingContext resultedMessage = await _messageCallback(intervalPullRequest).ConfigureAwait(false);
try
{
bool isUserMessage = resultedMessage.AS4Message?.IsUserMessage == true;
Interval intervalResult = isUserMessage ? Interval.Reset : Interval.Increase;
Logger.Info($"PullRequest result in {(isUserMessage ? "UserMessage" : "Error")} next interval will be \"{intervalResult}\"");
return(intervalResult);
}
finally
{
resultedMessage?.Dispose();
}
}
public async Task Use_ReceivingPMode_When_No_SendingPMode_Is_Available()
{
// Arrange
var userMessage = new UserMessage($"user-{Guid.NewGuid()}");
var message = AS4Message.Create(userMessage);
var output = new MemoryStream();
await SerializerProvider
.Default
.Get(message.ContentType)
.SerializeAsync(message, output);
var ctx = new MessagingContext(
message,
new ReceivedMessage(output, message.ContentType),
MessagingContextMode.Send)
{
ReceivingPMode = new ReceivingProcessingMode
{
ReplyHandling =
{
ResponseConfiguration = new PushConfiguration
{
Protocol ={ Url = "http://some/endpoint/path" }
}
}
}
};
var receipt = new Receipt($"receipt-{Guid.NewGuid()}", userMessage.MessageId);
var stub = StubHttpClient.ThatReturns(AS4Message.Create(receipt));
IStep sut = CreateSendStepWithResponse(stub);
// Act
StepResult result = await sut.ExecuteAsync(ctx);
// Assert
Assert.True(result.Succeeded, "Sending UserMessage step has not succeeded");
Assert.Equal(receipt, result.MessagingContext.AS4Message.PrimaryMessageUnit);
// TearDown
ctx.Dispose();
}
