/// <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 void SetUp()
{
_connection = EmbeddedEventStore.Connection;
_reader = AsyncSnapshotReaderFactory.Create();
_configuration = EventReaderConfigurationFactory.Create();
_unitOfWork = new ConcurrentUnitOfWork();
_factory = SnapshotableAggregateRootEntityStub.Factory;
}
public void SetUp()
{
_connection = EmbeddedEventStore.Instance.Connection;
_reader = AsyncSnapshotReaderFactory.Create();
_configuration = EventReaderConfigurationFactory.Create();
_unitOfWork = new ConcurrentUnitOfWork();
_factory = SnapshotableAggregateRootEntityStub.Factory;
}
/// <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 SnapshotableRepository(IAsyncSnapshotReader snapshotReader
, IUnitOfWorkAsync unitOfworkAsync
, IEventStoreConnection connection
, ISerializer serializer)
{
_snapshotReader = snapshotReader ?? throw new ArgumentNullException(nameof(snapshotReader));
_unitOfworkAsync = unitOfworkAsync ?? throw new ArgumentNullException(nameof(unitOfworkAsync));
_connection = connection ?? throw new ArgumentNullException(nameof(connection));
_serializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
}
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 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);
}
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 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 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 SnapshotableRepository(IAsyncSnapshotReader snapshotReader, IUnitOfWorkAsync unitOfworkAsync
, IEventStoreConnection connection, ISerializer serializer)
: base(snapshotReader, unitOfworkAsync, connection, serializer)
{
}
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);
}
