protected override void Context() { _committed = new[] { BuildCommitStub(2, 1, _eventsPerCommit), // 1-2 BuildCommitStub(4, 2, _eventsPerCommit), // 3-4 BuildCommitStub(6, 3, _eventsPerCommit), // 5-6 <-- asked up to this one BuildCommitStub(8, 4, _eventsPerCommit) // 7-8 }; // the persistence returns all the data in the stream A.CallTo(() => Persistence.GetFrom(BucketId, StreamId, MinRevision, MaxRevision)).Returns(_committed); A.CallTo(() => Persistence.Commit(A <CommitAttempt> ._)) .ReturnsLazily((CommitAttempt attempt) => new Commit( attempt.BucketId, attempt.StreamId, attempt.StreamRevision, attempt.CommitId, attempt.CommitSequence, attempt.CommitStamp, 0, attempt.Headers, attempt.Events)); Stream = new OptimisticEventStream(BucketId, StreamId, Persistence, MinRevision, MaxRevision); }
protected override Task Because() { Stream = new OptimisticEventStream(BucketId, StreamId, Persistence, SystemTimeProvider); Stream.Add(new EventMessage() { Body = "body" }); return(Stream.CommitChanges(Guid.NewGuid())); }
protected override void Context() { _committed = new[] { BuildCommitStub(1, 1, 1) }; _dupliateCommitId = _committed[0].CommitId; A.CallTo(() => Persistence.GetFrom(BucketId, StreamId, 0, int.MaxValue)).Returns(_committed); Stream = new OptimisticEventStream(BucketId, StreamId, Persistence, 0, int.MaxValue); }
protected override void Because() { Stream = new OptimisticEventStream(BucketId, StreamId, Persistence); Stream.Add(new EventMessage() { Body = "body" }); Stream.CommitChanges(Guid.NewGuid()); }
protected override Task Context() { _committed = new[] { BuildCommitStub(1, 1, 1) }; _dupliateCommitId = _committed[0].CommitId; A.CallTo(() => Persistence.GetFromAsync(BucketId, StreamId, 0, int.MaxValue)).Returns(_committed); Stream = new OptimisticEventStream(BucketId, StreamId, Persistence, 0, int.MaxValue, CancellationToken.None); return(Task.CompletedTask); }
public virtual async Task<IEventStream> OpenStream(string bucketId, string streamId, int minRevision, int maxRevision) { maxRevision = maxRevision <= 0 ? int.MaxValue : maxRevision; Logger.Debug(Resources.OpeningStreamAtRevision, streamId, bucketId, minRevision, maxRevision); var stream = new OptimisticEventStream(bucketId, streamId, this, _systemTimeProvider); await stream.Initialize(minRevision, maxRevision); return stream; }
public virtual async Task <IEventStream> OpenStream(string bucketId, string streamId, int minRevision, int maxRevision) { maxRevision = maxRevision <= 0 ? int.MaxValue : maxRevision; Logger.Debug(Resources.OpeningStreamAtRevision, streamId, bucketId, minRevision, maxRevision); var stream = new OptimisticEventStream(bucketId, streamId, this, _systemTimeProvider); await stream.Initialize(minRevision, maxRevision); return(stream); }
protected override async Task Context() { _committed = new[] { BuildCommitStub(1, 1, 1) }; _dupliateCommitId = _committed[0].CommitId; //A.CallTo(() => Persistence.GetFrom(BucketId, StreamId, 0, int.MaxValue)).Returns(_committed.AsAsyncEnumerable()); Persistence.GetFrom(BucketId, StreamId, 0, int.MaxValue).Returns(_committed.AsAsyncEnumerable()); Stream = new OptimisticEventStream(BucketId, StreamId, Persistence, SystemTimeProvider); await Stream.Initialize(0, int.MaxValue); }
protected override void Context() { _committed = new[] { BuildCommitStub(1, 1, 1) }; _discoveredOnCommit = new[] { BuildCommitStub(3, 2, 2) }; A.CallTo(() => Persistence.Commit(A <CommitAttempt> ._)).Throws(new ConcurrencyException()); A.CallTo(() => Persistence.GetFrom(BucketId, StreamId, StreamRevision, int.MaxValue)).Returns(_committed); A.CallTo(() => Persistence.GetFrom(BucketId, StreamId, StreamRevision + 1, int.MaxValue)).Returns(_discoveredOnCommit); Stream = new OptimisticEventStream(BucketId, StreamId, Persistence, StreamRevision, int.MaxValue); Stream.Add(_uncommitted); }
protected override void Context() { _committed = new[] { BuildCommitStub(1, 1, 1) }; _dupliateCommitId = _committed[0].CommitId; Persistence .Setup(x => x.GetFrom(Bucket.Default, StreamId, 0, int.MaxValue)) .Returns(_committed); Stream = new OptimisticEventStream( StreamId, Persistence.Object, 0, int.MaxValue); }
protected override Task Context() { _committed = new[] { BuildCommitStub(1, 1, 1) }; _discoveredOnCommit = new[] { BuildCommitStub(3, 2, 2) }; A.CallTo(() => Persistence.CommitAsync(A <CommitAttempt> ._, A <CancellationToken> ._)).Throws(new ConcurrencyException()); A.CallTo(() => Persistence.GetFromAsync(BucketId, StreamId, StreamRevision, int.MaxValue)).Returns(_committed); A.CallTo(() => Persistence.GetFromAsync(BucketId, StreamId, StreamRevision + 1, int.MaxValue)).Returns(_discoveredOnCommit); Stream = new OptimisticEventStream(BucketId, StreamId, Persistence, StreamRevision, int.MaxValue, CancellationToken.None); Stream.Add(_uncommitted); return(Task.CompletedTask); }
public virtual async Task <IEventStream> OpenStream(ISnapshot snapshot, int maxRevision) { if (snapshot == null) { throw new ArgumentNullException("snapshot"); } Logger.Debug(Resources.OpeningStreamWithSnapshot, snapshot.StreamId, snapshot.StreamRevision, maxRevision); maxRevision = maxRevision <= 0 ? int.MaxValue : maxRevision; var stream = new OptimisticEventStream( snapshot.BucketId, snapshot.StreamId, this, _systemTimeProvider); await stream.Initialize(snapshot, maxRevision); return(stream); }
protected override void Context() { _committed = new[] { BuildCommitStub(1, 1, 1) }; _discoveredOnCommit = new[] { BuildCommitStub(3, 2, 2) }; Persistence .Setup(x => x.Commit(It.IsAny <CommitAttempt>())) .Throws(new ConcurrencyException()); Persistence .Setup(x => x.GetFrom(Bucket.Default, StreamId, StreamRevision, int.MaxValue)) .Returns(_committed); Persistence .Setup(x => x.GetFrom(Bucket.Default, StreamId, StreamRevision + 1, int.MaxValue)) .Returns(_discoveredOnCommit); Stream = new OptimisticEventStream(StreamId, Persistence.Object, StreamRevision, int.MaxValue); Stream.Add(_uncommitted); }
protected override async Task Context() { _committed = new[] { BuildCommitStub(1, 1, 1) }; _discoveredOnCommit = new[] { BuildCommitStub(3, 2, 2) }; //A.CallTo(() => Persistence.Commit(A<CommitAttempt>._)).Throws(new ConcurrencyException()); //A.CallTo(() => Persistence.GetFrom(BucketId, StreamId, StreamRevision, int.MaxValue)).Returns(_committed.AsAsyncEnumerable()); //A.CallTo(() => Persistence.GetFrom(BucketId, StreamId, StreamRevision + 1, int.MaxValue)).Returns(_discoveredOnCommit.AsAsyncEnumerable()); Persistence .When(x => x.Commit(Arg.Any <CommitAttempt>())) .Do(x => { throw new ConcurrencyException(); }); Persistence.GetFrom(BucketId, StreamId, StreamRevision, int.MaxValue).Returns(_committed.AsAsyncEnumerable()); Persistence.GetFrom(BucketId, StreamId, StreamRevision + 1, int.MaxValue).Returns(_discoveredOnCommit.AsAsyncEnumerable()); Stream = new OptimisticEventStream(BucketId, StreamId, Persistence, SystemTimeProvider); await Stream.Initialize(StreamRevision, int.MaxValue); Stream.Add(_uncommitted); //await Stream.CommitChanges(Guid.NewGuid()); }
protected override void Because() { Stream = new OptimisticEventStream(StreamId, Persistence.Object, MinRevision, MaxRevision); }
protected override Task Because() { Stream = new OptimisticEventStream(BucketId, StreamId, Persistence, MinRevision, MaxRevision, CancellationToken.None); return(Task.CompletedTask); }
protected override void Because() { Stream = new OptimisticEventStream(StreamId, Persistence.Object, 0, int.MaxValue); }
protected override async Task Because() { Stream = new OptimisticEventStream(BucketId, StreamId, Persistence, SystemTimeProvider); await Stream.Initialize(0, int.MaxValue); }
protected override Task Because() { Stream = new OptimisticEventStream(BucketId, StreamId, Persistence, SystemTimeProvider); Stream.Initialize(MinRevision, MaxRevision).Wait(); return(Task.FromResult(true)); }
protected override void Because() { Stream = new OptimisticEventStream(BucketId, StreamId, Persistence, 0, int.MaxValue); }
public virtual async Task<IEventStream> OpenStream(ISnapshot snapshot, int maxRevision) { if (snapshot == null) { throw new ArgumentNullException("snapshot"); } Logger.Debug(Resources.OpeningStreamWithSnapshot, snapshot.StreamId, snapshot.StreamRevision, maxRevision); maxRevision = maxRevision <= 0 ? int.MaxValue : maxRevision; var stream = new OptimisticEventStream( snapshot.BucketId, snapshot.StreamId, this, _systemTimeProvider); await stream.Initialize(snapshot, maxRevision); return stream; }