public Task <Unit> Handle(CreateSomeDataCommand request, CancellationToken cancellationToken)
{
try
{
using (var context = _dbContext)
{
var businessUser = _businessUserRepositoy.GetByApplicationUserId(request.ApplicationUserId, context);
var someData = SomeAggregate.Create(request, businessUser.Id);
_someDataWriteRepository.Create(someData, context);
context.SaveChanges();
}
_eventBus.Publish(new SomeDataCreatedEvent(request.Id,
request.FirstName,
request.MiddleName,
request.LastName,
request.Title,
request.CreationDate));
return(Unit.Task);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public void SaveSomeDataShoulUpdateSomeDataInDatabaseAndSaveChanges()
{
var updateSomeDataCommand = BuildUpdateSomeDataCommand();
var businessUser = new BusinessUser
{
Id = Guid.NewGuid(),
Gender = "SomeGender",
Locale = "SomeLocale",
Location = "SomeLocation",
Identity = new ApplicationUser
{
Email = "*****@*****.**"
}
};
var someDataDb = SomeDataMapper.UpdateSomeDataCommandToPersistanceModel(updateSomeDataCommand);
someDataDb.BusinessUserId = businessUser.Id;
var someDataDbSet = new List <SomeData>
{
someDataDb
};
var businessUserDb = new List <BusinessUser>
{
businessUser
};
var businessUserMockSet = new MockDbSet <BusinessUser>(businessUserDb);
var someDataMockSet = new MockDbSet <SomeData>(someDataDbSet);
var contextMock = new Mock <SomeDataContext>();
contextMock.Setup(c => c.SomeData).Returns(someDataMockSet.Object);
contextMock.Setup(c => c.BusinessUsers).Returns(businessUserMockSet.Object);
var someDataRepository = new SomeDataWriteRepository(contextMock.Object);
var updatedSomeData = SomeAggregate.Create(updateSomeDataCommand.SomeDataId,
"NewFirstName",
"NewMiddleName",
"NewLastName",
"NewTitle",
new Color("#c1d0c3"),
DateTime.Now,
new FacebookUrl(null),
Guid.NewGuid());
someDataRepository.Save(updatedSomeData);
var updatedDb = someDataRepository.Get(updateSomeDataCommand.SomeDataId);
contextMock.Verify(x => x.SaveChanges(), Times.Once);
Assert.Equal(updatedDb.Id, updatedSomeData.Id);
Assert.Equal(updatedDb.Color, updatedSomeData.Color);
Assert.Equal(updatedDb.CreationDate, updatedSomeData.CreationDate);
Assert.Equal(updatedDb.FacebookUrl, updatedSomeData.FacebookUrl);
Assert.Equal(updatedDb.FirstName, updatedSomeData.FirstName);
Assert.Equal(updatedDb.LastName, updatedSomeData.LastName);
Assert.Equal(updatedDb.MiddleName, updatedSomeData.MiddleName);
Assert.Equal(updatedDb.Title, updatedSomeData.Title);
}
public void Delete(SomeAggregate someData, SomeDataContext dbContext)
{
var someDataToDelete = dbContext.SomeData.FirstOrDefault(d => d.Id == someData.Id);
if (someDataToDelete != null)
{
dbContext.SomeData.Remove(someDataToDelete);
}
}
public SomeAggregate BuildSomeAggregate(SomeData someData)
{
return(SomeAggregate.Create(someData.Id,
someData.FirstName,
someData.MiddleName,
someData.LastName,
someData.Title,
new Color(someData.Color),
someData.CreationDate,
new FacebookUrl(someData.FacebookUrl),
someData.BusinessUserId));
}
public SomeAggregate BuildSomeAggregate(Guid someDataId)
{
return(SomeAggregate.Create(someDataId,
firstName,
middleName,
lastName,
title,
new Color(color),
creationDate,
new FacebookUrl(facebookUrl),
Guid.NewGuid()));
}
public static SomeAggregate PersistanceModelToAggregateRoot(Data.Contexts.Models.SomeData persistanceModel)
{
return(SomeAggregate.Create(
persistanceModel.Id,
persistanceModel.FirstName,
persistanceModel.MiddleName,
persistanceModel.LastName,
persistanceModel.Title,
new Color(persistanceModel.Color),
persistanceModel.CreationDate,
new FacebookUrl(persistanceModel.FacebookUrl),
persistanceModel.BusinessUserId));
}
public void FailsOnSequenceMismatch()
{
var someAggregate = new SomeAggregate();
var @eventWithTooLateSeqNumber = new SomeEvent("something");
// some global seq - not important
@eventWithTooLateSeqNumber.Meta[DomainEvent.MetadataKeys.GlobalSequenceNumber] = 10.ToString();
// local seq that are too far ahead
@eventWithTooLateSeqNumber.Meta[DomainEvent.MetadataKeys.SequenceNumber] = 1.ToString();
Assert.Throws <ApplicationException>(() => someAggregate.ApplyEvent(@eventWithTooLateSeqNumber, ReplayState.ReplayApply));
}
public static Data.Contexts.Models.SomeData SomeAggregateToPersistanceModel(SomeAggregate aggregate)
{
return(new Data.Contexts.Models.SomeData
{
Id = aggregate.Id,
FirstName = aggregate.FirstName,
MiddleName = aggregate.MiddleName,
LastName = aggregate.LastName,
Title = aggregate.Title,
Color = aggregate.Color.Value,
CreationDate = aggregate.CreationDate,
FacebookUrl = aggregate.FacebookUrl.Value,
BusinessUserId = aggregate.BusinessUserId
});
}
public void AppliesEmittedEvents()
{
var aggregateRootRepository = CreateAggregateRootRepository();
var someAggregate = new SomeAggregate
{
UnitOfWork = new ConsoleOutUnitOfWork(aggregateRootRepository),
};
someAggregate.Initialize("root_id");
someAggregate.DoSomething();
Assert.That(someAggregate.StuffThatWasDone.Count, Is.EqualTo(1));
Assert.That(someAggregate.StuffThatWasDone.First(), Is.EqualTo("emitted an event"));
}
public void Save(SomeAggregate someData)
{
try
{
using (var context = SomeDataEntities)
{
Save(someData);
context.SaveChanges();
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public void Save(SomeAggregate someData, SomeDataContext dbContext)
{
var someDataToUpdate = dbContext.SomeData.FirstOrDefault(d => d.Id == someData.Id);
if (someDataToUpdate == null)
{
return;
}
someDataToUpdate.Color = someData.Color.Value;
someDataToUpdate.CreationDate = someData.CreationDate;
someDataToUpdate.FacebookUrl = someData.FacebookUrl.Value;
someDataToUpdate.FirstName = someData.FirstName;
someDataToUpdate.LastName = someData.LastName;
someDataToUpdate.MiddleName = someData.MiddleName;
someDataToUpdate.Title = someData.Title;
someDataToUpdate.BusinessUserId = someData.BusinessUserId;
}
public void ProvidesSuitableMetadataOnEvents()
{
var timeForFirstEvent = new DateTime(1979, 3, 19, 19, 0, 0, DateTimeKind.Utc);
var timeForNextEvent = timeForFirstEvent.AddMilliseconds(2);
var aggregateRootRepository = CreateAggregateRootRepository();
var eventCollector = new InMemoryUnitOfWork(aggregateRootRepository, _defaultDomainTypeNameMapper);
var someAggregate = new SomeAggregate
{
UnitOfWork = eventCollector,
};
someAggregate.Initialize("root_id");
TimeMachine.FixCurrentTimeTo(timeForFirstEvent);
someAggregate.DoSomething();
TimeMachine.FixCurrentTimeTo(timeForNextEvent);
someAggregate.DoSomething();
var events = eventCollector.Cast <SomeEvent>().ToList();
var firstEvent = events[0];
Assert.That(firstEvent.Meta[DomainEvent.MetadataKeys.TimeUtc], Is.EqualTo(timeForFirstEvent.ToString("u")));
Assert.That(firstEvent.Meta[DomainEvent.MetadataKeys.Owner], Is.EqualTo("d60.Cirqus.Tests.Aggregates.TestEventApplication+SomeAggregate, d60.Cirqus.Tests"));
Assert.That(firstEvent.Meta[DomainEvent.MetadataKeys.Type], Is.EqualTo("d60.Cirqus.Tests.Aggregates.TestEventApplication+SomeEvent, d60.Cirqus.Tests"));
Assert.That(firstEvent.Meta[DomainEvent.MetadataKeys.SequenceNumber], Is.EqualTo("0"));
Assert.That(firstEvent.Meta[DomainEvent.MetadataKeys.AggregateRootId], Is.EqualTo("root_id"));
var nextEvent = events[1];
Assert.That(nextEvent.Meta[DomainEvent.MetadataKeys.TimeUtc], Is.EqualTo(timeForNextEvent.ToString("u")));
Assert.That(nextEvent.Meta[DomainEvent.MetadataKeys.Owner], Is.EqualTo("d60.Cirqus.Tests.Aggregates.TestEventApplication+SomeAggregate, d60.Cirqus.Tests"));
Assert.That(nextEvent.Meta[DomainEvent.MetadataKeys.Type], Is.EqualTo("d60.Cirqus.Tests.Aggregates.TestEventApplication+SomeEvent, d60.Cirqus.Tests"));
Assert.That(nextEvent.Meta[DomainEvent.MetadataKeys.SequenceNumber], Is.EqualTo("1"));
Assert.That(nextEvent.Meta[DomainEvent.MetadataKeys.AggregateRootId], Is.EqualTo("root_id"));
}
public void Create(SomeAggregate someData, SomeDataContext dbContext)
{
var someDatatoSave = SomeDataMapper.SomeAggregateToPersistanceModel(someData);
dbContext.SomeData.Add(someDatatoSave);
}
