ue-mcp 1.2.3 → 1.3.0

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

@@ -0,0 +1,205 @@
+// Coverage for the transient verification actors (#956) and the component
+// material overrides (#946).
+//
+// spawn_transient_actor is safe to run for real: its whole contract is that it
+// cannot persist anything, and asserting that contract is most of the point.
+// It is still cleaned up here, because a test that leaves an actor behind
+// while testing an action about not leaving actors behind would be absurd.
+
+#if WITH_DEV_AUTOMATION_TESTS
+
+#include "HandlerRegistry.h"
+#include "Handlers/LevelHandlers.h"
+#include "Misc/AutomationTest.h"
+
+namespace
+{
+	TSharedPtr<FJsonObject> MCPTransientTestRun(
+		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(
+	FLevelTransientActorContractTest,
+	"UE.MCP.Level.TransientActor.CannotBeSavedIntoTheMap",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FLevelTransientActorContractTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FLevelHandlers::RegisterHandlers(Registry);
+
+	for (const TCHAR* Method : {
+		TEXT("spawn_transient_actor"),
+		TEXT("destroy_transient_actor"),
+		TEXT("list_transient_actors"),
+		TEXT("set_component_materials") })
+	{
+		TestTrue(FString::Printf(TEXT("%s is registered"), Method), Registry.HasHandler(Method));
+	}
+
+	// An unresolvable class is named rather than producing a null actor.
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetStringField(TEXT("actorClass"), TEXT("NotARealActorClassAtAll"));
+		const TSharedPtr<FJsonObject> Response =
+			MCPTransientTestRun(Registry, TEXT("spawn_transient_actor"), Request);
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("an unresolvable class fails"), Response->GetBoolField(TEXT("success")));
+		}
+	}
+
+	// An unknown initialize level is rejected by name, because silently
+	// falling back to 'none' would leave a caller reading an uninitialised
+	// component and believing it had asked for more.
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetStringField(TEXT("actorClass"), TEXT("StaticMeshActor"));
+		Request->SetStringField(TEXT("initialize"), TEXT("everything"));
+		const TSharedPtr<FJsonObject> Response =
+			MCPTransientTestRun(Registry, TEXT("spawn_transient_actor"), Request);
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("an unknown initialize level fails"), Response->GetBoolField(TEXT("success")));
+			TestTrue(TEXT("and lists the ones that exist"),
+				Response->GetStringField(TEXT("error")).Contains(TEXT("beginPlay")));
+		}
+	}
+
+	// destroy with no target does nothing rather than guessing.
+	{
+		const TSharedPtr<FJsonObject> Response =
+			MCPTransientTestRun(Registry, TEXT("destroy_transient_actor"), MakeShared<FJsonObject>());
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("destroy with no target fails"), Response->GetBoolField(TEXT("success")));
+		}
+	}
+
+	// The real round trip, in whatever map is open.
+	TSharedPtr<FJsonObject> SpawnRequest = MakeShared<FJsonObject>();
+	SpawnRequest->SetStringField(TEXT("actorClass"), TEXT("StaticMeshActor"));
+	SpawnRequest->SetStringField(TEXT("label"), TEXT("UEMCP_TransientContractTest"));
+	const TSharedPtr<FJsonObject> SpawnResponse =
+		MCPTransientTestRun(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> Actor = SpawnResponse->GetObjectField(TEXT("actor"));
+	const FString ActorPath = Actor->GetStringField(TEXT("actorPath"));
+	TestTrue(TEXT("the spawned actor really is RF_Transient"), Actor->GetBoolField(TEXT("transient")));
+
+	// The #966-shaped guarantee: a verification spawn that dirties the map has
+	// failed at its one job, label included, since SetActorLabel dirties by
+	// default and this passes bMarkDirty=false.
+	TestFalse(TEXT("spawning a verification actor dirties nothing"),
+		SpawnResponse->GetBoolField(TEXT("dirtiedPackages")));
+
+	// It shows up in the listing, so nothing can be left behind unnoticed.
+	{
+		const TSharedPtr<FJsonObject> ListResponse =
+			MCPTransientTestRun(Registry, TEXT("list_transient_actors"), MakeShared<FJsonObject>());
+		if (ListResponse.IsValid() && ListResponse->GetBoolField(TEXT("success")))
+		{
+			TestTrue(TEXT("the listing sees it"),
+				static_cast<int32>(ListResponse->GetNumberField(TEXT("total"))) >= 1);
+		}
+	}
+
+	// And cleanup destroys exactly it.
+	TSharedPtr<FJsonObject> DestroyRequest = MakeShared<FJsonObject>();
+	DestroyRequest->SetStringField(TEXT("actorPath"), ActorPath);
+	const TSharedPtr<FJsonObject> DestroyResponse =
+		MCPTransientTestRun(Registry, TEXT("destroy_transient_actor"), DestroyRequest);
+	TestTrue(TEXT("destroy succeeds"), DestroyResponse.IsValid() && DestroyResponse->GetBoolField(TEXT("success")));
+	if (DestroyResponse.IsValid())
+	{
+		TestEqual(TEXT("destroy removed exactly one actor"),
+			static_cast<int32>(DestroyResponse->GetNumberField(TEXT("destroyed"))), 1);
+	}
+
+	return true;
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FLevelSetComponentMaterialsContractTest,
+	"UE.MCP.Level.SetComponentMaterials.Contract",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FLevelSetComponentMaterialsContractTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FLevelHandlers::RegisterHandlers(Registry);
+
+	// No selector would mean every actor in the level.
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetStringField(TEXT("material"), TEXT("/Engine/EngineMaterials/DefaultMaterial.DefaultMaterial"));
+		const TSharedPtr<FJsonObject> Response =
+			MCPTransientTestRun(Registry, TEXT("set_component_materials"), Request);
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("no selector fails"), Response->GetBoolField(TEXT("success")));
+		}
+	}
+
+	// A selector but no instruction about what to write.
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetStringField(TEXT("labelPrefix"), TEXT("Anything"));
+		const TSharedPtr<FJsonObject> Response =
+			MCPTransientTestRun(Registry, TEXT("set_component_materials"), Request);
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("no materials fails"), Response->GetBoolField(TEXT("success")));
+			TestTrue(TEXT("and lists the three modes"),
+				Response->GetStringField(TEXT("error")).Contains(TEXT("clearOverrides")));
+		}
+	}
+
+	// Two modes at once would fight over the same slots.
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetStringField(TEXT("labelPrefix"), TEXT("Anything"));
+		Request->SetStringField(TEXT("material"), TEXT("/Engine/EngineMaterials/DefaultMaterial.DefaultMaterial"));
+		Request->SetBoolField(TEXT("clearOverrides"), true);
+		const TSharedPtr<FJsonObject> Response =
+			MCPTransientTestRun(Registry, TEXT("set_component_materials"), Request);
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("two modes fail"), Response->GetBoolField(TEXT("success")));
+		}
+	}
+
+	// A material path that does not resolve fails the whole call rather than
+	// half-applying across the matched actors.
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetStringField(TEXT("labelPrefix"), TEXT("Anything"));
+		Request->SetStringField(TEXT("material"), TEXT("/Game/UEMCPNoSuchMaterialForTests"));
+		const TSharedPtr<FJsonObject> Response =
+			MCPTransientTestRun(Registry, TEXT("set_component_materials"), Request);
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("an unresolvable material fails before any write"),
+				Response->GetBoolField(TEXT("success")));
+		}
+	}
+
+	return true;
+}
+
+#endif // WITH_DEV_AUTOMATION_TESTS

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

@@ -0,0 +1,168 @@
+// Coverage for the World Partition streaming surface (#985).
+//
+// These actions write the streaming configuration of whatever map is open, so
+// the assertions stay on the paths specified to change nothing: the refusals
+// that keep a bad request from half-applying, and the shape of the read. A test
+// that retuned CellSize to prove CellSize can be retuned would leave somebody's
+// map streaming differently.
+//
+// The read is asserted on whichever map the run happens to have open. On a
+// non-partitioned map it must refuse by name rather than answering with an
+// empty success, because "this map has no grids" and "this map is not World
+// Partition" are different facts and only one of them is actionable.
+
+#if WITH_DEV_AUTOMATION_TESTS
+
+#include "Editor.h"
+#include "Engine/World.h"
+#include "HandlerRegistry.h"
+#include "Handlers/LevelHandlers.h"
+#include "Misc/AutomationTest.h"
+#include "WorldPartition/WorldPartition.h"
+
+namespace
+{
+	TSharedPtr<FJsonObject> MCPWorldPartitionTestRun(
+		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(
+	FLevelWorldPartitionSettingsSurfaceTest,
+	"UE.MCP.Level.WorldPartition.SettingsSurface",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FLevelWorldPartitionSettingsSurfaceTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FLevelHandlers::RegisterHandlers(Registry);
+
+	for (const TCHAR* Method : {
+		TEXT("get_world_partition_settings"),
+		TEXT("set_world_partition_settings"),
+		TEXT("add_runtime_cell_transformer"),
+		TEXT("set_actor_hlod_layer") })
+	{
+		TestTrue(FString::Printf(TEXT("%s is registered"), Method), Registry.HasHandler(Method));
+	}
+
+	UWorld* World = GEditor ? GEditor->GetEditorWorldContext().World() : nullptr;
+	if (!World) return true;
+	const bool bPartitioned = World->GetWorldPartition() != nullptr;
+
+	// The read.
+	{
+		const TSharedPtr<FJsonObject> Response =
+			MCPWorldPartitionTestRun(Registry, TEXT("get_world_partition_settings"), MakeShared<FJsonObject>());
+		if (Response.IsValid())
+		{
+			if (bPartitioned)
+			{
+				TestTrue(TEXT("a World Partition map answers"), Response->GetBoolField(TEXT("success")));
+				const TArray<TSharedPtr<FJsonValue>>* Grids = nullptr;
+				TestTrue(TEXT("and reports its streaming grids"),
+					Response->TryGetArrayField(TEXT("grids"), Grids));
+				const TArray<TSharedPtr<FJsonValue>>* Transformers = nullptr;
+				TestTrue(TEXT("and its runtime cell transformer stack"),
+					Response->TryGetArrayField(TEXT("cellTransformers"), Transformers));
+				FString WorldPartitionPath;
+				TestTrue(TEXT("and names the world partition object"),
+					Response->TryGetStringField(TEXT("worldPartition"), WorldPartitionPath));
+			}
+			else
+			{
+				// The distinction that matters: not partitioned is a refusal
+				// with a reason, not an empty success a caller reads as "no
+				// grids configured".
+				TestFalse(TEXT("a non-partitioned map is refused"), Response->GetBoolField(TEXT("success")));
+				TestTrue(TEXT("and the refusal says why"),
+					Response->GetStringField(TEXT("error")).Contains(TEXT("World Partition")));
+			}
+		}
+	}
+
+	// A write with nothing in it is a request that means nothing.
+	{
+		const TSharedPtr<FJsonObject> Response =
+			MCPWorldPartitionTestRun(Registry, TEXT("set_world_partition_settings"), MakeShared<FJsonObject>());
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("an empty write is refused"), Response->GetBoolField(TEXT("success")));
+		}
+	}
+
+	// A path that does not resolve fails the whole call. Streaming settings are
+	// changed in batches and a half-applied batch is a configuration nobody
+	// asked for.
+	if (bPartitioned)
+	{
+		TSharedPtr<FJsonObject> Settings = MakeShared<FJsonObject>();
+		Settings->SetNumberField(TEXT("NotARealWorldPartitionProperty"), 1.0);
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetObjectField(TEXT("settings"), Settings);
+		const TSharedPtr<FJsonObject> Response =
+			MCPWorldPartitionTestRun(Registry, TEXT("set_world_partition_settings"), Request);
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("an unresolvable path fails the call"), Response->GetBoolField(TEXT("success")));
+			TestTrue(TEXT("and says nothing was written"),
+				Response->GetStringField(TEXT("error")).Contains(TEXT("Nothing was written")));
+		}
+	}
+
+	// A class that is not a cell transformer is refused by name rather than
+	// added and left to fail at streaming-generation time.
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetStringField(TEXT("transformerClass"), TEXT("StaticMeshActor"));
+		const TSharedPtr<FJsonObject> Response =
+			MCPWorldPartitionTestRun(Registry, TEXT("add_runtime_cell_transformer"), Request);
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("a non-transformer class is refused"), Response->GetBoolField(TEXT("success")));
+		}
+	}
+
+	// The HLOD batch refuses an unbounded run, like every other selector-driven
+	// write in this category.
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetStringField(TEXT("hlodLayer"), FString());
+		const TSharedPtr<FJsonObject> Response =
+			MCPWorldPartitionTestRun(Registry, TEXT("set_actor_hlod_layer"), Request);
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("an unbounded HLOD assignment is refused"), Response->GetBoolField(TEXT("success")));
+			TestTrue(TEXT("and names the selectors it wants"),
+				Response->GetStringField(TEXT("error")).Contains(TEXT("actorLabels")));
+		}
+	}
+
+	// And a missing hlodLayer is refused rather than treated as "clear it",
+	// because clearing 295 actors' overrides by omission would be a disaster.
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetStringField(TEXT("labelPrefix"), TEXT("UEMCP_NoSuchActorPrefix"));
+		const TSharedPtr<FJsonObject> Response =
+			MCPWorldPartitionTestRun(Registry, TEXT("set_actor_hlod_layer"), Request);
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("omitting hlodLayer is refused"), Response->GetBoolField(TEXT("success")));
+			TestTrue(TEXT("and says the parameter is required"),
+				Response->GetStringField(TEXT("error")).Contains(TEXT("hlodLayer")));
+		}
+	}
+
+	return true;
+}
+
+#endif // WITH_DEV_AUTOMATION_TESTS

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/Tests/MCPInstancedStructPathTestTypes.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "StructUtils/InstancedStruct.h"
+#include "MCPInstancedStructPathTestTypes.generated.h"
+
+/** Reflected payload used only by the FInstancedStruct property-path tests. */
+USTRUCT()
+struct FUEMCPInstancedStructPathElement
+{
+	GENERATED_BODY()
+
+	UPROPERTY()
+	int32 Scalar = 0;
+
+	UPROPERTY()
+	FString Sibling;
+};
+
+/** Payload shape with both scalar and indexed nested leaves. */
+USTRUCT()
+struct FUEMCPInstancedStructPathPayload
+{
+	GENERATED_BODY()
+
+	UPROPERTY()
+	int32 Scalar = 0;
+
+	UPROPERTY()
+	FString Sibling;
+
+	UPROPERTY()
+	TArray<FUEMCPInstancedStructPathElement> Elements;
+};
+
+/** In-memory UObject target resolved by both property handlers through its object path. */
+UCLASS()
+class UUEMCPInstancedStructPathTestObject : public UObject
+{
+	GENERATED_BODY()
+
+public:
+	UPROPERTY()
+	FInstancedStruct Payload;
+
+	UPROPERTY()
+	FInstancedStruct EmptyPayload;
+
+	UPROPERTY()
+	TArray<FInstancedStruct> OpStack;
+};