public async Task save_reset_inconsistent() { var cache = new Testing.InMemoryCache(); var projection = new Mock <IProjection <int, string> >(); projection.Setup(p => p.Initial).Returns("0"); projection.Setup(p => p.FullName).Returns("test"); projection.Setup(p => p.State).Returns(typeof(string)); projection.Setup(p => p.TrySaveAsync(It.IsAny <Stream>(), It.IsAny <string>(), It.IsAny <CancellationToken>())) .Returns <Stream, string, CancellationToken>((s, state, c) => { var bytes = Encoding.UTF8.GetBytes(state); s.Write(bytes, 0, bytes.Length); return(Task.FromResult(true)); }); var reified = Make(projection.Object, cache); reified.SetPossiblyInconsistent(); reified.Reset(); await reified.TrySaveAsync(CancellationToken.None); Assert.Equal(new byte[] { 0x00, 0x00, 0x00, 0x00, // Sequence number (first) 0x30, // Contents "0" 0x00, 0x00, 0x00, 0x00 // Sequence number (last) }, cache.Streams["test"].ToArray()); }
public async Task with_restart() { var memory = new MemoryStorageDriver(); var cache = new Testing.InMemoryCache(); var ew = new EventStreamWrapper <TstEvent, CheckSequence>( memory, new [] { new CheckSequence.Projection() }, cache ); await ew.AppendEventsAsync(new[] { new TstEvent(1) }); await ew.AppendEventsAsync(new[] { new TstEvent(2) }); await ew.AppendEventsAsync(new[] { new TstEvent(3) }); await ew.TrySaveAsync(); await ew.AppendEventsAsync(new[] { new TstEvent(4) }); await ew.AppendEventsAsync(new[] { new TstEvent(5) }); Assert.Equal(5u, ew.Current.LastEvt); // try to read: var ew2 = new EventStreamWrapper <TstEvent, CheckSequence>( memory, new[] { new CheckSequence.Projection() }, cache); await ew2.InitializeAsync(); Assert.Equal(5u, ew2.Current.LastEvt); }
public async Task save_throws() { var cache = new Testing.InMemoryCache(); var projection = new Mock <IProjection <int, string> >(); projection.Setup(p => p.Initial).Returns("0"); projection.Setup(p => p.FullName).Returns("test"); projection.Setup(p => p.State).Returns(typeof(string)); projection.Setup(p => p.TrySaveAsync(It.IsAny <Stream>(), It.IsAny <string>(), It.IsAny <CancellationToken>())) .Throws(new Exception("Projection.TrySaveAsync")); var reified = Make(projection.Object, cache); try { await reified.TrySaveAsync(CancellationToken.None); Assert.True(false); } catch (Exception e) { Assert.Equal("Projection.TrySaveAsync", e.Message); } Assert.Empty(cache.Streams); }
public async Task load_state_bad_name() { var cache = new Testing.InMemoryCache { { "test", new byte[] { 0x02, 0x00, 0x00, 0x00, // Current position (beginning) 0x30, 0x30, 0x30, 0x30, // Event data "0000" 0x02, 0x00, 0x00, 0x00 // Current position (end) } }, { "other", new byte[0] } }; var projection = new Mock <IProjection <int, string> >(); projection.Setup(p => p.Initial).Returns("I"); projection.Setup(p => p.FullName).Returns("other"); projection.Setup(p => p.State).Returns(typeof(string)); ReturnsExtensions.ReturnsAsync(projection.Setup(p => p.TryLoadAsync(It.IsAny <Stream>(), It.IsAny <CancellationToken>())), "bad"); var reified = Make(projection.Object, cache); await reified.TryLoadAsync(CancellationToken.None); Assert.Equal(0U, reified.Sequence); Assert.Equal("I", reified.Current); }
public async Task load_state() { var cache = new Testing.InMemoryCache { { "test", new byte[] { 0x02, 0x00, 0x00, 0x00, // Current position (beginning) 0x30, 0x30, 0x30, 0x30, // Event data "0000" 0x02, 0x00, 0x00, 0x00 // Current position (end) } } }; var projection = new Mock <IProjection <int, string> >(); projection.Setup(p => p.Initial).Returns("I"); projection.Setup(p => p.FullName).Returns("test"); projection.Setup(p => p.State).Returns(typeof(string)); projection.Setup(p => p.TryLoadAsync(It.IsAny <Stream>(), It.IsAny <CancellationToken>())) .Returns <Stream, CancellationToken>((s, c) => { var bytes = new byte[4]; Assert.Equal(0, s.Position); s.Read(bytes, 0, 4); return(Task.FromResult(Encoding.UTF8.GetString(bytes))); }); var reified = Make(projection.Object, cache); await reified.TryLoadAsync(CancellationToken.None); Assert.Equal(2U, reified.Sequence); Assert.Equal("0000", reified.Current); }
public async Task skip_for_projection() { var stream = GetStream(); var imm = new Testing.InMemoryCache(); var ess1 = EventStreamService <Ev, Sta> .StartNew( stream, new[] { new Project() }, imm, null, CancellationToken.None); await ess1.Ready; await ess1.TrySaveAsync(); await ess1.AppendEventsAsync(new[] { new Ev { Value = 41 } }); var evs = new List <int>(); var seqs = new List <uint>(); var ess = EventStreamService <Ev, Sta> .StartNew( stream, new[] { new Project() }, null, new[] { Tuple.Create <EventStream <Ev> .Listener, uint>( (e, s) => { evs.Add(e.Value); seqs.Add(s); }, 2u) }, null, CancellationToken.None); await ess.Ready; CollectionAssert.AreEqual(new[] { 25, 30, 41 }, evs); CollectionAssert.AreEqual(new[] { 2u, 3u, 4u }, seqs); Assert.AreEqual(11 + 25 + 30 + 41, ess.LocalState.Sum); }
public async Task save_inconsistent() { var ms = new MemoryStream(); var cache = new Testing.InMemoryCache(); var projection = new Mock <IProjection <int, string> >(); projection.Setup(p => p.Initial).Returns("0"); projection.Setup(p => p.FullName).Returns("test"); projection.Setup(p => p.State).Returns(typeof(string)); projection.Setup(p => p.TrySaveAsync(It.IsAny <Stream>(), It.IsAny <string>(), It.IsAny <CancellationToken>())) .Throws(new Exception("Projection.TrySaveAsync")); var reified = Make(projection.Object, cache); reified.SetPossiblyInconsistent(); await reified.TrySaveAsync(CancellationToken.None); Assert.False(cache.Streams.ContainsKey("test")); }
public virtual async Task save_auto_inconsistent() { var cache = new Testing.InMemoryCache(); var projection = new Mock <IProjection <int, string> >(); projection.Setup(p => p.Initial).Returns("0"); projection.Setup(p => p.FullName).Returns("test"); projection.Setup(p => p.State).Returns(typeof(string)); projection.Setup(p => p.TrySaveAsync(It.IsAny <Stream>(), It.IsAny <string>(), It.IsAny <CancellationToken>())) .Throws(new Exception("Projection.TrySaveAsync")); projection.Setup(p => p.Apply(It.IsAny <uint>(), It.IsAny <int>(), It.IsAny <string>())) .Throws(new Exception("Boo.")); var reified = Make(projection.Object, cache); try { reified.Apply(1U, 13); /* Sets 'inconsistent' */ } catch {} await reified.TrySaveAsync(CancellationToken.None); Assert.Empty(cache.Streams); }
public async Task multi_apply_separate() { var cache = new Testing.InMemoryCache { { "string", new byte[] { 0x02, 0x00, 0x00, 0x00, // Current position (beginning) 0x30, 0x30, 0x30, 0x30, // Event data "0000" 0x02, 0x00, 0x00, 0x00 // Current position (end) } } }; var str = MockString(); str.Setup(p => p.TryLoadAsync(It.IsAny <Stream>(), It.IsAny <CancellationToken>())) .Returns <Stream, CancellationToken>((s, c) => { var bytes = new byte[4]; s.Read(bytes, 0, 4); return(Task.FromResult(Encoding.UTF8.GetString(bytes))); }); var reified = new ReifiedProjectionGroup <int, State>(new IProjection <int>[] { MockInteger().Object, str.Object }, cache); await reified.TryLoadAsync(CancellationToken.None); reified.Apply(1U, 10); reified.Apply(4U, 14); Assert.Equal(4U, reified.Sequence); Assert.Equal(24, reified.Current.I.Value); Assert.Equal("0000(14:4)", reified.Current.S); }