public async Task SnapshotStore_SaveAsyncInvokesSerializeOnIAggregateSerializer()
{
var options = SetupContext();
using (var context = new InfrastructureContext(options))
{
var mockSerializer = new Mock <IAggregateSerializer>();
mockSerializer.Setup(s => s.Serialize(It.IsAny <FakeAggregate>()))
.Returns <FakeAggregate>(aggr =>
{
var payload = JsonConvert.SerializeObject(
aggr,
new JsonSerializerSettings
{
ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor,
TypeNameAssemblyFormatHandling = TypeNameAssemblyFormatHandling.Full,
TypeNameHandling = TypeNameHandling.All,
ContractResolver = new Serialization.NonPublicPropertiesContractResolver()
});
return(Encoding.UTF8.GetBytes(payload));
});
var sut = new SnapshotStore(mockSerializer.Object, context);
var aggregate = new FakeAggregate(Guid.Empty);
await sut.SaveAsync(aggregate);
mockSerializer.Setup(s => s.Serialize(It.IsAny <FakeAggregate>()));
}
}
public async Task SnapshotStore_FindAsyncWithMaxVersionReturnsInvokesDeserializeOnIAggregateSerializer()
{
var options = PopulateContext();
using (var context = new InfrastructureContext(options))
{
var mockSerializer = new Mock <IAggregateSerializer>();
mockSerializer.Setup(s => s.Deserialize <FakeAggregate>(It.IsAny <byte[]>()))
.Returns <byte[]>(bytes =>
{
var payload = Encoding.UTF8.GetString(bytes);
return(JsonConvert.DeserializeObject <FakeAggregate>(
payload,
new JsonSerializerSettings
{
ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor,
TypeNameAssemblyFormatHandling = TypeNameAssemblyFormatHandling.Full,
TypeNameHandling = TypeNameHandling.All,
ContractResolver = new Serialization.NonPublicPropertiesContractResolver()
}));
});
var sut = new SnapshotStore(mockSerializer.Object, context);
var aggregate = await sut.GetByIdAsync <FakeAggregate>(ToGuid(1), 10);
mockSerializer.Setup(s => s.Deserialize <FakeAggregate>(It.IsAny <byte[]>()));
}
}
public async Task TrackedCommandBus_SendCommandAsyncPersistsChangesToContext()
{
var command = new FakeCommand();
var options = SetupContext();
using (var context = new InfrastructureContext(options))
{
var sut = new TrackedCommandBus(
Mock.Of <IServiceProvider>(),
Mock.Of <IHttpContextAccessor>(),
Mock.Of <IMessageSerializer>(),
Mock.Of <ILogger>(),
context);
await sut.SendCommandAsync(command);
}
using (var context = new InfrastructureContext(options))
{
var commandEntity = await context.Commands.FindAsync(command.MessageId);
Assert.NotNull(commandEntity);
Assert.Equal(command.MessageId, commandEntity.Id);
}
}
public EventStore(
IMessageSerializer messageSerializer,
InfrastructureContext db)
{
this.messageSerializer = messageSerializer ?? throw new ArgumentNullException("messageSerializer");
this.db = db ?? throw new ArgumentNullException("db");
}
public async Task EventStore_EventEntityHasPropertiesWithCorrectValues()
{
var options = SetupContext();
var fakeEvent = new FakeEvent(Guid.Empty, 1, "Fake Value");
using (var context = new InfrastructureContext(options))
{
var sut = new EventStore(Mock.Of <IHttpContextAccessor>(), Mock.Of <IMessageSerializer>(), context);
sut.Save(typeof(FakeAggregate), fakeEvent);
await sut.SaveChangesAsync();
}
using (var context = new InfrastructureContext(options))
{
var eventEntity = context.Events.FirstOrDefault();
Assert.Equal(fakeEvent.AggregateId, eventEntity.AggregateId);
Assert.Equal(fakeEvent.Version, eventEntity.Version);
Assert.Equal(typeof(FakeAggregate).FullName, eventEntity.SourceType);
Assert.Equal(typeof(FakeEvent).AssemblyQualifiedName, eventEntity.Type);
Assert.Equal(typeof(FakeEvent).FullName, eventEntity.FullName);
}
}
public async Task SagaStore_FindAsyncWhenSagaHasPendingCommandPutThemToBus()
{
var options = PopulateContext();
using (var context = new InfrastructureContext(options))
{
var mockBus = new Mock <ICommandBus>();
var stubSagaSerializer = new Mock <ISagaSerializer>();
stubSagaSerializer.Setup(s => s.Deserialize <FakeSaga>(It.IsAny <byte[]>()))
.Returns <byte[]>((v) =>
{
var payload = Encoding.UTF8.GetString(v);
return(JsonConvert.DeserializeObject <FakeSaga>(
payload,
new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.All
}));
});
var sut = new SagaStore(mockBus.Object, stubSagaSerializer.Object, context);
await sut.FindAsync <FakeSaga>(ToGuid(2));
mockBus.Verify(s => s.SendCommandAsync <Command>(It.IsAny <FakeCommand>()));
}
}
public async Task ServiceBus_PublishIntegrationEventsAsyncPersistsChangesToContext()
{
var @event = new FakeIntegrationEvent("Fake Value");
var options = SetupContext();
using (var context = new InfrastructureContext(options))
{
var mockSerializer = new Mock <IMessageSerializer>();
var sut = new ServiceBus(
Mock.Of <IMessageSerializer>(),
Mock.Of <IHttpContextAccessor>(),
Mock.Of <IQueueClient>(),
Mock.Of <ITopicClient>(),
Mock.Of <ILogger>(),
context);
await sut.PublishEventsAsync(@event);
}
using (var context = new InfrastructureContext(options))
{
var eventEntity = await context.IntegrationEvents.FindAsync(@event.MessageId);
Assert.NotNull(eventEntity);
Assert.Equal(@event.MessageId, eventEntity.Id);
}
}
public async Task SagaStore_FindAsyncWhenSagaIsCompletedReturnsNull()
{
var options = PopulateContext();
using (var context = new InfrastructureContext(options))
{
var stubSagaSerializer = new Mock <ISagaSerializer>();
stubSagaSerializer.Setup(s => s.Deserialize <FakeSaga>(It.IsAny <byte[]>()))
.Returns <byte[]>((v) =>
{
var payload = Encoding.UTF8.GetString(v);
return(JsonConvert.DeserializeObject <FakeSaga>(
payload,
new JsonSerializerSettings {
TypeNameHandling = TypeNameHandling.All
}));
});
var sut = new SagaStore(Mock.Of <ICommandBus>(), stubSagaSerializer.Object, context);
var saga = await sut.FindAsync <FakeSaga>(ToGuid(3));
Assert.Null(saga);
}
}
public async Task SagaStore_SaveAsyncWhenPendingCommandsPutThemToBusIfExceptionThrownSagaPersisted()
{
var options = PopulateContext();
using (var context = new InfrastructureContext(options))
{
var mockBus = new Mock <ICommandBus>();
mockBus.SetupSequence(s => s.SendCommandAsync <Command>(It.IsAny <FakeCommand>()))
.Returns(Task.CompletedTask)
.Throws(new DbUpdateException("Cannot save entity in db. Connection closed", new Exception()));
var saga = new FakeSaga {
Id = Guid.Empty, PendingCommands = { new FakeCommand(), new FakeCommand() }
};
var sut = new SagaStore(mockBus.Object, Mock.Of <ISagaSerializer>(), context);
await Assert.ThrowsAsync <DbUpdateException>(async() => await sut.SaveAsync(saga));
Assert.Equal(1, saga.PendingCommands.Count);
}
using (var context = new InfrastructureContext(options))
{
var sagaEntity = context.Sagas.FindAsync(Guid.Empty, typeof(SagaStore).FullName);
Assert.NotNull(sagaEntity);
}
}
public async Task SagaStore_SaveAsyncInvokesSerializeOnISagaSerializer()
{
var options = PopulateContext();
using (var context = new InfrastructureContext(options))
{
var stubSagaSerializer = new Mock <ISagaSerializer>();
stubSagaSerializer.Setup(s => s.Serialize(It.IsAny <FakeSaga>()))
.Returns <FakeSaga>((s) =>
{
var payload = JsonConvert.SerializeObject(
s,
new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.All
});
return(Encoding.UTF8.GetBytes(payload));
});
var saga = new FakeSaga {
Id = Guid.Empty
};
var sut = new SagaStore(Mock.Of <ICommandBus>(), stubSagaSerializer.Object, context);
await sut.SaveAsync(saga);
stubSagaSerializer.Verify(v => v.Serialize(saga));
}
}
public SagaStore(
ICommandBus bus,
ISagaSerializer sagaSerializer,
InfrastructureContext db)
{
this.bus = bus ?? throw new ArgumentNullException("bus");
this.sagaSerializer = sagaSerializer ?? throw new ArgumentNullException("sagaSerializer");
this.db = db ?? throw new ArgumentNullException("db");
}
public EventStore(
IHttpContextAccessor httpContextAccessor,
IMessageSerializer messageSerializer,
InfrastructureContext db)
{
this.httpContextAccessor = httpContextAccessor ?? throw new ArgumentNullException(nameof(httpContextAccessor));
this.messageSerializer = messageSerializer ?? throw new ArgumentNullException(nameof(httpContextAccessor));
this.db = db ?? throw new ArgumentNullException(nameof(httpContextAccessor));
}
public void SnapshotStore_IsAssignableFromISnapshotStore()
{
var options = PopulateContext();
using (var context = new InfrastructureContext(options))
{
Assert.IsAssignableFrom <ISnapshotStore>(new SnapshotStore(Mock.Of <IAggregateSerializer>(), context));
}
}
public void EventStore_IsAssignableFromIEventStore()
{
var options = SetupContext();
using (var context = new InfrastructureContext(options))
{
var sut = new EventStore(Mock.Of <IHttpContextAccessor>(), Mock.Of <IMessageSerializer>(), context);
Assert.IsAssignableFrom <IEventStore>(sut);
}
}
public void SagaStore_IsAssignableFromISagaStore()
{
var options = SetupContext();
using (var context = new InfrastructureContext(options))
{
var sut = new SagaStore(Mock.Of <ICommandBus>(), Mock.Of <ISagaSerializer>(), context);
Assert.IsAssignableFrom <ISagaStore>(sut);
}
}
public SubjectController(
InfrastructureContext dbContext,
ISubjectService subjectService,
ICurrentUserService currentUserService,
ILogger <SubjectController> logger
)
{
_dbContext = dbContext;
_subjectService = subjectService;
_currentUserService = currentUserService;
_logger = logger;
}
public async Task EventStore_LoadAsyncReturnsAppropiateEvents()
{
var options = PopulateContext();
using (var context = new InfrastructureContext(options))
{
var sut = new EventStore(Mock.Of <IHttpContextAccessor>(), Mock.Of <IMessageSerializer>(), context);
var eventEntities = await sut.LoadAsync <FakeAggregate>(Aggregate1);
Assert.Equal(4, eventEntities.Count());
}
}
public TrackedCommandBus(
IServiceProvider serviceProvider,
IHttpContextAccessor httpContextAccessor,
IMessageSerializer messageSerializer,
ILogger logger,
InfrastructureContext db)
{
this.serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider));
this.httpContextAccessor = httpContextAccessor ?? throw new ArgumentNullException(nameof(httpContextAccessor));
this.messageSerializer = messageSerializer ?? throw new ArgumentNullException(nameof(messageSerializer));
this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
this.db = db ?? throw new ArgumentNullException(nameof(db));
}
public ServiceBus(
IMessageSerializer messageSerializer,
ISettingManager settingsManager,
ILogger logger,
InfrastructureContext db)
{
this.messageSerializer = messageSerializer ?? throw new ArgumentNullException("messageSerializer");
this.settingsManager = settingsManager ?? throw new ArgumentNullException("settingsManager");
this.logger = logger ?? throw new ArgumentNullException("logger");
this.db = db ?? throw new ArgumentNullException("db");
this.commandsQueueClient = GetQueueClient("machete-commands");
this.eventsQueueClient = GetQueueClient("machete-events");
}
public ServiceBus(
IMessageSerializer messageSerializer,
IHttpContextAccessor httpContextAccessor,
IQueueClient queueClient,
ITopicClient topicClient,
ILogger logger,
InfrastructureContext db)
{
this.messageSerializer = messageSerializer ?? throw new ArgumentNullException(nameof(messageSerializer));
this.httpContextAccessor = httpContextAccessor ?? throw new ArgumentNullException(nameof(httpContextAccessor));
this.topicClient = topicClient ?? throw new ArgumentNullException(nameof(topicClient));
this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
this.db = db ?? throw new ArgumentNullException(nameof(db));
}
private DbContextOptions <InfrastructureContext> PopulateContext()
{
var options = SetupContext();
using (var context = new InfrastructureContext(options))
{
context.Sagas.Add(GenerateSagaEntity(ToGuid(1), false, false));
context.Sagas.Add(GenerateSagaEntity(ToGuid(2), false, true));
context.Sagas.Add(GenerateSagaEntity(ToGuid(3), true, false));
context.Sagas.Add(GenerateSagaEntity(ToGuid(4), true, true));
context.SaveChanges();
}
return(options);
}
public void TrackedCommandBus_IsAssignableFromICommandBus()
{
var options = SetupContext();
using (var context = new InfrastructureContext(options))
{
var sut = new TrackedCommandBus(
Mock.Of <IServiceProvider>(),
Mock.Of <IHttpContextAccessor>(),
Mock.Of <IMessageSerializer>(),
Mock.Of <ILogger>(),
context);
Assert.IsAssignableFrom <ICommandBus>(sut);
}
}
private DbContextOptions <InfrastructureContext> PopulateContext()
{
var options = SetupContext();
using (var context = new InfrastructureContext(options))
{
context.Snapshots.Add(GenerateSnapshotEntity(ToGuid(1), 10));
context.Snapshots.Add(GenerateSnapshotEntity(ToGuid(1), 20));
context.Snapshots.Add(GenerateSnapshotEntity(ToGuid(2), 10));
context.Snapshots.Add(GenerateSnapshotEntity(ToGuid(2), 20));
context.Snapshots.Add(GenerateSnapshotEntity(ToGuid(2), 30));
context.SaveChanges();
}
return(options);
}
public void ServiceBus_IsAssignableFromIIntegrationEventBus()
{
var options = SetupContext();
using (var context = new InfrastructureContext(options))
{
var sut = new ServiceBus(
Mock.Of <IMessageSerializer>(),
Mock.Of <IHttpContextAccessor>(),
Mock.Of <IQueueClient>(),
Mock.Of <ITopicClient>(),
Mock.Of <ILogger>(),
context);
Assert.IsAssignableFrom <IIntegrationEventBus>(sut);
}
}
public async Task SagaStore_SaveAsyncWhenPendingCommandsPutThemToBus()
{
var options = PopulateContext();
using (var context = new InfrastructureContext(options))
{
var mockBus = new Mock <ICommandBus>();
var saga = new FakeSaga {
Id = Guid.Empty, PendingCommands = { new FakeCommand() }
};
var sut = new SagaStore(mockBus.Object, Mock.Of <ISagaSerializer>(), context);
await sut.SaveAsync(saga);
mockBus.Verify(s => s.SendCommandAsync <Command>(It.IsAny <FakeCommand>()));
}
}
public static void Setup()
{
var connectionString = ConfigurationManager.ConnectionStrings["DDDCinema"].ConnectionString;
using (var movieContext = new CinemaContext(connectionString))
using (var promotionsContext = new PromotionsContext(connectionString))
using (var infrastructureContext = new InfrastructureContext(connectionString))
{
Database.SetInitializer(new MoviesDbInitializer());
movieContext.Database.Initialize(true);
Database.SetInitializer(new DropCreateDatabaseIfModelChanges <PromotionsContext>());
promotionsContext.Database.Initialize(true);
Database.SetInitializer(new DropCreateDatabaseIfModelChanges <InfrastructureContext>());
infrastructureContext.Database.Initialize(true);
}
}
public FaqController(
InfrastructureContext dbContext,
IFaqService faqService,
IRepository <Faq, int> repository,
ICurrentUserService currentUserService,
IMappingEntitiesAndViewModels <FaqViewModel, Faq> createFaqFromViewwModel,
IMappingEntitiesAndViewModels <Faq, FaqViewModel> createFaqViewModelFromFaq,
ILogger <FaqController> logger
)
{
_dbContext = dbContext;
_faqService = faqService;
_repository = repository;
_currentUserService = currentUserService;
_createFaqFromViewwModel = createFaqFromViewwModel;
_createFaqViewModelFromFaq = createFaqViewModelFromFaq;
_logger = logger;
}
public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler)
{
if (bundle.JobDetail.JobType == typeof(EmailSendingJob))
{
var context = new InfrastructureContext("DDDCinema");
var notificationRepository = new EfNotificationRepository(context);
var job = new EmailSendingJob(notificationRepository, new SmtpMailSender());
return(new TransactionalJob(job, context));
}
if (bundle.JobDetail.JobType == typeof(SmsSendingJob))
{
var context = new InfrastructureContext("DDDCinema");
var notificationRepository = new EfNotificationRepository(context);
var job = new SmsSendingJob(notificationRepository, new GateSmsSender());
return(new TransactionalJob(job, context));
}
throw new InvalidOperationException("Not supported job type");
}
public async Task EventStore_NoChangesPersistedUntilSaveChangesAsyncCalled()
{
var options = SetupContext();
using (var context = new InfrastructureContext(options))
{
var sut = new EventStore(Mock.Of <IHttpContextAccessor>(), Mock.Of <IMessageSerializer>(), context);
sut.Save(typeof(FakeAggregate), new FakeEvent(Guid.Empty, 1, "Fake Value"));
Assert.False(await context.Events.AnyAsync());
await sut.SaveChangesAsync();
}
using (var context = new InfrastructureContext(options))
{
Assert.True(await context.Events.AnyAsync());
}
}
public async Task ServiceBus_PublishIntegrationEventsAsyncInvokesSerializeOnIMessageSerializer()
{
var @event = new FakeIntegrationEvent("Fake Value");
var options = SetupContext();
using (var context = new InfrastructureContext(options))
{
var mockSerializer = new Mock <IMessageSerializer>();
var sut = new ServiceBus(mockSerializer.Object,
Mock.Of <IHttpContextAccessor>(),
Mock.Of <IQueueClient>(),
Mock.Of <ITopicClient>(),
Mock.Of <ILogger>(),
context);
await sut.PublishEventsAsync(@event);
mockSerializer.Verify(s => s.Serialize <IntegrationEvent>(@event));
}
}
public EfNotificationRepository(InfrastructureContext context)
{
_context = context;
}
