/// <summary>
/// Initializes a new instance of the <see cref="SnapshotableRepository{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"/> is null.</exception>
public SnapshotableRepository(Func <TAggregateRoot> rootFactory, UnitOfWork unitOfWork,
IEventStoreConnection connection, EventReaderConfiguration configuration,
ISnapshotReader 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 StoreSnapshots(IMetrics metrics, IStoreEvents store, ISnapshotReader snapshots)
{
_metrics = metrics;
_store = store;
_snapshots = snapshots;
_streamGen = Configuration.Settings.Generator;
}
public StateRehydrator(IEventReader eventReader,
IEventHandler <T> eventHandler)
{
_snapshotReader = DefaultSnapshotReader.Instance;
_eventReader = eventReader;
_eventHandler = eventHandler;
}
public StoreSnapshots(IMetrics metrics, IStoreEvents store, ISnapshotReader snapshots, StreamIdGenerator streamGen)
{
_metrics = metrics;
_store = store;
_snapshots = snapshots;
_streamGen = streamGen;
}
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();
}
_root = SnapshotableAggregateRootEntityStub.Factory();
_unitOfWork = new UnitOfWork();
_resolver = A.Fake <IStreamNameResolver>();
_reader = A.Fake <ISnapshotReader>();
A.CallTo(() => _resolver.Resolve(_model.KnownIdentifier)).Returns(_model.KnownIdentifier);
A.CallTo(() => _resolver.Resolve(_model.UnknownIdentifier)).Returns(_model.UnknownIdentifier);
A.CallTo(() => _reader.ReadOptional(_model.KnownIdentifier)).Returns(Optional <Snapshot> .Empty);
A.CallTo(() => _reader.ReadOptional(_model.UnknownIdentifier)).Returns(Optional <Snapshot> .Empty);
_sut = new SnapshotableRepository <SnapshotableAggregateRootEntityStub>(
() => _root,
_unitOfWork,
EmbeddedEventStore.Connection,
EventReaderConfigurationFactory.CreateWithResolver(_resolver),
_reader);
}
public void SetUp()
{
_connection = EmbeddedEventStore.Connection;
_reader = SnapshotReaderFactory.Create();
_configuration = EventReaderConfigurationFactory.Create();
_unitOfWork = new UnitOfWork();
_factory = SnapshotableAggregateRootEntityStub.Factory;
}
public StateRehydrator(ISnapshotReader <T> snapshotReader,
IEventReader eventReader,
IEventHandler <T> eventHandler)
{
_snapshotReader = snapshotReader;
_eventReader = eventReader;
_eventHandler = eventHandler;
}
public void SetUp()
{
_connection = EmbeddedEventStore.Instance.Connection;
_reader = SnapshotReaderFactory.Create();
_configuration = EventReaderConfigurationFactory.Create();
_unitOfWork = new UnitOfWork();
_factory = SnapshotableAggregateRootEntityStub.Factory;
}
public SnapshotableRootRepository(ISnapshotReader snapshotStore,
IAggregateStore aggregateStore,
IAggregateChangeTracker changeTracker,
IStreamNameProvider streamNameProvider)
{
_snapshotStore = snapshotStore;
_aggregateStore = aggregateStore;
_changeTracker = changeTracker;
_streamNameProvider = streamNameProvider;
}
/// <summary>
/// Initializes a new instance of the <see cref="SnapshotableRepository{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" /> is null.
/// </exception>
public SnapshotableRepository(Func <TAggregateRoot> rootFactory, UnitOfWork unitOfWork,
IEventStoreConnection connection, EventReaderConfiguration configuration,
ISnapshotReader 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 SnapshottedStateRehydrator(Func <Guid, T> seedFactory,
ISnapshotReader <T> snapshotReader,
IEventReader eventReader,
IEventHandler <T> eventHandler)
{
_seedFactory = seedFactory;
_snapshotReader = snapshotReader;
_eventReader = eventReader;
_eventHandler = eventHandler;
}
public void SetUp()
{
EmbeddedEventStore.Connection.DeleteAllStreams();
_model = new Model();
_unitOfWork = new UnitOfWork();
_resolver = A.Fake <IStreamNameResolver>();
_reader = A.Fake <ISnapshotReader>();
A.CallTo(() => _resolver.Resolve(_model.KnownIdentifier)).Returns(_model.KnownIdentifier);
A.CallTo(() => _resolver.Resolve(_model.UnknownIdentifier)).Returns(_model.UnknownIdentifier);
A.CallTo(() => _reader.ReadOptional(_model.KnownIdentifier)).Returns(Optional <Snapshot> .Empty);
A.CallTo(() => _reader.ReadOptional(_model.UnknownIdentifier)).Returns(Optional <Snapshot> .Empty);
_sut = new SnapshotableRepository <SnapshotableAggregateRootEntityStub>(
SnapshotableAggregateRootEntityStub.Factory,
_unitOfWork,
EmbeddedEventStore.Connection,
EventReaderConfigurationFactory.CreateWithResolver(_resolver),
_reader);
}
public async Task SetUp()
{
await EmbeddedEventStore.Connection.DeleteAllStreamsAsync();
_model = new Model();
_root = SnapshotableAggregateRootEntityStub.Factory();
_unitOfWork = new UnitOfWork();
_unitOfWork.Attach(new Aggregate(_model.KnownIdentifier, 0, _root));
_resolver = A.Fake <IStreamNameResolver>();
_reader = A.Fake <ISnapshotReader>();
_state = new object();
A.CallTo(() => _resolver.Resolve(_model.KnownIdentifier)).Returns(_model.KnownIdentifier);
A.CallTo(() => _resolver.Resolve(_model.UnknownIdentifier)).Returns(_model.UnknownIdentifier);
A.CallTo(() => _reader.ReadOptional(_model.KnownIdentifier))
.Returns(new Optional <Snapshot>(new Snapshot(100, _state)));
A.CallTo(() => _reader.ReadOptional(_model.UnknownIdentifier))
.Returns(new Optional <Snapshot>(new Snapshot(100, _state)));
_sut = new SnapshotableRepository <SnapshotableAggregateRootEntityStub>(
SnapshotableAggregateRootEntityStub.Factory,
_unitOfWork,
EmbeddedEventStore.Connection,
EventReaderConfigurationFactory.CreateWithResolver(_resolver),
_reader);
}
public EventStoreBaseRepository(IEventStoreConnection connection, IUnitOfWork unitOfWork, ISnapshotReader snapshotReader)
{
_connection = connection;
_unitOfWork = unitOfWork;
_snapshotReader = snapshotReader;
}
public void SetUp()
{
EmbeddedEventStore.Instance.Connection.DeleteAllStreams();
_model = new Model();
_unitOfWork = new UnitOfWork();
_resolver = A.Fake<IStreamNameResolver>();
_reader = A.Fake<ISnapshotReader>();
A.CallTo(() => _resolver.Resolve(_model.KnownIdentifier)).Returns(_model.KnownIdentifier);
A.CallTo(() => _resolver.Resolve(_model.UnknownIdentifier)).Returns(_model.UnknownIdentifier);
A.CallTo(() => _reader.ReadOptional(_model.KnownIdentifier)).Returns(Optional<Snapshot>.Empty);
A.CallTo(() => _reader.ReadOptional(_model.UnknownIdentifier)).Returns(Optional<Snapshot>.Empty);
_sut = new SnapshotableRepository<SnapshotableAggregateRootEntityStub>(
SnapshotableAggregateRootEntityStub.Factory,
_unitOfWork,
EmbeddedEventStore.Instance.Connection,
EventReaderConfigurationFactory.CreateWithResolver(_resolver),
_reader);
}
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 UnitOfWork();
_resolver = A.Fake<IStreamNameResolver>();
_reader = A.Fake<ISnapshotReader>();
A.CallTo(() => _resolver.Resolve(_model.KnownIdentifier)).Returns(_model.KnownIdentifier);
A.CallTo(() => _resolver.Resolve(_model.UnknownIdentifier)).Returns(_model.UnknownIdentifier);
A.CallTo(() => _reader.ReadOptional(_model.KnownIdentifier))
.Returns(new Optional<Snapshot>(new Snapshot(1, _state)));
A.CallTo(() => _reader.ReadOptional(_model.UnknownIdentifier))
.Returns(new Optional<Snapshot>(new Snapshot(1, _state)));
_sut = new SnapshotableRepository<SnapshotableAggregateRootEntityStub>(
() => _root,
_unitOfWork,
EmbeddedEventStore.Instance.Connection,
EventReaderConfigurationFactory.CreateWithResolver(_resolver),
_reader);
}
public async Task SetUp()
{
await EmbeddedEventStore.Connection.DeleteAllStreamsAsync();
_model = new Model();
_root = SnapshotableAggregateRootEntityStub.Factory();
_unitOfWork = new UnitOfWork();
_unitOfWork.Attach(new Aggregate(_model.KnownIdentifier, 0, _root));
_resolver = A.Fake<IStreamNameResolver>();
_reader = A.Fake<ISnapshotReader>();
_state = new object();
A.CallTo(() => _resolver.Resolve(_model.KnownIdentifier)).Returns(_model.KnownIdentifier);
A.CallTo(() => _resolver.Resolve(_model.UnknownIdentifier)).Returns(_model.UnknownIdentifier);
A.CallTo(() => _reader.ReadOptional(_model.KnownIdentifier))
.Returns(new Optional<Snapshot>(new Snapshot(100, _state)));
A.CallTo(() => _reader.ReadOptional(_model.UnknownIdentifier))
.Returns(new Optional<Snapshot>(new Snapshot(100, _state)));
_sut = new SnapshotableRepository<SnapshotableAggregateRootEntityStub>(
SnapshotableAggregateRootEntityStub.Factory,
_unitOfWork,
EmbeddedEventStore.Connection,
EventReaderConfigurationFactory.CreateWithResolver(_resolver),
_reader);
}
/// <summary>
/// creates a new SnapshotClient
/// </summary>
/// <param name="snapshotReader"></param>
/// <param name="snapshotWriter"></param>
/// <param name="snapshotCompare"></param>
public SnapshotClient(ISnapshotReader snapshotReader, ISnapshotWriter snapshotWriter, ISnapshotCompare snapshotCompare)
{
_snapshotReader = snapshotReader;
_snapshotWriter = snapshotWriter;
_snapshotCompare = snapshotCompare;
}
public DomainStart(ISnapshotReader subscriber, ReadOnlySettings settings)
{
_subscriber = subscriber;
_settings = settings;
_cancellationTokenSource = new CancellationTokenSource();
}
