Qualify handler order attribute analysis

Author: cursoragent

DesignPatterns.Analyzers/UnregisteredHandlerAnalyzer.cs

@@ -143,13 +143,21 @@ private static bool IsHandlerOrderAttribute(INamedTypeSymbol? attributeClass)
             return false;
         }
 
-        var metadataName = attributeClass.MetadataName;
-        if (metadataName == "HandlerOrderAttribute")
+        return GetFullMetadataName(attributeClass) == HandlerAnalysisConstants.HandlerOrderMetadataName ||
+               GetFullMetadataName(attributeClass.OriginalDefinition) == HandlerAnalysisConstants.HandlerOrderGenericMetadataName;
+    }
+
+    private static string GetFullMetadataName(INamedTypeSymbol typeSymbol)
+    {
+        var metadataName = typeSymbol.MetadataName;
+        for (var containingType = typeSymbol.ContainingType; containingType is not null; containingType = containingType.ContainingType)
         {
-            return true;
+            metadataName = containingType.MetadataName + "+" + metadataName;
         }
 
-        return attributeClass.OriginalDefinition.MetadataName == "HandlerOrderAttribute`1";
+        return typeSymbol.ContainingNamespace.IsGlobalNamespace
+            ? metadataName
+            : typeSymbol.ContainingNamespace.ToDisplayString() + "." + metadataName;
     }
 
     private static INamedTypeSymbol? TryGetContextFromAttribute(AttributeData attribute)

tests/DesignPatterns.Analyzers.Tests/UnregisteredHandlerAnalyzerTests.cs

@@ -112,4 +112,113 @@ public ValueTask InvokeAsync(
 
         Assert.DoesNotContain(diagnostics, diagnostic => diagnostic.Id == "DP024");
     }
+
+    [Fact]
+    public async Task DoesNotTreatForeignHandlerOrderAsRegisteredContext()
+    {
+        const string source = """
+            using System;
+            using System.Threading;
+            using System.Threading.Tasks;
+            using DesignPatterns.Behavioral;
+
+            namespace Other
+            {
+                [AttributeUsage(AttributeTargets.Class)]
+                public sealed class HandlerOrderAttribute : Attribute
+                {
+                    public HandlerOrderAttribute(int order, Type contextType) { }
+                }
+            }
+
+            namespace TestAssembly
+            {
+                public sealed class RequestContext
+                {
+                }
+
+                [Other.HandlerOrder(10, typeof(RequestContext))]
+                public sealed class LoggingHandler : IHandler<RequestContext>
+                {
+                    public ValueTask InvokeAsync(
+                        RequestContext context,
+                        HandlerDelegate<RequestContext> next,
+                        CancellationToken cancellationToken = default) =>
+                        default;
+                }
+
+                public sealed class AuditHandler : IHandler<RequestContext>
+                {
+                    public ValueTask InvokeAsync(
+                        RequestContext context,
+                        HandlerDelegate<RequestContext> next,
+                        CancellationToken cancellationToken = default) =>
+                        default;
+                }
+            }
+            """;
+
+        var diagnostics = await AnalyzerTestContext.RunAnalyzersAsync(
+            source,
+            new UnregisteredHandlerAnalyzer());
+
+        Assert.DoesNotContain(diagnostics, diagnostic => diagnostic.Id == "DP024");
+    }
+
+    [Fact]
+    public async Task ReportsWhenOnlyForeignHandlerOrderIsPresentOnImplementation()
+    {
+        const string source = """
+            using System;
+            using System.Threading;
+            using System.Threading.Tasks;
+            using DesignPatterns.Behavioral;
+
+            namespace Other
+            {
+                [AttributeUsage(AttributeTargets.Class)]
+                public sealed class HandlerOrderAttribute<TContext> : Attribute
+                {
+                    public HandlerOrderAttribute(int order) { }
+                }
+            }
+
+            namespace TestAssembly
+            {
+                public sealed class RequestContext
+                {
+                }
+
+                [DesignPatterns.Behavioral.HandlerOrder<RequestContext>(10)]
+                public sealed class LoggingHandler : IHandler<RequestContext>
+                {
+                    public ValueTask InvokeAsync(
+                        RequestContext context,
+                        HandlerDelegate<RequestContext> next,
+                        CancellationToken cancellationToken = default) =>
+                        default;
+                }
+
+                [Other.HandlerOrder<RequestContext>(20)]
+                public sealed class AuditHandler : IHandler<RequestContext>
+                {
+                    public ValueTask InvokeAsync(
+                        RequestContext context,
+                        HandlerDelegate<RequestContext> next,
+                        CancellationToken cancellationToken = default) =>
+                        default;
+                }
+            }
+            """;
+
+        var diagnostics = await AnalyzerTestContext.RunAnalyzersAsync(
+            source,
+            new UnregisteredHandlerAnalyzer());
+
+        Assert.Contains(
+            diagnostics,
+            diagnostic =>
+                diagnostic.Id == "DP024" &&
+                diagnostic.GetMessage().Contains("AuditHandler", StringComparison.Ordinal));
+    }
 }