public void Setup()
{
var updateStorage = new InMemoryDbUpdateStorage();
this.readStorage = updateStorage;
ValidationOrderDenormilizer denormilizer = new ValidationOrderDenormilizer(updateStorage, new EmptyLogger());
denormilizer.Consume(new OrderValidatedByManager(managerId, orderId, "Max Cole"));
}
public PolicyRuleExecutor(
[NotNull] ILog log,
[NotNull] IQueryStorage queryStorage,
[NotNull] IQueryExecutor queryExecutor,
[NotNull] IUserPrincipal userPrincipal)
{
if (log == null)
{
throw new ArgumentNullException(nameof(log));
}
if (queryStorage == null)
{
throw new ArgumentNullException(nameof(queryStorage));
}
if (queryExecutor == null)
{
throw new ArgumentNullException(nameof(queryExecutor));
}
if (userPrincipal == null)
{
throw new ArgumentNullException(nameof(userPrincipal));
}
_queryStorage = queryStorage;
_queryExecutor = queryExecutor;
_userPrincipal = userPrincipal;
_log = log;
}
public void Setup()
{
var updateStorage = new InMemoryDbUpdateStorage();
this.readStorage = updateStorage;
OrderAcceptedDenormalizer denormalizer = new OrderAcceptedDenormalizer(updateStorage, new EmptyLogger());
denormalizer.Consume(new OrderAccepted(orderId, "fake order"));
}
public PersonsStorage(ILogger logger, IDomainFactory domainFactory,
IEventStreamStorage <PersonAggregate> eventStreamStorage,
IRepository repository)
{
this.queryStorage = new GeneralQueryStorage <Person>(logger, domainFactory, repository);
this.eventingStorage = eventStreamStorage;
}
public void Setup()
{
var updateStorage = new InMemoryDbUpdateStorage();
this.readStorage = updateStorage;
ManagerInfoDenormalizer denormalizer = new ManagerInfoDenormalizer(updateStorage);
denormalizer.Consume(new ManagerCreated(managerId, "Max", "Cole"));
}
public PersonStorage(IEventStreamStorage <PersonEntity> eventingStorage, IQueryStorage <Person> queryStorage)
{
queryStorage.GuardAgainstNull(nameof(queryStorage));
eventingStorage.GuardAgainstNull(nameof(eventingStorage));
this.queryStorage = queryStorage;
this.eventingStorage = eventingStorage;
}
public PersonStorage(IRecorder recorder, IDomainFactory domainFactory,
IEventStreamStorage <PersonEntity> eventStreamStorage,
IRepository repository)
{
this.queryStorage = new GeneralQueryStorage <Person>(recorder, domainFactory, repository);
this.eventingStorage = eventStreamStorage;
}
public UpdateQueryCommandHandler([NotNull] IQueryStorage queryStorage)
{
if (queryStorage == null)
{
throw new ArgumentNullException(nameof(queryStorage));
}
_queryStorage = queryStorage;
}
public QueryByNameQueryHandler([NotNull] IQueryStorage queryStorage)
{
if (queryStorage == null)
{
throw new ArgumentNullException(nameof(queryStorage));
}
_queryStorage = queryStorage;
}
public ClinicStorage(IEventStreamStorage <ClinicEntity> clinicEventStreamStorage,
IQueryStorage <Doctor> doctorQueryStorage,
IQueryStorage <Unavailability> unavailabilitiesQueryStorage)
{
doctorQueryStorage.GuardAgainstNull(nameof(doctorQueryStorage));
clinicEventStreamStorage.GuardAgainstNull(nameof(clinicEventStreamStorage));
unavailabilitiesQueryStorage.GuardAgainstNull(nameof(unavailabilitiesQueryStorage));
this.doctorQueryStorage = doctorQueryStorage;
this.clinicEventStreamStorage = clinicEventStreamStorage;
this.unavailabilitiesQueryStorage = unavailabilitiesQueryStorage;
}
public CarStorage(IEventStreamStorage <CarEntity> carEventStreamStorage,
IQueryStorage <Car> carQueryStorage,
IQueryStorage <Unavailability> unavailabilitiesQueryStorage)
{
carQueryStorage.GuardAgainstNull(nameof(carQueryStorage));
carEventStreamStorage.GuardAgainstNull(nameof(carEventStreamStorage));
unavailabilitiesQueryStorage.GuardAgainstNull(nameof(unavailabilitiesQueryStorage));
this.carQueryStorage = carQueryStorage;
this.carEventStreamStorage = carEventStreamStorage;
this.unavailabilitiesQueryStorage = unavailabilitiesQueryStorage;
}
public CarStorage(IRecorder recorder, IDomainFactory domainFactory,
IEventStreamStorage <CarEntity> eventStreamStorage,
IRepository repository)
{
recorder.GuardAgainstNull(nameof(recorder));
domainFactory.GuardAgainstNull(nameof(domainFactory));
eventStreamStorage.GuardAgainstNull(nameof(eventStreamStorage));
repository.GuardAgainstNull(nameof(repository));
this.carQueryStorage = new GeneralQueryStorage <Car>(recorder, domainFactory, repository);
this.carEventStreamStorage = eventStreamStorage;
this.unavailabilitiesQueryStorage =
new GeneralQueryStorage <Unavailability>(recorder, domainFactory, repository);
}
public ClinicStorage(ILogger logger, IDomainFactory domainFactory,
IEventStreamStorage <ClinicEntity> eventStreamStorage,
IRepository repository)
{
logger.GuardAgainstNull(nameof(logger));
domainFactory.GuardAgainstNull(nameof(domainFactory));
eventStreamStorage.GuardAgainstNull(nameof(eventStreamStorage));
repository.GuardAgainstNull(nameof(repository));
this.doctorQueryStorage = new GeneralQueryStorage <Doctor>(logger, domainFactory, repository);
this.clinicEventStreamStorage = eventStreamStorage;
this.unavailabilitiesQueryStorage =
new GeneralQueryStorage <Unavailability>(logger, domainFactory, repository);
}
public static void InitializeAllTests(TestContext context)
{
webHost = WebHost.CreateDefaultBuilder(null)
.UseModularStartup <TestStartup>()
.UseUrls(ServiceUrl)
.UseKestrel()
.ConfigureLogging((ctx, builder) => builder.AddConsole())
.Build();
webHost.Start();
var container = HostContext.Container;
personQueryStorage = container.Resolve <IQueryStorage <Person> >();
personEventingStorage = container.Resolve <IEventStreamStorage <PersonAggregate> >();
}
public void Setup()
{
var updateStorage = new InMemoryDbUpdateStorage();
updateStorage.Add(new OrderInProgress()
{
OrderId = orderId.ToString(),
Description = "fake order",
ProductName = "fake_product",
Price = 1,
Quantity = 10,
TotalAmount = 10
});
this.readStorage = updateStorage;
OrderInProgressDenormilizer denormilizer = new OrderInProgressDenormilizer(updateStorage, new EmptyLogger());
denormilizer.Consume(new OrderRejected(orderId, "fake order", "order is not valid!"));
}
public static void InitializeAllTests(TestContext context)
{
webHost = WebHost.CreateDefaultBuilder(null)
.UseModularStartup <TestStartup>()
.UseUrls(ServiceUrl)
.UseKestrel()
.ConfigureLogging((ctx, builder) => builder.AddConsole())
.Build();
webHost.Start();
var container = HostContext.Container;
doctorQueryStorage = container.Resolve <IQueryStorage <Doctor> >();
unavailabilityQueryStorage = container.Resolve <IQueryStorage <Unavailability> >();
clinicEventingStorage = container.Resolve <IEventStreamStorage <ClinicEntity> >();
appointmentEventingStorage = container.Resolve <IEventStreamStorage <AppointmentEntity> >();
paymentEventingStorage = container.Resolve <IEventStreamStorage <PaymentEntity> >();
}
public void Setup()
{
this.eventstore = Wireup.Init()
.UsingInMemoryPersistence()
.UsingSynchronousDispatchScheduler()
.DispatchTo(new DelegateMessageDispatcher(c =>
{
c.Events.ForEach(dispatchedEvents.Add);
c.Events.Select(m=>m.Body).ToList().ForEach(bus.Publish);
}))
.Build();
var aggregateRepository = new EventStoreRepository(
eventstore
, new AggregateFactory()
,new ConflictDetector());
var updateStorage = new InMemoryDbUpdateStorage();
this.readStorage = updateStorage;
this.bus = ServiceBusFactory.New(sbc =>
{
sbc.ReceiveFrom("loopback://localhost/test");
sbc.Subscribe(x => x.Consumer(() => new ManagerCommandHandler(aggregateRepository)));
sbc.Subscribe(x => x.Consumer(() => new ManagerInfoDenormalizer(updateStorage)));
});
var createManagerCommand = new CreateManager(managerId, "Max", "Cole");
bus.Publish(createManagerCommand);
TaskManager taskManager = new TaskManager(TimeSpan.FromMilliseconds(500));
taskManager.
When(() => this.readStorage.Items<ManagerInfo>().Any()).
Then(()=>this.sync.Set());
this.sync.WaitOne(TimeSpan.FromSeconds(5));
}
public void Setup()
{
var updateStorage = new InMemoryDbUpdateStorage();
this.readStorage = updateStorage;
OrderInProgressDenormilizer denormilizer = new OrderInProgressDenormilizer(updateStorage, new EmptyLogger());
denormilizer.Consume(new OrderPlaced(orderId, "fake order", "fake_product", 1, 10));
}
public PersonController(IQueryStorage store, ISendMessages bus)
{
this.store = store;
this.bus = bus;
}
public PersonQueryService(IQueryStorage storage)
{
this.storage = storage;
}
public PersonController(IQueryStorage store, ISendMessages bus)
{
this.store = store;
this.bus = bus;
}
public Handler(IQueryStorage queryStorage, IGraphQlQueryExecutor graphQlQueryExecutor)
{
_queryStorage = queryStorage;
_graphQlQueryExecutor = graphQlQueryExecutor;
}
public PersonQueryService(IQueryStorage storage)
{
this.storage = storage;
}
public ReadModel(IQueryStorage storage)
{
if (storage == null) throw new ArgumentNullException("storage");
this.storage = storage;
}
