refactor(source-generators-tests): 拆分 ContextRegistrationAnalyzerTests 结构

- 重构 ContextRegistrationAnalyzerTests 的场景源码常量，保持 analyzer 输入与 markup span 不变

- 补充测试方法与辅助 helper 文档，并统一诊断断言路径以收口 MA0051

GFramework.SourceGenerators.Tests/Analyzers/ContextRegistrationAnalyzerTests.cs

@@ -132,11 +132,8 @@ public sealed class ContextRegistrationAnalyzerTests
                                         }
                                         """;
 
-    [Test]
+    // Keep scenario fixtures at class scope so MA0051 reduction does not change analyzer inputs or markup spans.
-    public async Task Reports_Warning_When_FieldInjectedModel_Is_Not_Registered()
+    private const string MissingFieldInjectedModelRegistrationSource = """
-    {
-        var markup = MarkupTestSource.Parse(
-            Wrap("""
                                                                       namespace TestApp
                                                                       {
                                                                           using GFramework.Core.Abstractions.Model;
@@ -160,21 +157,9 @@ public sealed class ContextRegistrationAnalyzerTests
                                                                               }
                                                                           }
                                                                       }
-                 """));
+                                                                      """;
 
-        await AnalyzerTestDriver<ContextRegistrationAnalyzer>.RunAsync(
+    private const string RegisteredFieldInjectedModelSource = """
-            markup.Source,
-            markup.WithSpan(
-                new DiagnosticResult("GF_ContextRegistration_001", DiagnosticSeverity.Warning)
-                    .WithArguments("IInventoryModel", "InventoryPanelSystem", "GameArchitecture"),
-                "0"));
-    }
-
-    [Test]
-    public async Task Does_Not_Report_When_FieldInjectedModel_Is_Registered()
-    {
-        await AnalyzerTestDriver<ContextRegistrationAnalyzer>.RunAsync(
-            Wrap("""
                                                               namespace TestApp
                                                               {
                                                                   using GFramework.Core.Abstractions.Model;
@@ -201,14 +186,9 @@ public sealed class ContextRegistrationAnalyzerTests
                                                                       }
                                                                   }
                                                               }
-                 """));
+                                                              """;
-    }
 
-    [Test]
+    private const string MissingHandWrittenGetSystemRegistrationSource = """
-    public async Task Reports_Warning_When_HandWrittenGetSystem_Call_Has_No_Registration()
-    {
-        var markup = MarkupTestSource.Parse(
-            Wrap("""
                                                                         namespace TestApp
                                                                         {
                                                                             using GFramework.Core.Abstractions.Systems;
@@ -234,21 +214,9 @@ public sealed class ContextRegistrationAnalyzerTests
                                                                                 }
                                                                             }
                                                                         }
-                 """));
+                                                                        """;
 
-        await AnalyzerTestDriver<ContextRegistrationAnalyzer>.RunAsync(
+    private const string ModuleProvidedModelRegistrationSource = """
-            markup.Source,
-            markup.WithSpan(
-                new DiagnosticResult("GF_ContextRegistration_002", DiagnosticSeverity.Warning)
-                    .WithArguments("ICombatSystem", "UiUtility", "GameArchitecture"),
-                "0"));
-    }
-
-    [Test]
-    public async Task Does_Not_Report_When_Registration_Comes_From_Installed_Module()
-    {
-        await AnalyzerTestDriver<ContextRegistrationAnalyzer>.RunAsync(
-            Wrap("""
                                                                  namespace TestApp
                                                                  {
                                                                      using GFramework.Core.Abstractions.Architectures;
@@ -284,14 +252,9 @@ public sealed class ContextRegistrationAnalyzerTests
                                                                          }
                                                                      }
                                                                  }
-                 """));
+                                                                 """;
-    }
 
-    [Test]
+    private const string AmbiguousOwningArchitectureSource = """
-    public async Task Does_Not_Report_When_Owning_Architecture_Cannot_Be_Uniquely_Determined()
-    {
-        await AnalyzerTestDriver<ContextRegistrationAnalyzer>.RunAsync(
-            Wrap("""
                                                             namespace TestApp
                                                             {
                                                                 using GFramework.Core.Abstractions.Model;
@@ -323,14 +286,9 @@ public sealed class ContextRegistrationAnalyzerTests
                                                                     }
                                                                 }
                                                             }
-                 """));
+                                                            """;
-    }
 
-    [Test]
+    private const string MissingGetUtilitiesRegistrationSource = """
-    public async Task Reports_Warning_When_GetUtilities_Field_Has_No_Registered_Utility()
-    {
-        var markup = MarkupTestSource.Parse(
-            Wrap("""
                                                                  namespace TestApp
                                                                  {
                                                                      using System.Collections.Generic;
@@ -355,22 +313,9 @@ public sealed class ContextRegistrationAnalyzerTests
                                                                          }
                                                                      }
                                                                  }
-                 """));
+                                                                 """;
 
-        await AnalyzerTestDriver<ContextRegistrationAnalyzer>.RunAsync(
+    private const string DerivedArchitectureVirtualHelperRegistrationSource = """
-            markup.Source,
-            markup.WithSpan(
-                new DiagnosticResult("GF_ContextRegistration_003", DiagnosticSeverity.Warning)
-                    .WithArguments("IInventoryUtility", "InventoryPanelSystem", "GameArchitecture"),
-                "0"));
-    }
-
-    [Test]
-    public async Task
-        Does_Not_Report_When_Inherited_OnInitialize_Calls_Virtual_Helper_Overridden_In_Derived_Architecture()
-    {
-        await AnalyzerTestDriver<ContextRegistrationAnalyzer>.RunAsync(
-            Wrap("""
                                                                             namespace TestApp
                                                                             {
                                                                                 using GFramework.Core.Abstractions.Model;
@@ -409,14 +354,9 @@ public sealed class ContextRegistrationAnalyzerTests
                                                                                     }
                                                                                 }
                                                                             }
-                 """));
+                                                                            """;
-    }
 
-    [Test]
+    private const string DerivedModuleVirtualHelperRegistrationSource = """
-    public async Task Does_Not_Report_When_Inherited_Module_Install_Calls_Virtual_Helper_Overridden_In_Derived_Module()
-    {
-        await AnalyzerTestDriver<ContextRegistrationAnalyzer>.RunAsync(
-            Wrap("""
                                                                        namespace TestApp
                                                                        {
                                                                            using GFramework.Core.Abstractions.Architectures;
@@ -464,14 +404,9 @@ public sealed class ContextRegistrationAnalyzerTests
                                                                                }
                                                                            }
                                                                        }
-                 """));
+                                                                       """;
-    }
 
-    [Test]
+    private const string DerivedArchitectureBaseHelperCallSource = """
-    public async Task Reports_Warning_When_Derived_Architecture_Explicitly_Calls_Base_Helper()
-    {
-        var markup = MarkupTestSource.Parse(
-            Wrap("""
                                                                   namespace TestApp
                                                                   {
                                                                       using GFramework.Core.Abstractions.Model;
@@ -511,21 +446,9 @@ public sealed class ContextRegistrationAnalyzerTests
                                                                           }
                                                                       }
                                                                   }
-                 """));
+                                                                  """;
 
-        await AnalyzerTestDriver<ContextRegistrationAnalyzer>.RunAsync(
+    private const string DerivedModuleBaseHelperCallSource = """
-            markup.Source,
-            markup.WithSpan(
-                new DiagnosticResult("GF_ContextRegistration_001", DiagnosticSeverity.Warning)
-                    .WithArguments("IInventoryModel", "InventoryPanelSystem", "GameArchitecture"),
-                "0"));
-    }
-
-    [Test]
-    public async Task Reports_Warning_When_Derived_Module_Explicitly_Calls_Base_Helper()
-    {
-        var markup = MarkupTestSource.Parse(
-            Wrap("""
                                                             namespace TestApp
                                                             {
                                                                 using GFramework.Core.Abstractions.Architectures;
@@ -578,16 +501,176 @@ public sealed class ContextRegistrationAnalyzerTests
                                                                     }
                                                                 }
                                                             }
-                 """));
+                                                            """;
 
-        await AnalyzerTestDriver<ContextRegistrationAnalyzer>.RunAsync(
+    /// <summary>
-            markup.Source,
+    ///     验证字段注入模型未注册时会报告缺失注册告警。
-            markup.WithSpan(
+    /// </summary>
-                new DiagnosticResult("GF_ContextRegistration_001", DiagnosticSeverity.Warning)
+    [Test]
-                    .WithArguments("IInventoryModel", "InventoryPanelSystem", "GameArchitecture"),
+    public Task Reports_Warning_When_FieldInjectedModel_Is_Not_Registered()
-                "0"));
+    {
+        return RunWarningScenarioAsync(
+            MissingFieldInjectedModelRegistrationSource,
+            CreateContextRegistrationWarning(
+                "GF_ContextRegistration_001",
+                "IInventoryModel",
+                "InventoryPanelSystem",
+                "GameArchitecture"));
     }
 
+    /// <summary>
+    ///     验证字段注入模型已注册时不会产生误报。
+    /// </summary>
+    [Test]
+    public Task Does_Not_Report_When_FieldInjectedModel_Is_Registered()
+    {
+        return RunNoDiagnosticScenarioAsync(RegisteredFieldInjectedModelSource);
+    }
+
+    /// <summary>
+    ///     验证手写扩展方法访问未注册 System 时会报告缺失注册告警。
+    /// </summary>
+    [Test]
+    public Task Reports_Warning_When_HandWrittenGetSystem_Call_Has_No_Registration()
+    {
+        return RunWarningScenarioAsync(
+            MissingHandWrittenGetSystemRegistrationSource,
+            CreateContextRegistrationWarning(
+                "GF_ContextRegistration_002",
+                "ICombatSystem",
+                "UiUtility",
+                "GameArchitecture"));
+    }
+
+    /// <summary>
+    ///     验证模块安装链路提供注册时分析器会把该注册视为有效来源。
+    /// </summary>
+    [Test]
+    public Task Does_Not_Report_When_Registration_Comes_From_Installed_Module()
+    {
+        return RunNoDiagnosticScenarioAsync(ModuleProvidedModelRegistrationSource);
+    }
+
+    /// <summary>
+    ///     验证无法唯一推导所属 Architecture 时分析器保持静默以避免误报。
+    /// </summary>
+    [Test]
+    public Task Does_Not_Report_When_Owning_Architecture_Cannot_Be_Uniquely_Determined()
+    {
+        return RunNoDiagnosticScenarioAsync(AmbiguousOwningArchitectureSource);
+    }
+
+    /// <summary>
+    ///     验证集合注入 Utility 缺失注册时仍会报告对应告警。
+    /// </summary>
+    [Test]
+    public Task Reports_Warning_When_GetUtilities_Field_Has_No_Registered_Utility()
+    {
+        return RunWarningScenarioAsync(
+            MissingGetUtilitiesRegistrationSource,
+            CreateContextRegistrationWarning(
+                "GF_ContextRegistration_003",
+                "IInventoryUtility",
+                "InventoryPanelSystem",
+                "GameArchitecture"));
+    }
+
+    /// <summary>
+    ///     验证基类初始化经由虚方法分派到派生实现时，派生注册仍会被识别。
+    /// </summary>
+    [Test]
+    public Task
+        Does_Not_Report_When_Inherited_OnInitialize_Calls_Virtual_Helper_Overridden_In_Derived_Architecture()
+    {
+        return RunNoDiagnosticScenarioAsync(DerivedArchitectureVirtualHelperRegistrationSource);
+    }
+
+    /// <summary>
+    ///     验证模块基类通过虚方法转发注册时，派生模块的注册依然会被识别。
+    /// </summary>
+    [Test]
+    public Task Does_Not_Report_When_Inherited_Module_Install_Calls_Virtual_Helper_Overridden_In_Derived_Module()
+    {
+        return RunNoDiagnosticScenarioAsync(DerivedModuleVirtualHelperRegistrationSource);
+    }
+
+    /// <summary>
+    ///     验证显式调用基类 helper 时，分析器按基类实际执行的注册路径发出告警。
+    /// </summary>
+    [Test]
+    public Task Reports_Warning_When_Derived_Architecture_Explicitly_Calls_Base_Helper()
+    {
+        return RunWarningScenarioAsync(
+            DerivedArchitectureBaseHelperCallSource,
+            CreateContextRegistrationWarning(
+                "GF_ContextRegistration_001",
+                "IInventoryModel",
+                "InventoryPanelSystem",
+                "GameArchitecture"));
+    }
+
+    /// <summary>
+    ///     验证模块显式调用基类 helper 时，分析器按实际执行的安装路径发出告警。
+    /// </summary>
+    [Test]
+    public Task Reports_Warning_When_Derived_Module_Explicitly_Calls_Base_Helper()
+    {
+        return RunWarningScenarioAsync(
+            DerivedModuleBaseHelperCallSource,
+            CreateContextRegistrationWarning(
+                "GF_ContextRegistration_001",
+                "IInventoryModel",
+                "InventoryPanelSystem",
+                "GameArchitecture"));
+    }
+
+    /// <summary>
+    ///     运行包含诊断标记的 analyzer 场景，并把预期诊断绑定到统一的 `#0` span。
+    /// </summary>
+    /// <param name="source">不含公共前导代码的测试源码。</param>
+    /// <param name="expectedDiagnostic">需要命中的预期诊断。</param>
+    /// <returns>代表 analyzer 验证流程的异步任务。</returns>
+    private static Task RunWarningScenarioAsync(string source, DiagnosticResult expectedDiagnostic)
+    {
+        MarkupTestSource markup = MarkupTestSource.Parse(Wrap(source));
+        return AnalyzerTestDriver<ContextRegistrationAnalyzer>.RunAsync(
+            markup.Source,
+            markup.WithSpan(expectedDiagnostic, "0"));
+    }
+
+    /// <summary>
+    ///     运行不应产生诊断的 analyzer 场景。
+    /// </summary>
+    /// <param name="source">不含公共前导代码的测试源码。</param>
+    /// <returns>代表 analyzer 验证流程的异步任务。</returns>
+    private static Task RunNoDiagnosticScenarioAsync(string source)
+    {
+        return AnalyzerTestDriver<ContextRegistrationAnalyzer>.RunAsync(Wrap(source));
+    }
+
+    /// <summary>
+    ///     构造 Context 注册分析器的统一预期诊断，以保持断言参数顺序稳定。
+    /// </summary>
+    /// <param name="diagnosticId">预期诊断 ID。</param>
+    /// <param name="serviceType">缺失注册的服务或依赖类型。</param>
+    /// <param name="ownerType">触发访问的拥有者类型。</param>
+    /// <param name="architectureType">推导出的所属 Architecture 类型。</param>
+    /// <returns>配置好参数的预期诊断结果。</returns>
+    private static DiagnosticResult CreateContextRegistrationWarning(
+        string diagnosticId,
+        string serviceType,
+        string ownerType,
+        string architectureType)
+    {
+        return new DiagnosticResult(diagnosticId, DiagnosticSeverity.Warning)
+            .WithArguments(serviceType, ownerType, architectureType);
+    }
+
+    /// <summary>
+    ///     将公共测试前导代码与具体场景源码拼接为完整编译单元。
+    /// </summary>
+    /// <param name="source">具体测试场景源码。</param>
+    /// <returns>包含公共前导代码的完整源码文本。</returns>
     private static string Wrap(string source)
     {
         return $"{TestPreamble}{Environment.NewLine}{Environment.NewLine}{source}";