Add retry-resilient merchant balance regression coverage

TransactionProcessor.ProjectionEngine/Repository/MerchantBalanceStateRepository.cs

@@ -120,11 +120,20 @@ private async Task<Result<MerchantBalanceState>> LoadHelper(Guid estateId,
         using ResolvedDbContext<EstateManagementContext>? resolvedContext = this.Resolver.Resolve(EstateManagementDatabaseName, estateId.ToString());
         await using EstateManagementContext context = resolvedContext.Context;
 
-        MerchantBalanceProjectionState? entity = await context.MerchantBalanceProjectionState.Where(m => m.MerchantId == merchantId).SingleOrDefaultAsync(cancellationToken: cancellationToken);
+        IQueryable<MerchantBalanceProjectionState> query = context.MerchantBalanceProjectionState.Where(m => m.MerchantId == merchantId);
+        Result<MerchantBalanceProjectionState> entityResult = await DbQueryHelpers.ExecuteQuerySafeSingleOrDefault(query,
+                                                                                                                  cancellationToken,
+                                                                                                                  $"Error getting merchant balance state for estate {estateId} and merchant {merchantId}");
 
-        if (entity == null) {
+        if (entityResult.Status == ResultStatus.NotFound) {
             return Result.Success(new MerchantBalanceState());
         }
+
+        if (entityResult.IsFailed) {
+            return Result.Failure(entityResult.Message);
+        }
+
+        MerchantBalanceProjectionState entity = entityResult.Data;
 
         // We have located a state record so we need to translate to the Model type
         return Result.Success(new MerchantBalanceState {
@@ -159,4 +168,4 @@ private async Task<Result<MerchantBalanceState>> LoadHelper(Guid estateId,
     private const String ConnectionStringIdentifier = "EstateReportingReadModel";
 
     #endregion
-}
+}

TransactionProcessor.Tests/RepositoryTests/MerchantBalanceStateRepositoryTests.cs

@@ -0,0 +1,79 @@
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Diagnostics;
+using Microsoft.Extensions.DependencyInjection;
+using Moq;
+using Shared.EntityFramework;
+using Shouldly;
+using System;
+using System.Data.Common;
+using System.Threading;
+using System.Threading.Tasks;
+using TransactionProcessor.Database.Contexts;
+using TransactionProcessor.ProjectionEngine.Repository;
+using Xunit;
+
+namespace TransactionProcessor.Tests.RepositoryTests;
+
+public class MerchantBalanceStateRepositoryTests
+{
+    [Fact]
+    public async Task Load_ReturnsFailure_WhenQueryThrows()
+    {
+        Guid estateId = Guid.NewGuid();
+        Guid merchantId = Guid.NewGuid();
+
+        using SqliteConnection connection = new("DataSource=:memory:");
+        await connection.OpenAsync();
+
+        DbContextOptions<EstateManagementContext> setupOptions = new DbContextOptionsBuilder<EstateManagementContext>()
+            .UseSqlite(connection)
+            .Options;
+
+        await using (EstateManagementContext setupContext = new(setupOptions))
+        {
+            await setupContext.Database.EnsureCreatedAsync();
+        }
+
+        DbContextOptions<EstateManagementContext> failingOptions = new DbContextOptionsBuilder<EstateManagementContext>()
+            .UseSqlite(connection)
+            .AddInterceptors(new ThrowingDbCommandInterceptor())
+            .Options;
+
+        ServiceProvider serviceProvider = new ServiceCollection()
+            .AddScoped(_ => new EstateManagementContext(failingOptions))
+            .BuildServiceProvider();
+
+        using IServiceScope scope = serviceProvider.CreateScope();
+
+        Mock<IDbContextResolver<EstateManagementContext>> resolver = new();
+        resolver.Setup(r => r.Resolve(It.IsAny<string>(), It.IsAny<string>()))
+                .Returns(new ResolvedDbContext<EstateManagementContext>(scope));
+
+        MerchantBalanceStateRepository repository = new(resolver.Object);
+
+        var result = await repository.Load(estateId, merchantId, CancellationToken.None);
+
+        result.IsFailed.ShouldBeTrue();
+        result.Message.ShouldContain("Error getting merchant balance state");
+        result.Message.ShouldContain("Simulated transient SQL failure");
+    }
+
+    private sealed class ThrowingDbCommandInterceptor : DbCommandInterceptor
+    {
+        public override InterceptionResult<DbDataReader> ReaderExecuting(DbCommand command,
+                                                                         CommandEventData eventData,
+                                                                         InterceptionResult<DbDataReader> result)
+        {
+            throw new InvalidOperationException("Simulated transient SQL failure");
+        }
+
+        public override ValueTask<InterceptionResult<DbDataReader>> ReaderExecutingAsync(DbCommand command,
+                                                                                          CommandEventData eventData,
+                                                                                          InterceptionResult<DbDataReader> result,
+                                                                                          CancellationToken cancellationToken = default)
+        {
+            throw new InvalidOperationException("Simulated transient SQL failure");
+        }
+    }
+}

TransactionProcessor/Bootstrapper/RepositoryRegistry.cs

@@ -82,7 +82,9 @@ public RepositoryRegistry() {
                     }));
                 }
                 else {
-                    this.AddDbContext<EstateManagementContext>(options => options.UseSqlServer(ConfigurationReader.GetConnectionString("TransactionProcessorReadModel"), retry => { }));
+                    this.AddDbContext<EstateManagementContext>(options => options.UseSqlServer(ConfigurationReader.GetConnectionString("TransactionProcessorReadModel"), retry => {
+                        retry.EnableRetryOnFailure();
+                    }));
                 }
             }
 
@@ -140,4 +142,4 @@ private void RegisterAggregateCachingFunc() {
             });
         }
     }
-}
+}