public async Task CantSaveOnDispose2Async()
        {
            // Arrange
            var ctx        = _ctx;
            var logger     = new Mock <ILogger <ProcessingDataUnitOfWork> >();
            var serializer = new Mock <ISerializer <IProcessingData> >();

            var data = new TestData
            {
                Id    = 1,
                Value = 2
            };
            var testJson = "test";

            serializer.Setup(x => x.Serialize(data)).Returns(testJson);
            var uow = new ProcessingDataUnitOfWork(ctx, logger.Object, serializer.Object);
            await uow.DisposeAsync();

            // Act
            var exception = await Record.ExceptionAsync(async() =>
            {
                await uow.SaveAsync(CancellationToken.None);
            });

            // Assert
            exception.Should().NotBeNull().And.BeOfType <ObjectDisposedException>();
        }
        public async Task CanProcessNewDataRollBackAsync()
        {
            // Arrange
            var ctx        = _ctx;
            var logger     = new Mock <ILogger <ProcessingDataUnitOfWork> >();
            var serializer = new Mock <ISerializer <IProcessingData> >();

            var data = new TestData
            {
                Id    = 1,
                Value = 2
            };
            var testJson = "test";

            serializer.Setup(x => x.Serialize(data)).Returns(testJson);

            // Act
            var exception = await Record.ExceptionAsync(async() =>
            {
                using var uow = new ProcessingDataUnitOfWork(ctx, logger.Object, serializer.Object);
                await uow.ProcessDataAsync(data, CancellationToken.None);
            });

            // Assert
            exception.Should().BeNull();

            ctx.ProcessingData.Should().HaveCount(0);

            ctx.OutboxMessages.Should().HaveCount(0);
        }
        public async Task CantProcessNullDataAsync()
        {
            // Arrange
            var ctx        = _ctx;
            var logger     = new Mock <ILogger <ProcessingDataUnitOfWork> >();
            var serializer = new Mock <ISerializer <IProcessingData> >();
            var uow        = new ProcessingDataUnitOfWork(ctx, logger.Object, serializer.Object);
            var data       = (IProcessingData)null !;
            // Act
            var exception = await Record.ExceptionAsync(() => uow.ProcessDataAsync(data, CancellationToken.None));

            // Assert
            exception.Should().NotBeNull().And.BeOfType <ArgumentNullException>();
        }
        public async Task CanProcessExistsDataRollBackAsync()
        {
            // Arrange
            var ctx     = _ctx;
            var oldData = new ProcessingData
            {
                Id    = 1,
                Value = 42
            };

            _ctx.ProcessingData.Add(oldData);
            _ctx.SaveChanges();
            var logger     = new Mock <ILogger <ProcessingDataUnitOfWork> >();
            var serializer = new Mock <ISerializer <IProcessingData> >();

            var data = new TestData
            {
                Id    = 1,
                Value = 2
            };
            var testJson = "test";

            serializer.Setup(x => x.Serialize(data)).Returns(testJson);

            // Act
            var exception = await Record.ExceptionAsync(async() =>
            {
                using var uow = new ProcessingDataUnitOfWork(ctx, logger.Object, serializer.Object);
                await uow.ProcessDataAsync(data, CancellationToken.None);
            });

            // Assert
            exception.Should().BeNull();

            // AsNoTracking to check real not cached data
            ctx.ProcessingData.AsNoTracking().Should().HaveCount(1);
            ctx.ProcessingData.AsNoTracking().Single().Id.Should().Be(1);
            ctx.ProcessingData.AsNoTracking().Single().Value.Should().Be(42);

            ctx.OutboxMessages.Should().HaveCount(0);
        }