public async Task <Unit> Handle(MakeTransfer command, CancellationToken cancellationToken = default)
{
var(fromAccountId, toAccountId, amount) = command;
var accountFrom = await Store.AggregateStreamAsync <Account>(fromAccountId, token : cancellationToken)
?? throw AggregateNotFoundException.For <Account>(fromAccountId);
accountFrom.RecordOutflow(toAccountId, amount);
var accountFromEvents = accountFrom.DequeueUncommittedEvents();
Store.Append(accountFrom.Id, accountFromEvents);
var accountTo = await Store.AggregateStreamAsync <Account>(toAccountId, token : cancellationToken)
?? throw AggregateNotFoundException.For <Account>(toAccountId);
accountTo.RecordInflow(fromAccountId, amount);
var accountToEvents = accountFrom.DequeueUncommittedEvents();
Store.Append(accountTo.Id, accountTo);
await session.SaveChangesAsync(cancellationToken);
await eventBus.Publish(accountFromEvents);
await eventBus.Publish(accountToEvents);
return(Unit.Value);
}
public async Task GivenAReferenceThatDoesNotExistsThenAnAggregateNotFoundExceptionIsThrownAsync()
{
_ = repository
.Setup(repo => repo.GetAsync(
It.IsAny <Guid>(),
It.IsAny <CancellationToken?>(),
It.IsAny <SignedVersion>()))
.ReturnsAsync(default(SerializableAggregateRoot));
var aggregateId = Guid.NewGuid();
var reference = Reference <SerializableAggregateRoot> .Create(aggregateId);
AggregateNotFoundException <SerializableAggregateRoot> exception =
await Assert.ThrowsAsync <AggregateNotFoundException <SerializableAggregateRoot> >(
() => reference.RetrieveAsync(context, repository.Object));
repository.Verify(
repo => repo.GetAsync(
It.IsAny <Guid>(),
It.IsAny <CancellationToken?>(),
It.IsAny <SignedVersion>()),
Times.Once);
Assert.Equal(reference, exception.Aggregate);
Assert.Equal(context, exception.Context);
}
private void HandleAggregateNotFoundException(ExceptionContext context)
{
AggregateNotFoundException aggregateNotFoundException =
context.Exception as AggregateNotFoundException;
context.Result = new ErrorResponse(aggregateNotFoundException).AsObjectResult();
context.ExceptionHandled = true;
}
public void UsingTheConstructorWithMessageReturnsExceptionWithExpectedProperties()
{
var sut = new AggregateNotFoundException(AggregateIdentifier, AggregateType, "Message");
Assert.That(sut.Identifier, Is.EqualTo(AggregateIdentifier));
Assert.That(sut.ClrType, Is.EqualTo(AggregateType));
Assert.That(sut.Message, Is.EqualTo("Message"));
Assert.That(sut.InnerException, Is.Null);
}
public void UsingTheDefaultContstructorReturnsExceptionWithExpectedProperties()
{
var sut = new AggregateNotFoundException(AggregateIdentifier, AggregateType);
Assert.That(sut.Identifier, Is.EqualTo(AggregateIdentifier));
Assert.That(sut.ClrType, Is.EqualTo(AggregateType));
Assert.That(sut.Message, Is.EqualTo(
"The Object aggregate with identifier " + AggregateIdentifier +
" could not be found. Please make sure the call site is indeed passing in an identifier for an Object aggregate."));
Assert.That(sut.InnerException, Is.Null);
}
public async Task <Unit> Handle(ConfirmReservation command, CancellationToken cancellationToken)
{
var reservation = await repository.Find(command.ReservationId, cancellationToken)
?? throw AggregateNotFoundException.For <Reservation>(command.ReservationId);
reservation.Confirm();
await repository.Update(reservation, cancellationToken);
return(Unit.Value);
}
public void UsingTheConstructorWithMessageReturnsExceptionWithExpectedProperties()
{
var aggregateId = Guid.NewGuid();
var aggregateType = typeof(Object);
var sut = new AggregateNotFoundException(aggregateId, aggregateType, "Message");
Assert.That(sut.AggregateId, Is.EqualTo(aggregateId));
Assert.That(sut.AggregateType, Is.EqualTo(aggregateType));
Assert.That(sut.Message, Is.EqualTo("Message"));
Assert.That(sut.InnerException, Is.Null);
}
public async Task <Unit> Handle(ScheduleMeeting request, CancellationToken cancellationToken)
{
var meeting = await repository.Find(request.MeetingId, cancellationToken)
?? throw AggregateNotFoundException.For <Meeting>(request.MeetingId);
meeting.Schedule(request.Occurs);
await repository.Update(meeting, cancellationToken);
return(Unit.Value);
}
public void GivenAnAggregateAndAContextThenAnInstanceIsReturnedWithAllPropertiesSet()
{
var aggregate = Guid.NewGuid().ToReference <SerializableAggregateRoot>();
var context = new SerializableMessage();
var instance = new AggregateNotFoundException <SerializableAggregateRoot>(
context,
aggregate);
Assert.Equal(aggregate, instance.Aggregate);
Assert.Equal(context, instance.Context);
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseExceptionHandlingMiddleware(exception => exception switch
{
AggregateNotFoundException _ => HttpStatusCode.NotFound,
_ => HttpStatusCode.InternalServerError
});
public async Task <Unit> Handle(ScheduleMeeting command, CancellationToken cancellationToken)
{
var(meetingId, dateRange) = command;
var meeting = await repository.Find(meetingId, cancellationToken)
?? throw AggregateNotFoundException.For <Meeting>(meetingId);
meeting.Schedule(dateRange);
await repository.Update(meeting, cancellationToken);
return(Unit.Value);
}
public async Task <Unit> Handle(CancelReservation command, CancellationToken cancellationToken)
{
Guard.Against.Null(command, nameof(command));
var reservation = await repository.Find(command.ReservationId, cancellationToken)
?? throw AggregateNotFoundException.For <Reservation>(command.ReservationId);
reservation.Cancel();
await repository.Update(reservation, cancellationToken);
return(Unit.Value);
}
public void GivenAnInstanceThenAllPropertiesAreSerialized()
{
var aggregate = Guid.NewGuid().ToReference <SerializableAggregateRoot>();
var context = new SerializableMessage();
var original = new AggregateNotFoundException <SerializableAggregateRoot>(
context,
aggregate);
AggregateNotFoundException <SerializableAggregateRoot> deserialized = original.Clone();
Assert.NotSame(original, deserialized);
Assert.Equal(original.Aggregate, deserialized.Aggregate);
Assert.Equal(original.Context, deserialized.Context);
}
public async Task <CartDetails> Handle(GetCartAtVersion request, CancellationToken cancellationToken)
{
var cart = await eventStore.AggregateStream <CartDetails>(
request.CartId,
cancellationToken,
request.Version
);
if (cart == null)
{
throw AggregateNotFoundException.For <Cart>(request.CartId);
}
return(cart);
}
public async Task Handle(CartConfirmed @event, CancellationToken cancellationToken)
{
var cart = await querySession.LoadAsync <Cart>(@event.CartId, cancellationToken)
?? throw AggregateNotFoundException.For <Cart>(@event.CartId);
var externalEvent = CartFinalized.Create(
@event.CartId,
cart.ClientId,
cart.ProductItems.ToList(),
cart.TotalPrice,
@event.ConfirmedAt
);
await eventBus.Publish(externalEvent);
}
public static HttpStatusCodeInfo Map(Exception exception)
{
var code = exception switch
{
UnauthorizedAccessException _ => HttpStatusCode.Unauthorized,
NotImplementedException _ => HttpStatusCode.NotImplemented,
InvalidOperationException _ => HttpStatusCode.Conflict,
ArgumentException _ => HttpStatusCode.BadRequest,
ValidationException _ => HttpStatusCode.BadRequest,
AggregateNotFoundException _ => HttpStatusCode.NotFound,
_ => HttpStatusCode.InternalServerError
};
return(new HttpStatusCodeInfo(code, exception.Message));
}
}
public void CanBeSerialized()
{
var innerException = new Exception("InnerMessage");
var sut = new AggregateNotFoundException(AggregateIdentifier, AggregateType, "Message", innerException);
using (var stream = new MemoryStream())
{
var formatter = new BinaryFormatter();
formatter.Serialize(stream, sut);
stream.Position = 0;
var result = (AggregateNotFoundException)formatter.Deserialize(stream);
Assert.That(result.Identifier, Is.EqualTo(AggregateIdentifier));
Assert.That(result.ClrType, Is.EqualTo(AggregateType));
Assert.That(result.Message, Is.EqualTo(result.Message));
Assert.That(result.InnerException.Message, Is.EqualTo(result.InnerException.Message));
}
}
public void CanBeSerialized()
{
var innerException = new Exception("InnerMessage");
var aggregateId = Guid.NewGuid();
var aggregateType = typeof(Object);
var sut = new AggregateNotFoundException(aggregateId, aggregateType, "Message", innerException);
using (var stream = new MemoryStream()) {
var formatter = new BinaryFormatter();
formatter.Serialize(stream, sut);
stream.Position = 0;
var result = (AggregateNotFoundException)formatter.Deserialize(stream);
Assert.That(sut.AggregateId, Is.EqualTo(aggregateId));
Assert.That(sut.AggregateType, Is.EqualTo(aggregateType));
Assert.That(sut.Message, Is.EqualTo(result.Message));
Assert.That(sut.InnerException.Message, Is.EqualTo(result.InnerException.Message));
}
}
public void UsingTheDefaultContstructorReturnsExceptionWithExpectedProperties()
{
var aggregateId = Guid.NewGuid();
var aggregateType = typeof (Object);
var sut = new AggregateNotFoundException(aggregateId, aggregateType);
Assert.That(sut.AggregateId, Is.EqualTo(aggregateId));
Assert.That(sut.AggregateType, Is.EqualTo(aggregateType));
Assert.That(sut.Message, Is.EqualTo(
"The Object aggregate with identifier " + aggregateId + " could not be found. Please make sure the callsite is indeed passing in an identifier for an Object aggregate."));
Assert.That(sut.InnerException, Is.Null);
}
public ErrorResponse(AggregateNotFoundException aggregateNotFoundException)
{
this.StatusCode = StatusCodes.Status404NotFound;
this.Message = aggregateNotFoundException.Message;
}