public async Task OutExceptionPModeInformationIsCorrectlyPersisted()
{
long savedId;
const string pmodeId = "pmode-id1";
const string pmodeContent = "<pmode></pmode>";
using (var db = GetDataStoreContext())
{
var outException = OutException.ForEbmsMessageId("message-id", "some-error-happened");
outException.SetPModeInformation(pmodeId, pmodeContent);
db.OutExceptions.Add(outException);
await db.SaveChangesAsync();
savedId = outException.Id;
Assert.NotEqual(default(long), savedId);
}
using (var db = GetDataStoreContext())
{
var outException = db.OutExceptions.FirstOrDefault(i => i.Id == savedId);
Assert.NotNull(outException);
Assert.Equal(pmodeId, outException.PModeId);
Assert.Equal(pmodeContent, outException.PMode);
}
}
private static OutException CreateOutException(string ebmsMessageId, DateTimeOffset insertionTime)
{
OutException ex = OutException.ForEbmsMessageId(ebmsMessageId, exception: string.Empty);
ex.InsertionTime = insertionTime;
return(ex);
}
private async Task <MessagingContext> HandleNotifyException(Exception exception, MessagingContext context)
{
Logger.Error(exception.Message);
using (var dbContext = _createContext())
{
var repository = new DatastoreRepository(dbContext);
if (context.NotifyMessage.EntityType == typeof(InMessage) ||
context.NotifyMessage.EntityType == typeof(InException))
{
var inException = InException.ForEbmsMessageId(context.EbmsMessageId, exception);
repository.InsertInException(inException);
if (context.NotifyMessage.EntityType == typeof(InMessage))
{
Logger.Debug("Fatal fail in notification, set InMessage(s).Status=Exception");
repository.UpdateInMessage(context.EbmsMessageId, i => i.SetStatus(InStatus.Exception));
}
}
else if (context.NotifyMessage.EntityType != typeof(OutMessage) ||
context.NotifyMessage.EntityType == typeof(OutException))
{
var outException = OutException.ForEbmsMessageId(context.EbmsMessageId, exception);
repository.InsertOutException(outException);
if (context.NotifyMessage.EntityType == typeof(OutMessage) &&
context.MessageEntityId != null)
{
Logger.Debug("Fatal fail in notification, set OutMessage.Status=Exception");
repository.UpdateOutMessage(
context.MessageEntityId.Value,
o => o.SetStatus(OutStatus.Exception));
}
}
if (context.MessageEntityId != null)
{
Logger.Debug("Abort retry operation due to fatal notification exception, set Status=Completed");
repository.UpdateRetryReliability(
context.MessageEntityId.Value,
r => r.Status = RetryStatus.Completed);
}
await dbContext.SaveChangesAsync();
}
return(new MessagingContext(exception));
}
public async void ThenOutExceptionIsTransformedToNotifyEnvelope()
{
// Arrange
ReceivedEntityMessage receivedMessage = CreateReceivedExceptionMessage(OutException.ForEbmsMessageId("id", "error"), Operation.ToBeNotified);
var transformer = new NotifyMessageTransformer();
// Act
MessagingContext result = await transformer.TransformAsync(receivedMessage);
// Assert
Assert.NotNull(result.NotifyMessage);
Assert.Equal(
((ExceptionEntity)receivedMessage.Entity).EbmsRefToMessageId,
result.NotifyMessage.MessageInfo.RefToMessageId);
}
public async Task ThenInsertOutExceptionSucceeds()
{
// Arrange
var outException = OutException.ForEbmsMessageId($"outex-{Guid.NewGuid()}", "error");
// Act
using (DatastoreContext context = GetDataStoreContext())
{
new DatastoreRepository(context).InsertOutException(outException);
await context.SaveChangesAsync();
}
// Assert
GetDataStoreContext.AssertOutException(outException.EbmsRefToMessageId, Assert.NotNull);
}
/// <summary>
/// Insert an <see cref="OutException"/> based on an exception that occured during the outgoing processing of an <see cref="AS4Message"/>.
/// </summary>
/// <param name="exception">The exception which message will be inserted.</param>
/// <param name="ebmsMessageId">The primary message id of the <see cref="AS4Message"/> that caused the exception</param>
/// <param name="entityId">The primary key of the stored record to which the mesage is refering to.</param>
/// <param name="pmode">The PMode that was used during the processing of the message.</param>
public async Task <OutException> InsertOutgoingAS4MessageExceptionAsync(
Exception exception,
string ebmsMessageId,
long?entityId,
SendingProcessingMode pmode)
{
OutException entity =
OutException
.ForEbmsMessageId(ebmsMessageId, exception)
.SetOperationFor(pmode?.ExceptionHandling);
await entity.SetPModeInformationAsync(pmode);
_repository.InsertOutException(entity);
if (entityId.HasValue)
{
_repository.UpdateOutMessage(entityId.Value, m => m.SetStatus(OutStatus.Exception));
}
return(entity);
}
protected virtual void SetupDataStore()
{
using (datastoreContext = new DatastoreContext(options, StubConfig.Default))
{
string pmodeString = AS4XmlSerializer.ToString(pmode);
string pmodeId = pmode.Id;
{
var message = new InMessage(ebmsMessageId: InEbmsMessageId1)
{
EbmsRefToMessageId = InEbmsRefToMessageId1,
InsertionTime = DateTime.UtcNow.AddMinutes(-1),
};
message.SetStatus(InStatus.Created);
message.SetPModeInformation(pmodeId, pmodeString);
datastoreContext.InMessages.Add(message);
}
{
var message = new InMessage(ebmsMessageId: InEbmsMessageId2)
{
EbmsRefToMessageId = InEbmsRefToMessageId2,
InsertionTime = DateTime.UtcNow.AddMinutes(-1)
};
message.SetStatus(InStatus.Received);
datastoreContext.InMessages.Add(message);
}
{
var message = new OutMessage(OutEbmsMessageId1)
{
EbmsRefToMessageId = OutEbmsRefToMessageId1,
InsertionTime = DateTime.UtcNow.AddMinutes(-1)
};
message.SetStatus(OutStatus.Created);
datastoreContext.OutMessages.Add(message);
}
{
var message = new OutMessage(OutEbmsMessageId2)
{
EbmsRefToMessageId = OutEbmsRefToMessageId2,
InsertionTime = DateTime.UtcNow.AddMinutes(-1)
};
message.SetStatus(OutStatus.Created);
datastoreContext.OutMessages.Add(message);
}
InException inEx1 = Entities.InException.ForEbmsMessageId(InEbmsMessageId1, InException);
inEx1.InsertionTime = DateTime.UtcNow.AddMinutes(-1);
datastoreContext.InExceptions.Add(inEx1);
InException inEx2 = Entities.InException.ForEbmsMessageId(InEbmsMessageId1, InException);
inEx2.InsertionTime = DateTime.UtcNow.AddMinutes(-1);
datastoreContext.InExceptions.Add(inEx2);
InException inEx3 = Entities.InException.ForMessageBody(MessageLocation, InException);
inEx3.InsertionTime = DateTime.UtcNow.AddMinutes(-1);
datastoreContext.InExceptions.Add(inEx3);
OutException outEx1 = Entities.OutException.ForEbmsMessageId(OutEbmsRefToMessageId1, InException);
outEx1.InsertionTime = DateTime.UtcNow.AddMinutes(-1);
datastoreContext.OutExceptions.Add(outEx1);
OutException outEx2 = OutException.ForEbmsMessageId(InEbmsRefToMessageId1, Exception);
outEx2.InsertionTime = DateTime.UtcNow.AddMinutes(-1);
datastoreContext.OutExceptions.Add(outEx2);
OutException outEx3 = OutException.ForMessageBody(MessageLocation, Exception);
outEx3.InsertionTime = DateTime.UtcNow.AddMinutes(-1);
datastoreContext.OutExceptions.Add(outEx3);
datastoreContext.SaveChanges();
foreach (var inMessage in datastoreContext.InMessages)
{
inMessage.SetPModeInformation(pmodeId, pmodeString);
}
foreach (var outMessage in datastoreContext.OutMessages)
{
outMessage.SetPModeInformation(pmodeId, pmodeString);
}
foreach (var inException in datastoreContext.InExceptions)
{
inException.SetPModeInformation(pmodeId, pmodeString);
}
foreach (var outException in datastoreContext.OutExceptions)
{
outException.SetPModeInformation(pmodeId, pmodeString);
}
datastoreContext.SaveChanges();
}
}