ue-mcp 1.2.3 → 1.3.0

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

@@ -0,0 +1,170 @@
+// Coverage for #916.
+//
+// asset(mesh_boolean) writes a StaticMesh, and everything it can refuse it
+// refuses BEFORE it touches one. These assertions cover that front half: the
+// argument validation, the destructive-form guard, and the protected-mount
+// guardrail, all of which run before the Geometry Script plugin is even asked
+// for. That is deliberate, and it is what makes them assertable on a machine
+// where the plugin is disabled.
+//
+// The boolean itself needs two real meshes and the Geometry Script plugin, so
+// it belongs to the live smoke pass rather than here. Nothing in this file
+// creates, loads or writes an asset.
+
+#if WITH_DEV_AUTOMATION_TESTS
+
+#include "HandlerRegistry.h"
+#include "HandlerUtils.h"
+#include "Handlers/AssetHandlers_MeshBoolean.h"
+
+#include "Dom/JsonObject.h"
+#include "Dom/JsonValue.h"
+#include "Misc/AutomationTest.h"
+
+namespace
+{
+	TSharedPtr<FJsonObject> BooleanResponseObject(const TSharedPtr<FJsonValue>& Response)
+	{
+		return (Response.IsValid() && Response->Type == EJson::Object)
+			? Response->AsObject()
+			: TSharedPtr<FJsonObject>();
+	}
+
+	bool BooleanResponseBool(const TSharedPtr<FJsonValue>& Response, const TCHAR* Field, bool bDefault = false)
+	{
+		const TSharedPtr<FJsonObject> Obj = BooleanResponseObject(Response);
+		if (!Obj.IsValid()) return bDefault;
+		bool bValue = bDefault;
+		Obj->TryGetBoolField(Field, bValue);
+		return bValue;
+	}
+
+	FString BooleanResponseString(const TSharedPtr<FJsonValue>& Response, const TCHAR* Field)
+	{
+		const TSharedPtr<FJsonObject> Obj = BooleanResponseObject(Response);
+		if (!Obj.IsValid()) return FString();
+		FString Value;
+		Obj->TryGetStringField(Field, Value);
+		return Value;
+	}
+
+	/** The shape every case here sends, with one field swapped per case. */
+	TSharedPtr<FJsonObject> BaseBooleanParams()
+	{
+		TSharedPtr<FJsonObject> Params = MakeShared<FJsonObject>();
+		Params->SetStringField(TEXT("operation"), TEXT("subtract"));
+		Params->SetStringField(TEXT("targetPath"), TEXT("/Game/UEMCPNeverExists/SM_Target"));
+		Params->SetStringField(TEXT("toolPath"), TEXT("/Game/UEMCPNeverExists/SM_Tool"));
+		return Params;
+	}
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FMCPMeshBooleanRefusesBeforeWritingTest,
+	"UE.MCP.Asset.MeshBoolean.RefusesBeforeItTouchesAnAsset",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FMCPMeshBooleanRefusesBeforeWritingTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FAssetMeshBooleanHandlers::RegisterHandlers(Registry);
+	if (!TestTrue(TEXT("mesh_boolean is registered"), Registry.HasHandler(TEXT("mesh_boolean")))) return false;
+
+	// The boolean can run for minutes on a repair-sized mesh, so it registers a
+	// timeout of its own. The client mirrors that number by hand, and this is
+	// the assertion that the registration it mirrors actually happened.
+	TestEqual(TEXT("mesh_boolean registers its own game-thread timeout"),
+		Registry.GetHandlerTimeout(TEXT("mesh_boolean")), 300.0f);
+
+	{
+		TSharedPtr<FJsonObject> Params = BaseBooleanParams();
+		Params->SetStringField(TEXT("operation"), TEXT("smoosh"));
+
+		const TSharedPtr<FJsonValue> Response = Registry.ExecuteHandler(TEXT("mesh_boolean"), Params);
+		TestFalse(TEXT("an unknown operation is refused"),
+			BooleanResponseBool(Response, TEXT("success"), true));
+		TestTrue(TEXT("an unknown operation lists the ones that exist"),
+			BooleanResponseString(Response, TEXT("error")).Contains(TEXT("subtract")));
+	}
+
+	{
+		// Two destinations, no way to honour both. Guessing here would pick
+		// between writing a new asset and overwriting the caller's target.
+		TSharedPtr<FJsonObject> Params = BaseBooleanParams();
+		Params->SetBoolField(TEXT("inPlace"), true);
+		Params->SetStringField(TEXT("outputPath"), TEXT("/Game/UEMCPNeverExists/SM_Result"));
+
+		const TSharedPtr<FJsonValue> Response = Registry.ExecuteHandler(TEXT("mesh_boolean"), Params);
+		TestFalse(TEXT("outputPath together with inPlace is refused"),
+			BooleanResponseBool(Response, TEXT("success"), true));
+		TestTrue(TEXT("the refusal says both were given"),
+			BooleanResponseString(Response, TEXT("error")).Contains(TEXT("inPlace")));
+	}
+
+	{
+		TSharedPtr<FJsonObject> Params = BaseBooleanParams();
+		Params->SetStringField(TEXT("lodType"), TEXT("WhicheverIsFine"));
+
+		const TSharedPtr<FJsonValue> Response = Registry.ExecuteHandler(TEXT("mesh_boolean"), Params);
+		TestFalse(TEXT("an unknown lodType is refused"),
+			BooleanResponseBool(Response, TEXT("success"), true));
+		TestTrue(TEXT("the refusal lists the LOD selectors"),
+			BooleanResponseString(Response, TEXT("error")).Contains(TEXT("MaxAvailable")));
+	}
+
+	{
+		TSharedPtr<FJsonObject> Params = BaseBooleanParams();
+		Params->SetStringField(TEXT("nanite"), TEXT("maybe"));
+
+		const TSharedPtr<FJsonValue> Response = Registry.ExecuteHandler(TEXT("mesh_boolean"), Params);
+		TestFalse(TEXT("an unknown nanite mode is refused"),
+			BooleanResponseBool(Response, TEXT("success"), true));
+		TestTrue(TEXT("the refusal lists the nanite modes"),
+			BooleanResponseString(Response, TEXT("error")).Contains(TEXT("inherit")));
+	}
+
+	{
+		TSharedPtr<FJsonObject> Params = BaseBooleanParams();
+		Params->SetStringField(TEXT("onConflict"), TEXT("clobber"));
+
+		const TSharedPtr<FJsonValue> Response = Registry.ExecuteHandler(TEXT("mesh_boolean"), Params);
+		TestFalse(TEXT("an unknown onConflict is refused"),
+			BooleanResponseBool(Response, TEXT("success"), true));
+	}
+
+	{
+		// The guardrail runs before the Geometry Script plugin is asked for
+		// anything, so engine content is refused whether or not the plugin is
+		// installed on this machine.
+		TSharedPtr<FJsonObject> Params = BaseBooleanParams();
+		Params->SetStringField(TEXT("outputPath"), TEXT("/Engine/UEMCPNeverExists/SM_Result"));
+
+		const TSharedPtr<FJsonValue> Response = Registry.ExecuteHandler(TEXT("mesh_boolean"), Params);
+		TestFalse(TEXT("an output path on a protected mount is refused"),
+			BooleanResponseBool(Response, TEXT("success"), true));
+		TestTrue(TEXT("the refusal names the guardrail"),
+			BooleanResponseString(Response, TEXT("error")).Contains(TEXT("protected mount")));
+	}
+
+	{
+		// Everything valid, nothing on disk. Whether the Geometry Script plugin
+		// is here or not, the answer is a named failure rather than a crash,
+		// and it is one of exactly two reasons.
+		const TSharedPtr<FJsonValue> Response =
+			Registry.ExecuteHandler(TEXT("mesh_boolean"), BaseBooleanParams());
+		TestFalse(TEXT("a missing target mesh is not a success"),
+			BooleanResponseBool(Response, TEXT("success"), true));
+
+		const FString Reason = BooleanResponseString(Response, TEXT("reason"));
+		TestTrue(FString::Printf(
+			TEXT("the failure is either the missing asset or the missing plugin, not something unnamed (got '%s')"),
+			*Reason),
+			Reason == TEXT("missing")
+			|| Reason == TEXT("notIndexed")
+			|| Reason == TEXT("geometry_scripting_unavailable"));
+	}
+
+	return true;
+}
+
+#endif

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

@@ -0,0 +1,116 @@
+// Coverage for asset(get_mesh_geometry) and asset(measure_mesh_geometry) that
+// is safe to run anywhere.
+//
+// run_automation_tests dispatches every EditorContext/EngineFilter test in the
+// process when it is called without a filter, against whatever project the
+// bridge is attached to. Both handlers here are reads, so nothing they do can
+// mutate a project, but a test that named a real mesh would still only pass on
+// the machine that had it. Everything below is registration and argument
+// validation, which holds in any project; the geometry itself is exercised by
+// the smoke suite against the dedicated test project.
+
+#if WITH_DEV_AUTOMATION_TESTS
+
+#include "HandlerRegistry.h"
+#include "Handlers/AssetHandlers_Geometry.h"
+#include "Misc/AutomationTest.h"
+
+namespace
+{
+TSharedPtr<FJsonObject> MakeGeometryResponseObject(const TSharedPtr<FJsonValue>& Response)
+{
+	return (Response.IsValid() && Response->Type == EJson::Object) ? Response->AsObject() : nullptr;
+}
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FAssetMeshGeometryRegistrationTest,
+	"UE.MCP.Asset.MeshGeometry.RegistrationAndValidation",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FAssetMeshGeometryRegistrationTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FAssetGeometryHandlers::RegisterHandlers(Registry);
+	TestTrue(TEXT("get_mesh_geometry is registered"), Registry.HasHandler(TEXT("get_mesh_geometry")));
+	TestTrue(TEXT("measure_mesh_geometry is registered"), Registry.HasHandler(TEXT("measure_mesh_geometry")));
+
+	// Missing assetPath names the parameter it wants.
+	{
+		const TSharedPtr<FJsonObject> Missing = MakeGeometryResponseObject(
+			Registry.ExecuteHandler(TEXT("get_mesh_geometry"), MakeShared<FJsonObject>()));
+		TestTrue(TEXT("missing assetPath returns an object"), Missing.IsValid());
+		if (Missing.IsValid())
+		{
+			TestFalse(TEXT("missing assetPath is unsuccessful"), Missing->GetBoolField(TEXT("success")));
+			TestTrue(TEXT("missing assetPath names assetPath"),
+				Missing->GetStringField(TEXT("error")).Contains(TEXT("assetPath")));
+		}
+	}
+	{
+		const TSharedPtr<FJsonObject> Missing = MakeGeometryResponseObject(
+			Registry.ExecuteHandler(TEXT("measure_mesh_geometry"), MakeShared<FJsonObject>()));
+		TestTrue(TEXT("measure missing assetPath returns an object"), Missing.IsValid());
+		if (Missing.IsValid())
+		{
+			TestFalse(TEXT("measure missing assetPath is unsuccessful"), Missing->GetBoolField(TEXT("success")));
+			TestTrue(TEXT("measure missing assetPath names assetPath"),
+				Missing->GetStringField(TEXT("error")).Contains(TEXT("assetPath")));
+		}
+	}
+
+	// An unknown include token is rejected before anything is loaded, and the
+	// message carries the full allowed set so a caller does not have to guess.
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetStringField(TEXT("assetPath"), TEXT("/Game/UEMCP/DoesNotExist_MeshGeometryTest"));
+		Request->SetArrayField(TEXT("include"), { MakeShared<FJsonValueString>(TEXT("tangents")) });
+		const TSharedPtr<FJsonObject> Rejected = MakeGeometryResponseObject(
+			Registry.ExecuteHandler(TEXT("get_mesh_geometry"), Request));
+		TestTrue(TEXT("bad include returns an object"), Rejected.IsValid());
+		if (Rejected.IsValid())
+		{
+			TestFalse(TEXT("bad include is unsuccessful"), Rejected->GetBoolField(TEXT("success")));
+			const FString Error = Rejected->GetStringField(TEXT("error"));
+			TestTrue(TEXT("bad include quotes the offending token"), Error.Contains(TEXT("tangents")));
+			TestTrue(TEXT("bad include lists the allowed set"), Error.Contains(TEXT("positions")));
+			TestTrue(TEXT("bad include lists triangles too"), Error.Contains(TEXT("triangles")));
+		}
+	}
+
+	// An empty include is a request for nothing, which is a mistake rather than
+	// an answer, so it is refused instead of returning empty section arrays.
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetStringField(TEXT("assetPath"), TEXT("/Game/UEMCP/DoesNotExist_MeshGeometryTest"));
+		Request->SetArrayField(TEXT("include"), TArray<TSharedPtr<FJsonValue>>());
+		const TSharedPtr<FJsonObject> Rejected = MakeGeometryResponseObject(
+			Registry.ExecuteHandler(TEXT("get_mesh_geometry"), Request));
+		TestTrue(TEXT("empty include returns an object"), Rejected.IsValid());
+		if (Rejected.IsValid())
+		{
+			TestFalse(TEXT("empty include is unsuccessful"), Rejected->GetBoolField(TEXT("success")));
+			TestTrue(TEXT("empty include says what to pass"),
+				Rejected->GetStringField(TEXT("error")).Contains(TEXT("include")));
+		}
+	}
+
+	// A path that resolves to nothing reports the path, not a null dereference.
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetStringField(TEXT("assetPath"), TEXT("/Game/UEMCP/DoesNotExist_MeshGeometryTest"));
+		const TSharedPtr<FJsonObject> NotFound = MakeGeometryResponseObject(
+			Registry.ExecuteHandler(TEXT("get_mesh_geometry"), Request));
+		TestTrue(TEXT("unknown asset returns an object"), NotFound.IsValid());
+		if (NotFound.IsValid())
+		{
+			TestFalse(TEXT("unknown asset is unsuccessful"), NotFound->GetBoolField(TEXT("success")));
+			TestTrue(TEXT("unknown asset echoes the path"),
+				NotFound->GetStringField(TEXT("error")).Contains(TEXT("DoesNotExist_MeshGeometryTest")));
+		}
+	}
+
+	return true;
+}
+
+#endif // WITH_DEV_AUTOMATION_TESTS

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

@@ -0,0 +1,161 @@
+// Regression coverage for #949.
+//
+// SaveAssetPackage built its target filename with the asset extension
+// unconditionally, so every handler that mutated an actor or a component in the
+// open level wrote Content/Maps/<Level>.uasset alongside the existing
+// Content/Maps/<Level>.umap. Two package files then claimed the same long
+// package name, level(save) kept writing one and the ~87 SaveAssetPackage call
+// sites kept writing the other, and the two diverged in silence. Unreal resolves
+// the ".uasset" first, so the fork is the copy that wins.
+//
+// The test writes nowhere near the attached project. run_automation_tests
+// dispatches every EditorContext/EngineFilter test in the process against
+// whatever project the bridge happens to be attached to, so this registers its
+// own mount point over a fresh directory in the system temp area, does the whole
+// exercise there, then unmounts and deletes it.
+
+#if WITH_DEV_AUTOMATION_TESTS
+
+#include "HandlerUtils.h"
+
+#include "Engine/World.h"
+#include "HAL/FileManager.h"
+#include "HAL/PlatformProcess.h"
+#include "Misc/AutomationTest.h"
+#include "Misc/Guid.h"
+#include "Misc/PackageName.h"
+#include "Misc/Paths.h"
+#include "UObject/Package.h"
+
+namespace
+{
+	const TCHAR* const MCPExtensionTestRoot = TEXT("/UEMCPPackageExtensionTest/");
+
+	/** Mount a private content root for the duration of the test and take it
+	 *  back down again, so no assertion here can touch a user's content. */
+	struct FScopedTestMount
+	{
+		FString RootPath;
+		FString ContentPath;
+
+		FScopedTestMount()
+			: RootPath(MCPExtensionTestRoot)
+			, ContentPath(FPaths::Combine(
+				FPaths::ConvertRelativePathToFull(FString(FPlatformProcess::UserTempDir())),
+				FString(TEXT("UEMCPPackageExtensionTest")),
+				FGuid::NewGuid().ToString(EGuidFormats::Digits)))
+		{
+			IFileManager::Get().MakeDirectory(*ContentPath, /*Tree=*/true);
+			FPackageName::RegisterMountPoint(RootPath, ContentPath);
+		}
+
+		~FScopedTestMount()
+		{
+			FPackageName::UnRegisterMountPoint(RootPath, ContentPath);
+			IFileManager::Get().DeleteDirectory(*ContentPath, /*RequireExists=*/false, /*Tree=*/true);
+		}
+
+		FScopedTestMount(const FScopedTestMount&) = delete;
+		FScopedTestMount& operator=(const FScopedTestMount&) = delete;
+	};
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FPackageSaveExtensionTest,
+	"UE.MCP.Save.PackageExtension.WorldPackagesWriteUMap",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FPackageSaveExtensionTest::RunTest(const FString& Parameters)
+{
+	const FScopedTestMount Mount;
+	IFileManager& FM = IFileManager::Get();
+
+	// A package with no world in it keeps the asset extension. This is the half
+	// the old code got right, and it has to stay right: one-file-per-actor
+	// packages under __ExternalActors__ hold an AActor and no UWorld, and OFPA
+	// expects those on disk as ".uasset".
+	const FString AssetPackageName = FString(MCPExtensionTestRoot) + TEXT("AssetPackage");
+	UPackage* AssetPackage = CreatePackage(*AssetPackageName);
+	TestNotNull(TEXT("asset package created"), AssetPackage);
+	if (AssetPackage)
+	{
+		TestFalse(TEXT("a package with no world is not a map package"), IsMapPackage(AssetPackage));
+		TestEqual(TEXT("a package with no world takes the asset extension"),
+			PackageFileExtension(AssetPackage), FPackageName::GetAssetPackageExtension());
+	}
+
+	// The regression itself: an object whose outermost is a UWorld.
+	const FString WorldPackageName = FString(MCPExtensionTestRoot) + TEXT("TestLevel");
+	UPackage* WorldPackage = CreatePackage(*WorldPackageName);
+	TestNotNull(TEXT("world package created"), WorldPackage);
+	if (!WorldPackage)
+	{
+		return false;
+	}
+
+	UWorld* World = UWorld::CreateWorld(
+		EWorldType::Inactive,
+		/*bInformEngineOfWorld=*/false,
+		FName(TEXT("TestLevel")),
+		WorldPackage,
+		/*bAddToRoot=*/false);
+	TestNotNull(TEXT("world created inside the package"), World);
+	if (!World)
+	{
+		return false;
+	}
+	// Mirror what UWorldFactory stamps on a newly authored map, so the save has
+	// a top-level asset to pick up under SaveAssetPackage's TopLevelFlags.
+	World->SetFlags(RF_Public | RF_Standalone);
+	const FGCRootScope KeepWorldAlive(World);
+
+	TestTrue(TEXT("the world's outermost is the world package"), World->GetOutermost() == WorldPackage);
+	TestTrue(TEXT("a package holding a world is a map package"), IsMapPackage(WorldPackage));
+	TestEqual(TEXT("a world package takes the map extension"),
+		PackageFileExtension(WorldPackage), FPackageName::GetMapPackageExtension());
+
+	FString ResolvedFileName;
+	TestTrue(TEXT("the world package resolves to a filename"),
+		ResolvePackageFileName(WorldPackage, ResolvedFileName));
+	TestTrue(TEXT("the resolved filename is a .umap"),
+		ResolvedFileName.EndsWith(FPackageName::GetMapPackageExtension(), ESearchCase::IgnoreCase));
+	TestFalse(TEXT("the resolved filename is not a .uasset"),
+		ResolvedFileName.EndsWith(FPackageName::GetAssetPackageExtension(), ESearchCase::IgnoreCase));
+
+	FString BaseFileName;
+	TestTrue(TEXT("the package name maps into the test mount"),
+		FPackageName::TryConvertLongPackageNameToFilename(WorldPackageName, BaseFileName));
+	const FString MapFile = BaseFileName + FPackageName::GetMapPackageExtension();
+	const FString AssetSibling = BaseFileName + FPackageName::GetAssetPackageExtension();
+
+	TestFalse(TEXT("no map file on disk before the save"), FM.FileExists(*MapFile));
+	TestFalse(TEXT("no asset sibling on disk before the save"), FM.FileExists(*AssetSibling));
+
+	const bool bSaved = SaveAssetPackage(World);
+
+	// This is the assertion that fails on a #949 regression, and it holds
+	// whatever the save itself decided to do: the asset sibling must never be
+	// created for a package that already lives on disk as a map.
+	TestFalse(TEXT("saving a world package writes no .uasset sibling"), FM.FileExists(*AssetSibling));
+	if (bSaved)
+	{
+		TestTrue(TEXT("saving a world package writes the .umap"), FM.FileExists(*MapFile));
+	}
+	else
+	{
+		AddInfo(TEXT("SavePackage declined to write the test world; the .uasset sibling assertion still stands."));
+	}
+
+	// Leave nothing dirty behind: a later editor(save_dirty) would otherwise
+	// find these packages and try to flush them through an unmounted root.
+	WorldPackage->SetDirtyFlag(false);
+	if (AssetPackage)
+	{
+		AssetPackage->SetDirtyFlag(false);
+	}
+	World->DestroyWorld(/*bInformEngineOfWorld=*/false);
+
+	return true;
+}
+
+#endif