moved acceptable check closer to resources since docs are markdown

consolidated 405 and 406 tests

Author: thefringeninja

src/SqlStreamStore.HAL.Tests/AcceptHeaderTests.cs

@@ -0,0 +1,129 @@
+namespace SqlStreamStore.HAL.Tests
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Collections.Immutable;
+    using System.Linq;
+    using System.Net;
+    using System.Net.Http;
+    using System.Net.Http.Headers;
+    using System.Reflection;
+    using System.Threading.Tasks;
+    using Shouldly;
+    using Xunit;
+
+    public class ClientErrorTests : IDisposable
+    {
+        private static readonly ImmutableHashSet<HttpMethod> s_AllMethods
+            = ImmutableHashSet.Create(
+                (from property in typeof(HttpMethod).GetProperties(BindingFlags.Public | BindingFlags.Static)
+                    where property.PropertyType == typeof(HttpMethod)
+                    select (HttpMethod) property.GetValue(null)).ToArray());
+
+        private static readonly MediaTypeWithQualityHeaderValue s_HalJson =
+            MediaTypeWithQualityHeaderValue.Parse(Constants.MediaTypes.HalJson);
+
+        private static readonly MediaTypeWithQualityHeaderValue s_TextMarkdown =
+            MediaTypeWithQualityHeaderValue.Parse(Constants.MediaTypes.TextMarkdown);
+
+        private static readonly MediaTypeWithQualityHeaderValue s_TextPlain =
+            MediaTypeWithQualityHeaderValue.Parse("text/plain");
+
+        private static readonly (string requestUri, MediaTypeWithQualityHeaderValue[] notAcceptable, HttpMethod[]
+            methods)
+            [] s_ResourceConfigurations =
+            {
+                ("/", new[] { s_TextMarkdown, s_TextPlain }, new[]
+                {
+                    HttpMethod.Get,
+                    HttpMethod.Head
+                }),
+                ("/stream", new[] { s_TextMarkdown, s_TextPlain }, new[]
+                {
+                    HttpMethod.Get,
+                    HttpMethod.Head
+                }),
+                ("/streams/a-stream", new[] { s_TextMarkdown, s_TextPlain }, new[]
+                {
+                    HttpMethod.Get,
+                    HttpMethod.Head,
+                    HttpMethod.Post,
+                    HttpMethod.Delete
+                }),
+                ("/streams/a-stream/0", new[] { s_TextMarkdown, s_TextPlain }, new[]
+                {
+                    HttpMethod.Get,
+                    HttpMethod.Head,
+                    HttpMethod.Delete
+                }),
+                ($"/streams/a-stream/{Guid.Empty}", new[] { s_TextMarkdown, s_TextPlain }, new[]
+                {
+                    HttpMethod.Get,
+                    HttpMethod.Head,
+                    HttpMethod.Delete
+                }),
+
+                ("/streams/a-stream/metadata", new[] { s_TextMarkdown, s_TextPlain }, new[]
+                {
+                    HttpMethod.Get,
+                    HttpMethod.Head,
+                    HttpMethod.Post
+                }),
+                ("/docs/doc", new[] { s_HalJson, s_TextPlain }, new[]
+                {
+                    HttpMethod.Get,
+                    HttpMethod.Head
+                })
+            };
+
+
+        private readonly SqlStreamStoreHalMiddlewareFixture _fixture;
+
+        public ClientErrorTests()
+        {
+            _fixture = new SqlStreamStoreHalMiddlewareFixture();
+        }
+
+        public static IEnumerable<object[]> MethodNotAllowedCases()
+            => from _ in s_ResourceConfigurations
+                let allowed = _.methods.Concat(new[] { HttpMethod.Options }).ToArray() // options are always allowed
+                from method in s_AllMethods.Except(allowed)
+                select new object[] { _.requestUri, method, allowed };
+
+        [Theory, MemberData(nameof(MethodNotAllowedCases))]
+        public async Task method_not_allowed(string requestUri, HttpMethod method, HttpMethod[] allowed)
+        {
+            using(var response = await _fixture.HttpClient.SendAsync(new HttpRequestMessage(method, requestUri)))
+            {
+                response.StatusCode.ShouldBe(HttpStatusCode.MethodNotAllowed);
+
+                response.Headers.TryGetValues(Constants.Headers.Allowed, out var allowedHeaders).ShouldBeTrue();
+
+                allowedHeaders.ShouldBe(allowed.Select(x => x.Method), true);
+            }
+        }
+
+        public static IEnumerable<object[]> NotAcceptableCases()
+            => from _ in s_ResourceConfigurations
+                from method in _.methods.Except(new[] { HttpMethod.Delete }).ToArray() // deletes return 204
+                from notAcceptable in _.notAcceptable
+                select new object[] { _.requestUri, method, notAcceptable };
+
+        [Theory, MemberData(nameof(NotAcceptableCases))]
+        public async Task not_acceptable(
+            string requestUri,
+            HttpMethod method,
+            MediaTypeWithQualityHeaderValue mediaType)
+        {
+            using(var response = await _fixture.HttpClient.SendAsync(new HttpRequestMessage(method, requestUri)
+            {
+                Headers = { Accept = { mediaType } }
+            }))
+            {
+                response.StatusCode.ShouldBe(HttpStatusCode.NotAcceptable);
+            }
+        }
+
+        public void Dispose() => _fixture.Dispose();
+    }
+}

src/SqlStreamStore.HAL.Tests/ClientErrorTests.cs

@@ -0,0 +1,33 @@
+namespace SqlStreamStore.HAL
+{
+    using System.Linq;
+    using Halcyon.HAL;
+    using Microsoft.AspNetCore.Builder;
+    using MidFunc = System.Func<
+        Microsoft.AspNetCore.Http.HttpContext,
+        System.Func<System.Threading.Tasks.Task>,
+        System.Threading.Tasks.Task
+    >;
+
+    internal static class AcceptMiddleware
+    {
+        public static IApplicationBuilder UseAccept(this IApplicationBuilder builder, params string[] acceptable)
+            => builder.Use(Accept(acceptable));
+
+        private static MidFunc Accept(params string[] acceptable) => (context, next) =>
+        {
+            var acceptHeaders = context.Request.GetAcceptHeaders();
+
+            return acceptHeaders.Any(
+                acceptHeader => acceptHeader == Constants.MediaTypes.Any || acceptable.Contains(acceptHeader))
+                ? next()
+                : context.WriteResponse(new HalJsonResponse(new HALResponse(new
+                    {
+                        type = "Not Acceptable",
+                        title = "Not Acceptable",
+                        detail = $"The target resource only understands {string.Join(", ", acceptable)}."
+                    }),
+                    406));
+        };
+    }
+}

src/SqlStreamStore.HAL.Tests/MethodNotAllowedTests.cs

@@ -27,7 +27,9 @@ private static bool IsAllStream(this PathString pathString)
         private static Action<IApplicationBuilder> Configure(AllStreamResource allStream)
             => builder => builder
                 .UseMiddlewareLogging(typeof(AllStreamMiddleware))
-                .MapWhen(HttpMethod.Get, inner => inner.Use(GetStream(allStream)))
+                .MapWhen(
+                    HttpMethod.Get,
+                    inner => inner.UseAccept(Constants.MediaTypes.HalJson).Use(GetStream(allStream)))
                 .UseAllowedMethods(allStream);
 
         private static MidFunc GetStream(AllStreamResource allStream) => async (context, next) =>

src/SqlStreamStore.HAL/AcceptMiddleware.cs

@@ -27,7 +27,9 @@ private static bool IsAllStreamMessage(this PathString requestPath)
         private static Action<IApplicationBuilder> Configure(AllStreamMessageResource allStreamMessages)
             => builder => builder
                 .UseMiddlewareLogging(typeof(AllStreamMessageMiddleware))
-                .MapWhen(HttpMethod.Get, inner => inner.Use(GetStreamMessage(allStreamMessages)))
+                .MapWhen(
+                    HttpMethod.Get,
+                    inner => inner.UseAccept(Constants.MediaTypes.HalJson).Use(GetStreamMessage(allStreamMessages)))
                 .UseAllowedMethods(allStreamMessages);
 
         private static MidFunc GetStreamMessage(AllStreamMessageResource allStreamMessages) => async (context, next) =>

src/SqlStreamStore.HAL/AllStream/AllStreamMiddleware.cs

@@ -38,8 +38,8 @@ Task Docs(HttpContext context, Func<Task> next)
 
             return builder => builder
                 .UseMiddlewareLogging(typeof(DocsMiddleware))
-                .UseAllowedMethods(documentation)
-                .MapWhen(HttpMethod.Get, inner => inner.Use(Docs));
+                .MapWhen(HttpMethod.Get, inner => inner.UseAccept(Constants.MediaTypes.TextMarkdown).Use(Docs))
+                .UseAllowedMethods(documentation);
         }
     }
 }

src/SqlStreamStore.HAL/AllStreamMessage/AllStreamMessageMiddleware.cs

@@ -24,7 +24,7 @@ private static bool IsMatch(HttpContext context)
         private static Action<IApplicationBuilder> Configure(IndexResource index)
             => builder => builder
                 .UseMiddlewareLogging(typeof(IndexMiddleware))
-                .MapWhen(HttpMethod.Get, inner => inner.Use(Index(index)))
+                .MapWhen(HttpMethod.Get, inner => inner.UseAccept(Constants.MediaTypes.HalJson).Use(Index(index)))
                 .UseAllowedMethods(index);
 
         private static MidFunc Index(IndexResource index)