public void Does_not_dispose_twice()
            {
                // Arrange
                var database    = new Mock <IDbConnection>();
                var transaction = new Mock <IDbTransaction>();

                var sut = new DefaultUnitOfWork(database.Object, transaction.Object, PeregrineConfig.Postgres);

                // Act
                sut.Dispose();
                sut.Dispose();

                // Assert
                database.Verify(d => d.Dispose(), Times.Once);
                transaction.Verify(t => t.Dispose(), Times.Once);
            }
            public void Disposes_only_once()
            {
                // Arrange
                var database    = new Mock <IDatabase>();
                var transaction = new Mock <IDbTransaction>();

                var sut = new DefaultUnitOfWork(database.Object, transaction.Object);

                sut.Dispose();

                // Act
                sut.Dispose();

                // Assert
                database.Verify(d => d.Dispose(), Times.Once);
                transaction.Verify(t => t.Dispose(), Times.Once);
            }
            public void Disposes_transaction()
            {
                // Arrange
                var database    = new Mock <IDbConnection>();
                var transaction = new Mock <IDbTransaction>();

                var sut = new DefaultUnitOfWork(database.Object, transaction.Object, PeregrineConfig.Postgres);

                // Act
                sut.Dispose();

                // Assert
                transaction.Verify(t => t.Dispose());
            }
            public void Rollsback_transaction()
            {
                // Arrange
                var database    = new Mock <IDatabase>();
                var transaction = new Mock <IDbTransaction>();

                var sut = new DefaultUnitOfWork(database.Object, transaction.Object);

                // Act
                sut.Dispose();

                // Assert
                transaction.Verify(t => t.Rollback());
            }
            public void Disposes_transaction_but_not_database()
            {
                // Arrange
                var database    = new Mock <IDbConnection>();
                var transaction = new Mock <IDbTransaction>();

                var sut = new DefaultUnitOfWork(database.Object, transaction.Object, PeregrineConfig.Postgres, true);

                // Act
                sut.Dispose();

                // Assert
                database.Verify(d => d.Dispose(), Times.Never);
                transaction.Verify(t => t.Dispose());
            }
            public void Does_not_rollback_a_saved_unit_of_work()
            {
                // Arrange
                var database    = new Mock <IDbConnection>();
                var transaction = new Mock <IDbTransaction>();

                var sut = new DefaultUnitOfWork(database.Object, transaction.Object, PeregrineConfig.Postgres);

                sut.SaveChanges();

                // Act
                sut.Dispose();

                // Assert
                transaction.Verify(t => t.Rollback(), Times.Never);
                database.Verify(d => d.Dispose());
                transaction.Verify(t => t.Dispose());
            }
            public void Disposes_database_even_if_exception_occurs_during_disposing_transaction()
            {
                // Arrange
                var database    = new Mock <IDbConnection>();
                var transaction = new Mock <IDbTransaction>();

                transaction.Setup(t => t.Dispose()).Throws <CustomException>();

                var sut = new DefaultUnitOfWork(database.Object, transaction.Object, PeregrineConfig.Postgres);

                // Act
                Action act = () => sut.Dispose();

                // Assert
                act.Should().Throw <CustomException>();
                database.Verify(d => d.Dispose());
                transaction.Verify(t => t.Dispose());
            }
            public void Does_not_rollback_twice()
            {
                // Arrange
                var database    = new Mock <IDatabase>();
                var transaction = new Mock <IDbTransaction>();

                var sut = new DefaultUnitOfWork(database.Object, transaction.Object);

                sut.Rollback();

                // Act
                sut.Dispose();

                // Assert
                transaction.Verify(t => t.Rollback(), Times.Once);
                database.Verify(d => d.Dispose());
                transaction.Verify(t => t.Dispose());
            }
            public void Disposes_database_and_transaction_even_if_exception_occurs_during_rollback()
            {
                // Arrange
                var database    = new Mock <IDatabase>();
                var transaction = new Mock <IDbTransaction>();

                transaction.Setup(t => t.Rollback())
                .Throws <CustomException>();

                var sut = new DefaultUnitOfWork(database.Object, transaction.Object);

                // Act
                Action act = () => sut.Dispose();

                // Assert
                act.ShouldThrow <CustomException>();
                database.Verify(d => d.Dispose());
                transaction.Verify(t => t.Dispose());
            }