ue-mcp 1.2.4 → 1.3.0

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

@@ -0,0 +1,243 @@
+// Regression coverage for #957 and #913.
+//
+// A short package path and its object path form name the same asset, and
+// asset(search) reports the short one. Several actions accepted only the object
+// path, so an asset that existed and had just been reported by search answered
+// "Asset not found", and the sentence was the same one a genuinely missing path
+// produced. These tests pin the two halves of the fix: every path form derives
+// the same object path, and a miss carries enough structure to tell a path-shape
+// bug from a missing asset.
+//
+// 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/DataTable.h"
+#include "Engine/Texture2D.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 MCPAssetPathTestRoot = TEXT("/UEMCPAssetPathTest/");
+
+	/** 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 FScopedAssetPathTestMount
+	{
+		FString RootPath;
+		FString ContentPath;
+
+		FScopedAssetPathTestMount()
+			: RootPath(MCPAssetPathTestRoot)
+			, ContentPath(FPaths::Combine(
+				FPaths::ConvertRelativePathToFull(FString(FPlatformProcess::UserTempDir())),
+				FString(TEXT("UEMCPAssetPathTest")),
+				FGuid::NewGuid().ToString(EGuidFormats::Digits)))
+		{
+			IFileManager::Get().MakeDirectory(*ContentPath, /*Tree=*/true);
+			FPackageName::RegisterMountPoint(RootPath, ContentPath);
+		}
+
+		~FScopedAssetPathTestMount()
+		{
+			FPackageName::UnRegisterMountPoint(RootPath, ContentPath);
+			IFileManager::Get().DeleteDirectory(*ContentPath, /*RequireExists=*/false, /*Tree=*/true);
+		}
+
+		FScopedAssetPathTestMount(const FScopedAssetPathTestMount&) = delete;
+		FScopedAssetPathTestMount& operator=(const FScopedAssetPathTestMount&) = delete;
+	};
+
+	/** Read one string field off an error response. */
+	FString ErrorField(const TSharedPtr<FJsonValue>& Value, const TCHAR* Field)
+	{
+		if (!Value.IsValid()) return FString();
+		const TSharedPtr<FJsonObject> Obj = Value->AsObject();
+		if (!Obj.IsValid()) return FString();
+		FString Out;
+		Obj->TryGetStringField(Field, Out);
+		return Out;
+	}
+
+	bool ErrorSucceeded(const TSharedPtr<FJsonValue>& Value)
+	{
+		if (!Value.IsValid()) return false;
+		const TSharedPtr<FJsonObject> Obj = Value->AsObject();
+		if (!Obj.IsValid()) return false;
+		bool bSuccess = true;
+		Obj->TryGetBoolField(TEXT("success"), bSuccess);
+		return bSuccess;
+	}
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FMCPAssetPathFormsTest,
+	"UE.MCP.Asset.PathResolution.EveryFormDerivesOneObjectPath",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FMCPAssetPathFormsTest::RunTest(const FString& Parameters)
+{
+	// The bare package path: the form asset(search) reports and #957 rejected.
+	{
+		const FMCPAssetPathForms Forms = MCPAssetPathForms(TEXT("/Game/MyFolder/DT_Thing"));
+		TestEqual(TEXT("package path from a bare package path"),
+			Forms.PackagePath, FString(TEXT("/Game/MyFolder/DT_Thing")));
+		TestEqual(TEXT("object path derived from a bare package path"),
+			Forms.ObjectPath, FString(TEXT("/Game/MyFolder/DT_Thing.DT_Thing")));
+		TestEqual(TEXT("asset name from a bare package path"),
+			Forms.AssetName, FString(TEXT("DT_Thing")));
+		TestFalse(TEXT("a bare package path carried no object name"), Forms.bInputCarriedObjectName);
+	}
+
+	// The object path: unchanged, and the same object path as the short form.
+	{
+		const FMCPAssetPathForms Forms = MCPAssetPathForms(TEXT("/Game/MyFolder/DT_Thing.DT_Thing"));
+		TestEqual(TEXT("package path from an object path"),
+			Forms.PackagePath, FString(TEXT("/Game/MyFolder/DT_Thing")));
+		TestEqual(TEXT("object path from an object path"),
+			Forms.ObjectPath, FString(TEXT("/Game/MyFolder/DT_Thing.DT_Thing")));
+		TestTrue(TEXT("an object path carried an object name"), Forms.bInputCarriedObjectName);
+	}
+
+	// The export-text form, which arrives from copied editor references.
+	{
+		const FMCPAssetPathForms Forms = MCPAssetPathForms(TEXT("DataTable'/Game/MyFolder/DT_Thing.DT_Thing'"));
+		TestEqual(TEXT("object path from an export text path"),
+			Forms.ObjectPath, FString(TEXT("/Game/MyFolder/DT_Thing.DT_Thing")));
+	}
+
+	// A subobject path keeps its own leaf, and still names its own package.
+	{
+		const FMCPAssetPathForms Forms = MCPAssetPathForms(TEXT("/Game/MyFolder/DT_Thing.DT_Thing:Inner"));
+		TestEqual(TEXT("package path from a subobject path"),
+			Forms.PackagePath, FString(TEXT("/Game/MyFolder/DT_Thing")));
+		TestEqual(TEXT("object path from a subobject path"),
+			Forms.ObjectPath, FString(TEXT("/Game/MyFolder/DT_Thing.DT_Thing:Inner")));
+		TestEqual(TEXT("asset name from a subobject path"),
+			Forms.AssetName, FString(TEXT("Inner")));
+	}
+
+	// Surrounding whitespace is a copy-paste artefact, not a different asset.
+	{
+		const FMCPAssetPathForms Forms = MCPAssetPathForms(TEXT("  /Game/MyFolder/DT_Thing  "));
+		TestEqual(TEXT("whitespace does not change the derived object path"),
+			Forms.ObjectPath, FString(TEXT("/Game/MyFolder/DT_Thing.DT_Thing")));
+	}
+
+	// An empty path derives nothing rather than an object path of ".".
+	{
+		const FMCPAssetPathForms Forms = MCPAssetPathForms(FString());
+		TestTrue(TEXT("an empty path derives an empty object path"), Forms.ObjectPath.IsEmpty());
+	}
+
+	return true;
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FMCPAssetPathResolutionTest,
+	"UE.MCP.Asset.PathResolution.ShortPathResolvesAndMissesAreDiagnosable",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FMCPAssetPathResolutionTest::RunTest(const FString& Parameters)
+{
+	const FScopedAssetPathTestMount Mount;
+
+	const FString PackageName = FString(MCPAssetPathTestRoot) + TEXT("DT_PathProbe");
+	const FString ObjectPath = PackageName + TEXT(".DT_PathProbe");
+
+	UPackage* Package = CreatePackage(*PackageName);
+	TestNotNull(TEXT("probe package created"), Package);
+	if (!Package)
+	{
+		return false;
+	}
+
+	UDataTable* Probe = NewObject<UDataTable>(
+		Package, FName(TEXT("DT_PathProbe")), RF_Public | RF_Standalone);
+	TestNotNull(TEXT("probe asset created"), Probe);
+	if (!Probe)
+	{
+		Package->SetDirtyFlag(false);
+		return false;
+	}
+	const FGCRootScope KeepProbeAlive(Probe);
+
+	// #957: this is the assertion that fails on a regression. The short form is
+	// what asset(search) reports, and it must resolve to the same object the
+	// object path does.
+	TestTrue(TEXT("a bare package path resolves to the asset"),
+		MCPLoadAssetObject(PackageName) == Probe);
+	TestTrue(TEXT("an object path resolves to the same asset"),
+		MCPLoadAssetObject(ObjectPath) == Probe);
+	TestTrue(TEXT("an export text path resolves to the same asset"),
+		MCPLoadAssetObject(FString::Printf(TEXT("DataTable'%s'"), *ObjectPath)) == Probe);
+	TestTrue(TEXT("a path with surrounding whitespace resolves to the same asset"),
+		MCPLoadAssetObject(FString::Printf(TEXT("  %s  "), *PackageName)) == Probe);
+
+	// The resolver never hands back the package in place of the asset.
+	TestTrue(TEXT("the resolver answers the asset, never its package"),
+		MCPLoadAssetObject(PackageName) != static_cast<UObject*>(Package));
+
+	// The typed loader rides on the same resolution, so a short path works for
+	// the type-specific readers too (#913).
+	TestTrue(TEXT("a typed load resolves a bare package path"),
+		LoadAssetByPath<UDataTable>(PackageName) == Probe);
+	TestNull(TEXT("a typed load of the wrong type resolves to nothing"),
+		LoadAssetByPath<UTexture2D>(PackageName));
+
+	// A path that resolved to the wrong type says which type it found, so it is
+	// distinguishable from a path that resolved to nothing at all.
+	{
+		const TSharedPtr<FJsonValue> Wrong = MCPAssetLoadError(PackageName, TEXT("Texture2D"));
+		TestFalse(TEXT("a wrong-type answer is an error"), ErrorSucceeded(Wrong));
+		TestEqual(TEXT("a wrong-type answer names the class that was found"),
+			ErrorField(Wrong, TEXT("foundClass")), FString(TEXT("DataTable")));
+		TestEqual(TEXT("a wrong-type answer names the class that was expected"),
+			ErrorField(Wrong, TEXT("expectedClass")), FString(TEXT("Texture2D")));
+	}
+
+	// A genuinely missing asset reports the forms that were tried and says the
+	// package is not there, rather than a bare "Asset not found".
+	{
+		const FString MissingPath = FString(MCPAssetPathTestRoot) + TEXT("DT_NotThere");
+		TestNull(TEXT("a missing path resolves to nothing"), MCPLoadAssetObject(MissingPath));
+
+		const TSharedPtr<FJsonValue> Missing = MCPAssetNotFoundError(MissingPath);
+		TestFalse(TEXT("a miss is an error"), ErrorSucceeded(Missing));
+		TestEqual(TEXT("a miss echoes the caller's own path"),
+			ErrorField(Missing, TEXT("assetPath")), MissingPath);
+		TestEqual(TEXT("a miss names the normalized package path"),
+			ErrorField(Missing, TEXT("packagePath")), MissingPath);
+		TestEqual(TEXT("a miss names the object path form it tried"),
+			ErrorField(Missing, TEXT("objectPath")), MissingPath + TEXT(".DT_NotThere"));
+		TestEqual(TEXT("a miss with nothing on disk and nothing in the registry reads as missing"),
+			ErrorField(Missing, TEXT("reason")), FString(TEXT("missing")));
+	}
+
+	// A context label names what the path was supposed to be.
+	{
+		const TSharedPtr<FJsonValue> Missing = MCPAssetNotFoundError(
+			FString(MCPAssetPathTestRoot) + TEXT("DT_NotThere"), TEXT("Source asset"));
+		TestTrue(TEXT("a context label leads the message"),
+			ErrorField(Missing, TEXT("error")).StartsWith(TEXT("Source asset not found:")));
+	}
+
+	// Leave nothing dirty behind: a later editor(save_dirty) would otherwise
+	// find this package and try to flush it through an unmounted root.
+	Package->SetDirtyFlag(false);
+	return true;
+}
+
+#endif

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

@@ -0,0 +1,213 @@
+// Regression coverage for #931.
+//
+// asset(set_property) marked the package dirty and stopped there. The value
+// read back correctly, stayed correct for the rest of the editor session, and
+// was gone on the next start, because nothing ever wrote the package. A
+// GameplayAbility whose default reverted that way computed correct values and
+// applied no effect, with nothing pointing at the cause.
+//
+// UPackage::IsDirty is the engine's own record and is the direct check: after a
+// write that persisted, the package is clean; after a write that did not, it is
+// still dirty and the response says why.
+//
+// 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 "HandlerRegistry.h"
+#include "HandlerUtils.h"
+#include "Handlers/AssetHandlers.h"
+
+#include "Dom/JsonObject.h"
+#include "Dom/JsonValue.h"
+#include "Engine/DataTable.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"
+#include "UObject/PerPlatformProperties.h"
+
+namespace
+{
+	const TCHAR* const MCPPersistTestRoot = TEXT("/UEMCPAssetPersistTest/");
+
+	/** 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 FScopedPersistTestMount
+	{
+		FString RootPath;
+		FString ContentPath;
+
+		FScopedPersistTestMount()
+			: RootPath(MCPPersistTestRoot)
+			, ContentPath(FPaths::Combine(
+				FPaths::ConvertRelativePathToFull(FString(FPlatformProcess::UserTempDir())),
+				FString(TEXT("UEMCPAssetPersistTest")),
+				FGuid::NewGuid().ToString(EGuidFormats::Digits)))
+		{
+			IFileManager::Get().MakeDirectory(*ContentPath, /*Tree=*/true);
+			FPackageName::RegisterMountPoint(RootPath, ContentPath);
+		}
+
+		~FScopedPersistTestMount()
+		{
+			FPackageName::UnRegisterMountPoint(RootPath, ContentPath);
+			IFileManager::Get().DeleteDirectory(*ContentPath, /*RequireExists=*/false, /*Tree=*/true);
+		}
+
+		FScopedPersistTestMount(const FScopedPersistTestMount&) = delete;
+		FScopedPersistTestMount& operator=(const FScopedPersistTestMount&) = delete;
+	};
+
+	TSharedPtr<FJsonObject> ResponseObject(const TSharedPtr<FJsonValue>& Response)
+	{
+		return (Response.IsValid() && Response->Type == EJson::Object)
+			? Response->AsObject()
+			: TSharedPtr<FJsonObject>();
+	}
+
+	bool ResponseBool(const TSharedPtr<FJsonValue>& Response, const TCHAR* Field, bool bDefault = false)
+	{
+		const TSharedPtr<FJsonObject> Obj = ResponseObject(Response);
+		if (!Obj.IsValid()) return bDefault;
+		bool bValue = bDefault;
+		Obj->TryGetBoolField(Field, bValue);
+		return bValue;
+	}
+
+	FString ResponseString(const TSharedPtr<FJsonValue>& Response, const TCHAR* Field)
+	{
+		const TSharedPtr<FJsonObject> Obj = ResponseObject(Response);
+		if (!Obj.IsValid()) return FString();
+		FString Value;
+		Obj->TryGetStringField(Field, Value);
+		return Value;
+	}
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FMCPSetAssetPropertyPersistsTest,
+	"UE.MCP.Asset.SetProperty.WriteReachesThePackage",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FMCPSetAssetPropertyPersistsTest::RunTest(const FString& Parameters)
+{
+	const FScopedPersistTestMount Mount;
+
+	const FString PackageName = FString(MCPPersistTestRoot) + TEXT("DT_PersistProbe");
+	UPackage* Package = CreatePackage(*PackageName);
+	if (!TestNotNull(TEXT("probe package created"), Package)) return false;
+
+	UDataTable* Probe = NewObject<UDataTable>(
+		Package, FName(TEXT("DT_PersistProbe")), RF_Public | RF_Standalone);
+	if (!TestNotNull(TEXT("probe asset created"), Probe))
+	{
+		Package->SetDirtyFlag(false);
+		return false;
+	}
+	Probe->RowStruct = FPerPlatformInt::StaticStruct();
+	const FGCRootScope KeepProbeAlive(Probe);
+
+	FString PackageFileName;
+	if (!TestTrue(TEXT("the probe package name maps into the test mount"),
+		FPackageName::TryConvertLongPackageNameToFilename(
+			PackageName, PackageFileName, FPackageName::GetAssetPackageExtension())))
+	{
+		Package->SetDirtyFlag(false);
+		return false;
+	}
+	TestFalse(TEXT("no package file on disk before the write"),
+		IFileManager::Get().FileExists(*PackageFileName));
+
+	FMCPHandlerRegistry Registry;
+	FAssetHandlers::RegisterHandlers(Registry);
+	if (!TestTrue(TEXT("set_asset_property is registered"), Registry.HasHandler(TEXT("set_asset_property"))))
+	{
+		Package->SetDirtyFlag(false);
+		return false;
+	}
+
+	// The default write. This is the #931 assertion: it must reach disk without
+	// the caller asking for a save.
+	{
+		TSharedPtr<FJsonObject> Params = MakeShared<FJsonObject>();
+		Params->SetStringField(TEXT("assetPath"), PackageName);
+		Params->SetStringField(TEXT("propertyName"), TEXT("ImportKeyField"));
+		Params->SetStringField(TEXT("value"), TEXT("PersistedKey"));
+
+		const TSharedPtr<FJsonValue> Response =
+			Registry.ExecuteHandler(TEXT("set_asset_property"), Params);
+
+		TestTrue(FString::Printf(TEXT("the write succeeded (%s)"), *ResponseString(Response, TEXT("error"))),
+			ResponseBool(Response, TEXT("success")));
+		TestEqual(TEXT("the value landed on the asset"),
+			Probe->ImportKeyField, FString(TEXT("PersistedKey")));
+
+		// The two halves of the fix: the response says it persisted, and the
+		// engine's own dirty record agrees.
+		TestTrue(TEXT("the response reports the write as persisted"),
+			ResponseBool(Response, TEXT("persisted")));
+		TestEqual(TEXT("the response names the package it wrote"),
+			ResponseString(Response, TEXT("packageName")), PackageName);
+		TestFalse(TEXT("the package is no longer dirty after a persisted write"), Package->IsDirty());
+		TestTrue(TEXT("the package file exists on disk after the write"),
+			IFileManager::Get().FileExists(*PackageFileName));
+	}
+
+	// The opt-out. A write the caller asked not to save is still reported
+	// honestly rather than as a plain success.
+	{
+		TSharedPtr<FJsonObject> Params = MakeShared<FJsonObject>();
+		Params->SetStringField(TEXT("assetPath"), PackageName);
+		Params->SetStringField(TEXT("propertyName"), TEXT("ImportKeyField"));
+		Params->SetStringField(TEXT("value"), TEXT("InMemoryOnly"));
+		Params->SetBoolField(TEXT("save"), false);
+
+		const TSharedPtr<FJsonValue> Response =
+			Registry.ExecuteHandler(TEXT("set_asset_property"), Params);
+
+		TestTrue(TEXT("an unsaved write still reports the write itself as done"),
+			ResponseBool(Response, TEXT("success")));
+		TestEqual(TEXT("the value landed on the asset in memory"),
+			Probe->ImportKeyField, FString(TEXT("InMemoryOnly")));
+		TestFalse(TEXT("an unsaved write reports persisted=false"),
+			ResponseBool(Response, TEXT("persisted"), true));
+		TestFalse(TEXT("an unsaved write names the reason"),
+			ResponseString(Response, TEXT("persistError")).IsEmpty());
+		TestTrue(TEXT("an unsaved write leaves the package dirty"), Package->IsDirty());
+	}
+
+	// Leave nothing dirty behind: a later editor(save_dirty) would otherwise
+	// find this package and try to flush it through an unmounted root.
+	Package->SetDirtyFlag(false);
+	return true;
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FMCPSetAssetPropertyProtectedMountTest,
+	"UE.MCP.Asset.SetProperty.ProtectedMountIsNeverWritten",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FMCPSetAssetPropertyProtectedMountTest::RunTest(const FString& Parameters)
+{
+	// The persistence step routes through the shared protected-mount guardrail,
+	// so a write that lands on engine content is reported as unpersisted rather
+	// than written. Asserting the guardrail directly keeps this test off any
+	// engine package.
+	TestTrue(TEXT("engine content is a protected mount"),
+		MCPIsProtectedAssetPath(TEXT("/Engine/EngineMaterials/DefaultMaterial")));
+	TestTrue(TEXT("script paths are a protected mount"),
+		MCPIsProtectedAssetPath(TEXT("/Script/Engine")));
+	TestFalse(TEXT("game content is not a protected mount"),
+		MCPIsProtectedAssetPath(TEXT("/Game/MyFolder/DT_Thing")));
+	return true;
+}
+
+#endif