ue-mcp 1.2.3 → 1.3.0

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/Tests/LevelBatchWriteTests.cpp

@@ -0,0 +1,176 @@
+// Coverage for the level batch writes that is safe to run anywhere.
+//
+// run_automation_tests dispatches every EditorContext/EngineFilter test in the
+// process against whatever project the bridge is attached to, so nothing here
+// may mutate a level. Everything below stays on the paths that are specified
+// to write nothing: argument rejection, selector refusal, and the dry run.
+// The committing paths are exercised by the smoke suite against the dedicated
+// test project instead.
+
+#if WITH_DEV_AUTOMATION_TESTS
+
+#include "HandlerRegistry.h"
+#include "Handlers/LevelHandlers.h"
+#include "Misc/AutomationTest.h"
+
+namespace
+{
+	TSharedPtr<FJsonObject> MCPBatchTestRun(
+		FMCPHandlerRegistry& Registry,
+		const TCHAR* Method,
+		const TSharedPtr<FJsonObject>& Request)
+	{
+		const TSharedPtr<FJsonValue> Response = Registry.ExecuteHandler(Method, Request);
+		if (!Response.IsValid() || Response->Type != EJson::Object)
+		{
+			return nullptr;
+		}
+		return Response->AsObject();
+	}
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FLevelBatchWriteRegistrationTest,
+	"UE.MCP.Level.BatchWrite.Registration",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FLevelBatchWriteRegistrationTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FLevelHandlers::RegisterHandlers(Registry);
+
+	for (const TCHAR* Method : {
+		TEXT("batch_set_actor_properties"),
+		TEXT("bulk_set_component_property"),
+		TEXT("remove_components_by_class"),
+		TEXT("spawn_actors_batch") })
+	{
+		TestTrue(FString::Printf(TEXT("%s is registered"), Method), Registry.HasHandler(Method));
+		TestTrue(
+			FString::Printf(TEXT("%s carries its own timeout"), Method),
+			Registry.GetHandlerTimeout(Method) > 0.0f);
+	}
+	return true;
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FLevelBatchWriteRefusalTest,
+	"UE.MCP.Level.BatchWrite.RefusesAnUnboundedRequest",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FLevelBatchWriteRefusalTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FLevelHandlers::RegisterHandlers(Registry);
+
+	// batch_set_properties with no selector would mean "every actor in the
+	// level", which is never what someone means by a property batch.
+	{
+		TSharedPtr<FJsonObject> Properties = MakeShared<FJsonObject>();
+		Properties->SetBoolField(TEXT("bHidden"), true);
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetObjectField(TEXT("properties"), Properties);
+		const TSharedPtr<FJsonObject> Response =
+			MCPBatchTestRun(Registry, TEXT("batch_set_actor_properties"), Request);
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("no selector fails"), Response->GetBoolField(TEXT("success")));
+			TestTrue(TEXT("and lists the selectors it accepts"),
+				Response->GetStringField(TEXT("error")).Contains(TEXT("labelPrefix")));
+		}
+	}
+
+	// And properties are required: a selector on its own does nothing.
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetStringField(TEXT("tag"), TEXT("SomeTag"));
+		const TSharedPtr<FJsonObject> Response =
+			MCPBatchTestRun(Registry, TEXT("batch_set_actor_properties"), Request);
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("no properties fails"), Response->GetBoolField(TEXT("success")));
+			TestTrue(TEXT("and names the parameter"),
+				Response->GetStringField(TEXT("error")).Contains(TEXT("properties")));
+		}
+	}
+
+	// spawn_actors_batch needs exactly one source. Two would make the spawn
+	// count ambiguous, which is the sort of ambiguity that spawns 380 actors.
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetStringField(TEXT("actorClass"), TEXT("StaticMeshActor"));
+		Request->SetArrayField(TEXT("instances"), { MakeShared<FJsonValueObject>(MakeShared<FJsonObject>()) });
+		Request->SetObjectField(TEXT("fromComponents"), MakeShared<FJsonObject>());
+		const TSharedPtr<FJsonObject> Response =
+			MCPBatchTestRun(Registry, TEXT("spawn_actors_batch"), Request);
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("two spawn sources fail"), Response->GetBoolField(TEXT("success")));
+		}
+	}
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetStringField(TEXT("actorClass"), TEXT("StaticMeshActor"));
+		const TSharedPtr<FJsonObject> Response =
+			MCPBatchTestRun(Registry, TEXT("spawn_actors_batch"), Request);
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("no spawn source fails"), Response->GetBoolField(TEXT("success")));
+		}
+	}
+
+	// An unresolvable component class is named rather than matching nothing.
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetStringField(TEXT("componentClass"), TEXT("NotARealComponentClass"));
+		const TSharedPtr<FJsonObject> Response =
+			MCPBatchTestRun(Registry, TEXT("remove_components_by_class"), Request);
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("an unresolvable component class fails"), Response->GetBoolField(TEXT("success")));
+			TestEqual(TEXT("and says why"),
+				Response->GetStringField(TEXT("reason")), FString(TEXT("class_not_found")));
+		}
+	}
+
+	return true;
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FLevelBatchWriteDryRunDefaultTest,
+	"UE.MCP.Level.BatchWrite.RemoveComponentsPreviewsByDefault",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FLevelBatchWriteDryRunDefaultTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FLevelHandlers::RegisterHandlers(Registry);
+
+	// remove_components_by_class deletes components whose auto-generated names
+	// a caller cannot enumerate, so it previews unless told otherwise. This
+	// runs against whatever map is open with no actor selector at all, which
+	// is the widest request the action accepts, and it must still write
+	// nothing.
+	TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+	Request->SetStringField(TEXT("componentClass"), TEXT("SplineMeshComponent"));
+
+	const TSharedPtr<FJsonObject> Response =
+		MCPBatchTestRun(Registry, TEXT("remove_components_by_class"), Request);
+	if (!Response.IsValid() || !Response->GetBoolField(TEXT("success")))
+	{
+		// No editor world available in this context, and this test may not
+		// open a map to make one.
+		return true;
+	}
+
+	TestTrue(TEXT("dryRun defaults to true"), Response->GetBoolField(TEXT("dryRun")));
+	TestFalse(TEXT("a preview saves nothing"), Response->GetBoolField(TEXT("saved")));
+	TestTrue(TEXT("a preview reports what it would have removed"),
+		Response->HasField(TEXT("wouldRemoveComponents")));
+	TestFalse(TEXT("and does not claim to have removed anything"),
+		Response->HasField(TEXT("removedComponents")));
+
+	return true;
+}
+
+#endif // WITH_DEV_AUTOMATION_TESTS

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/Tests/LevelComponentTreeInstanceCountTests.cpp

@@ -0,0 +1,189 @@
+// Coverage for per-ISM instance counts in get_component_tree (#986).
+//
+// The tree reported an instanced mesh component's class, its mesh and its
+// materials, and not how many instances it held. That is the one number that
+// decides whether to touch it: a component with three instances and one with
+// three hundred thousand were the same row. Getting it meant dumping every
+// instance transform through get_instance_transforms just to count them.
+//
+// The round trip runs on a transient verification actor, which cannot be saved
+// into the map and is destroyed at the end.
+
+#if WITH_DEV_AUTOMATION_TESTS
+
+#include "HandlerRegistry.h"
+#include "Handlers/LevelHandlers.h"
+#include "Misc/AutomationTest.h"
+
+namespace
+{
+	TSharedPtr<FJsonObject> MCPInstanceCountTestRun(
+		FMCPHandlerRegistry& Registry,
+		const TCHAR* Method,
+		const TSharedPtr<FJsonObject>& Request)
+	{
+		const TSharedPtr<FJsonValue> Response = Registry.ExecuteHandler(Method, Request);
+		if (!Response.IsValid() || Response->Type != EJson::Object)
+		{
+			return nullptr;
+		}
+		return Response->AsObject();
+	}
+
+	/** One transform entry for add_hismc_instances. */
+	TSharedPtr<FJsonValue> MCPInstanceCountTestTransform(double X)
+	{
+		TSharedPtr<FJsonObject> Location = MakeShared<FJsonObject>();
+		Location->SetNumberField(TEXT("x"), X);
+		Location->SetNumberField(TEXT("y"), 0.0);
+		Location->SetNumberField(TEXT("z"), 0.0);
+		TSharedPtr<FJsonObject> Entry = MakeShared<FJsonObject>();
+		Entry->SetObjectField(TEXT("location"), Location);
+		return MakeShared<FJsonValueObject>(Entry);
+	}
+
+	/** The component row for a named component in a get_component_tree response. */
+	TSharedPtr<FJsonObject> MCPInstanceCountTestFindComponent(
+		const TSharedPtr<FJsonObject>& Response,
+		const FString& NameContains)
+	{
+		if (!Response.IsValid()) return nullptr;
+		const TArray<TSharedPtr<FJsonValue>>* Rows = nullptr;
+		if (!Response->TryGetArrayField(TEXT("components"), Rows) || !Rows) return nullptr;
+		for (const TSharedPtr<FJsonValue>& Value : *Rows)
+		{
+			const TSharedPtr<FJsonObject> Row = Value.IsValid() ? Value->AsObject() : nullptr;
+			if (!Row.IsValid()) continue;
+			if (Row->GetStringField(TEXT("name")).Contains(NameContains, ESearchCase::IgnoreCase)) return Row;
+		}
+		return nullptr;
+	}
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FLevelComponentTreeInstanceCountTest,
+	"UE.MCP.Level.ComponentTree.ReportsInstanceCounts",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FLevelComponentTreeInstanceCountTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FLevelHandlers::RegisterHandlers(Registry);
+	TestTrue(TEXT("get_component_tree is registered"), Registry.HasHandler(TEXT("get_component_tree")));
+
+	TSharedPtr<FJsonObject> SpawnRequest = MakeShared<FJsonObject>();
+	SpawnRequest->SetStringField(TEXT("actorClass"), TEXT("StaticMeshActor"));
+	SpawnRequest->SetStringField(TEXT("label"), TEXT("UEMCP_InstanceCountTest"));
+	const TSharedPtr<FJsonObject> SpawnResponse =
+		MCPInstanceCountTestRun(Registry, TEXT("spawn_transient_actor"), SpawnRequest);
+	if (!SpawnResponse.IsValid() || !SpawnResponse->GetBoolField(TEXT("success")))
+	{
+		// No editor world in this context, and this test may not open a map.
+		return true;
+	}
+	const TSharedPtr<FJsonObject> SpawnedActor = SpawnResponse->GetObjectField(TEXT("actor"));
+	const FString ActorPath = SpawnedActor.IsValid() ? SpawnedActor->GetStringField(TEXT("actorPath")) : FString();
+	const FString ActorLabel = TEXT("UEMCP_InstanceCountTest");
+	const FString ComponentName = TEXT("UEMCP_TestHISM");
+
+	bool bAddedComponent = false;
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetStringField(TEXT("actorLabel"), ActorLabel);
+		Request->SetStringField(TEXT("componentClass"), TEXT("HierarchicalInstancedStaticMeshComponent"));
+		Request->SetStringField(TEXT("componentName"), ComponentName);
+		const TSharedPtr<FJsonObject> Response =
+			MCPInstanceCountTestRun(Registry, TEXT("add_component_to_actor"), Request);
+		bAddedComponent = Response.IsValid() && Response->GetBoolField(TEXT("success"));
+	}
+
+	if (bAddedComponent)
+	{
+		// An empty instanced component still has to report a count. Zero is an
+		// answer; a missing field is not, because a caller cannot tell it apart
+		// from a field that was trimmed.
+		{
+			TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+			Request->SetStringField(TEXT("actorLabel"), ActorLabel);
+			const TSharedPtr<FJsonObject> Response =
+				MCPInstanceCountTestRun(Registry, TEXT("get_component_tree"), Request);
+			const TSharedPtr<FJsonObject> Row = MCPInstanceCountTestFindComponent(Response, ComponentName);
+			TestNotNull(TEXT("the tree lists the instanced component"), Row.Get());
+			if (Row.IsValid())
+			{
+				double Count = -1.0;
+				TestTrue(TEXT("an empty ISM still reports instanceCount"),
+					Row->TryGetNumberField(TEXT("instanceCount"), Count));
+				TestEqual(TEXT("which is zero"), static_cast<int32>(Count), 0);
+				const TSharedPtr<FJsonObject>* Instanced = nullptr;
+				if (Row->TryGetObjectField(TEXT("instanced"), Instanced) && Instanced)
+				{
+					TestTrue(TEXT("and a HISM is reported as hierarchical"),
+						(*Instanced)->GetBoolField(TEXT("hierarchical")));
+				}
+			}
+		}
+
+		// Add instances, then read the count back through the tree rather than
+		// through the writer's own report.
+		{
+			TArray<TSharedPtr<FJsonValue>> Transforms;
+			Transforms.Add(MCPInstanceCountTestTransform(0.0));
+			Transforms.Add(MCPInstanceCountTestTransform(100.0));
+			Transforms.Add(MCPInstanceCountTestTransform(200.0));
+			TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+			Request->SetStringField(TEXT("actorLabel"), ActorLabel);
+			Request->SetStringField(TEXT("componentName"), ComponentName);
+			Request->SetArrayField(TEXT("transforms"), Transforms);
+			const TSharedPtr<FJsonObject> AddResponse =
+				MCPInstanceCountTestRun(Registry, TEXT("add_hismc_instances"), Request);
+			if (AddResponse.IsValid() && AddResponse->GetBoolField(TEXT("success")))
+			{
+				TSharedPtr<FJsonObject> TreeRequest = MakeShared<FJsonObject>();
+				TreeRequest->SetStringField(TEXT("actorLabel"), ActorLabel);
+				const TSharedPtr<FJsonObject> TreeResponse =
+					MCPInstanceCountTestRun(Registry, TEXT("get_component_tree"), TreeRequest);
+				const TSharedPtr<FJsonObject> Row =
+					MCPInstanceCountTestFindComponent(TreeResponse, ComponentName);
+				if (Row.IsValid())
+				{
+					double Count = -1.0;
+					Row->TryGetNumberField(TEXT("instanceCount"), Count);
+					TestEqual(TEXT("the tree reports the instances that were added"),
+						static_cast<int32>(Count), 3);
+				}
+			}
+		}
+	}
+
+	// A component that holds no instances at all must NOT grow the field, so a
+	// caller can use its presence to mean "this is an instanced component".
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetStringField(TEXT("actorLabel"), ActorLabel);
+		const TSharedPtr<FJsonObject> Response =
+			MCPInstanceCountTestRun(Registry, TEXT("get_component_tree"), Request);
+		const TSharedPtr<FJsonObject> Root =
+			MCPInstanceCountTestFindComponent(Response, TEXT("StaticMeshComponent"));
+		if (Root.IsValid())
+		{
+			double Count = -1.0;
+			TestFalse(TEXT("a plain StaticMeshComponent has no instanceCount"),
+				Root->TryGetNumberField(TEXT("instanceCount"), Count));
+		}
+	}
+
+	if (!ActorPath.IsEmpty())
+	{
+		TSharedPtr<FJsonObject> DestroyRequest = MakeShared<FJsonObject>();
+		DestroyRequest->SetStringField(TEXT("actorPath"), ActorPath);
+		const TSharedPtr<FJsonObject> DestroyResponse =
+			MCPInstanceCountTestRun(Registry, TEXT("destroy_transient_actor"), DestroyRequest);
+		TestTrue(TEXT("the verification actor is destroyed"),
+			DestroyResponse.IsValid() && DestroyResponse->GetBoolField(TEXT("success")));
+	}
+
+	return true;
+}
+
+#endif // WITH_DEV_AUTOMATION_TESTS

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/Tests/LevelConvertBrushesTests.cpp

@@ -0,0 +1,100 @@
+// Coverage for level(convert_brushes_to_static_mesh) (#911).
+//
+// The committing path destroys actors and writes new mesh packages, so nothing
+// here goes near it. What is asserted is the set of refusals, because those
+// are the whole feature: ConvertActors itself is one engine call.
+
+#if WITH_DEV_AUTOMATION_TESTS
+
+#include "HandlerRegistry.h"
+#include "Handlers/LevelHandlers.h"
+#include "Misc/AutomationTest.h"
+
+namespace
+{
+	TSharedPtr<FJsonObject> MCPConvertTestRun(FMCPHandlerRegistry& Registry, const TSharedPtr<FJsonObject>& Request)
+	{
+		const TSharedPtr<FJsonValue> Response =
+			Registry.ExecuteHandler(TEXT("convert_brushes_to_static_mesh"), Request);
+		if (!Response.IsValid() || Response->Type != EJson::Object)
+		{
+			return nullptr;
+		}
+		return Response->AsObject();
+	}
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FLevelConvertBrushesGuardrailTest,
+	"UE.MCP.Level.ConvertBrushes.Guardrails",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FLevelConvertBrushesGuardrailTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FLevelHandlers::RegisterHandlers(Registry);
+
+	TestTrue(TEXT("convert_brushes_to_static_mesh is registered"),
+		Registry.HasHandler(TEXT("convert_brushes_to_static_mesh")));
+	TestTrue(TEXT("it carries its own timeout, because generating meshes is slow"),
+		Registry.GetHandlerTimeout(TEXT("convert_brushes_to_static_mesh")) > 0.0f);
+
+	// No selector would mean "every brush in the level", and this destroys what
+	// it converts.
+	{
+		const TSharedPtr<FJsonObject> Response = MCPConvertTestRun(Registry, MakeShared<FJsonObject>());
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("an unbounded conversion fails"), Response->GetBoolField(TEXT("success")));
+			TestTrue(TEXT("and says it will not run against a whole level"),
+				Response->GetStringField(TEXT("error")).Contains(TEXT("implicitly")));
+		}
+	}
+
+	// The generated meshes must not land in engine content.
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetStringField(TEXT("folderPath"), TEXT("Blockout"));
+		Request->SetStringField(TEXT("destinationPath"), TEXT("/Engine/Meshes"));
+		const TSharedPtr<FJsonObject> Response = MCPConvertTestRun(Registry, Request);
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("an engine destination fails"), Response->GetBoolField(TEXT("success")));
+			TestTrue(TEXT("and says why"),
+				Response->GetStringField(TEXT("error")).Contains(TEXT("writable")));
+		}
+	}
+
+	// A class filter that is not a brush class is a caller error, not an empty
+	// result set.
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetStringField(TEXT("folderPath"), TEXT("Blockout"));
+		Request->SetStringField(TEXT("classFilter"), TEXT("StaticMeshActor"));
+		const TSharedPtr<FJsonObject> Response = MCPConvertTestRun(Registry, Request);
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("a non-brush class filter fails"), Response->GetBoolField(TEXT("success")));
+		}
+	}
+
+	// And the default is a preview, on a selector that is valid but matches
+	// nothing in an arbitrary project.
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetStringField(TEXT("folderPath"), TEXT("UEMCPNoSuchFolderForTests"));
+		const TSharedPtr<FJsonObject> Response = MCPConvertTestRun(Registry, Request);
+		if (Response.IsValid() && Response->GetBoolField(TEXT("success")))
+		{
+			TestTrue(TEXT("dryRun defaults to true"), Response->GetBoolField(TEXT("dryRun")));
+			TestEqual(TEXT("an empty folder is eligible for nothing"),
+				static_cast<int32>(Response->GetNumberField(TEXT("eligible"))), 0);
+			TestTrue(TEXT("and explains what the exclusions are"),
+				Response->HasField(TEXT("zeroMatchNote")));
+		}
+	}
+
+	return true;
+}
+
+#endif // WITH_DEV_AUTOMATION_TESTS