Improves sitemap generation and route handling.

Refactors sitemap XML generation to use a dedicated service for route configuration.

This change improves the sitemap generation process by:

- Introducing `IRouteConfigurationService` to centralize route retrieval and filtering logic.
- Excluding Identity, Index, and Error routes from the sitemap.
- Adding tests to validate sitemap generation.
- Configuring the base URL for sitemap generation through configuration.
- Ensuring sitemap health by validating canonical links.

This approach provides better control over the routes included in the sitemap and enhances the overall maintainability and testability of the sitemap generation process.

Author: BenjaminMichaelis

EssentialCSharp.Web.Tests/RouteConfigurationServiceTests.cs

@@ -1,28 +1,26 @@
 using EssentialCSharp.Web.Services;
-using Microsoft.AspNetCore.Mvc.Testing;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace EssentialCSharp.Web.Tests;
 
 public class RouteConfigurationServiceTests : IClassFixture<WebApplicationFactory>
 {
     private readonly WebApplicationFactory _Factory;
-    private readonly IRouteConfigurationService _RouteConfigurationService;
 
-    internal RouteConfigurationServiceTests(WebApplicationFactory factory)
+    public RouteConfigurationServiceTests(WebApplicationFactory factory)
     {
         _Factory = factory;
-
-        // Get the service from the DI container to test with real routes
-        var scope = _Factory.Services.CreateScope();
-        _RouteConfigurationService = scope.ServiceProvider.GetRequiredService<IRouteConfigurationService>();
     }
 
     [Fact]
     public void GetStaticRoutes_ShouldReturnExpectedRoutes()
     {
         // Act
-        var routes = _RouteConfigurationService.GetStaticRoutes().ToList();
+        var routes = _Factory.InServiceScope(serviceProvider =>
+        {
+            var routeConfigurationService = serviceProvider.GetRequiredService<IRouteConfigurationService>();
+            return routeConfigurationService.GetStaticRoutes().ToList();
+        });
 
         // Assert
         Assert.NotEmpty(routes);
@@ -34,32 +32,4 @@ public void GetStaticRoutes_ShouldReturnExpectedRoutes()
         Assert.Contains("announcements", routes);
         Assert.Contains("termsofservice", routes);
     }
-
-    [Fact]
-    public void GetStaticRoutes_ShouldIncludeAllHomeControllerRoutes()
-    {
-        // Act
-        var routes = _RouteConfigurationService.GetStaticRoutes().ToHashSet(StringComparer.OrdinalIgnoreCase);
-
-        // Assert - check all expected routes from HomeController
-        var expectedRoutes = new[] { "home", "about", "guidelines", "announcements", "termsofservice" };
-
-        foreach (var expectedRoute in expectedRoutes)
-        {
-            Assert.True(routes.Contains(expectedRoute),
-                $"Expected route '{expectedRoute}' was not found in discovered routes: [{string.Join(", ", routes)}]");
-        }
-    }
-
-    [Fact]
-    public void GetStaticRoutes_ShouldNotIncludeIdentityRoutes()
-    {
-        // Act
-        var routes = _RouteConfigurationService.GetStaticRoutes();
-
-        // Assert - ensure no Identity area routes are included
-        Assert.DoesNotContain("identity", routes, StringComparer.OrdinalIgnoreCase);
-    }
-
-
 }

EssentialCSharp.Web.Tests/SitemapXmlHelpersTests.cs

@@ -0,0 +1,285 @@
+using System.Globalization;
+using DotnetSitemapGenerator;
+using EssentialCSharp.Web.Helpers;
+using EssentialCSharp.Web.Services;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+
+namespace EssentialCSharp.Web.Tests;
+
+public class SitemapXmlHelpersTests : IClassFixture<WebApplicationFactory>
+{
+    private readonly WebApplicationFactory _Factory;
+
+    public SitemapXmlHelpersTests(WebApplicationFactory factory)
+    {
+        _Factory = factory;
+    }
+
+    [Fact]
+    public void EnsureSitemapHealthy_WithValidSiteMappings_DoesNotThrow()
+    {
+        // Arrange
+        var siteMappings = new List<SiteMapping>
+        {
+            CreateSiteMapping(1, 1, true),
+            CreateSiteMapping(1, 2, true),
+            CreateSiteMapping(2, 1, true)
+        };
+
+        // Act & Assert
+        var exception = Record.Exception(() => SitemapXmlHelpers.EnsureSitemapHealthy(siteMappings));
+        Assert.Null(exception);
+    }
+
+    [Fact]
+    public void EnsureSitemapHealthy_WithMultipleCanonicalLinksForSamePage_ThrowsException()
+    {
+        // Arrange - Two mappings for the same chapter/page both marked as canonical
+        var siteMappings = new List<SiteMapping>
+        {
+            CreateSiteMapping(1, 1, true),
+            CreateSiteMapping(1, 1, true) // Same chapter/page, also canonical
+        };
+
+        // Act & Assert
+        var exception = Assert.Throws<InvalidOperationException>(() =>
+            SitemapXmlHelpers.EnsureSitemapHealthy(siteMappings));
+
+        Assert.Contains("Chapter 1, Page 1", exception.Message);
+        Assert.Contains("more than one canonical link", exception.Message);
+    }
+
+    [Fact]
+    public void EnsureSitemapHealthy_WithNoCanonicalLinksForPage_ThrowsException()
+    {
+        // Arrange - No mappings marked as canonical for this page
+        var siteMappings = new List<SiteMapping>
+        {
+            CreateSiteMapping(1, 1, false),
+            CreateSiteMapping(1, 1, false) // Same chapter/page, neither canonical
+        };
+
+        // Act & Assert
+        var exception = Assert.Throws<InvalidOperationException>(() =>
+            SitemapXmlHelpers.EnsureSitemapHealthy(siteMappings));
+
+        Assert.Contains("Chapter 1, Page 1", exception.Message);
+    }
+
+    [Fact]
+    public void GenerateSitemapXml_DoesNotIncludeIdentityRoutes()
+    {
+        // Arrange
+        var tempDir = new DirectoryInfo(Path.GetTempPath());
+        var siteMappings = new List<SiteMapping> { CreateSiteMapping(1, 1, true) };
+        var baseUrl = "https://test.example.com/";
+
+        // Act & Assert
+        var nodes = _Factory.InServiceScope(serviceProvider =>
+        {
+            var routeConfigurationService = serviceProvider.GetRequiredService<IRouteConfigurationService>();
+            SitemapXmlHelpers.GenerateSitemapXml(
+                tempDir,
+                siteMappings,
+                routeConfigurationService,
+                baseUrl,
+                out var nodes);
+            return nodes;
+        });
+
+        var allUrls = nodes.Select(n => n.Url).ToList();
+
+        // Verify no Identity routes are included
+        Assert.DoesNotContain(allUrls, url => url.Contains("Identity", StringComparison.OrdinalIgnoreCase));
+        Assert.DoesNotContain(allUrls, url => url.Contains("Account", StringComparison.OrdinalIgnoreCase));
+
+        // But verify that expected routes are included
+        Assert.Contains(allUrls, url => url.Contains("/home", StringComparison.OrdinalIgnoreCase));
+        Assert.Contains(allUrls, url => url.Contains("/about", StringComparison.OrdinalIgnoreCase));
+    }
+
+    [Fact]
+    public void GenerateSitemapXml_IncludesBaseUrl()
+    {
+        // Arrange
+        var tempDir = new DirectoryInfo(Path.GetTempPath());
+        var siteMappings = new List<SiteMapping>();
+        var baseUrl = "https://test.example.com/";
+
+        // Act & Assert
+        var nodes = _Factory.InServiceScope(serviceProvider =>
+        {
+            var routeConfigurationService = serviceProvider.GetRequiredService<IRouteConfigurationService>();
+            SitemapXmlHelpers.GenerateSitemapXml(
+                tempDir,
+                siteMappings,
+                routeConfigurationService,
+                baseUrl,
+                out var nodes);
+            return nodes;
+        });
+
+        Assert.Contains(nodes, node => node.Url == baseUrl);
+
+        // Verify the root URL has highest priority
+        var rootNode = nodes.First(node => node.Url == baseUrl);
+        Assert.Equal(1.0M, rootNode.Priority);
+        Assert.Equal(ChangeFrequency.Daily, rootNode.ChangeFrequency);
+    }
+
+    [Fact]
+    public void GenerateSitemapXml_IncludesSiteMappingsMarkedForXml()
+    {
+        // Arrange
+        var tempDir = new DirectoryInfo(Path.GetTempPath());
+        var baseUrl = "https://test.example.com/";
+
+        var siteMappings = new List<SiteMapping>
+        {
+            CreateSiteMapping(1, 1, true, "test-page-1"),
+            CreateSiteMapping(1, 2, false, "test-page-2"), // Not included in XML
+            CreateSiteMapping(2, 1, true, "test-page-3")
+        };
+
+        // Act & Assert
+        _Factory.InServiceScope(serviceProvider =>
+        {
+            var routeConfigurationService = serviceProvider.GetRequiredService<IRouteConfigurationService>();
+            SitemapXmlHelpers.GenerateSitemapXml(
+                tempDir,
+                siteMappings,
+                routeConfigurationService,
+                baseUrl,
+                out var nodes);
+
+            var allUrls = nodes.Select(n => n.Url).ToList();
+
+            Assert.Contains(allUrls, url => url.Contains("test-page-1"));
+            Assert.DoesNotContain(allUrls, url => url.Contains("test-page-2")); // Not marked for XML
+            Assert.Contains(allUrls, url => url.Contains("test-page-3"));
+        });
+    }
+
+    [Fact]
+    public void GenerateSitemapXml_DoesNotIncludeIndexRoutes()
+    {
+        // Arrange
+        var tempDir = new DirectoryInfo(Path.GetTempPath());
+        var siteMappings = new List<SiteMapping>();
+        var baseUrl = "https://test.example.com/";
+
+        // Act & Assert
+        _Factory.InServiceScope(serviceProvider =>
+        {
+            var routeConfigurationService = serviceProvider.GetRequiredService<IRouteConfigurationService>();
+            SitemapXmlHelpers.GenerateSitemapXml(
+                tempDir,
+                siteMappings,
+                routeConfigurationService,
+                baseUrl,
+                out var nodes);
+
+            var allUrls = nodes.Select(n => n.Url).ToList();
+
+            // Should not include Index action routes (they're the default)
+            Assert.DoesNotContain(allUrls, url => url.Contains("/Index", StringComparison.OrdinalIgnoreCase));
+        });
+    }
+
+    [Fact]
+    public void GenerateSitemapXml_DoesNotIncludeErrorRoutes()
+    {
+        // Arrange
+        var tempDir = new DirectoryInfo(Path.GetTempPath());
+        var siteMappings = new List<SiteMapping>();
+        var baseUrl = "https://test.example.com/";
+
+        // Act & Assert
+        _Factory.InServiceScope(serviceProvider =>
+        {
+            var routeConfigurationService = serviceProvider.GetRequiredService<IRouteConfigurationService>();
+            SitemapXmlHelpers.GenerateSitemapXml(
+                tempDir,
+                siteMappings,
+                routeConfigurationService,
+                baseUrl,
+                out var nodes);
+
+            var allUrls = nodes.Select(n => n.Url).ToList();
+
+            // Should not include Error action routes
+            Assert.DoesNotContain(allUrls, url => url.Contains("/Error", StringComparison.OrdinalIgnoreCase));
+        });
+    }
+
+    [Fact]
+    public void GenerateAndSerializeSitemapXml_CreatesFileSuccessfully()
+    {
+        // Arrange
+        var logger = _Factory.Services.GetRequiredService<ILogger<SitemapXmlHelpersTests>>();
+        var tempDir = new DirectoryInfo(Path.GetTempPath());
+        var siteMappings = new List<SiteMapping> { CreateSiteMapping(1, 1, true) };
+        var baseUrl = "https://test.example.com/";
+
+        // Clean up any existing file
+        var expectedXmlPath = Path.Combine(tempDir.FullName, "sitemap.xml");
+        if (File.Exists(expectedXmlPath))
+        {
+            File.Delete(expectedXmlPath);
+        }
+
+        try
+        {
+            // Act
+            _Factory.InServiceScope(serviceProvider =>
+            {
+                var routeConfigurationService = serviceProvider.GetRequiredService<IRouteConfigurationService>();
+                SitemapXmlHelpers.GenerateAndSerializeSitemapXml(
+                    tempDir,
+                    siteMappings,
+                    logger,
+                    routeConfigurationService,
+                    baseUrl);
+            });
+
+            // Assert
+            Assert.True(File.Exists(expectedXmlPath));
+
+            var xmlContent = File.ReadAllText(expectedXmlPath);
+            Assert.Contains("<?xml", xmlContent);
+            Assert.Contains("<urlset", xmlContent);
+            Assert.Contains(baseUrl, xmlContent);
+        }
+        finally
+        {
+            // Clean up
+            if (File.Exists(expectedXmlPath))
+            {
+                File.Delete(expectedXmlPath);
+            }
+        }
+    }
+
+    private static SiteMapping CreateSiteMapping(
+        int chapterNumber,
+        int pageNumber,
+        bool includeInSitemapXml,
+        string key = "test-key")
+    {
+        return new SiteMapping(
+            keys: [key],
+            primaryKey: key,
+            pagePath: ["Chapters", chapterNumber.ToString("00", CultureInfo.InvariantCulture), "Pages", $"{pageNumber:00}.html"],
+            chapterNumber: chapterNumber,
+            pageNumber: pageNumber,
+            orderOnPage: 0,
+            chapterTitle: $"Chapter {chapterNumber}",
+            rawHeading: "Test Heading",
+            anchorId: key,
+            indentLevel: 1,
+            contentHash: "TestHash123",
+            includeInSitemapXml: includeInSitemapXml
+        );
+    }
+}

EssentialCSharp.Web.Tests/WebApplicationFactory.cs

@@ -6,7 +6,7 @@
 
 namespace EssentialCSharp.Web.Tests;
 
-internal sealed class WebApplicationFactory : WebApplicationFactory<Program>
+public sealed class WebApplicationFactory : WebApplicationFactory<Program>
 {
     protected override void ConfigureWebHost(IWebHostBuilder builder)
     {
@@ -36,4 +36,28 @@ protected override void ConfigureWebHost(IWebHostBuilder builder)
             db.Database.EnsureCreated();
         });
     }
+
+    /// <summary>
+    /// Executes an action within a service scope, handling scope creation and cleanup automatically.
+    /// </summary>
+    /// <typeparam name="T">The return type of the action</typeparam>
+    /// <param name="action">The action to execute with the scoped service provider</param>
+    /// <returns>The result of the action</returns>
+    public T InServiceScope<T>(Func<IServiceProvider, T> action)
+    {
+        var factory = Services.GetRequiredService<IServiceScopeFactory>();
+        using var scope = factory.CreateScope();
+        return action(scope.ServiceProvider);
+    }
+
+    /// <summary>
+    /// Executes an action within a service scope, handling scope creation and cleanup automatically.
+    /// </summary>
+    /// <param name="action">The action to execute with the scoped service provider</param>
+    public void InServiceScope(Action<IServiceProvider> action)
+    {
+        var factory = Services.GetRequiredService<IServiceScopeFactory>();
+        using var scope = factory.CreateScope();
+        action(scope.ServiceProvider);
+    }
 }