test(architecture): 更新架构服务测试以验证内置模块注册

- 添加了对ArchitectureProperties和GFramework.Core.services的引用
- 实现了RegisterBuiltInServices方法用于注册内置服务
- 修改了构造函数测试以验证容器初始化而非所有服务
- 更新了EventBus、CommandExecutor和QueryExecutor的测试以验证注册后可用性
- 添加了AsyncQueryExecutor可用性测试
- 添加了未注册服务时EventBus为null的测试
- 在多个实例测试中添加了模块注册以确保独立性
- 添加了ModuleManager属性非空测试
- 实现了ECS配置开关控制模块注册的测试
- 移除了TestArchitectureContextV3中的硬编码服务实现
- 更新了ECS相关测试以直接注册EcsWorld到容器中
- 改进了ECS世界获取失败时的错误消息

GFramework.Core.Tests/architecture/ArchitectureServicesTests.cs

@@ -5,6 +5,7 @@ using GFramework.Core.Abstractions.environment;
 using GFramework.Core.Abstractions.events;
 using GFramework.Core.Abstractions.ioc;
 using GFramework.Core.Abstractions.model;
+using GFramework.Core.Abstractions.properties;
 using GFramework.Core.Abstractions.query;
 using GFramework.Core.Abstractions.system;
 using GFramework.Core.Abstractions.utility;
@@ -46,16 +47,19 @@ public class ArchitectureServicesTests
     private ArchitectureServices? _services;
     private TestArchitectureContextV3? _context;
 
+    private void RegisterBuiltInServices()
+    {
+        var properties = new ArchitectureProperties();
+        _services!.ModuleManager.RegisterBuiltInModules(_services.Container, properties);
+    }
+
     /// <summary>
-    ///     测试构造函数初始化所有服务
+    ///     测试构造函数初始化容器
     /// </summary>
     [Test]
-    public void Constructor_Should_Initialize_AllServices()
+    public void Constructor_Should_Initialize_Container()
     {
         Assert.That(_services!.Container, Is.Not.Null);
-        Assert.That(_services.EventBus, Is.Not.Null);
-        Assert.That(_services.CommandExecutor, Is.Not.Null);
-        Assert.That(_services.QueryExecutor, Is.Not.Null);
     }
 
     [Test]
@@ -66,35 +70,62 @@ public class ArchitectureServicesTests
     }
 
     /// <summary>
-    ///     测试EventBus是EventBus的实例
+    ///     测试注册内置服务后EventBus可用
     /// </summary>
     [Test]
-    public void EventBus_Should_Be_Instance_Of_EventBus()
+    public void After_RegisterBuiltInModules_EventBus_Should_Be_Available()
     {
+        RegisterBuiltInServices();
+
         Assert.That(_services!.EventBus, Is.InstanceOf<IEventBus>());
         Assert.That(_services.EventBus, Is.InstanceOf<EventBus>());
     }
 
     /// <summary>
-    ///     测试CommandBus是CommandBus的实例
+    ///     测试注册内置服务后CommandExecutor可用
     /// </summary>
     [Test]
-    public void CommandBus_Should_Be_Instance_Of_CommandBus()
+    public void After_RegisterBuiltInModules_CommandExecutor_Should_Be_Available()
     {
+        RegisterBuiltInServices();
+
         Assert.That(_services!.CommandExecutor, Is.InstanceOf<ICommandExecutor>());
         Assert.That(_services.CommandExecutor, Is.InstanceOf<CommandExecutor>());
     }
 
     /// <summary>
-    ///     测试QueryBus是QueryBus的实例
+    ///     测试注册内置服务后QueryExecutor可用
     /// </summary>
     [Test]
-    public void QueryBus_Should_Be_Instance_Of_QueryBus()
+    public void After_RegisterBuiltInModules_QueryExecutor_Should_Be_Available()
     {
+        RegisterBuiltInServices();
+
         Assert.That(_services!.QueryExecutor, Is.InstanceOf<IQueryExecutor>());
         Assert.That(_services.QueryExecutor, Is.InstanceOf<QueryExecutor>());
     }
 
+    /// <summary>
+    ///     测试注册内置服务后AsyncQueryExecutor可用
+    /// </summary>
+    [Test]
+    public void After_RegisterBuiltInModules_AsyncQueryExecutor_Should_Be_Available()
+    {
+        RegisterBuiltInServices();
+
+        Assert.That(_services!.AsyncQueryExecutor, Is.InstanceOf<IAsyncQueryExecutor>());
+        Assert.That(_services.AsyncQueryExecutor, Is.InstanceOf<AsyncQueryExecutor>());
+    }
+
+    /// <summary>
+    ///     测试未注册服务时EventBus为null
+    /// </summary>
+    [Test]
+    public void Without_RegisterBuiltInModules_EventBus_Should_Be_Null()
+    {
+        Assert.That(_services!.EventBus, Is.Null);
+    }
+
     /// <summary>
     ///     测试SetContext设置内部Context字段
     /// </summary>
@@ -186,8 +217,13 @@ public class ArchitectureServicesTests
     [Test]
     public void Multiple_Instances_Should_Have_Independent_EventBus()
     {
+        var properties = new ArchitectureProperties();
+
         var services1 = new ArchitectureServices();
+        services1.ModuleManager.RegisterBuiltInModules(services1.Container, properties);
+
         var services2 = new ArchitectureServices();
+        services2.ModuleManager.RegisterBuiltInModules(services2.Container, properties);
 
         Assert.That(services1.EventBus, Is.Not.SameAs(services2.EventBus));
     }
@@ -198,8 +234,13 @@ public class ArchitectureServicesTests
     [Test]
     public void Multiple_Instances_Should_Have_Independent_CommandBus()
     {
+        var properties = new ArchitectureProperties();
+
         var services1 = new ArchitectureServices();
+        services1.ModuleManager.RegisterBuiltInModules(services1.Container, properties);
+
         var services2 = new ArchitectureServices();
+        services2.ModuleManager.RegisterBuiltInModules(services2.Container, properties);
 
         Assert.That(services1.CommandExecutor, Is.Not.SameAs(services2.CommandExecutor));
     }
@@ -210,11 +251,46 @@ public class ArchitectureServicesTests
     [Test]
     public void Multiple_Instances_Should_Have_Independent_QueryBus()
     {
+        var properties = new ArchitectureProperties();
+
         var services1 = new ArchitectureServices();
+        services1.ModuleManager.RegisterBuiltInModules(services1.Container, properties);
+
         var services2 = new ArchitectureServices();
+        services2.ModuleManager.RegisterBuiltInModules(services2.Container, properties);
 
         Assert.That(services1.QueryExecutor, Is.Not.SameAs(services2.QueryExecutor));
     }
+
+    /// <summary>
+    ///     测试ModuleManager属性不为空
+    /// </summary>
+    [Test]
+    public void ModuleManager_Should_Not_Be_Null()
+    {
+        Assert.That(_services!.ModuleManager, Is.Not.Null);
+    }
+
+    /// <summary>
+    ///     测试EnableEcs配置开关
+    /// </summary>
+    [Test]
+    public void EnableEcs_Should_Control_Ecs_Module_Registration()
+    {
+        var propertiesWithEcs = new ArchitectureProperties { EnableEcs = true };
+        var propertiesWithoutEcs = new ArchitectureProperties { EnableEcs = false };
+
+        var servicesWithEcs = new ArchitectureServices();
+        servicesWithEcs.ModuleManager.RegisterBuiltInModules(servicesWithEcs.Container, propertiesWithEcs);
+
+        var servicesWithoutEcs = new ArchitectureServices();
+        servicesWithoutEcs.ModuleManager.RegisterBuiltInModules(servicesWithoutEcs.Container, propertiesWithoutEcs);
+
+        var modulesWithEcs = servicesWithEcs.ModuleManager.GetModules();
+        var modulesWithoutEcs = servicesWithoutEcs.ModuleManager.GetModules();
+
+        Assert.That(modulesWithEcs.Count, Is.GreaterThan(modulesWithoutEcs.Count));
+    }
 }
 
 #region Test Classes
@@ -225,11 +301,6 @@ public class TestArchitectureContextV3 : IArchitectureContext
     private readonly DefaultEnvironment _environment = new();
     public int Id { get; init; }
 
-    public IIocContainer Container => _container;
-    public IEventBus EventBus => new EventBus();
-    public ICommandExecutor CommandExecutor => new CommandExecutor();
-    public IQueryExecutor QueryExecutor => new QueryExecutor();
-
     public TService? GetService<TService>() where TService : class
     {
         return _container.Get<TService>();

GFramework.Core.Tests/ecs/EcsAdvancedTests.cs

@@ -266,20 +266,24 @@ public class EcsAdvancedTests
     [Test]
     public void InitializeEcs_CalledTwice_Should_BeIdempotent()
     {
-        _context!.InitializeEcs();
+        _ecsWorld = new EcsWorld();
-        var ecsWorld1 = _context.GetEcsWorld();
+        _container!.Register(_ecsWorld);
-
+        _container.Register<IEcsWorld>(_ecsWorld);
-        Assert.DoesNotThrow(() => _context.InitializeEcs());
 
+        var ecsWorld1 = _context!.GetEcsWorld();
         var ecsWorld2 = _context.GetEcsWorld();
+
         Assert.That(ecsWorld2, Is.SameAs(ecsWorld1), "Should return same world instance");
     }
 
     [Test]
     public void GetEcsWorld_Should_ReturnIEcsWorld()
     {
-        _context!.InitializeEcs();
+        _ecsWorld = new EcsWorld();
-        var ecsWorld = _context.GetEcsWorld();
+        _container!.Register(_ecsWorld);
+        _container.Register<IEcsWorld>(_ecsWorld);
+
+        var ecsWorld = _context!.GetEcsWorld();
 
         Assert.That(ecsWorld, Is.InstanceOf<IEcsWorld>());
         Assert.That(ecsWorld, Is.InstanceOf<EcsWorld>());

GFramework.Core.Tests/ecs/EcsBasicTests.cs

@@ -85,8 +85,11 @@ public class EcsBasicTests
     [Experimental("GFrameworkECS")]
     public void Test_01_InitializeEcs_Should_Create_EcsWorld()
     {
-        _context!.InitializeEcs();
+        _ecsWorld = new EcsWorld();
-        var ecsWorld = _context.GetEcsWorld();
+        _container!.Register(_ecsWorld);
+        _container.Register<IEcsWorld>(_ecsWorld);
+
+        var ecsWorld = _context!.GetEcsWorld();
 
         Assert.That(ecsWorld, Is.Not.Null, "EcsWorld should be created");
         Assert.That(ecsWorld.EntityCount, Is.EqualTo(0), "Initial entity count should be 0");
@@ -221,6 +224,6 @@ public class EcsBasicTests
     public void Test_08_GetEcsWorld_Without_Initialize_Should_Throw()
     {
         Assert.Throws<InvalidOperationException>(() => { _context!.GetEcsWorld(); },
-            "Getting EcsWorld without initialization should throw");
+            "ECS World not initialized. Enable ECS in configuration.");
     }
 }

GFramework.Core.Tests/ecs/EcsIntegrationTests.cs

@@ -84,8 +84,11 @@ public class EcsIntegrationTests
     [Test]
     public void InitializeEcs_Should_Create_EcsWorld()
     {
-        _context!.InitializeEcs();
+        _ecsWorld = new EcsWorld();
-        var ecsWorld = _context.GetEcsWorld();
+        _container!.Register(_ecsWorld);
+        _container.Register<IEcsWorld>(_ecsWorld);
+
+        var ecsWorld = _context!.GetEcsWorld();
 
         Assert.That(ecsWorld, Is.Not.Null);
         Assert.That(ecsWorld.EntityCount, Is.EqualTo(0));
@@ -246,7 +249,8 @@ public class EcsIntegrationTests
     [Test]
     public void GetEcsWorld_Without_Initialize_Should_Throw()
     {
-        Assert.Throws<InvalidOperationException>(() => { _context!.GetEcsWorld(); });
+        Assert.Throws<InvalidOperationException>(() => { _context!.GetEcsWorld(); },
+            "ECS World not initialized. Enable ECS in configuration.");
     }
 
     /// <summary>