handling special case where request uri is not rooted at the pathbase

Author: thefringeninja

src/SqlStreamStore.Server/Browser/SqlStreamStoreBrowserMiddleware.cs

@@ -12,17 +12,19 @@ namespace SqlStreamStore.Server.Browser
     internal static class SqlStreamStoreBrowserMiddleware
     {
         public static IApplicationBuilder UseSqlStreamStoreBrowser(
-            this IApplicationBuilder builder)
+            this IApplicationBuilder builder,
+            Type rootType = default)
         {
+            rootType = rootType ?? typeof(SqlStreamStoreBrowserMiddleware);
             var sqlStreamStoreBrowserFileProvider = new EmbeddedFileProvider(
-                typeof(SqlStreamStoreBrowserMiddleware).Assembly,
-                typeof(SqlStreamStoreBrowserMiddleware).Namespace);
+                rootType.Assembly,
+                rootType.Namespace);
 
-            var staticFiles = typeof(SqlStreamStoreBrowserMiddleware).Assembly.GetManifestResourceNames()
-                .Where(name => name.StartsWith(typeof(SqlStreamStoreBrowserMiddleware).Namespace));
+            var staticFiles = rootType.Assembly.GetManifestResourceNames()
+                .Where(name => name.StartsWith(rootType.Namespace));
 
             Log.Debug(
-                "The following embedded resources were found and will be served as static content: {staticFiles}", 
+                "The following embedded resources were found and will be served as static content: {staticFiles}",
                 string.Join(", ", staticFiles));
 
             return builder.Use(IndexPage).UseStaticFiles(new StaticFileOptions
@@ -32,11 +34,12 @@ public static IApplicationBuilder UseSqlStreamStoreBrowser(
 
             Task IndexPage(HttpContext context, Func<Task> next)
             {
-                if(GetAcceptHeaders(context.Request).Contains("text/html"))
+                if (!GetAcceptHeaders(context.Request).Contains("text/html"))
                 {
-                    context.Request.Path = new PathString("/index.html");
+                    return TryRedirectStaticContent(context, next);
                 }
 
+                context.Request.Path = new PathString("/index.html");
                 return next();
             }
         }
@@ -47,5 +50,36 @@ private static string[] GetAcceptHeaders(HttpRequest contextRequest)
                 value => MediaTypeWithQualityHeaderValue.TryParse(value, out var header)
                     ? header.MediaType
                     : null);
+
+        private static Task TryRedirectStaticContent(HttpContext context, Func<Task> next)
+        {
+            if (!context.Request.Path.HasValue)
+            {
+                return next();
+            }
+
+            var requestPieces = context.Request.Path.Value.Split('/');
+
+            for (var i = 2; i < requestPieces.Length; i++)
+            {
+                if (requestPieces[i] != "static")
+                {
+                    continue;
+                }
+
+                var staticFilePath = new string[requestPieces.Length - i];
+                for (var j = i; j < requestPieces.Length; j++)
+                {
+                    staticFilePath[j - i] = requestPieces[j];
+                }
+
+                context.Response.StatusCode = 308;
+                context.Response.Headers["Location"] =
+                    $"{string.Join("/", Enumerable.Repeat("..", i + 1))}/{string.Join("/", staticFilePath)}";
+                return Task.CompletedTask;
+            }
+
+            return next();
+        }
     }
 }

src/SqlStreamStore.Server/SqlStreamStoreServerStartup.cs

@@ -4,7 +4,6 @@
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Http;
 using Microsoft.Extensions.DependencyInjection;
-using Serilog;
 using SqlStreamStore.HAL;
 using SqlStreamStore.Server.Browser;
 

tests/SqlStreamStore.Server.Tests/Browser/SqlStreamStoreBrowserTests.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.TestHost;
+using SqlStreamStore.Server.Browser;
+using Xunit;
+
+namespace SqlStreamStore.Server.Tests.Browser
+{
+    public class SqlStreamStoreBrowserTests : IDisposable
+    {
+        private readonly TestServer _server;
+        private readonly HttpClient _httpClient;
+
+        public SqlStreamStoreBrowserTests()
+        {
+            _server = new TestServer(
+                new WebHostBuilder()
+                    .Configure(app => app.UseSqlStreamStoreBrowser(typeof(SqlStreamStoreBrowserTests))));
+
+            _httpClient = new HttpClient(_server.CreateHandler())
+            {
+                BaseAddress = new UriBuilder().Uri
+            };
+        }
+
+        public static IEnumerable<object[]> IndexPageCases()
+        {
+            yield return new object[] {"/"};
+            yield return new object[] {"/stream"};
+            yield return new object[] {"/streams/a-stream"};
+            yield return new object[] {"/streams/a-stream/metadata"};
+        }
+
+        [Theory, MemberData(nameof(IndexPageCases))]
+        public async Task RequestsForHtmlReturnTheIndexPage(string path)
+        {
+            using (var response = await _httpClient.SendAsync(new HttpRequestMessage(HttpMethod.Get, path)
+            {
+                Headers = {Accept = {new MediaTypeWithQualityHeaderValue("text/html")}}
+            }))
+            {
+                Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+                Assert.Equal(await GetStaticEmbeddedResource("index.html"), await response.Content.ReadAsStringAsync());
+            }
+        }
+
+        [Fact]
+        public async Task RequestsForStaticFilesFromRootAreReturned()
+        {
+            using (var response = await _httpClient.SendAsync(
+                new HttpRequestMessage(HttpMethod.Get, "/static/js/ws.js")
+                {
+                    Headers = {Accept = {new MediaTypeWithQualityHeaderValue("*/*")}}
+                }))
+            {
+                Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+                Assert.Equal(
+                    await GetStaticEmbeddedResource("static.js.ws.js"),
+                    await response.Content.ReadAsStringAsync());
+            }
+        }
+
+        public static IEnumerable<object[]> StaticContentCases()
+        {
+            yield return new object[] {"/stream/", "../../../"};
+            yield return new object[] {"/streams/a-stream/", "../../../../"};
+            yield return new object[] {"/streams/a-stream/metadata/", "../../../../../"};
+        }
+
+        [Theory, MemberData(nameof(StaticContentCases))]
+        public async Task RequestsForStaticAreRedirectedIfNotAtRoot(string path, string parent)
+        {
+            using (var response = await _httpClient.SendAsync(
+                new HttpRequestMessage(HttpMethod.Get, $"{path}static/js/ws.js")
+                {
+                    Headers = {Accept = {new MediaTypeWithQualityHeaderValue("*/*")}}
+                }))
+            {
+                Assert.Equal(HttpStatusCode.PermanentRedirect, response.StatusCode);
+                Assert.Equal($"{parent}static/js/ws.js", response.Headers.Location?.ToString());
+            }
+        }
+
+        private static async Task<string> GetStaticEmbeddedResource(string resource)
+        {
+            using (var stream = typeof(SqlStreamStoreBrowserTests)
+                .Assembly
+                .GetManifestResourceStream(typeof(SqlStreamStoreBrowserTests), resource))
+            using (var reader = new StreamReader(stream))
+            {
+                return await reader.ReadToEndAsync();
+            }
+        }
+
+        public void Dispose()
+        {
+            _httpClient?.Dispose();
+            _server?.Dispose();
+        }
+    }
+}

tests/SqlStreamStore.Server.Tests/Browser/index.html

@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Title</title>
+</head>
+<body>
+
+</body>
+</html>

tests/SqlStreamStore.Server.Tests/Browser/static/js/ws.js

@@ -0,0 +1,2 @@
+(function () {
+})();

tests/SqlStreamStore.Server.Tests/SqlStreamStore.Server.Tests.csproj

@@ -13,4 +13,12 @@
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1" />
   </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="Browser\**" Exclude="Browser\**\*.cs">
+      <Link>Browser\%(RecursiveDir)%(Filename)%(Extension)</Link>
+    </EmbeddedResource>
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Browser\static\js\ws.js" />
+  </ItemGroup>
 </Project>

tests/SqlStreamStore.Server.Tests/SqlStreamStoreServerStartupTests.cs

@@ -4,7 +4,6 @@
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.TestHost;
-using Microsoft.Extensions.DependencyInjection;
 using SqlStreamStore;
 using SqlStreamStore.HAL;
 using SqlStreamStore.Server;
@@ -15,8 +14,7 @@ namespace SQLStreamStore.Server.Tests
     public class SqlStreamStoreServerStartupTests : IDisposable
     {
         private readonly InMemoryStreamStore _streamStore;
-        private readonly IWebHost _host;
-        private TestServer _server;
+        private readonly TestServer _server;
         private readonly HttpClient _httpClient;
 
         public SqlStreamStoreServerStartupTests()
@@ -52,7 +50,7 @@ public async Task StartsUp()
         public void Dispose()
         {
             _streamStore?.Dispose();
-            _host?.Dispose();
+            _server?.Dispose();
             _httpClient?.Dispose();
         }
     }