Exemple #1
0
        public async Task save_write_throws()
        {
            var stream = new Mock <Stream>();

            stream.Setup(s => s.Write(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>()))
            .Throws(new Exception("Stream.Write"));

            stream.Setup(s => s.CanWrite).Returns(true);

            var cache = new Mock <IProjectionCacheProvider>();

            ReturnsExtensions.ReturnsAsync(cache.Setup(c => c.OpenWriteAsync("test")), stream.Object);

            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.Object);

            try
            {
                await reified.TrySaveAsync(CancellationToken.None);

                Assert.Fail("Exception expected.");
            }
            catch (Exception e)
            {
                Assert.AreEqual("Stream.Write", e.Message);
            }
        }
Exemple #2
0
        public override async Task save_auto_inconsistent()
        {
            var ms = new MemoryStream();

            var cache = new Mock <IProjectionCacheProvider>();

            ReturnsExtensions.ReturnsAsync(cache.Setup(c => c.OpenWriteAsync("test")), ms);

            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.Object);

            Assert.Throws <AggregateException>(() => reified.Apply(1U, 13), "Boo."); // Sets 'inconsistent'

            await reified.TrySaveAsync(CancellationToken.None);

            CollectionAssert.AreEqual(new byte[]
            {
                // Cut short
            }, ms.ToArray());
        }
Exemple #3
0
        public async Task save_reset_inconsistent()
        {
            var ms = new MemoryStream();

            var cache = new Mock <IProjectionCacheProvider>();

            ReturnsExtensions.ReturnsAsync(cache.Setup(c => c.OpenWriteAsync("test")), ms);

            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((string)state);
                s.Write(bytes, 0, bytes.Length);
                return(Task.FromResult(true));
            });

            var reified = Make(projection.Object, cache.Object);

            reified.SetPossiblyInconsistent();
            reified.Reset();

            await reified.TrySaveAsync(CancellationToken.None);

            CollectionAssert.AreEqual(new byte[]
            {
                0x00, 0x00, 0x00, 0x00, // Sequence number (first)
                0x30,                   // Contents "0"
                0x00, 0x00, 0x00, 0x00  // Sequence number (last)
            }, ms.ToArray());
        }
Exemple #4
0
        public async Task save_throws()
        {
            var ms = new MemoryStream();

            var cache = new Mock <IProjectionCacheProvider>();

            ReturnsExtensions.ReturnsAsync(cache.Setup(c => c.OpenWriteAsync("test")), ms);

            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.Object);

            try
            {
                await reified.TrySaveAsync(CancellationToken.None);

                Assert.Fail("Exception expected.");
            }
            catch (Exception e)
            {
                Assert.AreEqual("Projection.TrySaveAsync", e.Message);
            }

            CollectionAssert.AreEqual(new byte[]
            {
                0x00, 0x00, 0x00, 0x00, // Sequence number (first)
                // Cut short
            }, ms.ToArray());
        }
Exemple #5
0
        public async Task load_state_bad_name()
        {
            var cache = new Mock <IProjectionCacheProvider>();

            ReturnsExtensions.ReturnsAsync(cache.Setup(c => c.OpenReadAsync("test")), new MemoryStream(new byte[]
            {
                0x02, 0x00, 0x00, 0x00,     // Current position (beginning)
                0x30, 0x30, 0x30, 0x30,     // Event data "0000"
                0x02, 0x00, 0x00, 0x00      // Current position (end)
            }));


            ReturnsExtensions.ReturnsAsync(cache.Setup(c => c.OpenReadAsync("other")), new MemoryStream(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.Object);

            await reified.TryLoadAsync(CancellationToken.None);

            Assert.AreEqual((uint)0U, (uint)reified.Sequence);
            Assert.AreEqual("I", reified.Current);
        }
Exemple #6
0
        public async Task load_state()
        {
            var cache = new Mock <IProjectionCacheProvider>();

            ReturnsExtensions.ReturnsAsync(cache.Setup(c => c.OpenReadAsync("test")), new MemoryStream(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];
                s.Read(bytes, 0, 4);
                return(Task.FromResult(Encoding.UTF8.GetString(bytes)));
            });

            var reified = Make(projection.Object, cache.Object);

            await reified.TryLoadAsync(CancellationToken.None);

            Assert.AreEqual((uint)2U, (uint)reified.Sequence);
            Assert.AreEqual("0000", reified.Current);
        }
        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 void GetFailure()
        {
            ReturnsExtensions.ReturnsAsync(_firebaseRequestManagerMock.Setup(
                                               firebaseRequestManager => firebaseRequestManager.RequestAsync(HttpMethod.Get, "todos", (object)null)),
                                           _failureResponse);

            Assert.Throws <FirebaseException>(() => _firebaseClient.Get("todos"));
        }
        public void DeleteAsyncFailure()
        {
            ReturnsExtensions.ReturnsAsync(_firebaseRequestManagerMock.Setup(
                                               firebaseRequestManager => firebaseRequestManager.RequestAsync(HttpMethod.Delete, "todos", (object)null)),
                                           _failureResponse);

            Assert.Throws <FirebaseException>(async() => await _firebaseClient.DeleteAsync("todos"));
        }
        public void UpdateAsyncFailure()
        {
            ReturnsExtensions.ReturnsAsync(_firebaseRequestManagerMock.Setup(
                                               firebaseRequestManager => firebaseRequestManager.RequestAsync(RequestManager.Patch, "todos", _expected)),
                                           _failureResponse);

            Assert.Throws <FirebaseException>(async() => await _firebaseClient.UpdateAsync("todos", _expected));
        }
        public void PushAsyncFailure()
        {
            ReturnsExtensions.ReturnsAsync(_firebaseRequestManagerMock.Setup(
                                               firebaseRequestManager => firebaseRequestManager.RequestAsync(HttpMethod.Post, "todos", _expected)),
                                           _failureResponse);

            Assert.Throws <FirebaseException>(async() => await _firebaseClient.PushAsync("todos", _expected));
        }
Exemple #12
0
        public async Task multi_apply_separate()
        {
            var cache = new Mock <IProjectionCacheProvider>();

            ReturnsExtensions.ReturnsAsync(cache.Setup(c => c.OpenReadAsync("string")), new MemoryStream(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.Object);

            await reified.TryLoadAsync(CancellationToken.None);

            reified.Apply(1U, 10);
            reified.Apply(4U, 14);

            Assert.AreEqual((uint)4U, (uint)reified.Sequence);
            Assert.AreEqual((int)24, (int)reified.Current.I.Value);
            Assert.AreEqual("0000(14:4)", reified.Current.S);
        }
Exemple #13
0
        public async Task load_state_sream_throws()
        {
            var stream = new Mock <Stream>();

            stream.Setup(s => s.Read(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>()))
            .Throws(new Exception("Stream.Read"));

            stream.Setup(s => s.CanRead).Returns(true);

            var cache = new Mock <IProjectionCacheProvider>();

            ReturnsExtensions.ReturnsAsync(cache.Setup(c => c.OpenReadAsync("test")), stream.Object);

            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));
            ReturnsExtensions.ReturnsAsync(projection.Setup(p => p.TryLoadAsync(It.IsAny <Stream>(), It.IsAny <CancellationToken>())), "bad");

            var reified = Make(projection.Object, cache.Object);

            try
            {
                await reified.TryLoadAsync(CancellationToken.None);

                Assert.Fail("Expected exception");
            }
            catch (Exception e)
            {
                Assert.AreEqual("Stream.Read", e.Message);
            }

            Assert.AreEqual((uint)0U, (uint)reified.Sequence);
            Assert.AreEqual("I", reified.Current);
        }