more tests and simplify ReflectionExtensions

Author: SimonCropp

src/Paramore.Brighter/Extensions/ReflectionExtensions.cs

@@ -22,9 +22,7 @@ THE SOFTWARE. */
 
 #endregion
 
-using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Reflection;
 using Paramore.Brighter.Inbox.Attributes;
 
@@ -33,22 +31,13 @@ namespace Paramore.Brighter.Extensions
     internal static class ReflectionExtensions
     {
         internal static IEnumerable<RequestHandlerAttribute> GetOtherHandlersInPipeline(this MethodInfo targetMethod)
-        {
-            var customAttributes = targetMethod.GetCustomAttributes(true);
-            return customAttributes.OfType<RequestHandlerAttribute>();
-        }
+            => targetMethod.GetCustomAttributes<RequestHandlerAttribute>(true);
 
         internal static IEnumerable<WrapWithAttribute> GetOtherWrapsInPipeline(this MethodInfo targetMethod)
-        {
-            var customAttributes = targetMethod.GetCustomAttributes(true);
-            return customAttributes.OfType<WrapWithAttribute>();
-        }
+            => targetMethod.GetCustomAttributes<WrapWithAttribute>(true);
 
         internal static IEnumerable<UnwrapWithAttribute> GetOtherUnwrapsInPipeline(this MethodInfo targetMethod)
-        {
-            var customAttributes = targetMethod.GetCustomAttributes(true);
-            return customAttributes.OfType<UnwrapWithAttribute>();
-        }
+            => targetMethod.GetCustomAttributes<UnwrapWithAttribute>(true);
 
         internal static bool HasNoInboxAttributesInPipeline(this MethodInfo targetMethod)
             => targetMethod.IsDefined(typeof(NoGlobalInboxAttribute), true);

tests/Paramore.Brighter.Core.Tests/Extensions/ReflectionExtensionsTests.cs

@@ -69,6 +69,34 @@ private sealed class AnotherUnwrapWithAttribute(int step) :
         public override Type GetHandlerType() => typeof(object);
     }
 
+    // Deeply inherited attributes (two levels of inheritance)
+    private class BaseRequestHandlerAttribute(int step) :
+        RequestHandlerAttribute(step)
+    {
+        public override Type GetHandlerType() => typeof(object);
+    }
+
+    private sealed class DerivedRequestHandlerAttribute(int step) :
+        BaseRequestHandlerAttribute(step);
+
+    private class BaseWrapWithAttribute(int step) :
+        WrapWithAttribute(step)
+    {
+        public override Type GetHandlerType() => typeof(object);
+    }
+
+    private sealed class DerivedWrapWithAttribute(int step) :
+        BaseWrapWithAttribute(step);
+
+    private class BaseUnwrapWithAttribute(int step) :
+        UnwrapWithAttribute(step)
+    {
+        public override Type GetHandlerType() => typeof(object);
+    }
+
+    private sealed class DerivedUnwrapWithAttribute(int step) :
+        BaseUnwrapWithAttribute(step);
+
     private sealed class NoAttributesHandler
     {
         public void Handle() { }
@@ -140,6 +168,25 @@ private sealed class MixedAttributesHandler
         public void Handle() { }
     }
 
+    // Handlers with deeply inherited attributes
+    private sealed class DeeplyInheritedRequestHandlerAttributeHandler
+    {
+        [DerivedRequestHandler(1)]
+        public void Handle() { }
+    }
+
+    private sealed class DeeplyInheritedWrapWithAttributeMapper
+    {
+        [DerivedWrapWith(1)]
+        public void MapToMessage() { }
+    }
+
+    private sealed class DeeplyInheritedUnwrapWithAttributeMapper
+    {
+        [DerivedUnwrapWith(1)]
+        public void MapToRequest() { }
+    }
+
     [Fact]
     public void When_method_has_no_attributes_should_return_empty()
     {
@@ -188,6 +235,18 @@ public void When_method_has_non_request_handler_attributes_should_not_return_the
         Assert.IsType<TestRequestHandlerAttribute>(result[0]);
     }
 
+    [Fact]
+    public void When_method_has_deeply_inherited_request_handler_attribute_should_return_it()
+    {
+        var method = typeof(DeeplyInheritedRequestHandlerAttributeHandler)
+            .GetMethod(nameof(DeeplyInheritedRequestHandlerAttributeHandler.Handle))!;
+
+        var result = method.GetOtherHandlersInPipeline().ToList();
+
+        Assert.Single(result);
+        Assert.IsType<DerivedRequestHandlerAttribute>(result[0]);
+    }
+
     [Fact]
     public void When_method_has_no_wrap_attributes_should_return_empty()
     {
@@ -236,6 +295,18 @@ public void When_method_has_non_wrap_attributes_should_not_return_them()
         Assert.IsType<TestWrapWithAttribute>(result[0]);
     }
 
+    [Fact]
+    public void When_method_has_deeply_inherited_wrap_attribute_should_return_it()
+    {
+        var method = typeof(DeeplyInheritedWrapWithAttributeMapper)
+            .GetMethod(nameof(DeeplyInheritedWrapWithAttributeMapper.MapToMessage))!;
+
+        var result = method.GetOtherWrapsInPipeline().ToList();
+
+        Assert.Single(result);
+        Assert.IsType<DerivedWrapWithAttribute>(result[0]);
+    }
+
     [Fact]
     public void When_method_has_no_unwrap_attributes_should_return_empty()
     {
@@ -284,6 +355,18 @@ public void When_method_has_non_unwrap_attributes_should_not_return_them()
         Assert.IsType<TestUnwrapWithAttribute>(result[0]);
     }
 
+    [Fact]
+    public void When_method_has_deeply_inherited_unwrap_attribute_should_return_it()
+    {
+        var method = typeof(DeeplyInheritedUnwrapWithAttributeMapper)
+            .GetMethod(nameof(DeeplyInheritedUnwrapWithAttributeMapper.MapToRequest))!;
+
+        var result = method.GetOtherUnwrapsInPipeline().ToList();
+
+        Assert.Single(result);
+        Assert.IsType<DerivedUnwrapWithAttribute>(result[0]);
+    }
+
     [Fact]
     public void When_method_has_no_inbox_attribute_should_return_true()
     {