/// <summary>
/// Initializes a new instance of the <see cref="AsyncRepository{TAggregateRoot}"/> class.
/// </summary>
/// <param name="rootFactory">The aggregate root entity factory.</param>
/// <param name="unitOfWork">The unit of work to interact with.</param>
/// <param name="connection">The event store connection to use.</param>
/// <param name="configuration">The event store configuration to use.</param>
/// <param name="reader">The snapshot reader to use.</param>
/// <exception cref="System.ArgumentNullException">Thrown when the <paramref name="rootFactory"/> or <paramref name="unitOfWork"/> or <paramref name="connection"/> or <paramref name="configuration"/> or <paramref name="reader"/> is null.</exception>
public AsyncSnapshotableRepository(Func <TAggregateRoot> rootFactory, ConcurrentUnitOfWork unitOfWork,
IEventStoreConnection connection, EventReaderConfiguration configuration,
IAsyncSnapshotReader reader)
{
if (rootFactory == null)
{
throw new ArgumentNullException("rootFactory");
}
if (unitOfWork == null)
{
throw new ArgumentNullException("unitOfWork");
}
if (connection == null)
{
throw new ArgumentNullException("connection");
}
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
if (reader == null)
{
throw new ArgumentNullException("reader");
}
_rootFactory = rootFactory;
_unitOfWork = unitOfWork;
_connection = connection;
_configuration = configuration;
_reader = reader;
}
public IdempotentCommandHandlerModuleProcessor(
Func <IAddresses> getAddresses,
ConcurrentUnitOfWork concurrentUnitOfWork,
IPersistentLocalIdGenerator persistentLocalIdGenerator,
Func <IStreamStore> getStreamStore,
EventMapping eventMapping,
EventSerializer eventSerializer,
AddressProvenanceFactory addressProvenanceFactory,
CrabAddressProvenanceFactory crabProvenanceFactory,
AddressPersistentLocalIdentifierProvenanceFactory addressPersistentLocalIdentifierProvenanceFactory)
{
_getAddresses = getAddresses;
_concurrentUnitOfWork = concurrentUnitOfWork;
_provenanceFactory = crabProvenanceFactory.CreateFrom;
_addressPersistentLocalIdProvenanceFactory = addressPersistentLocalIdentifierProvenanceFactory.CreateFrom;
_addressCommandHandlerModule = new AddressCommandHandlerModule(
_getAddresses,
() => concurrentUnitOfWork,
persistentLocalIdGenerator,
getStreamStore,
eventMapping,
eventSerializer,
addressProvenanceFactory,
crabProvenanceFactory,
addressPersistentLocalIdentifierProvenanceFactory);
}
private static async Task AppendToStream <T>(ConcurrentUnitOfWork uow, IEventStoreConnection connection, Now now, IStreamNameResolver getStreamName) where T : IAggregateRootEntity
{
foreach (Aggregate aggregate in uow.GetChanges())
{
EventData[] changes = aggregate.Root.GetChanges()
.Select(@event => new EventData(
Guid.NewGuid(),
@event.GetType().TypeQualifiedName(),
true,
Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(@event)),
Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(new EventMetadata
{
TimeStamp = now(),
AggregateType = typeof(T).Name,
AggregateAssemblyQualifiedName = typeof(T).AssemblyQualifiedName,
IsSnapshot = false
}))
)).ToArray();
try
{
await connection.AppendToStreamAsync(getStreamName.Resolve(aggregate.Identifier), aggregate.ExpectedVersion, changes);
}
catch (WrongExpectedVersionException)
{
StreamEventsSlice page = await connection.ReadStreamEventsBackwardAsync(aggregate.Identifier, -1, 1, false);
throw new WrongExpectedStreamVersionException(
$"Failed to append stream {aggregate.Identifier} with expected version {aggregate.ExpectedVersion}. " +
$"{(page.Status == SliceReadStatus.StreamNotFound ? "Stream not found!" : $"Current Version: {page.LastEventNumber}")}");
}
}
}
public IdempotentCommandHandlerModuleProcessor(
Func <IParcels> getParcels,
IParcelFactory parcelFactory,
ConcurrentUnitOfWork concurrentUnitOfWork,
Func <IStreamStore> getStreamStore,
EventMapping eventMapping,
EventSerializer eventSerializer,
ParcelProvenanceFactory provenanceFactory)
{
_getParcels = getParcels;
_parcelFactory = parcelFactory;
_concurrentUnitOfWork = concurrentUnitOfWork;
_provenanceFactory = provenanceFactory.CreateFrom;
var fixGrar1475ProvenanceFactory = new FixGrar1475ProvenanceFactory();
_fixGrar1475ProvenanceFactory = fixGrar1475ProvenanceFactory.CreateFrom;
var fixGrar1637ProvenanceFactory = new FixGrar1637ProvenanceFactory();
_fixGrar1637ProvenanceFactory = fixGrar1637ProvenanceFactory.CreateFrom;
_parcelCommandHandlerModule = new ParcelCommandHandlerModule(
getParcels,
parcelFactory,
() => concurrentUnitOfWork,
getStreamStore,
eventMapping,
eventSerializer,
provenanceFactory,
fixGrar1475ProvenanceFactory,
fixGrar1637ProvenanceFactory);
}
/// <summary>
/// Initializes a new instance of the <see cref="AsyncRepository{TAggregateRoot}" /> class.
/// </summary>
/// <param name="rootFactory">The aggregate root entity factory.</param>
/// <param name="unitOfWork">The unit of work to interact with.</param>
/// <param name="connection">The event store connection to use.</param>
/// <param name="configuration">The event store configuration to use.</param>
/// <exception cref="System.ArgumentNullException">
/// Thrown when the <paramref name="rootFactory" /> or
/// <paramref name="unitOfWork" /> or <paramref name="connection" /> or <paramref name="configuration" /> is null.
/// </exception>
public AsyncRepository(Func <TAggregateRoot> rootFactory, ConcurrentUnitOfWork unitOfWork,
IEventStoreConnection connection, EventReaderConfiguration configuration)
{
RootFactory = rootFactory ?? throw new ArgumentNullException(nameof(rootFactory));
UnitOfWork = unitOfWork ?? throw new ArgumentNullException(nameof(unitOfWork));
Connection = connection ?? throw new ArgumentNullException(nameof(connection));
Configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
}
public void SetUp()
{
_store = new InMemoryStreamStore(() => DateTime.UtcNow);
_unitOfWork = new ConcurrentUnitOfWork();
_factory = AggregateRootEntityStub.Factory;
_eventDeserializer = new EventDeserializer(SimpleJson.DeserializeObject);
_eventMapping = new EventMapping(new Dictionary <string, Type>());
}
public void SetUp()
{
_connection = EmbeddedEventStore.Instance.Connection;
_reader = AsyncSnapshotReaderFactory.Create();
_configuration = EventReaderConfigurationFactory.Create();
_unitOfWork = new ConcurrentUnitOfWork();
_factory = SnapshotableAggregateRootEntityStub.Factory;
}
public void SetUp()
{
_connection = EmbeddedEventStore.Connection;
_reader = AsyncSnapshotReaderFactory.Create();
_configuration = EventReaderConfigurationFactory.Create();
_unitOfWork = new ConcurrentUnitOfWork();
_factory = SnapshotableAggregateRootEntityStub.Factory;
}
public void Setup()
{
_aggregate1 = AggregateStubs.Create(new ChangedAggregateRootEntityStub());
_aggregate2 = AggregateStubs.Create(new ChangedAggregateRootEntityStub());
_sut = new ConcurrentUnitOfWork();
_sut.Attach(_aggregate1);
_sut.Attach(_aggregate2);
}
public RepositoryScenarioBuilder(EventMapping eventMapping, EventDeserializer eventDeserializer)
{
_eventStore = new InMemoryStreamStore(() => DateTime.UtcNow);
_unitOfWork = new ConcurrentUnitOfWork();
_eventStoreSchedule = new List <Action <IStreamStore> >();
_unitOfWorkSchedule = new List <Action <ConcurrentUnitOfWork> >();
_eventMapping = eventMapping;
_eventDeserializer = eventDeserializer;
}
public Repository(
Func <TAggregateRoot> factory,
ConcurrentUnitOfWork unitOfWork,
IStreamStore eventStore,
EventMapping eventMapping,
EventDeserializer eventDeserializer)
: base(factory, unitOfWork, eventStore, eventMapping, eventDeserializer)
{
}
public RepositoryScenarioBuilder(IStreamStore connection)
{
_unitOfWork = new UnitOfWork();
_connection = connection;
_concurrentUnitOfWork = new ConcurrentUnitOfWork();
_eventStoreSchedule = new List <Action <IStreamStore> >();
_unitOfWorkSchedule = new List <Action <UnitOfWork> >();
_concurrentUnitOfWorkSchedule = new List <Action <ConcurrentUnitOfWork> >();
_deserializer = new EventDeserializer();
}
/// <summary>
/// Initializes a new instance of the <see cref="AsyncRepository{TAggregateRoot}" /> class.
/// </summary>
/// <param name="rootFactory">The aggregate root entity factory.</param>
/// <param name="unitOfWork">The unit of work to interact with.</param>
/// <param name="connection">The event store connection to use.</param>
/// <param name="configuration">The event store configuration to use.</param>
/// <param name="reader">The snapshot reader to use.</param>
/// <exception cref="System.ArgumentNullException">
/// Thrown when the <paramref name="rootFactory" /> or
/// <paramref name="unitOfWork" /> or <paramref name="connection" /> or <paramref name="configuration" /> or
/// <paramref name="reader" /> is null.
/// </exception>
public AsyncSnapshotableRepository(Func <TAggregateRoot> rootFactory, ConcurrentUnitOfWork unitOfWork,
IEventStoreConnection connection, EventReaderConfiguration configuration,
IAsyncSnapshotReader reader)
{
_rootFactory = rootFactory ?? throw new ArgumentNullException(nameof(rootFactory));
_unitOfWork = unitOfWork ?? throw new ArgumentNullException(nameof(unitOfWork));
_connection = connection ?? throw new ArgumentNullException(nameof(connection));
_configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
_reader = reader ?? throw new ArgumentNullException(nameof(reader));
}
public RepositoryScenarioBuilder()
{
_connection = EmbeddedEventStore.Connection;
_unitOfWork = new UnitOfWork();
_concurrentUnitOfWork = new ConcurrentUnitOfWork();
_eventReaderConfiguration = EventReaderConfigurationFactory.Create();
_snapshotReaderConfiguration = SnapshotReaderConfigurationFactory.Create();
_eventStoreSchedule = new List<Action<IEventStoreConnection>>();
_unitOfWorkSchedule = new List<Action<UnitOfWork>>();
_concurrentUnitOfWorkSchedule = new List<Action<ConcurrentUnitOfWork>>();
}
public RepositoryScenarioBuilder()
{
_connection = EmbeddedEventStore.Instance.Connection;
_unitOfWork = new UnitOfWork();
_concurrentUnitOfWork = new ConcurrentUnitOfWork();
_eventReaderConfiguration = EventReaderConfigurationFactory.Create();
_snapshotReaderConfiguration = SnapshotReaderConfigurationFactory.Create();
_eventStoreSchedule = new List <Action <IEventStoreConnection> >();
_unitOfWorkSchedule = new List <Action <UnitOfWork> >();
_concurrentUnitOfWorkSchedule = new List <Action <ConcurrentUnitOfWork> >();
}
public AsyncRepository(
Func <TAggregateRoot> rootFactory,
ConcurrentUnitOfWork unitOfWork,
IStreamStore eventStore,
IEventDeserializer deserializer)
{
RootFactory = rootFactory ?? throw new ArgumentNullException(nameof(rootFactory));
UnitOfWork = unitOfWork ?? throw new ArgumentNullException(nameof(unitOfWork));
EventStore = eventStore ?? throw new ArgumentNullException(nameof(eventStore));
EventDeserializer = deserializer ?? throw new ArgumentNullException(nameof(deserializer));
}
public void SetUp()
{
_model = new Model();
using (var stream = new MemoryStream())
{
using (var writer = new BinaryWriter(stream))
{
new EventStub(1).Write(writer);
}
EmbeddedEventStore.Connection.AppendToStreamAsync(
_model.KnownIdentifier,
ExpectedVersion.NoStream,
new EventData(
Guid.NewGuid(),
typeof(EventStub).AssemblyQualifiedName,
false,
stream.ToArray(),
new byte[0])).Wait();
EmbeddedEventStore.Connection.AppendToStreamAsync(
_model.KnownIdentifier,
ExpectedVersion.Any,
new EventData(
Guid.NewGuid(),
typeof(EventStub).AssemblyQualifiedName,
false,
stream.ToArray(),
new byte[0])).Wait();
}
_root = SnapshotableAggregateRootEntityStub.Factory();
_state = new object();
_unitOfWork = new ConcurrentUnitOfWork();
_resolver = A.Fake <IStreamNameResolver>();
_reader = A.Fake <IAsyncSnapshotReader>();
A.CallTo(() => _resolver.Resolve(_model.KnownIdentifier)).Returns(_model.KnownIdentifier);
A.CallTo(() => _resolver.Resolve(_model.UnknownIdentifier)).Returns(_model.UnknownIdentifier);
A.CallTo(() => _reader.ReadOptionalAsync(_model.KnownIdentifier))
.Returns(Task.FromResult(new Optional <Snapshot>(new Snapshot(1, _state))));
A.CallTo(() => _reader.ReadOptionalAsync(_model.UnknownIdentifier))
.Returns(Task.FromResult(new Optional <Snapshot>(new Snapshot(1, _state))));
_sut = new AsyncSnapshotableRepository <SnapshotableAggregateRootEntityStub>(
() => _root,
_unitOfWork,
EmbeddedEventStore.Connection,
EventReaderConfigurationFactory.CreateWithResolver(_resolver),
_reader);
}
public IdempotentCommandHandlerModuleProcessor(
Func <IStreetNames> getStreetNames,
ConcurrentUnitOfWork concurrentUnitOfWork,
Func <IStreamStore> getStreamStore,
EventMapping eventMapping,
EventSerializer eventSerializer,
StreetNameProvenanceFactory provenanceFactory)
{
_getStreetNames = getStreetNames;
_concurrentUnitOfWork = concurrentUnitOfWork;
_provenanceFactory = provenanceFactory.CreateFrom;
_streetNameCommandHandlerModule = new StreetNameCommandHandlerModule(
getStreetNames,
() => concurrentUnitOfWork,
getStreamStore,
eventMapping,
eventSerializer,
provenanceFactory);
}
public void SetUp()
{
EmbeddedEventStore.Connection.DeleteAllStreams();
_model = new Model();
_unitOfWork = new ConcurrentUnitOfWork();
_resolver = A.Fake <IStreamNameResolver>();
_reader = A.Fake <IAsyncSnapshotReader>();
A.CallTo(() => _resolver.Resolve(_model.KnownIdentifier)).Returns(_model.KnownIdentifier);
A.CallTo(() => _resolver.Resolve(_model.UnknownIdentifier)).Returns(_model.UnknownIdentifier);
A.CallTo(() => _reader.ReadOptionalAsync(_model.KnownIdentifier))
.Returns(Task.FromResult(Optional <Snapshot> .Empty));
A.CallTo(() => _reader.ReadOptionalAsync(_model.UnknownIdentifier))
.Returns(Task.FromResult(Optional <Snapshot> .Empty));
_sut = new AsyncSnapshotableRepository <SnapshotableAggregateRootEntityStub>(
SnapshotableAggregateRootEntityStub.Factory,
_unitOfWork,
EmbeddedEventStore.Connection,
EventReaderConfigurationFactory.CreateWithResolver(_resolver),
_reader);
}
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);
}
private static async Task CreateSnapshot(
ISnapshotable snapshotSupport,
SnapshotStrategyContext context,
IStreamStore streamStore,
ConcurrentUnitOfWork uow,
EventMapping eventMapping,
EventSerializer eventSerializer,
CancellationToken ct)
{
if (!snapshotSupport.Strategy.ShouldCreateSnapshot(context))
{
return;
}
var snapshot = snapshotSupport.TakeSnapshot();
if (snapshot == null)
{
throw new InvalidOperationException("Snapshot missing.");
}
var snapshotContainer = new SnapshotContainer
{
Data = eventSerializer.SerializeObject(snapshot),
Info =
{
Type = eventMapping.GetEventName(snapshot.GetType()),
Position = context.SnapshotPosition
}
};
await streamStore.AppendToStream(
uow.GetSnapshotIdentifier(context.Aggregate.Identifier),
ExpectedVersion.Any,
new NewStreamMessage(
Deterministic.Create(Deterministic.Namespaces.Events, $"snapshot-{context.SnapshotPosition}"),
$"SnapshotContainer<{snapshotContainer.Info.Type}>",
eventSerializer.SerializeObject(snapshotContainer)),
ct);
}
public async Task SetUp()
{
await EmbeddedEventStore.Connection.DeleteAllStreamsAsync();
_model = new Model();
_root = SnapshotableAggregateRootEntityStub.Factory();
_unitOfWork = new ConcurrentUnitOfWork();
_unitOfWork.Attach(new Aggregate(_model.KnownIdentifier, 0, _root));
_resolver = A.Fake <IStreamNameResolver>();
_reader = A.Fake <IAsyncSnapshotReader>();
A.CallTo(() => _resolver.Resolve(_model.KnownIdentifier)).Returns(_model.KnownIdentifier);
A.CallTo(() => _resolver.Resolve(_model.UnknownIdentifier)).Returns(_model.UnknownIdentifier);
A.CallTo(() => _reader.ReadOptionalAsync(_model.KnownIdentifier))
.Returns(Task.FromResult(new Optional <Snapshot>(new Snapshot(100, new object()))));
A.CallTo(() => _reader.ReadOptionalAsync(_model.UnknownIdentifier))
.Returns(Task.FromResult(new Optional <Snapshot>(new Snapshot(100, new object()))));
_sut = new AsyncSnapshotableRepository <SnapshotableAggregateRootEntityStub>(
SnapshotableAggregateRootEntityStub.Factory,
_unitOfWork,
EmbeddedEventStore.Connection,
EventReaderConfigurationFactory.CreateWithResolver(_resolver),
_reader);
}
public Parcels(ConcurrentUnitOfWork unitOfWork, IStreamStore eventStore, EventMapping eventMapping, EventDeserializer eventDeserializer)
: base(Parcel.Factory, unitOfWork, eventStore, eventMapping, eventDeserializer)
{
}
public void Setup()
{
_sut = new ConcurrentUnitOfWork();
}
public Parcels(IParcelFactory parcelFactory, ConcurrentUnitOfWork unitOfWork, IStreamStore eventStore, EventMapping eventMapping, EventDeserializer eventDeserializer)
: base(parcelFactory.Create, unitOfWork, eventStore, eventMapping, eventDeserializer)
{
}
public Municipalities(ConcurrentUnitOfWork unitOfWork, IStreamStore eventStore, EventMapping eventMapping, EventDeserializer eventDeserializer)
: base(Municipality.Factory, unitOfWork, eventStore, eventMapping, eventDeserializer)
{
}
public void Setup()
{
_aggregate = AggregateStubs.Stub1;
_sut = new ConcurrentUnitOfWork();
_sut.Attach(_aggregate);
}
public void SetUp()
{
EmbeddedEventStore.Instance.Connection.DeleteAllStreams();
_model = new Model();
_unitOfWork = new ConcurrentUnitOfWork();
_resolver = A.Fake<IStreamNameResolver>();
_reader = A.Fake<IAsyncSnapshotReader>();
A.CallTo(() => _resolver.Resolve(_model.KnownIdentifier)).Returns(_model.KnownIdentifier);
A.CallTo(() => _resolver.Resolve(_model.UnknownIdentifier)).Returns(_model.UnknownIdentifier);
A.CallTo(() => _reader.ReadOptionalAsync(_model.KnownIdentifier))
.Returns(Task.FromResult(Optional<Snapshot>.Empty));
A.CallTo(() => _reader.ReadOptionalAsync(_model.UnknownIdentifier))
.Returns(Task.FromResult(Optional<Snapshot>.Empty));
_sut = new AsyncSnapshotableRepository<SnapshotableAggregateRootEntityStub>(
SnapshotableAggregateRootEntityStub.Factory,
_unitOfWork,
EmbeddedEventStore.Instance.Connection,
EventReaderConfigurationFactory.CreateWithResolver(_resolver),
_reader);
}
public ExampleAggregates(ConcurrentUnitOfWork unitOfWork, IStreamStore eventStore, EventMapping eventMapping, EventDeserializer eventDeserializer)
: base(ExampleAggregate.Factory, unitOfWork, eventStore, eventMapping, eventDeserializer)
{
}
public void SetUp()
{
_model = new Model();
using (var stream = new MemoryStream())
{
using (var writer = new BinaryWriter(stream))
{
new EventStub(1).Write(writer);
}
EmbeddedEventStore.Instance.Connection.AppendToStream(
_model.KnownIdentifier,
ExpectedVersion.NoStream,
new EventData(
Guid.NewGuid(),
typeof (EventStub).AssemblyQualifiedName,
false,
stream.ToArray(),
new byte[0]));
EmbeddedEventStore.Instance.Connection.AppendToStream(
_model.KnownIdentifier,
ExpectedVersion.Any,
new EventData(
Guid.NewGuid(),
typeof (EventStub).AssemblyQualifiedName,
false,
stream.ToArray(),
new byte[0]));
}
_root = SnapshotableAggregateRootEntityStub.Factory();
_state = new object();
_unitOfWork = new ConcurrentUnitOfWork();
_resolver = A.Fake<IStreamNameResolver>();
_reader = A.Fake<IAsyncSnapshotReader>();
A.CallTo(() => _resolver.Resolve(_model.KnownIdentifier)).Returns(_model.KnownIdentifier);
A.CallTo(() => _resolver.Resolve(_model.UnknownIdentifier)).Returns(_model.UnknownIdentifier);
A.CallTo(() => _reader.ReadOptionalAsync(_model.KnownIdentifier))
.Returns(Task.FromResult(new Optional<Snapshot>(new Snapshot(1, _state))));
A.CallTo(() => _reader.ReadOptionalAsync(_model.UnknownIdentifier))
.Returns(Task.FromResult(new Optional<Snapshot>(new Snapshot(1, _state))));
_sut = new AsyncSnapshotableRepository<SnapshotableAggregateRootEntityStub>(
() => _root,
_unitOfWork,
EmbeddedEventStore.Instance.Connection,
EventReaderConfigurationFactory.CreateWithResolver(_resolver),
_reader);
}
public void Setup()
{
_aggregate1 = AggregateStubs.Create(new ChangedAggregateRootEntityStub());
_aggregate2 = AggregateStubs.Create(new ChangedAggregateRootEntityStub());
_sut = new ConcurrentUnitOfWork();
_sut.Attach(_aggregate1);
_sut.Attach(_aggregate2);
}
public StreetNames(ConcurrentUnitOfWork unitOfWork, IStreamStore eventStore, EventMapping eventMapping, EventDeserializer eventDeserializer)
: base(StreetName.Factory, unitOfWork, eventStore, eventMapping, eventDeserializer)
{
}
public void Setup()
{
_sut = new ConcurrentUnitOfWork();
}
public PostalInformationSet(ConcurrentUnitOfWork unitOfWork, IStreamStore eventStore, EventMapping eventMapping, EventDeserializer eventDeserializer)
: base(PostalInformation.Factory, unitOfWork, eventStore, eventMapping, eventDeserializer)
{
}
public void Setup()
{
_aggregate = AggregateStubs.Stub1;
_sut = new ConcurrentUnitOfWork();
_sut.Attach(_aggregate);
}
public Accounts(ConcurrentUnitOfWork unitOfWork, IStreamStore eventStore, EventMapping eventMapping, EventDeserializer eventDeserializer)
: base(Account.Factory, unitOfWork, eventStore, eventMapping, eventDeserializer)
{
}
public async Task SetUp()
{
await EmbeddedEventStore.Connection.DeleteAllStreamsAsync();
_model = new Model();
_root = SnapshotableAggregateRootEntityStub.Factory();
_unitOfWork = new ConcurrentUnitOfWork();
_unitOfWork.Attach(new Aggregate(_model.KnownIdentifier, 0, _root));
_resolver = A.Fake<IStreamNameResolver>();
_reader = A.Fake<IAsyncSnapshotReader>();
A.CallTo(() => _resolver.Resolve(_model.KnownIdentifier)).Returns(_model.KnownIdentifier);
A.CallTo(() => _resolver.Resolve(_model.UnknownIdentifier)).Returns(_model.UnknownIdentifier);
A.CallTo(() => _reader.ReadOptionalAsync(_model.KnownIdentifier))
.Returns(Task.FromResult(new Optional<Snapshot>(new Snapshot(100, new object()))));
A.CallTo(() => _reader.ReadOptionalAsync(_model.UnknownIdentifier))
.Returns(Task.FromResult(new Optional<Snapshot>(new Snapshot(100, new object()))));
_sut = new AsyncSnapshotableRepository<SnapshotableAggregateRootEntityStub>(
SnapshotableAggregateRootEntityStub.Factory,
_unitOfWork,
EmbeddedEventStore.Connection,
EventReaderConfigurationFactory.CreateWithResolver(_resolver),
_reader);
}
public RepositoryScenarioBuilder WithUnitOfWork(ConcurrentUnitOfWork value)
{
_unitOfWork = value;
return(this);
}
