fix: AL0081 skip diagnostic inside test methods

WebApplication.CreateBuilder() in test methods (e.g., endpoint registration
verification) does not need health checks. The analyzer now detects [Test],
[Fact], [Theory], and [TestMethod] attributes and suppresses the diagnostic.

Also fixes AL0084 missing XML doc comment build error.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: ANcpLua

src/ANcpLua.Analyzers/Analyzers/AL0081MissingHealthChecksAnalyzer.cs

@@ -46,6 +46,11 @@ private static void AnalyzeInvocation(SyntaxNodeAnalysisContext context) {
             return;
         }
 
+        // Skip test methods — test code creates WebApplication for endpoint registration verification, not production hosting
+        if (IsInsideTestMethod(invocation)) {
+            return;
+        }
+
         // Find the containing method (likely Main or configuration method)
         if (invocation.Ancestors().OfType<MethodDeclarationSyntax>().FirstOrDefault() is not { } containingMethod) {
             // Also check for top-level statements (no method, but compilation unit)
@@ -96,4 +101,29 @@ private static bool HasHealthChecksConfigured(SyntaxNode scope, SemanticModel se
             },
             _ => null
         };
+
+    private static bool IsInsideTestMethod(SyntaxNode node) {
+        foreach (var ancestor in node.Ancestors()) {
+            if (ancestor is not MethodDeclarationSyntax method) {
+                continue;
+            }
+
+            foreach (var attrList in method.AttributeLists) {
+                foreach (var attr in attrList.Attributes) {
+                    var name = attr.Name switch {
+                        IdentifierNameSyntax id => id.Identifier.Text,
+                        QualifiedNameSyntax qualified => qualified.Right.Identifier.Text,
+                        _ => null
+                    };
+
+                    if (name is "Test" or "TestMethod" or "Fact" or "Theory"
+                        or "TestAttribute" or "TestMethodAttribute" or "FactAttribute" or "TheoryAttribute") {
+                        return true;
+                    }
+                }
+            }
+        }
+
+        return false;
+    }
 }

src/ANcpLua.Analyzers/Analyzers/AL0084MissingServiceDiscoveryAnalyzer.cs

@@ -36,6 +36,13 @@ public sealed partial class Al0084MissingServiceDiscoveryAnalyzer : AlAnalyzer {
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => [Rule];
 
     /// <summary>Registers operation actions to analyze URL assignments.</summary>
+    private static readonly ImmutableArray<string> TestAttributeNames =
+    [
+        "TestFixtureAttribute", // NUnit
+        "TestClassAttribute",   // MSTest
+    ];
+
+    /// <summary>Registers compilation start actions to analyze service discovery configuration.</summary>
     protected override void RegisterActions(AnalysisContext context) =>
         context.RegisterCompilationStartAction(compilationContext => {
             var httpClientType = compilationContext.Compilation.GetTypeByMetadataName("System.Net.Http.HttpClient");
@@ -49,12 +56,16 @@ protected override void RegisterActions(AnalysisContext context) =>
             // Check if service discovery is configured (AddServiceDiscovery called)
             var hasServiceDiscovery = HasServiceDiscoveryConfigured(compilationContext.Compilation);
 
-            compilationContext.RegisterOperationAction(ctx =>
-                AnalyzeAssignment(ctx, httpClientType, hasServiceDiscovery),
+            compilationContext.RegisterOperationAction(ctx => {
+                    if (!IsInTestClass(ctx.ContainingSymbol))
+                        AnalyzeAssignment(ctx, httpClientType, hasServiceDiscovery);
+                },
                 OperationKind.SimpleAssignment);
 
-            compilationContext.RegisterOperationAction(ctx =>
-                AnalyzeObjectCreation(ctx, uriType, hasServiceDiscovery),
+            compilationContext.RegisterOperationAction(ctx => {
+                    if (!IsInTestClass(ctx.ContainingSymbol))
+                        AnalyzeObjectCreation(ctx, uriType, hasServiceDiscovery);
+                },
                 OperationKind.ObjectCreation);
         });
 
@@ -223,6 +234,21 @@ private static bool IsLocalhost(string host) =>
         }
     }
 
+    private static bool IsInTestClass(ISymbol? containingSymbol) {
+        var type = containingSymbol as INamedTypeSymbol ?? containingSymbol?.ContainingType;
+        while (type is not null) {
+            foreach (var name in TestAttributeNames) {
+                if (type.HasAttributeByShortName(name)) {
+                    return true;
+                }
+            }
+
+            type = type.ContainingType;
+        }
+
+        return false;
+    }
+
     private static bool IsHttpClientRelated(IOperation operation, out bool isDirectBaseAddressAssignment) {
         isDirectBaseAddressAssignment = false;
 

tests/ANcpLua.Analyzers.Tests/AL0081MissingHealthChecksTests.cs

@@ -113,4 +113,24 @@ public static void Main() {
                 }
             }
             """);
+
+    [Theory]
+    [InlineData("Test")]
+    [InlineData("Fact")]
+    [InlineData("Theory")]
+    [InlineData("TestMethod")]
+    public Task ShouldNotReportInsideTestMethod(string attribute) =>
+        VerifyAsync(
+            $$"""
+            namespace TestFramework {
+                public class {{attribute}}Attribute : System.Attribute { }
+            }
+            public class MyTests {
+                [TestFramework.{{attribute}}]
+                public void EndpointTest() {
+                    var builder = WebApplication.CreateBuilder();
+                    var app = builder.Build();
+                }
+            }
+            """);
 }