public ProductCommandHandlers(
GetStreamName getStreamName,
AsyncRepository <Product> repository,
AsyncSnapshotableRepository <Product> snapshotableRepository,
Now now) : base(getStreamName, repository, snapshotableRepository, now)
{
}
public async Task SetUp()
{
await EmbeddedEventStore.Connection.DeleteAllStreamsAsync();
_model = new Model();
_sut = new RepositoryScenarioBuilder().BuildForAsyncRepository();
}
public async void GivenObjectsNotInDatabase_AddRangeOfObjectsAsync()
{
var options = new DbContextOptionsBuilder <TestContext>()
.UseInMemoryDatabase(Helper.GetCallerName())
.Options;
var objectsToAdd = new[]
{
new TestObject(name: "Test1"),
new TestObject(name: "Test2"),
new TestObject(name: "Test3"),
new TestObject(name: "Test4")
};
using (var context = new TestContext(options))
{
var repository = new AsyncRepository <TestObject>(context);
await repository.AddRangeAsync(objectsToAdd);
}
using (var context = new TestContext(options))
{
var addedObjectNames = objectsToAdd.Select(o => o.Name);
context.TestObjects
.Select(testObject => testObject.Name)
.All(name => addedObjectNames.Contains(name))
.Should()
.BeTrue();
}
}
public async void GivenObjectIsNotSaved_ItShouldNotGetSavedByOtherSavesAsync()
{
var options = new DbContextOptionsBuilder <TestContext>()
.UseInMemoryDatabase(Helper.GetCallerName())
.Options;
var seedData = options.EnsureSeeded();
var seedObject = seedData.First();
using (var context = new TestContext(options))
{
var repository = new AsyncRepository <TestObject>(context);
var list = await repository.ListAsync(o => o.Id.Equals(seedObject.Id));
var testObject = list.First();
testObject.Name = "ChangedName";
var otherList = await repository.ListAsync(o => !o.Id.Equals(seedObject.Id));
// Potentially saves all tracked objects
await repository.EditAsync(otherList.First());
}
using (var context = new TestContext(options))
{
var repository = new AsyncRepository <TestObject>(context);
var list = await repository.ListAsync(o => o.Id.Equals(seedObject.Id));
var testObject = list.First();
testObject.Name.Should().NotBe("ChangedName");
}
}
public void SetUp()
{
EmbeddedEventStore.Instance.Connection.DeleteAllStreams();
_model = new Model();
_sut = new RepositoryScenarioBuilder().
ScheduleAppendToStream(_model.KnownIdentifier, new EventStub(1)).
BuildForAsyncRepository();
}
public void SetUp()
{
EmbeddedEventStore.Instance.Connection.DeleteAllStreams();
_model = new Model();
_root = AggregateRootEntityStub.Factory();
_sut = new RepositoryScenarioBuilder().
ScheduleAttachToUnitOfWork(new Aggregate(_model.KnownIdentifier, 0, _root)).
BuildForAsyncRepository();
}
public async Task SetUp()
{
await EmbeddedEventStore.Connection.DeleteAllStreamsAsync();
_model = new Model();
_sut = new RepositoryScenarioBuilder().
ScheduleAppendToStream(_model.KnownIdentifier, new EventStub(1)).
ScheduleDeleteStream(_model.KnownIdentifier).
BuildForAsyncRepository();
}
public CommandHandlerBase(
GetStreamName getStreamName,
AsyncRepository <T> repository,
AsyncSnapshotableRepository <T> snapshotableRepository,
Now now)
{
_repository = repository;
_now = now;
_getStreamName = getStreamName;
_snapshotableRepository = snapshotableRepository;
}
public async void GivenDatabaseIsEmpty_ItShouldReturnEmptyListAsync()
{
var options = new DbContextOptionsBuilder <TestContext>()
.UseInMemoryDatabase(Helper.GetCallerName())
.Options;
using (var context = new TestContext(options))
{
var repository = new AsyncRepository <TestObject>(context);
(await repository.ListAsync()).Should().BeEmpty();
}
}
public async Task BasicCrud()
{
using (var trans = DataSource.BeginTransaction())
{
var repo = new AsyncRepository<Employee, int>(trans, EmployeeTableName);
var emp1 = new Employee() { FirstName = "Tom", LastName = "Jones", Title = "President" };
var echo1 = await repo.InsertAsync(emp1);
Assert.AreNotEqual(0, echo1.EmployeeKey, "EmployeeKey was not set");
Assert.AreEqual(emp1.FirstName, echo1.FirstName, "FirstName");
Assert.AreEqual(emp1.LastName, echo1.LastName, "LastName");
Assert.AreEqual(emp1.Title, echo1.Title, "Title");
echo1.MiddleName = "G";
await repo.UpdateAsync(echo1);
var emp2 = new Employee() { FirstName = "Lisa", LastName = "Green", Title = "VP Transportation", ManagerKey = echo1.EmployeeKey };
var echo2 = await repo.InsertAsync(emp2);
Assert.AreNotEqual(0, echo2.EmployeeKey, "EmployeeKey was not set");
Assert.AreEqual(emp2.FirstName, echo2.FirstName, "FirstName");
Assert.AreEqual(emp2.LastName, echo2.LastName, "LastName");
Assert.AreEqual(emp2.Title, echo2.Title, "Title");
Assert.AreEqual(emp2.ManagerKey, echo2.ManagerKey, "ManagerKey");
var list = await repo.GetAllAsync();
Assert.IsTrue(list.Any(e => e.EmployeeKey == echo1.EmployeeKey), "Employee 1 is missing");
Assert.IsTrue(list.Any(e => e.EmployeeKey == echo2.EmployeeKey), "Employee 2 is missing");
var get1 = await repo.GetAsync(echo1.EmployeeKey.Value);
Assert.AreEqual(echo1.EmployeeKey, get1.EmployeeKey);
var whereSearch1 = await repo.QueryAsync("FirstName = @FN", new { FN = "Tom" });
Assert.IsTrue(whereSearch1.Any(x => x.EmployeeKey == echo1.EmployeeKey), "Emp1 should have been returned");
Assert.IsTrue(whereSearch1.All(x => x.FirstName == "Tom"), "Checking for incorrect return values");
var whereSearch2 = await repo.QueryAsync(new { FirstName = "Tom" });
Assert.IsTrue(whereSearch2.Any(x => x.EmployeeKey == echo1.EmployeeKey), "Emp1 should have been returned");
Assert.IsTrue(whereSearch2.All(x => x.FirstName == "Tom"), "Checking for incorrect return values");
await repo.DeleteAsync(echo2.EmployeeKey.Value);
await repo.DeleteAsync(echo1.EmployeeKey.Value);
var list2 = await repo.GetAllAsync();
Assert.AreEqual(list.Count - 2, list2.Count);
}
}
public async Task InsertWithDictionary()
{
var repo = new AsyncRepository<Employee, int>(DataSource, EmployeeTableName);
var emp1 = new Dictionary<string, object>() { { "FirstName", "Tom" }, { "LastName", "Jones" }, { "Title", "President" } };
var echo1 = await repo.InsertAsync(emp1);
Assert.AreNotEqual(0, echo1.EmployeeKey, "EmployeeKey was not set");
Assert.AreEqual(emp1["FirstName"], echo1.FirstName, "FirstName");
Assert.AreEqual(emp1["LastName"], echo1.LastName, "LastName");
Assert.AreEqual(emp1["Title"], echo1.Title, "Title");
await repo.DeleteAsync(echo1.EmployeeKey.Value);
}
public async void GivenDatabaseHasNoObjects_ItShouldReturnNullByIdAsync()
{
var options = new DbContextOptionsBuilder <TestContext>()
.UseInMemoryDatabase(Helper.GetCallerName())
.Options;
TestObject foundObject;
using (var context = new TestContext(options))
{
var repository = new AsyncRepository <TestObject>(context);
foundObject = await repository.GetByIdAsync(0);
}
foundObject.Should().BeNull();
}
public async void GivenDatabaseContainsObjects_ItShouldReturnAllBySpecificationAsync()
{
var options = new DbContextOptionsBuilder <TestContext>()
.UseInMemoryDatabase(Helper.GetCallerName())
.Options;
var seedData = options.EnsureSeeded();
IList <TestObject> returnedList;
using (var context = new TestContext(options))
{
var repository = new AsyncRepository <TestObject>(context);
returnedList = await repository.ListAsync(new EmptySpecification <TestObject>(o => true));
}
returnedList.Should().BeEquivalentTo(seedData);
}
public void GivenRemovingEntityNotInStore_ItShouldThrowWhenAwaiting()
{
var options = new DbContextOptionsBuilder <TestContext>()
.UseInMemoryDatabase(Helper.GetCallerName())
.Options;
using (var context = new TestContext(options))
{
var repository = new AsyncRepository <TestObject>(context);
repository.DeleteAsync(new TestObject())
.GetAwaiter()
.Invoking(awaiter => awaiter.GetResult())
.Should().Throw <DbUpdateConcurrencyException>()
.WithMessage("Attempted to update or delete an entity that does not exist in the store.");
}
}
public async void GivenDatabaseHasObjects_ItShouldReturnOneByIdAsync()
{
var options = new DbContextOptionsBuilder <TestContext>()
.UseInMemoryDatabase(Helper.GetCallerName())
.Options;
var seedData = options.EnsureSeeded();
var expectedObject = seedData[0];
TestObject foundObject;
using (var context = new TestContext(options))
{
var repository = new AsyncRepository <TestObject>(context);
foundObject = await repository.GetByIdAsync(expectedObject.Id);
}
foundObject.Should().BeEquivalentTo(expectedObject);
}
public async void GivenDatabaseContainsObjects_ItShouldReturnOnlyObjectsWithAThreeInTheNameAsync()
{
var options = new DbContextOptionsBuilder <TestContext>()
.UseInMemoryDatabase(Helper.GetCallerName())
.Options;
options.EnsureSeeded();
IList <TestObject> returnedList;
using (var context = new TestContext(options))
{
var repository = new AsyncRepository <TestObject>(context);
returnedList = await repository.ListAsync(o => o.Name.Contains("3"));
}
returnedList.Should()
.OnlyContain(o => o.Name.Contains("3"));
}
public async void GivenListByMultipleCriteria_ItShouldReturnObjectsMeetingCriteriaAsync()
{
var options = new DbContextOptionsBuilder <TestContext>()
.UseInMemoryDatabase(Helper.GetCallerName())
.Options;
var seedData = options.EnsureSeeded();
var searchingObject = seedData.First();
IList <TestObject> returnedList;
using (var context = new TestContext(options))
{
var repository = new AsyncRepository <TestObject>(context);
returnedList = await repository.ListAsync(o =>
o.Id.Equals(searchingObject.Id) && o.Name.Equals(searchingObject.Name));
}
returnedList.Should()
.ContainSingle(o => o.Id.Equals(searchingObject.Id) && o.Name.Equals(searchingObject.Name));
}
public async void GivenDeleteZero_ItShouldRemoveFirstObjectAsync()
{
var options = new DbContextOptionsBuilder <TestContext>()
.UseInMemoryDatabase(Helper.GetCallerName())
.Options;
var seedData = options.EnsureSeeded();
using (var context = new TestContext(options))
{
var repository = new AsyncRepository <TestObject>(context);
await repository.DeleteAsync(seedData[0]);
}
using (var context = new TestContext(options))
{
var foundObject = context.TestObjects.Find(seedData[0].Id);
foundObject.Should().BeNull();
}
}
public async void GivenDatabaseDoesNotContainObject_ItShouldAddAnObjectAsync()
{
var options = new DbContextOptionsBuilder <TestContext>()
.UseInMemoryDatabase(Helper.GetCallerName())
.Options;
TestObject addedObject;
using (var context = new TestContext(options))
{
var repository = new AsyncRepository <TestObject>(context);
addedObject = await repository.AddAsync(new TestObject { Name = "Test" });
}
using (var context = new TestContext(options))
{
var returnedObject = context.TestObjects.Find(addedObject.Id);
addedObject.Should().NotBeNull("an object should be added");
returnedObject.Should().BeEquivalentTo(addedObject);
}
}
private async Task InitProjections()
{
IEventStoreConnection esConnection = await GetEsConnection();
Func <IBucket> getBucket = GetCouchbaseBucket();
Func <string, Task <Aggregate> > getProductAggregate = async streamId =>
{
var defaultSerializer = new DefaultEventDeserializer();
var concurrentUnitOfWork = new ConcurrentUnitOfWork();
var productRepository = new AsyncRepository <Product>(
Product.Factory,
concurrentUnitOfWork,
esConnection,
new EventReaderConfiguration(
new SliceSize(500),
defaultSerializer,
new TypedStreamNameResolver(typeof(Product), s_sGetStreamName),
new NoStreamUserCredentialsResolver()));
await productRepository.GetAsync(streamId);
return(concurrentUnitOfWork.GetChanges().First());
};
await ProjectionManagerBuilder.With
.Connection(esConnection)
.Deserializer(new DefaultEventDeserializer())
.CheckpointStore(new CouchbaseCheckpointStore(getBucket))
.Snaphotter(
new EventStoreSnapshotter <Aggregate, ProductSnapshot>(
getProductAggregate,
() => esConnection,
e => e.Event.EventNumber > 0 && e.Event.EventNumber % 5 == 0,
stream => $"{stream}-Snapshot",
s_sNow))
.Projections(
ProjectorDefiner.For <ProductProjection>()
).Activate(getBucket);
}
public async void GivenObjectContainedInDatabaseIsEdited_ItShouldBePersistedAsync()
{
var options = new DbContextOptionsBuilder <TestContext>()
.UseInMemoryDatabase(Helper.GetCallerName())
.Options;
var seedData = options.EnsureSeeded();
var changedObject = seedData[0];
using (var context = new TestContext(options))
{
var repository = new AsyncRepository <TestObject>(context);
changedObject.Name = "EditedObject";
await repository.EditAsync(changedObject);
}
using (var context = new TestContext(options))
{
var foundObject = context.Find <TestObject>(changedObject.Id);
foundObject.Should().BeEquivalentTo(changedObject);
}
}
public async void GivenDatabaseContainsSameObject_ItShouldReplaceTheObjectAsync()
{
var options = new DbContextOptionsBuilder <TestContext>()
.UseInMemoryDatabase(Helper.GetCallerName())
.Options;
var addedEntity = new TestObject(id: 1, name: "TestObject");
TestObject actualEntity;
using (var context = new TestContext(options))
{
context.Add(addedEntity);
}
using (var context = new TestContext(options))
{
var newEntity = new TestObject(id: 1, name: "NewTestObject");
var repository = new AsyncRepository <TestObject>(context);
actualEntity = await repository.AddAsync(newEntity);
}
actualEntity.Should().BeEquivalentTo(new TestObject(1, "NewTestObject"));
}
public DefiningExportsMessageHandlersMarten(AsyncRepository <ExportDefinition> repository)
{
_repository = repository;
}
public async Task SetUp()
{
await EmbeddedEventStore.Connection.DeleteAllStreamsAsync();
_model = new Model();
_sut = new RepositoryScenarioBuilder().BuildForAsyncRepository();
}
public async Task SetUp()
{
await EmbeddedEventStore.Connection.DeleteAllStreamsAsync();
_model = new Model();
_sut = new RepositoryScenarioBuilder().
ScheduleAppendToStream(_model.KnownIdentifier, new EventStub(1)).
ScheduleDeleteStream(_model.KnownIdentifier).
BuildForAsyncRepository();
}
public async Task SetUp()
{
await EmbeddedEventStore.Connection.DeleteAllStreamsAsync();
_model = new Model();
_root = AggregateRootEntityStub.Factory();
_sut = new RepositoryScenarioBuilder().
ScheduleAttachToUnitOfWork(new Aggregate(_model.KnownIdentifier, 0, _root)).
BuildForAsyncRepository();
}
public static async Task AddWhen <T>(this AsyncRepository <T> repo, T aggregate, Now now, Func <T, AsyncRepository <T>, Task> when) where T : IAggregateRootEntity
{
await when(aggregate, repo);
await AppendToStream <T>(repo.UnitOfWork, repo.Connection, now, repo.Configuration.StreamNameResolver);
}
public ProductIntegrationTestBase()
{
var esConnection = Defaults
.GetEsConnection("admin", "changeit", "tcp://*****:*****@127.0.0.1:1113").GetAwaiter().GetResult();
_getBucket = Defaults.GetCouchbaseBucket(nameof(ProductContext), "Administrator", "password",
"http://localhost:8091");
var services = new ServiceCollection();
services.AddMediatR(typeof(ProductCommandHandlers).Assembly);
services.AddMediatR(typeof(ProductCommandHandlers).Assembly);
services.AddSingleton(p => esConnection);
services.AddTransient <IEventDeserializer, DefaultEventDeserializer>();
services.AddScoped <ConcurrentUnitOfWork>();
services.AddScoped <AsyncRepository <Product> >();
services.AddTransient(p => new EventReaderConfiguration(
new SliceSize(500),
p.GetService <IEventDeserializer>(),
new TypedStreamNameResolver(typeof(Product),
p.GetService <GetStreamName>()),
new NoStreamUserCredentialsResolver()));
services.AddScoped <AsyncSnapshotableRepository <Product> >();
services.AddTransient <IAsyncSnapshotReader, AsyncSnapshotReader>();
services.AddTransient(p => new SnapshotReaderConfiguration(
new DefaultSnapshotDeserializer(),
new SnapshotableStreamNameResolver(typeof(Product),
p.GetService <GetSnapshotStreamName>()),
new NoStreamUserCredentialsResolver()));
services.AddSingleton(s_getStreamName);
services.AddSingleton(s_getSnapshotStreamName);
services.AddSingleton(s_now);
services.AddTransient(provider => Product.Factory);
_serviceProvider = services.BuildServiceProvider();
Mediator = The <IMediator>();
Func <string, Task <Aggregate> > getProductAggregate = async streamId =>
{
var productRepository = new AsyncRepository <Product>(
Product.Factory,
new ConcurrentUnitOfWork(),
esConnection,
new EventReaderConfiguration(
new SliceSize(500),
new DefaultEventDeserializer(),
new PassThroughStreamNameResolver(),
new NoStreamUserCredentialsResolver()));
await productRepository.GetAsync(streamId);
productRepository.UnitOfWork.TryGet(streamId, out var aggregate);
return(aggregate);
};
ProjectionManagerBuilder.With
.Connection(esConnection)
.Deserializer(new DefaultEventDeserializer())
.CheckpointStore(new CouchbaseCheckpointStore(_getBucket))
.Snaphotter(
new EventStoreSnapshotter <Aggregate, ProductSnapshot>(
getProductAggregate,
() => esConnection,
e => e.Event.EventNumber > 0 && e.Event.EventNumber % 1 == 0,
stream => $"{stream}-Snapshot",
s_now
)
)
.Projections(
ProjectorDefiner.For <ProductProjection>()
).Activate(_getBucket).GetAwaiter().GetResult();
}
static void Main()
{
var store = DocumentStore.For(_ =>
{
_.Connection("host=localhost; database=event_store; password=postgres; username=postgres");
_.Events.StreamIdentity = StreamIdentity.AsString;
//.._.Events.AsyncProjections.AggregateStreamsWith<ExportDefinition>();
});
//using (var session = store.OpenSession())
//{
// // questId is the id of the stream
// var party = session.Events.AggregateStream<ExportDefinition>("5307eb1f-ed92-44dd-b7d4-1cca35da3fc5");
// Console.WriteLine(party);
// //var party_at_version_3 = session.Events
// // .AggregateStream<QuestParty>(questId, 3);
// //var party_yesterday = session.Events
// // .AggregateStream<QuestParty>(questId, timestamp: DateTime.UtcNow.AddDays(-1));
//}
//var id = new Guid("5307eb1f-ed92-44dd-b7d4-1cca35da3fc5");
var id = Guid.NewGuid();
var aggId = $@"ed-{id}";
using (var unitOfWork = new UnitOfTwerk(store.OpenSession()))
{
var bus = new InMemoryBus.InMemoryBus("bus");
var exportDefinitionRepo =
new AsyncRepository <ExportDefinition>(ExportDefinition.Factory, unitOfWork);
var definingExportsMessageHandlersMartenHandler = new DefiningExportsMessageHandlersMarten(exportDefinitionRepo);
bus.Subscribe <CreateExportDefinition>(definingExportsMessageHandlersMartenHandler);
bus.Subscribe <AddExportRowToExportDefinition>(definingExportsMessageHandlersMartenHandler);
bus.PublishAsync(new CreateExportDefinition(id, "newest ed")).Wait();
bus.PublishAsync(new AddExportRowToExportDefinition(id, "11 row")).Wait();
bus.PublishAsync(new AddExportRowToExportDefinition(id, "again row")).Wait();
unitOfWork.SaveChanges();
}
using (var session = store.OpenSession())
{
// events are an array of little IEvent objects
// that contain both the actual event object captured
// previously and metadata like the Id and stream version
//var events = session.Events.FetchStream("99ca96f2-a277-43c2-8af5-308189ef69fa");
var events = session.Events.FetchStream(aggId);
events.Each(evt =>
{
Console.WriteLine($"{evt.Version}.) {evt.Data}");
});
var party_at_version_3 = session.Events
.AggregateStream <ExportDefinition>(aggId, 3);
}
Console.ReadLine();
}
public ProductCommandHandlers(Now now, AsyncRepository <Product> repository)
{
_now = now;
_repository = repository;
}
public async Task UpdateWithDictionary()
{
using (var trans = DataSource.BeginTransaction())
{
var repo = new AsyncRepository<Employee, int>(trans, EmployeeTableName);
var emp1 = new Dictionary<string, object>() { { "FirstName", "Tom" }, { "LastName", "Jones" }, { "Title", "President" } };
var echo1 = await repo.InsertAsync(emp1);
Assert.AreNotEqual(0, echo1.EmployeeKey, "EmployeeKey was not set");
Assert.AreEqual(emp1["FirstName"], echo1.FirstName, "FirstName");
Assert.AreEqual(emp1["LastName"], echo1.LastName, "LastName");
Assert.AreEqual(emp1["Title"], echo1.Title, "Title");
var emp2 = new Dictionary<string, object>() { { "EmployeeKey", echo1.EmployeeKey }, { "LastName", "Brown" } };
await repo.UpdateAsync(emp2);
var echo2 = await repo.GetAsync(echo1.EmployeeKey.Value);
//these were changed
Assert.AreEqual(echo1.EmployeeKey, echo2.EmployeeKey, "EmployeeKey was not set");
Assert.AreEqual(emp2["LastName"], echo2.LastName, "LastName");
//these should be unchanged
Assert.AreEqual(emp1["FirstName"], echo2.FirstName, "FirstName");
Assert.AreEqual(emp1["Title"], echo2.Title, "Title");
await repo.DeleteAsync(echo1.EmployeeKey.Value);
}
}
static void Run()
{
var store = DocumentStore.For(_ =>
{
_.Connection("host=localhost; database=event_store; password=postgres; username=postgres");
_.Events.StreamIdentity = StreamIdentity.AsString;
});
var gen = new PersonNameGenerator();
Console.WriteLine("CQRS Test Harness. Type exit to quit.");
while (true)
{
Console.WriteLine("Enter a code to add more lines to an existing or enter to create a new object:");
var userInput = Console.ReadLine();
if (userInput == "exit")
{
break;
}
var isCreate = false;
if (Guid.TryParse(userInput, out var id) == false)
{
Console.WriteLine("No code input, creating new...");
id = Guid.NewGuid();
isCreate = true;
}
using (var unitOfWork = new UnitOfTwerk(store.OpenSession()))
{
var bus = new InMemoryBus.InMemoryBus("bus");
var exportDefinitionRepo =
new AsyncRepository <ExportDefinition>(ExportDefinition.Factory, unitOfWork);
var definingExportsMessageHandlersMartenHandler = new DefiningExportsMessageHandlersMarten(exportDefinitionRepo);
bus.Subscribe <CreateExportDefinition>(definingExportsMessageHandlersMartenHandler);
bus.Subscribe <AddExportRowToExportDefinition>(definingExportsMessageHandlersMartenHandler);
if (isCreate)
{
bus.PublishAsync(new CreateExportDefinition(id, gen.GenerateRandomLastName())).Wait();
}
bus.PublishAsync(new AddExportRowToExportDefinition(id, gen.GenerateRandomLastName())).Wait();
bus.PublishAsync(new AddExportRowToExportDefinition(id, gen.GenerateRandomLastName())).Wait();
unitOfWork.CommitChanges();
}
using (var session = store.OpenSession())
{
// events are an array of little IEvent objects
// that contain both the actual event object captured
// previously and metadata like the Id and stream version
//var events = session.Events.FetchStream("99ca96f2-a277-43c2-8af5-308189ef69fa");
var events = session.Events.FetchStream($@"ed-{id}");
events.Each(evt =>
{
Console.WriteLine($"{evt.Version}.) {evt.Data}");
});
}
}
}
public void SetUp()
{
EmbeddedEventStore.Connection.DeleteAllStreams();
_model = new Model();
_sut = new RepositoryScenarioBuilder().BuildForAsyncRepository();
}
public void SetUp()
{
EmbeddedEventStore.Instance.Connection.DeleteAllStreams();
_model = new Model();
_sut = new RepositoryScenarioBuilder().BuildForAsyncRepository();
}
protected async Task InitializeFixture()
{
var nodeBuilder = EmbeddedVNodeBuilder.AsSingleNode()
.OnDefaultEndpoints()
.RunInMemory();
var node = nodeBuilder.Build();
var ready = await node.StartAsync(true);
var connection = EmbeddedEventStoreConnection.Create(ready);
//var esConnection = await Defaults.GetEsConnection("admin", "changeit", "tcp://*****:*****@127.0.0.1:1113");
var esConnection = connection;
_getBucket = Defaults.GetCouchbaseBucket(nameof(ProductContext), "Administrator", "password", "http://localhost:8091");
var services = new ServiceCollection();
services.AddMediatR(typeof(ProductCommandHandlers).Assembly);
services.AddSingleton(p => esConnection);
services.AddTransient <IEventDeserializer, DefaultEventDeserializer>();
services.AddTransient <ConcurrentUnitOfWork>();
services.AddTransient <AsyncRepository <Product> >();
services.AddTransient <AsyncSnapshotableRepository <Product> >();
services.AddTransient <IAsyncSnapshotReader, AsyncSnapshotReader>();
services.AddSingleton(s_getStreamName);
services.AddSingleton(s_getSnapshotStreamName);
services.AddSingleton(s_now);
services.AddTransient(provider => Product.Factory);
services.AddTransient(p => new SnapshotReaderConfiguration(
new DefaultSnapshotDeserializer(),
new SnapshotableStreamNameResolver(typeof(Product),
p.GetService <GetSnapshotStreamName>()),
new NoStreamUserCredentialsResolver()));
services.AddTransient(p => new EventReaderConfiguration(
new SliceSize(500),
p.GetService <IEventDeserializer>(),
new TypedStreamNameResolver(typeof(Product),
p.GetService <GetStreamName>()),
new NoStreamUserCredentialsResolver()));
_serviceProvider = services.BuildServiceProvider();
Mediator = The <IMediator>();
async Task <Aggregate> GetProductAggregate(string streamId)
{
var productRepository = new AsyncRepository <Product>(
Product.Factory, new ConcurrentUnitOfWork(),
esConnection, new EventReaderConfiguration(new SliceSize(500),
new DefaultEventDeserializer(),
new PassThroughStreamNameResolver(),
new NoStreamUserCredentialsResolver()));
await productRepository.GetAsync(streamId);
productRepository.UnitOfWork.TryGet(streamId, out Aggregate aggregate);
return(aggregate);
}
await ProjectionManagerBuilder.With
.Connection(esConnection)
.Deserializer(new DefaultEventDeserializer())
.CheckpointStore(new CouchbaseCheckpointStore(_getBucket))
.Snaphotter(
new EventStoreSnapshotter <Aggregate, ProductSnapshot>(
GetProductAggregate,
() => esConnection,
e => e.Event.EventNumber > 0 && e.Event.EventNumber % 1 == 0,
stream => $"{stream}-Snapshot",
s_now
)
)
.Projections(
ProjectorDefiner.For <ProductProjection>()
).Activate(_getBucket);
}
public void SetUp()
{
EmbeddedEventStore.Instance.Connection.DeleteAllStreams();
_model = new Model();
_sut = new RepositoryScenarioBuilder().
ScheduleAppendToStream(_model.KnownIdentifier, new EventStub(1)).
BuildForAsyncRepository();
}
