In Auto setup, when IsUninitialized, response http status code 503

src/OrchardCore.Modules/OrchardCore.AutoSetup/AutoSetupMiddleware.cs

@@ -1,3 +1,4 @@
+using System.Text;
 using Microsoft.AspNetCore.Http;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
@@ -112,20 +113,23 @@ public async Task InvokeAsync(HttpContext httpContext)
                 }
 
                 // Check if the tenant was installed by another instance.
-                using var settings = (await _shellSettingsManager
-                    .LoadSettingsAsync(_shellSettings.Name))
-                    .AsDisposable();
+                using var settings = await _shellSettingsManager.LoadSettingsAsync(_shellSettings.Name);
 
-                if (!settings.IsUninitialized())
+                if (settings != null)
                 {
-                    await _shellHost.ReloadShellContextAsync(_shellSettings, eventSource: false);
-                    httpContext.Response.StatusCode = 503;
-
-                    return;
+                    settings.AsDisposable();
+                    if (!settings.IsUninitialized())
+                    {
+                        await _shellHost.ReloadShellContextAsync(_shellSettings, eventSource: false);
+                        httpContext.Response.StatusCode = StatusCodes.Status503ServiceUnavailable;
+                        await httpContext.Response.WriteAsync("The requested tenant is not initialized.");
+                        return;
+                    }
                 }
 
                 var autoSetupService = httpContext.RequestServices.GetRequiredService<IAutoSetupService>();
-                if (await autoSetupService.SetupTenantAsync(_setupOptions, _shellSettings))
+                (var setupContext, var isSuccess) = await autoSetupService.SetupTenantAsync(_setupOptions, _shellSettings);
+                if (isSuccess)
                 {
                     if (_setupOptions.IsDefault)
                     {
@@ -140,13 +144,17 @@ public async Task InvokeAsync(HttpContext httpContext)
                     }
 
                     httpContext.Response.Redirect(pathBase);
-
-                    return;
                 }
                 else
                 {
-                    httpContext.Response.StatusCode = 503;
+                    httpContext.Response.StatusCode = StatusCodes.Status503ServiceUnavailable;
+                    var stringBuilder = new StringBuilder();
+                    foreach (var error in setupContext.Errors)
+                    {
+                        stringBuilder.AppendLine($"{error.Key} : '{error.Value}'");
+                    }
 
+                    await httpContext.Response.WriteAsync($"The AutoSetup failed installing the site '{_setupOptions.SiteName}' with errors: {stringBuilder}.");
                     return;
                 }
             }

src/OrchardCore.Modules/OrchardCore.AutoSetup/Services/AutoSetupService.cs

@@ -27,7 +27,7 @@ ILogger<AutoSetupService> logger
         _logger = logger;
     }
 
-    public async Task<bool> SetupTenantAsync(TenantSetupOptions setupOptions, ShellSettings shellSettings)
+    public async Task<(SetupContext, bool)> SetupTenantAsync(TenantSetupOptions setupOptions, ShellSettings shellSettings)
     {
         var setupContext = await GetSetupContextAsync(setupOptions, shellSettings);
 
@@ -39,7 +39,7 @@ public async Task<bool> SetupTenantAsync(TenantSetupOptions setupOptions, ShellS
         {
             _logger.LogInformation("The AutoSetup successfully provisioned the site '{SiteName}'.", setupOptions.SiteName);
 
-            return true;
+            return (setupContext,true);
         }
 
         var stringBuilder = new StringBuilder();
@@ -50,7 +50,7 @@ public async Task<bool> SetupTenantAsync(TenantSetupOptions setupOptions, ShellS
 
         _logger.LogError("The AutoSetup failed installing the site '{SiteName}' with errors: {Errors}.", setupOptions.SiteName, stringBuilder);
 
-        return false;
+        return (setupContext, false);
     }
 
     public async Task<ShellSettings> CreateTenantSettingsAsync(TenantSetupOptions setupOptions)

src/OrchardCore.Modules/OrchardCore.AutoSetup/Services/IAutoSetupService.cs

@@ -29,5 +29,5 @@ public interface IAutoSetupService
     /// <returns>
     /// Returns <see langword="true" /> if successfully setup.
     /// </returns>
-    Task<bool> SetupTenantAsync(TenantSetupOptions setupOptions, ShellSettings shellSettings);
+    Task<(SetupContext, bool)> SetupTenantAsync(TenantSetupOptions setupOptions, ShellSettings shellSettings);
 }

test/OrchardCore.Tests/Modules/OrchardCore.AutoSetup/AutoSetupMiddlewareTests.cs

@@ -0,0 +1,161 @@
+using OrchardCore.AutoSetup;
+using OrchardCore.AutoSetup.Options;
+using OrchardCore.AutoSetup.Services;
+using OrchardCore.Environment.Shell;
+using OrchardCore.Environment.Shell.Models;
+using OrchardCore.Locking;
+using OrchardCore.Locking.Distributed;
+using OrchardCore.Setup.Services;
+
+namespace OrchardCore.Tests.Modules.OrchardCore.AutoSetup;
+
+public class AutoSetupMiddlewareTests
+{
+    private readonly Mock<IShellHost> _mockShellHost;
+    private readonly ShellSettings _shellSettings;
+    private readonly Mock<IShellSettingsManager> _mockShellSettingsManager;
+    private readonly Mock<IDistributedLock> _mockDistributedLock;
+    private readonly Mock<IOptions<AutoSetupOptions>> _mockOptions;
+    private readonly Mock<IAutoSetupService> _mockAutoSetupService;
+
+    public AutoSetupMiddlewareTests()
+    {
+        _shellSettings = new ShellSettings();
+        _shellSettings.AsDefaultShell();
+        _mockShellHost = new Mock<IShellHost>();
+        _mockShellSettingsManager = new Mock<IShellSettingsManager>();
+        _mockDistributedLock = new Mock<IDistributedLock>();
+        _mockOptions = new Mock<IOptions<AutoSetupOptions>>();
+        _mockAutoSetupService = new Mock<IAutoSetupService>();
+
+        _mockOptions.Setup(o => o.Value).Returns(new AutoSetupOptions
+        {
+            LockOptions = new LockOptions(),
+            Tenants = new List<TenantSetupOptions>
+                {
+                    new TenantSetupOptions { ShellName = ShellSettings.DefaultShellName }
+                }
+        });
+    }
+
+    [Fact]
+    public async Task InvokeAsync_InitializedShell_SkipsSetup()
+    {
+        // Arrange
+        _shellSettings.State = TenantState.Running;
+
+        var httpContext = new DefaultHttpContext();
+        var nextCalled = false;
+
+        var middleware = new AutoSetupMiddleware(
+            next: (innerHttpContext) => { nextCalled = true; return Task.CompletedTask; },
+            _mockShellHost.Object,
+            _shellSettings,
+            _mockShellSettingsManager.Object,
+            _mockDistributedLock.Object,
+            _mockOptions.Object);
+
+        // Act
+        await middleware.InvokeAsync(httpContext);
+
+        // Assert
+        Assert.True(nextCalled);
+        _mockAutoSetupService.Verify(s => s.SetupTenantAsync(It.IsAny<TenantSetupOptions>(), It.IsAny<ShellSettings>()), Times.Never);
+    }
+
+    [Fact]
+    public async Task InvokeAsync_FailedSetup_ReturnsServiceUnavailable()
+    {
+        // Arrange
+        _shellSettings.State = TenantState.Uninitialized;
+
+        SetupDistributedLockMock(true);
+
+        var setupContext = new SetupContext { Errors = new Dictionary<string, string> { { "Error", "Test error" } } };
+        _mockAutoSetupService.Setup(s => s.SetupTenantAsync(It.IsAny<TenantSetupOptions>(), It.IsAny<ShellSettings>()))
+            .ReturnsAsync((setupContext, false));
+
+        var httpContext = new DefaultHttpContext();
+        httpContext.RequestServices = new ServiceCollection()
+            .AddSingleton(_mockAutoSetupService.Object)
+            .BuildServiceProvider();
+
+        var middleware = new AutoSetupMiddleware(
+            next: (innerHttpContext) => Task.CompletedTask,
+            _mockShellHost.Object,
+            _shellSettings,
+            _mockShellSettingsManager.Object,
+            _mockDistributedLock.Object,
+            _mockOptions.Object);
+
+        // Act
+        await middleware.InvokeAsync(httpContext);
+
+        // Assert
+        Assert.Equal(StatusCodes.Status503ServiceUnavailable, httpContext.Response.StatusCode);
+    }
+
+    [Fact]
+    public async Task InvokeAsync_UnInitializedShell_PerformsSetup()
+    {
+        // Arrange
+        _shellSettings.State = TenantState.Uninitialized;
+
+        SetupDistributedLockMock(true);
+
+        var setupContext = new SetupContext();
+        _mockAutoSetupService.Setup(s => s.SetupTenantAsync(It.IsAny<TenantSetupOptions>(), It.IsAny<ShellSettings>()))
+            .ReturnsAsync((setupContext, true));
+
+        var httpContext = new DefaultHttpContext();
+        httpContext.RequestServices = new ServiceCollection()
+            .AddSingleton(_mockAutoSetupService.Object)
+            .BuildServiceProvider();
+
+        var middleware = new AutoSetupMiddleware(
+            next: (innerHttpContext) => Task.CompletedTask,
+            _mockShellHost.Object,
+            _shellSettings,
+            _mockShellSettingsManager.Object,
+            _mockDistributedLock.Object,
+            _mockOptions.Object);
+
+        // Act
+        await middleware.InvokeAsync(httpContext);
+
+        // Assert
+        Assert.Equal(StatusCodes.Status302Found, httpContext.Response.StatusCode); // Redirect
+        _mockAutoSetupService.Verify(s => s.SetupTenantAsync(It.IsAny<TenantSetupOptions>(), It.IsAny<ShellSettings>()), Times.Once);
+    }
+
+    [Fact]
+    public async Task InvokeAsync_FailedLockAcquisition_ThrowsTimeoutException()
+    {
+        // Arrange
+        _shellSettings.State = TenantState.Uninitialized;
+
+        SetupDistributedLockMock(false);
+
+        var httpContext = new DefaultHttpContext();
+
+        var middleware = new AutoSetupMiddleware(
+            next: (innerHttpContext) => Task.CompletedTask,
+            _mockShellHost.Object,
+            _shellSettings,
+            _mockShellSettingsManager.Object,
+            _mockDistributedLock.Object,
+            _mockOptions.Object);
+
+        // Act & Assert
+        await Assert.ThrowsAsync<TimeoutException>(() => middleware.InvokeAsync(httpContext));
+    }
+
+    private void SetupDistributedLockMock(bool acquireLock)
+    {
+        var mockLocker = new Mock<ILocker>();
+        _mockDistributedLock
+            .Setup(d => d.TryAcquireLockAsync(It.IsAny<string>(), It.IsAny<TimeSpan>(), It.IsAny<TimeSpan>()))
+            .ReturnsAsync((mockLocker.Object, acquireLock));
+    }
+}
+