feat: better test modes

1. use enum instead of bool
2. For Snapshot, old true = new AllRepositoriesDisposed, behavior unchanged
3. For Snapshot, new RepositoryFactoryDisposed - delete all snapshots only when the repository has been disposed
4. For Transaction, old true = new AllRepositoriesDisposed, behavior is extended, previously transactions would abort as soon as the repository was disposed
5. For Transaction, new RepositoryFactoryDiposed - abort transaction only when the repository factory has been disposed
6. lots of refactor on repositories to make them cleaner

Author: the-avid-engineer

src/EntityDb.Abstractions/Annotations/IEntityAnnotation.cs

@@ -0,0 +1,36 @@
+using System;
+
+namespace EntityDb.Abstractions.Annotations
+{
+    /// <summary>
+    ///     Represents data for a single entity that has already been committed, along with relevant information not contained in the data.
+    /// </summary>
+    /// <typeparam name="TData">The type of data.</typeparam>
+    public interface IEntityAnnotation<TData>
+    {
+        /// <summary>
+        ///     The transaction id associated with the data.
+        /// </summary>
+        Guid TransactionId { get; }
+
+        /// <summary>
+        ///     The transaction timestamp associated with the data.
+        /// </summary>
+        DateTime TransactionTimeStamp { get; }
+
+        /// <summary>
+        ///     The entity id associated with the data.
+        /// </summary>
+        Guid EntityId { get; }
+
+        /// <summary>
+        ///     The entity version number associated with the data.
+        /// </summary>
+        ulong EntityVersionNumber { get; }
+
+        /// <summary>
+        ///     The data.
+        /// </summary>
+        TData Data { get; }
+    }
+}

src/EntityDb.Abstractions/Commands/IAnnotatedCommand.cs

@@ -23,5 +23,12 @@ public interface ISnapshotRepository<TEntity> : IDisposable, IAsyncDisposable
         /// <param name="entity">The entity.</param>
         /// <returns><c>true</c> if the insert succeeded, or <c>false</c> if the insert failed.</returns>
         Task<bool> PutSnapshot(Guid entityId, TEntity entity);
+
+        /// <summary>
+        ///     Deletes multiple <typeparamref name="TEntity"/> snapshots.
+        /// </summary>
+        /// <param name="entityIds">The id of the entitie snapshots to delete.</param>
+        /// <returns><c>true</c> if the deletes all succeeded, or <c>false</c> if any deletes failed.</returns>
+        Task<bool> DeleteSnapshots(Guid[] entityIds);
     }
 }

src/EntityDb.Abstractions/Snapshots/ISnapshotRepository.cs

@@ -1,12 +1,13 @@
-using System.Threading.Tasks;
+using System;
+using System.Threading.Tasks;
 
 namespace EntityDb.Abstractions.Snapshots
 {
     /// <summary>
     ///     Represents a type used to create instances of <see cref="ISnapshotRepository{TEntity}" />
     /// </summary>
     /// <typeparam name="TEntity">The type of entity stored by the <see cref="ISnapshotRepository{TEntity}" />.</typeparam>
-    public interface ISnapshotRepositoryFactory<TEntity>
+    public interface ISnapshotRepositoryFactory<TEntity> : IDisposable, IAsyncDisposable
     {
         /// <summary>
         ///     Create a new instance of <see cref="ISnapshotRepository{TEntity}" />

src/EntityDb.Abstractions/Snapshots/ISnapshotRepositoryFactory.cs

@@ -1,4 +1,5 @@
-using EntityDb.Abstractions.Commands;
+using EntityDb.Abstractions.Annotations;
+using EntityDb.Abstractions.Commands;
 using EntityDb.Abstractions.Leases;
 using EntityDb.Abstractions.Queries;
 using EntityDb.Abstractions.Tags;
@@ -105,7 +106,7 @@ public interface ITransactionRepository<TEntity> : IDisposable, IAsyncDisposable
         /// </summary>
         /// <param name="commandQuery">The command query.</param>
         /// <returns>The annotated commands which are found by <paramref name="commandQuery" />.</returns>
-        Task<IAnnotatedCommand<TEntity>[]> GetAnnotatedCommands(ICommandQuery commandQuery);
+        Task<IEntityAnnotation<ICommand<TEntity>>[]> GetAnnotatedCommands(ICommandQuery commandQuery);
 
         /// <summary>
         ///     Inserts a single transaction with an atomic commit.

src/EntityDb.Abstractions/Transactions/ITransactionRepository.cs

@@ -1,12 +1,13 @@
-using System.Threading.Tasks;
+using System;
+using System.Threading.Tasks;
 
 namespace EntityDb.Abstractions.Transactions
 {
     /// <summary>
     ///     Represents a type used to create instances of <see cref="ITransactionRepository{TEntity}" />.
     /// </summary>
     /// <typeparam name="TEntity">The type of the entity stored by the <see cref="ITransactionRepository{TEntity}" />.</typeparam>
-    public interface ITransactionRepositoryFactory<TEntity>
+    public interface ITransactionRepositoryFactory<TEntity> : IDisposable, IAsyncDisposable
     {
         /// <summary>
         ///     Creates a new instance of <see cref="ITransactionRepository{TEntity}" />.

src/EntityDb.Abstractions/Transactions/ITransactionRepositoryFactory.cs

@@ -70,12 +70,12 @@ await serviceProvider.GetRequiredService<IEntityRepositoryFactory<TransactionEnt
 
             var firstTransaction = await BuildTransaction(entityId, 1, expectedSnapshotVersion, serviceProvider);
 
-            await entityRepository.PutTransaction(firstTransaction);
+            var firstTransactionInserted = await entityRepository.PutTransaction(firstTransaction);
 
             var secondTransaction = await BuildTransaction(entityId, expectedSnapshotVersion, expectedCurrentVersion,
                 serviceProvider, entityRepository);
 
-            await entityRepository.PutTransaction(secondTransaction);
+            var secondTransactionInserted = await entityRepository.PutTransaction(secondTransaction);
 
             // ACT
 
@@ -85,6 +85,9 @@ await serviceProvider.GetRequiredService<IEntityRepositoryFactory<TransactionEnt
 
             // ASSERT
 
+            firstTransactionInserted.ShouldBeTrue();
+            secondTransactionInserted.ShouldBeTrue();
+
             snapshot.ShouldNotBeNull();
             snapshot.VersionNumber.ShouldBe(expectedSnapshotVersion);
             current.VersionNumber.ShouldBe(expectedCurrentVersion);

src/EntityDb.Common.Tests/SnapshotTransactions/SnapshotTransactionsTestsBase.cs

@@ -41,17 +41,14 @@ public static void ConfigureTestsBaseServices(IServiceCollection serviceCollecti
         {
             serviceCollection.Configure<SnapshotSessionOptions>("TestWrite", (options) =>
             {
-                options.TestMode = true;
             });
 
             serviceCollection.Configure<TransactionSessionOptions>("TestWrite", (options) =>
             {
-                options.TestMode = true;
             });
 
             serviceCollection.Configure<TransactionSessionOptions>("TestReadOnly", (options) =>
             {
-                options.TestMode = true;
                 options.ReadOnly = true;
             });
         }

src/EntityDb.Common.Tests/Startup.cs

@@ -407,18 +407,35 @@ private Guid[] GetSortedGuids(int numberOfGuids)
         }
 
         [Fact]
-        public async Task GivenReadOnlyMode_WhenPuttingTransaction_ThenThrow()
+        public async Task GivenReadOnlyMode_WhenPuttingTransaction_ThenCannotWriteInReadOnlyModeExceptionIsLogged()
         {
             // ARRANGE
 
+            var loggerMock = new Mock<ILogger>(MockBehavior.Strict);
+
+            loggerMock
+                .Setup(logger => logger.LogError(It.IsAny<CannotWriteInReadOnlyModeException>(), It.IsAny<string>()))
+                .Verifiable();
+
             var transaction = TransactionSeeder.Create(1, 1);
 
-            await using var transactionRepository = await CreateRepository("TestReadOnly");
+            await using var transactionRepository = await CreateRepository("TestReadOnly", (serviceCollection) =>
+            {
+                serviceCollection.Configure<TransactionSessionOptions>("TestReadOnly", (options) =>
+                {
+                    options.LoggerOverride = loggerMock.Object;
+                });
+            });
+
+            // ACT
+
+            var inserted = await transactionRepository.PutTransaction(transaction);
 
             // ASSERT
 
-            await Should.ThrowAsync<CannotWriteInReadOnlyModeException>(async () =>
-                await transactionRepository.PutTransaction(transaction));
+            inserted.ShouldBeFalse();
+
+            loggerMock.Verify();
         }
 
         [Fact]
@@ -482,7 +499,6 @@ public async Task
             {
                 serviceCollection.Configure<TransactionSessionOptions>("TestWriteWithLoggerOverride", (options) =>
                 {
-                    options.TestMode = true;
                     options.LoggerOverride = loggerMock.Object;
                 });
             });
@@ -520,7 +536,6 @@ public async Task
             {
                 serviceCollection.Configure<TransactionSessionOptions>("TestWriteWithLoggerOverride", (options) =>
                 {
-                    options.TestMode = true;
                     options.LoggerOverride = loggerMock.Object;
                 });
             });
@@ -621,7 +636,7 @@ public async Task GivenCommandInserted_WhenGettingAnnotatedCommand_ThenReturnAnn
             annotatedCommands[0].TransactionId.ShouldBe(expectedTransactionId);
             annotatedCommands[0].EntityId.ShouldBe(expectedEntityId);
             annotatedCommands[0].EntityVersionNumber.ShouldBe(1ul);
-            annotatedCommands[0].Command.ShouldBe(expectedCommand);
+            annotatedCommands[0].Data.ShouldBe(expectedCommand);
 
             expectedTransactionTimeStamps.Contains(annotatedCommands[0].TransactionTimeStamp).ShouldBeTrue();
         }

src/EntityDb.Common.Tests/Transactions/TransactionTestsBase.cs

@@ -0,0 +1,14 @@
+using EntityDb.Abstractions.Annotations;
+using System;
+
+namespace EntityDb.Common.Annotations
+{
+    internal record EntityAnnotation<TData>
+    (
+        Guid TransactionId,
+        DateTime TransactionTimeStamp,
+        Guid EntityId,
+        ulong EntityVersionNumber,
+        TData Data
+    ) : IEntityAnnotation<TData>;
+}