public async Task Delete_deletes_Memento_entity()
        {
            // Arrange
            var sourceId = Guid.NewGuid();
            var memento  = new FakeUserMemento();

            var sut = new SqlMementoStore(
                () => new MementoStoreDbContext(_dbContextOptions),
                new JsonMessageSerializer());

            await sut.Save <FakeUser>(sourceId, memento, default);

            // Act
            await sut.Delete <FakeUser>(sourceId, default);

            // Assert
            using (var db = new MementoStoreDbContext(_dbContextOptions))
            {
                bool actual = await db
                              .Mementoes
                              .Where(m => m.AggregateId == sourceId)
                              .AnyAsync();

                actual.Should().BeFalse();
            }
        }
        public async Task Save_inserts_Memento_entity_correctly()
        {
            // Arrange
            var sourceId = Guid.NewGuid();
            var memento  = new FakeUserMemento();

            var serializer = new JsonMessageSerializer();

            var sut = new SqlMementoStore(
                () => new MementoStoreDbContext(_dbContextOptions),
                serializer);

            // Act
            await sut.Save <FakeUser>(sourceId, memento, default);

            // Assert
            using (var db = new MementoStoreDbContext(_dbContextOptions))
            {
                Memento actual = await db
                                 .Mementoes
                                 .AsNoTracking()
                                 .Where(m => m.AggregateId == sourceId)
                                 .SingleOrDefaultAsync();

                actual.Should().NotBeNull();
                object restored = serializer.Deserialize(actual.MementoJson);
                restored.Should().BeOfType <FakeUserMemento>();
                restored.ShouldBeEquivalentTo(memento);
            }
        }
        public async Task Save_overwrites_memento_blob_if_already_exists()
        {
            // Arrange
            var             userId     = Guid.NewGuid();
            FakeUserMemento oldMemento = fixture.Create <FakeUserMemento>();

            CloudBlockBlob blob = s_container.GetBlockBlobReference(
                AzureMementoStore.GetMementoBlobName <FakeUser>(userId));
            await blob.UploadTextAsync(serializer.Serialize(oldMemento));

            FakeUserMemento memento = fixture.Create <FakeUserMemento>();

            // Act
            Func <Task> action = () => sut.Save <FakeUser>(userId, memento, CancellationToken.None);

            // Assert
            action.ShouldNotThrow();
            blob.Exists().Should().BeTrue();
            using (Stream s = await blob.OpenReadAsync())
                using (var reader = new StreamReader(s))
                {
                    string json = await reader.ReadToEndAsync();

                    object actual = serializer.Deserialize(json);
                    actual.Should().BeOfType <FakeUserMemento>();
                    actual.ShouldBeEquivalentTo(memento);
                }
        }
        public async Task Find_returns_memento_correctly()
        {
            var             sourceId = Guid.NewGuid();
            FakeUserMemento memento  = _fixture.Create <FakeUserMemento>();
            await _sut.Save <FakeUser>(sourceId, memento, CancellationToken.None);

            IMemento actual = await
                              _sut.Find <FakeUser>(sourceId, CancellationToken.None);

            actual.Should().BeOfType <FakeUserMemento>();
            actual.ShouldBeEquivalentTo(memento);
        }
示例#5
0
        public async Task Find_returns_memento_correctly(
            Guid sourceId,
            FakeUserMemento memento)
        {
            await sut.Save <FakeUser>(sourceId, memento, CancellationToken.None);

            IMemento actual = await
                              sut.Find <FakeUser>(sourceId, CancellationToken.None);

            actual.Should().BeOfType <FakeUserMemento>();
            actual.ShouldBeEquivalentTo(memento);
        }
        public async Task Delete_deletes_memento_blob()
        {
            var             userId  = Guid.NewGuid();
            FakeUserMemento memento = fixture.Create <FakeUserMemento>();
            await sut.Save <FakeUser>(userId, memento, CancellationToken.None);

            await sut.Delete <FakeUser>(userId, CancellationToken.None);

            CloudBlockBlob blob = s_container.GetBlockBlobReference(
                AzureMementoStore.GetMementoBlobName <FakeUser>(userId));

            blob.Exists().Should().BeFalse();
        }
        public async Task Find_restores_memento_correctly()
        {
            // Arrange
            var             userId  = Guid.NewGuid();
            FakeUserMemento memento = fixture.Create <FakeUserMemento>();
            await sut.Save <FakeUser>(userId, memento, CancellationToken.None);

            // Act
            IMemento actual = await sut.Find <FakeUser>(userId, CancellationToken.None);

            // Assert
            actual.Should().BeOfType <FakeUserMemento>();
            actual.ShouldBeEquivalentTo(memento);
        }
        public async Task Save_sets_ContentType_to_application_json()
        {
            var             userId  = Guid.NewGuid();
            FakeUserMemento memento = fixture.Create <FakeUserMemento>();

            await sut.Save <FakeUser>(userId, memento, CancellationToken.None);

            string blobName =
                AzureMementoStore.GetMementoBlobName <FakeUser>(userId);
            ICloudBlob blob = await
                              s_container.GetBlobReferenceFromServerAsync(blobName);

            blob.Properties.ContentType.Should().Be("application/json");
        }
        public async Task Save_updates_Memento_entity_if_already_exists()
        {
            // Arrange
            var sourceId = Guid.NewGuid();

            var oldMemento = new FakeUserMemento();
            var newMemento = new FakeUserMemento();

            var serializer = new JsonMessageSerializer();

            long sequence = 0;

            using (var db = new MementoStoreDbContext(_dbContextOptions))
            {
                var memento = new Memento
                {
                    AggregateId = sourceId,
                    MementoJson = serializer.Serialize(oldMemento),
                };
                db.Mementoes.Add(memento);
                await db.SaveChangesAsync();

                sequence = memento.SequenceId;
            }

            var sut = new SqlMementoStore(
                () => new MementoStoreDbContext(_dbContextOptions),
                serializer);

            // Act
            await sut.Save <FakeUser>(sourceId, newMemento, default);

            // Assert
            using (var db = new MementoStoreDbContext(_dbContextOptions))
            {
                Memento actual = await db
                                 .Mementoes
                                 .Where(m => m.SequenceId == sequence)
                                 .SingleOrDefaultAsync();

                actual.Should().NotBeNull();
                actual.AggregateId.Should().Be(sourceId);
                object restored = serializer.Deserialize(actual.MementoJson);
                restored.Should().BeOfType <FakeUserMemento>();
                restored.ShouldBeEquivalentTo(newMemento);
            }
        }
        public async Task Find_returns_memento_correctly()
        {
            // Arrange
            var sourceId = Guid.NewGuid();
            var memento  = new FakeUserMemento();
            var sut      = new SqlMementoStore(
                () => new MementoStoreDbContext(_dbContextOptions),
                new JsonMessageSerializer());
            await sut.Save <FakeUser>(sourceId, memento, default);

            // Act
            IMemento actual = await sut.Find <FakeUser>(sourceId, default);

            // Assert
            actual.Should().BeOfType <FakeUserMemento>();
            actual.ShouldBeEquivalentTo(memento);
        }
        public async Task Delete_deletes_Memento_entity()
        {
            var             sourceId = Guid.NewGuid();
            FakeUserMemento memento  = _fixture.Create <FakeUserMemento>();
            await _sut.Save <FakeUser>(sourceId, memento, CancellationToken.None);

            await _sut.Delete <FakeUser>(sourceId, CancellationToken.None);

            using (var db = new DataContext())
            {
                bool actual = await db
                              .Mementoes
                              .Where(m => m.AggregateId == sourceId)
                              .AnyAsync();

                actual.Should().BeFalse();
            }
        }
示例#12
0
        public async Task Save_inserts_Memento_entity_correctly(
            Guid sourceId,
            FakeUserMemento memento)
        {
            await sut.Save <FakeUser>(sourceId, memento, CancellationToken.None);

            using (var db = new DataContext())
            {
                Memento actual = await db
                                 .Mementoes
                                 .AsNoTracking()
                                 .Where(m => m.AggregateId == sourceId)
                                 .SingleOrDefaultAsync();

                actual.Should().NotBeNull();
                object restored = serializer.Deserialize(actual.MementoJson);
                restored.Should().BeOfType <FakeUserMemento>();
                restored.ShouldBeEquivalentTo(memento);
            }
        }
        public async Task Save_updates_Memento_entity_if_already_exists()
        {
            // Arrange
            var             sourceId   = Guid.NewGuid();
            FakeUserMemento oldMemento = _fixture.Create <FakeUserMemento>();
            FakeUserMemento newMemento = _fixture.Create <FakeUserMemento>();

            long sequence = 0;

            using (var db = new DataContext())
            {
                var memento = new Memento
                {
                    AggregateId = sourceId,
                    MementoJson = _serializer.Serialize(oldMemento),
                };
                db.Mementoes.Add(memento);
                await db.SaveChangesAsync();

                sequence = memento.SequenceId;
            }

            // Act
            await _sut.Save <FakeUser>(sourceId, newMemento, CancellationToken.None);

            // Assert
            using (var db = new DataContext())
            {
                Memento actual = await db
                                 .Mementoes
                                 .Where(m => m.SequenceId == sequence)
                                 .SingleOrDefaultAsync();

                actual.Should().NotBeNull();
                actual.AggregateId.Should().Be(sourceId);
                object restored = _serializer.Deserialize(actual.MementoJson);
                restored.Should().BeOfType <FakeUserMemento>();
                restored.ShouldBeEquivalentTo(newMemento);
            }
        }
        public async Task Save_uploads_memento_blob_correctly()
        {
            // Arrange
            var             userId  = Guid.NewGuid();
            FakeUserMemento memento = fixture.Create <FakeUserMemento>();

            // Act
            await sut.Save <FakeUser>(userId, memento, CancellationToken.None);

            // Assert
            CloudBlockBlob blob = s_container.GetBlockBlobReference(
                AzureMementoStore.GetMementoBlobName <FakeUser>(userId));

            blob.Exists().Should().BeTrue();
            using (Stream s = await blob.OpenReadAsync())
                using (var reader = new StreamReader(s))
                {
                    string json = await reader.ReadToEndAsync();

                    object actual = serializer.Deserialize(json);
                    actual.Should().BeOfType <FakeUserMemento>();
                    actual.ShouldBeEquivalentTo(memento);
                }
        }