584 lines
22 KiB
C#
584 lines
22 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using Newtonsoft.Json.Linq;
|
|
using NUnit.Framework;
|
|
using UnityEditor;
|
|
using UnityEngine;
|
|
using MCPForUnity.Editor.Tools;
|
|
using MCPForUnity.Editor.Helpers;
|
|
using MCPForUnity.Editor.Resources.Scene;
|
|
using UnityEngine.TestTools;
|
|
using Debug = UnityEngine.Debug;
|
|
|
|
namespace MCPForUnityTests.Editor.Tools
|
|
{
|
|
/// <summary>
|
|
/// Stress tests for the GameObject API redesign.
|
|
/// Tests volume operations, pagination, and performance with large datasets.
|
|
/// </summary>
|
|
[TestFixture]
|
|
public class GameObjectAPIStressTests
|
|
{
|
|
private List<GameObject> _createdObjects = new List<GameObject>();
|
|
private const int SMALL_BATCH = 10;
|
|
private const int MEDIUM_BATCH = 50;
|
|
private const int LARGE_BATCH = 100;
|
|
|
|
[SetUp]
|
|
public void SetUp()
|
|
{
|
|
_createdObjects.Clear();
|
|
}
|
|
|
|
[TearDown]
|
|
public void TearDown()
|
|
{
|
|
foreach (var go in _createdObjects)
|
|
{
|
|
if (go != null)
|
|
{
|
|
UnityEngine.Object.DestroyImmediate(go);
|
|
}
|
|
}
|
|
_createdObjects.Clear();
|
|
}
|
|
|
|
private GameObject CreateTestObject(string name)
|
|
{
|
|
var go = new GameObject(name);
|
|
_createdObjects.Add(go);
|
|
return go;
|
|
}
|
|
|
|
private static JObject ToJObject(object result)
|
|
{
|
|
if (result == null) return new JObject();
|
|
if (result is JObject jobj) return jobj;
|
|
try
|
|
{
|
|
return JObject.FromObject(result);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.LogWarning($"[ToJObject] Failed to convert result: {ex.Message}");
|
|
return new JObject { ["error"] = ex.Message };
|
|
}
|
|
}
|
|
|
|
#region Bulk GameObject Creation
|
|
|
|
[Test]
|
|
public void BulkCreate_SmallBatch_AllSucceed()
|
|
{
|
|
var sw = Stopwatch.StartNew();
|
|
|
|
for (int i = 0; i < SMALL_BATCH; i++)
|
|
{
|
|
var result = ToJObject(ManageGameObject.HandleCommand(new JObject
|
|
{
|
|
["action"] = "create",
|
|
["name"] = $"BulkTest_{i}"
|
|
}));
|
|
|
|
Assert.IsTrue(result["success"]?.Value<bool>() ?? false, $"Failed to create object {i}");
|
|
|
|
// Track for cleanup
|
|
int instanceId = result["data"]?["instanceID"]?.Value<int>() ?? 0;
|
|
if (instanceId != 0)
|
|
{
|
|
var go = EditorUtility.InstanceIDToObject(instanceId) as GameObject;
|
|
if (go != null) _createdObjects.Add(go);
|
|
}
|
|
}
|
|
|
|
sw.Stop();
|
|
Debug.Log($"[BulkCreate] Created {SMALL_BATCH} objects in {sw.ElapsedMilliseconds}ms");
|
|
// Use generous threshold for CI variability
|
|
Assert.Less(sw.ElapsedMilliseconds, 10000, "Bulk create took too long (CI threshold)");
|
|
}
|
|
|
|
[Test]
|
|
public void BulkCreate_MediumBatch_AllSucceed()
|
|
{
|
|
var sw = Stopwatch.StartNew();
|
|
|
|
for (int i = 0; i < MEDIUM_BATCH; i++)
|
|
{
|
|
var result = ToJObject(ManageGameObject.HandleCommand(new JObject
|
|
{
|
|
["action"] = "create",
|
|
["name"] = $"MediumBulk_{i}"
|
|
}));
|
|
|
|
Assert.IsTrue(result["success"]?.Value<bool>() ?? false, $"Failed to create object {i}");
|
|
|
|
int instanceId = result["data"]?["instanceID"]?.Value<int>() ?? 0;
|
|
if (instanceId != 0)
|
|
{
|
|
var go = EditorUtility.InstanceIDToObject(instanceId) as GameObject;
|
|
if (go != null) _createdObjects.Add(go);
|
|
}
|
|
}
|
|
|
|
sw.Stop();
|
|
Debug.Log($"[BulkCreate] Created {MEDIUM_BATCH} objects in {sw.ElapsedMilliseconds}ms");
|
|
Assert.Less(sw.ElapsedMilliseconds, 15000, "Medium batch create took too long");
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Find GameObjects Pagination
|
|
|
|
[Test]
|
|
public void FindGameObjects_LargeBatch_PaginatesCorrectly()
|
|
{
|
|
// Create many objects with a unique marker component for reliable search
|
|
for (int i = 0; i < LARGE_BATCH; i++)
|
|
{
|
|
var go = CreateTestObject($"Searchable_{i:D3}");
|
|
go.AddComponent<GameObjectAPIStressTestMarker>();
|
|
}
|
|
|
|
// Find by searching for a specific object first
|
|
var firstResult = ToJObject(FindGameObjects.HandleCommand(new JObject
|
|
{
|
|
["searchTerm"] = "Searchable_000",
|
|
["searchMethod"] = "by_name",
|
|
["pageSize"] = 10
|
|
}));
|
|
|
|
Assert.IsTrue(firstResult["success"]?.Value<bool>() ?? false, "Should find specific named object");
|
|
var firstData = firstResult["data"] as JObject;
|
|
var firstIds = firstData?["instanceIDs"] as JArray;
|
|
Assert.IsNotNull(firstIds);
|
|
Assert.AreEqual(1, firstIds.Count, "Should find exactly one object with exact name match");
|
|
|
|
Debug.Log($"[FindGameObjects] Found object by exact name. Testing pagination with a unique marker component.");
|
|
|
|
// Now test pagination by searching for only the objects created by this test
|
|
var result = ToJObject(FindGameObjects.HandleCommand(new JObject
|
|
{
|
|
["searchTerm"] = typeof(GameObjectAPIStressTestMarker).FullName,
|
|
["searchMethod"] = "by_component",
|
|
["pageSize"] = 25
|
|
}));
|
|
|
|
Assert.IsTrue(result["success"]?.Value<bool>() ?? false);
|
|
var data = result["data"] as JObject;
|
|
Assert.IsNotNull(data);
|
|
|
|
var instanceIds = data["instanceIDs"] as JArray;
|
|
Assert.IsNotNull(instanceIds);
|
|
Assert.AreEqual(25, instanceIds.Count, "First page should have 25 items");
|
|
|
|
int totalCount = data["totalCount"]?.Value<int>() ?? 0;
|
|
Assert.AreEqual(LARGE_BATCH, totalCount, $"Should find exactly {LARGE_BATCH} objects created by this test");
|
|
|
|
bool hasMore = data["hasMore"]?.Value<bool>() ?? false;
|
|
Assert.IsTrue(hasMore, "Should have more pages");
|
|
|
|
Debug.Log($"[FindGameObjects] Found {totalCount} objects, first page has {instanceIds.Count}");
|
|
}
|
|
|
|
[Test]
|
|
public void FindGameObjects_PaginateThroughAll()
|
|
{
|
|
// Create objects - all will have a unique marker component
|
|
for (int i = 0; i < MEDIUM_BATCH; i++)
|
|
{
|
|
var go = CreateTestObject($"Paginate_{i:D3}");
|
|
go.AddComponent<GameObjectAPIStressTestMarker>();
|
|
}
|
|
|
|
// Track IDs we've created for verification
|
|
var createdIds = new HashSet<int>();
|
|
foreach (var go in _createdObjects)
|
|
{
|
|
if (go != null && go.name.StartsWith("Paginate_"))
|
|
{
|
|
createdIds.Add(go.GetInstanceID());
|
|
}
|
|
}
|
|
|
|
int pageSize = 10;
|
|
int cursor = 0;
|
|
int foundFromCreated = 0;
|
|
int pageCount = 0;
|
|
|
|
// Search by the unique marker component and check our created objects
|
|
while (true)
|
|
{
|
|
var result = ToJObject(FindGameObjects.HandleCommand(new JObject
|
|
{
|
|
["searchTerm"] = typeof(GameObjectAPIStressTestMarker).FullName,
|
|
["searchMethod"] = "by_component",
|
|
["pageSize"] = pageSize,
|
|
["cursor"] = cursor
|
|
}));
|
|
|
|
Assert.IsTrue(result["success"]?.Value<bool>() ?? false);
|
|
var data = result["data"] as JObject;
|
|
var instanceIds = data["instanceIDs"] as JArray;
|
|
|
|
// Count how many of our created objects are in this page
|
|
foreach (var id in instanceIds)
|
|
{
|
|
if (createdIds.Contains(id.Value<int>()))
|
|
{
|
|
foundFromCreated++;
|
|
}
|
|
}
|
|
pageCount++;
|
|
|
|
bool hasMore = data["hasMore"]?.Value<bool>() ?? false;
|
|
if (!hasMore) break;
|
|
|
|
cursor = data["nextCursor"]?.Value<int>() ?? cursor + pageSize;
|
|
|
|
// Safety limit
|
|
if (pageCount > 50) break;
|
|
}
|
|
|
|
Assert.AreEqual(MEDIUM_BATCH, foundFromCreated, $"Should find all {MEDIUM_BATCH} created objects across pages");
|
|
Debug.Log($"[Pagination] Found {foundFromCreated} created objects across {pageCount} pages");
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Component Operations at Scale
|
|
|
|
[Test]
|
|
public void AddComponents_MultipleToSingleObject()
|
|
{
|
|
var go = CreateTestObject("ComponentHost");
|
|
|
|
string[] componentTypeNames = new[]
|
|
{
|
|
"BoxCollider",
|
|
"Rigidbody",
|
|
"Light",
|
|
"Camera"
|
|
};
|
|
|
|
var sw = Stopwatch.StartNew();
|
|
|
|
foreach (var compType in componentTypeNames)
|
|
{
|
|
var result = ToJObject(ManageComponents.HandleCommand(new JObject
|
|
{
|
|
["action"] = "add",
|
|
["target"] = go.GetInstanceID().ToString(),
|
|
["searchMethod"] = "by_id",
|
|
["componentType"] = compType // Correct parameter name
|
|
}));
|
|
|
|
Assert.IsTrue(result["success"]?.Value<bool>() ?? false, $"Failed to add {compType}: {result["message"]}");
|
|
}
|
|
|
|
sw.Stop();
|
|
Debug.Log($"[AddComponents] Added {componentTypeNames.Length} components in {sw.ElapsedMilliseconds}ms");
|
|
|
|
// Verify all components present
|
|
Assert.AreEqual(componentTypeNames.Length + 1, go.GetComponents<Component>().Length); // +1 for Transform
|
|
}
|
|
|
|
[Test]
|
|
public void GetComponents_ObjectWithManyComponents()
|
|
{
|
|
var go = CreateTestObject("HeavyComponents");
|
|
|
|
// Add many components - but skip AudioSource as it triggers deprecated API warnings
|
|
go.AddComponent<BoxCollider>();
|
|
go.AddComponent<SphereCollider>();
|
|
go.AddComponent<CapsuleCollider>();
|
|
go.AddComponent<MeshCollider>();
|
|
go.AddComponent<Rigidbody>();
|
|
go.AddComponent<Light>();
|
|
go.AddComponent<Camera>();
|
|
go.AddComponent<AudioListener>();
|
|
|
|
var sw = Stopwatch.StartNew();
|
|
|
|
// Use the resource handler for getting components
|
|
var result = ToJObject(GameObjectComponentsResource.HandleCommand(new JObject
|
|
{
|
|
["instanceID"] = go.GetInstanceID(),
|
|
["includeProperties"] = true,
|
|
["pageSize"] = 50
|
|
}));
|
|
|
|
sw.Stop();
|
|
|
|
Assert.IsTrue(result["success"]?.Value<bool>() ?? false, $"GetComponents failed: {result["message"]}");
|
|
var data = result["data"] as JObject;
|
|
var components = data?["components"] as JArray;
|
|
|
|
Assert.IsNotNull(components);
|
|
Assert.AreEqual(9, components.Count); // 8 added + Transform
|
|
|
|
Debug.Log($"[GetComponents] Retrieved {components.Count} components with properties in {sw.ElapsedMilliseconds}ms");
|
|
}
|
|
|
|
[Test]
|
|
public void SetComponentProperties_ComplexRigidbody()
|
|
{
|
|
var go = CreateTestObject("RigidbodyTest");
|
|
go.AddComponent<Rigidbody>();
|
|
|
|
var result = ToJObject(ManageComponents.HandleCommand(new JObject
|
|
{
|
|
["action"] = "set_property",
|
|
["target"] = go.GetInstanceID().ToString(),
|
|
["searchMethod"] = "by_id",
|
|
["componentType"] = "Rigidbody", // Correct parameter name
|
|
["properties"] = new JObject // Correct parameter name
|
|
{
|
|
["mass"] = 10.5f,
|
|
["drag"] = 0.5f,
|
|
["angularDrag"] = 0.1f,
|
|
["useGravity"] = false,
|
|
["isKinematic"] = true
|
|
}
|
|
}));
|
|
|
|
Assert.IsTrue(result["success"]?.Value<bool>() ?? false, $"Set property failed: {result["message"]}");
|
|
|
|
var rb = go.GetComponent<Rigidbody>();
|
|
Assert.AreEqual(10.5f, rb.mass, 0.01f);
|
|
Assert.AreEqual(0.5f, rb.drag, 0.01f);
|
|
Assert.AreEqual(0.1f, rb.angularDrag, 0.01f);
|
|
Assert.IsFalse(rb.useGravity);
|
|
Assert.IsTrue(rb.isKinematic);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Deep Hierarchy Operations
|
|
|
|
[Test]
|
|
public void CreateDeepHierarchy_FindByPath()
|
|
{
|
|
// Create a deep hierarchy: Root/Level1/Level2/Level3/Target
|
|
var root = CreateTestObject("DeepRoot");
|
|
var current = root;
|
|
|
|
for (int i = 1; i <= 5; i++)
|
|
{
|
|
var child = CreateTestObject($"Level{i}");
|
|
child.transform.SetParent(current.transform);
|
|
current = child;
|
|
}
|
|
|
|
var target = CreateTestObject("DeepTarget");
|
|
target.transform.SetParent(current.transform);
|
|
|
|
// Find by path
|
|
var result = ToJObject(FindGameObjects.HandleCommand(new JObject
|
|
{
|
|
["searchTerm"] = "DeepRoot/Level1/Level2/Level3/Level4/Level5/DeepTarget",
|
|
["searchMethod"] = "by_path"
|
|
}));
|
|
|
|
Assert.IsTrue(result["success"]?.Value<bool>() ?? false);
|
|
var data = result["data"] as JObject;
|
|
var ids = data?["instanceIDs"] as JArray;
|
|
|
|
Assert.IsNotNull(ids);
|
|
Assert.AreEqual(1, ids.Count);
|
|
Assert.AreEqual(target.GetInstanceID(), ids[0].Value<int>());
|
|
}
|
|
|
|
[Test]
|
|
public void GetHierarchy_LargeScene_Paginated()
|
|
{
|
|
// Create flat hierarchy with many objects
|
|
for (int i = 0; i < MEDIUM_BATCH; i++)
|
|
{
|
|
CreateTestObject($"HierarchyItem_{i:D3}");
|
|
}
|
|
|
|
var result = ToJObject(ManageScene.HandleCommand(new JObject
|
|
{
|
|
["action"] = "get_hierarchy",
|
|
["pageSize"] = 20,
|
|
["maxNodes"] = 100
|
|
}));
|
|
|
|
Assert.IsTrue(result["success"]?.Value<bool>() ?? false);
|
|
var data = result["data"] as JObject;
|
|
var items = data?["items"] as JArray;
|
|
|
|
Assert.IsNotNull(items);
|
|
Assert.GreaterOrEqual(items.Count, 1);
|
|
|
|
// Verify componentTypes is included
|
|
var firstItem = items[0] as JObject;
|
|
Assert.IsNotNull(firstItem?["componentTypes"], "Should include componentTypes");
|
|
|
|
Debug.Log($"[GetHierarchy] Retrieved {items.Count} items from hierarchy");
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Resource Read Performance
|
|
|
|
[Test]
|
|
public void GameObjectResource_ReadComplexObject()
|
|
{
|
|
var go = CreateTestObject("ComplexObject");
|
|
go.tag = "Player";
|
|
go.layer = 8;
|
|
go.isStatic = true;
|
|
|
|
// Add components - AudioSource is OK here since we're only reading component types, not serializing properties
|
|
go.AddComponent<Rigidbody>();
|
|
go.AddComponent<BoxCollider>();
|
|
go.AddComponent<AudioSource>();
|
|
|
|
// Add children
|
|
for (int i = 0; i < 5; i++)
|
|
{
|
|
var child = CreateTestObject($"Child_{i}");
|
|
child.transform.SetParent(go.transform);
|
|
}
|
|
|
|
var sw = Stopwatch.StartNew();
|
|
|
|
// Call the resource directly (no action param needed)
|
|
var result = ToJObject(GameObjectResource.HandleCommand(new JObject
|
|
{
|
|
["instanceID"] = go.GetInstanceID()
|
|
}));
|
|
|
|
sw.Stop();
|
|
|
|
Assert.IsTrue(result["success"]?.Value<bool>() ?? false);
|
|
var data = result["data"] as JObject;
|
|
|
|
Assert.AreEqual("ComplexObject", data?["name"]?.Value<string>());
|
|
Assert.AreEqual("Player", data?["tag"]?.Value<string>());
|
|
Assert.AreEqual(8, data?["layer"]?.Value<int>());
|
|
|
|
var componentTypes = data?["componentTypes"] as JArray;
|
|
Assert.IsNotNull(componentTypes);
|
|
Assert.AreEqual(4, componentTypes.Count); // Transform + 3 added
|
|
|
|
var children = data?["children"] as JArray;
|
|
Assert.IsNotNull(children);
|
|
Assert.AreEqual(5, children.Count);
|
|
|
|
Debug.Log($"[GameObjectResource] Read complex object in {sw.ElapsedMilliseconds}ms");
|
|
}
|
|
|
|
[Test]
|
|
public void ComponentsResource_ReadAllWithFullSerialization()
|
|
{
|
|
var go = CreateTestObject("FullSerialize");
|
|
|
|
var rb = go.AddComponent<Rigidbody>();
|
|
rb.mass = 5.5f;
|
|
rb.drag = 1.2f;
|
|
|
|
var col = go.AddComponent<BoxCollider>();
|
|
col.size = new Vector3(2, 3, 4);
|
|
col.center = new Vector3(0.5f, 0.5f, 0.5f);
|
|
|
|
// Skip AudioSource to avoid deprecated API warnings
|
|
|
|
var sw = Stopwatch.StartNew();
|
|
|
|
// Use the components resource handler
|
|
var result = ToJObject(GameObjectComponentsResource.HandleCommand(new JObject
|
|
{
|
|
["instanceID"] = go.GetInstanceID(),
|
|
["includeProperties"] = true
|
|
}));
|
|
|
|
sw.Stop();
|
|
|
|
Assert.IsTrue(result["success"]?.Value<bool>() ?? false);
|
|
var data = result["data"] as JObject;
|
|
var components = data?["components"] as JArray;
|
|
|
|
Assert.IsNotNull(components);
|
|
Assert.AreEqual(3, components.Count); // Transform + Rigidbody + BoxCollider
|
|
|
|
Debug.Log($"[ComponentsResource] Full serialization of {components.Count} components in {sw.ElapsedMilliseconds}ms");
|
|
|
|
// Verify serialized data includes properties
|
|
bool foundRigidbody = false;
|
|
foreach (JObject comp in components)
|
|
{
|
|
var typeName = comp["typeName"]?.Value<string>();
|
|
if (typeName != null && typeName.Contains("Rigidbody"))
|
|
{
|
|
foundRigidbody = true;
|
|
// GameObjectSerializer puts properties inside a "properties" nested object
|
|
var props = comp["properties"] as JObject;
|
|
Assert.IsNotNull(props, $"Rigidbody should have properties. Component data: {comp}");
|
|
float massValue = props["mass"]?.Value<float>() ?? 0;
|
|
Assert.AreEqual(5.5f, massValue, 0.01f, $"Mass should be 5.5");
|
|
}
|
|
}
|
|
Assert.IsTrue(foundRigidbody, "Should find Rigidbody with serialized properties");
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Concurrent-Like Operations
|
|
|
|
[Test]
|
|
public void RapidFireOperations_CreateModifyDelete()
|
|
{
|
|
var sw = Stopwatch.StartNew();
|
|
|
|
for (int i = 0; i < SMALL_BATCH; i++)
|
|
{
|
|
// Create
|
|
var createResult = ToJObject(ManageGameObject.HandleCommand(new JObject
|
|
{
|
|
["action"] = "create",
|
|
["name"] = $"RapidFire_{i}"
|
|
}));
|
|
Assert.IsTrue(createResult["success"]?.Value<bool>() ?? false, $"Create failed: {createResult["message"]}");
|
|
|
|
int instanceId = createResult["data"]?["instanceID"]?.Value<int>() ?? 0;
|
|
Assert.AreNotEqual(0, instanceId, "Instance ID should not be 0");
|
|
|
|
// Modify - use layer 0 (Default) to avoid layer name issues
|
|
var modifyResult = ToJObject(ManageGameObject.HandleCommand(new JObject
|
|
{
|
|
["action"] = "modify",
|
|
["target"] = instanceId.ToString(),
|
|
["searchMethod"] = "by_id",
|
|
["name"] = $"RapidFire_Modified_{i}", // Use name modification instead
|
|
["setActive"] = true
|
|
}));
|
|
Assert.IsTrue(modifyResult["success"]?.Value<bool>() ?? false, $"Modify failed: {modifyResult["message"]}");
|
|
|
|
// Delete
|
|
var deleteResult = ToJObject(ManageGameObject.HandleCommand(new JObject
|
|
{
|
|
["action"] = "delete",
|
|
["target"] = instanceId.ToString(),
|
|
["searchMethod"] = "by_id"
|
|
}));
|
|
Assert.IsTrue(deleteResult["success"]?.Value<bool>() ?? false, $"Delete failed: {deleteResult["message"]}");
|
|
}
|
|
|
|
sw.Stop();
|
|
Debug.Log($"[RapidFire] {SMALL_BATCH} create-modify-delete cycles in {sw.ElapsedMilliseconds}ms");
|
|
Assert.Less(sw.ElapsedMilliseconds, 10000, "Rapid fire operations took too long");
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
/// <summary>
|
|
/// Marker component used for isolating component-based searches to objects created by this test fixture.
|
|
/// </summary>
|
|
public sealed class GameObjectAPIStressTestMarker : MonoBehaviour { }
|
|
}
|
|
|