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()
{
_model = new Model();
_root = SnapshotableAggregateRootEntityStub.Factory();
_unitOfWork = new UnitOfWork();
_unitOfWork.Attach(new Aggregate(_model.KnownIdentifier, 0, _root));
_sut = new RepositoryScenarioBuilder().WithUnitOfWork(_unitOfWork).BuildForSnapshotableRepository();
}
public void AddAttachesToUnitOfWork()
{
var root = SnapshotableAggregateRootEntityStub.Factory();
_sut.Add(_model.KnownIdentifier, root);
Aggregate aggregate;
var result = _unitOfWork.TryGet(_model.KnownIdentifier, out aggregate);
Assert.That(result, Is.True);
Assert.That(aggregate.Identifier, Is.EqualTo(_model.KnownIdentifier));
Assert.That(aggregate.Root, Is.SameAs(root));
}
public void SetUp()
{
EmbeddedEventStore.Connection.DeleteAllStreams();
_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>();
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 void SetUp()
{
EmbeddedEventStore.Instance.Connection.DeleteAllStreams();
_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.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 void SetUp()
{
EmbeddedEventStore.Instance.Connection.DeleteAllStreams();
_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.Instance.Connection,
EventReaderConfigurationFactory.CreateWithResolver(_resolver),
_reader);
}
public void SetUp()
{
_model = new Model();
_root = SnapshotableAggregateRootEntityStub.Factory();
_unitOfWork = new UnitOfWork();
_unitOfWork.Attach(new Aggregate(_model.KnownIdentifier, 0, _root));
_sut = new RepositoryScenarioBuilder().
WithUnitOfWork(_unitOfWork).
ScheduleSnapshots(new Snapshot(_model.KnownIdentifier, 100, new object())).
BuildForSnapshotableRepository();
}
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>();
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);
}
