/// <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(); }