ue-mcp 1.2.4 → 1.3.0

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

@@ -0,0 +1,334 @@
+#if WITH_DEV_AUTOMATION_TESTS
+
+#include "Handlers/GameplayHandlers.h"
+#include "HandlerRegistry.h"
+#include "Misc/AutomationTest.h"
+
+#include "Dom/JsonObject.h"
+#include "Dom/JsonValue.h"
+#include "UObject/Package.h"
+#include "UObject/UObjectGlobals.h"
+
+#include "BehaviorTree/BlackboardData.h"
+#include "BehaviorTree/Blackboard/BlackboardKeyType.h"
+#include "BehaviorTree/BTNode.h"
+
+namespace
+{
+	// The BT node classes under test are resolved by path rather than included
+	// by header, so a build without one of them skips the case instead of
+	// failing to link.
+	UClass* MCPBTTestFindClass(const TCHAR* ClassPath)
+	{
+		return FindObject<UClass>(nullptr, ClassPath);
+	}
+
+	UBTNode* MCPBTTestMakeNode(const TCHAR* ClassPath)
+	{
+		UClass* Class = MCPBTTestFindClass(ClassPath);
+		if (!Class) return nullptr;
+		return NewObject<UBTNode>(GetTransientPackage(), Class);
+	}
+
+	FString MCPBTTestGetString(const TSharedPtr<FJsonObject>& Object, const TCHAR* Field)
+	{
+		FString Value;
+		if (Object.IsValid()) Object->TryGetStringField(Field, Value);
+		return Value;
+	}
+}
+
+// #887: get_behavior_tree_info walked UBlackboardData::Keys as if it were an
+// array of UObject pointers. It is an array of FBlackboardEntry structs, so the
+// walk read each entry's FName as a pointer and dereferenced it, and every
+// blackboard with at least one key took the editor down with an access
+// violation. This test builds that exact shape in memory.
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FMCPBehaviorTreeBlackboardKeysTest,
+	"UE.MCP.Gameplay.BehaviorTree.BlackboardKeys",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FMCPBehaviorTreeBlackboardKeysTest::RunTest(const FString& Parameters)
+{
+	UBlackboardData* Blackboard = NewObject<UBlackboardData>(GetTransientPackage());
+	TestNotNull(TEXT("blackboard was created"), Blackboard);
+	if (!Blackboard) return false;
+
+	UClass* ObjectKeyClass = MCPBTTestFindClass(TEXT("/Script/AIModule.BlackboardKeyType_Object"));
+
+	FBlackboardEntry Typed;
+	Typed.EntryName = TEXT("TargetActor");
+	if (ObjectKeyClass)
+	{
+		Typed.KeyType = NewObject<UBlackboardKeyType>(Blackboard, ObjectKeyClass);
+	}
+	Blackboard->Keys.Add(Typed);
+
+	// A key whose type was never picked is a real authoring state, and the
+	// reader has to describe it rather than dereference it.
+	FBlackboardEntry Untyped;
+	Untyped.EntryName = TEXT("PatrolIndex");
+	Blackboard->Keys.Add(Untyped);
+
+	const TArray<TSharedPtr<FJsonValue>> Keys = FGameplayHandlers::DescribeBlackboardKeys(Blackboard);
+	TestEqual(TEXT("both keys are described"), Keys.Num(), 2);
+	if (Keys.Num() != 2) return false;
+
+	const TSharedPtr<FJsonObject> First = Keys[0]->AsObject();
+	const TSharedPtr<FJsonObject> Second = Keys[1]->AsObject();
+	TestEqual(TEXT("first key name"), MCPBTTestGetString(First, TEXT("name")), FString(TEXT("TargetActor")));
+	TestEqual(TEXT("second key name"), MCPBTTestGetString(Second, TEXT("name")), FString(TEXT("PatrolIndex")));
+	TestEqual(TEXT("untyped key reports an empty type instead of crashing"),
+		MCPBTTestGetString(Second, TEXT("type")), FString());
+	if (ObjectKeyClass)
+	{
+		TestEqual(TEXT("typed key reports its short type name"),
+			MCPBTTestGetString(First, TEXT("type")), FString(TEXT("Object")));
+	}
+
+	// A null blackboard is an empty answer, never a dereference.
+	TestEqual(TEXT("null blackboard yields no keys"),
+		FGameplayHandlers::DescribeBlackboardKeys(nullptr).Num(), 0);
+	return true;
+}
+
+// #888: BTDecorator_Blackboard keeps its whole configuration in protected C++
+// fields, so the graph read used to report class and name only. Every field a
+// "the tree runs but the wrong branch fires" investigation needs comes back now.
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FMCPBehaviorTreeDecoratorConfigTest,
+	"UE.MCP.Gameplay.BehaviorTree.DecoratorConfig",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FMCPBehaviorTreeDecoratorConfigTest::RunTest(const FString& Parameters)
+{
+	UBTNode* Decorator = MCPBTTestMakeNode(TEXT("/Script/AIModule.BTDecorator_Blackboard"));
+	if (!Decorator)
+	{
+		AddInfo(TEXT("BTDecorator_Blackboard is not present in this build; skipping."));
+		return true;
+	}
+
+	// The nested write is the #919 path: a dotted address into a protected
+	// struct field on an owned node subobject.
+	FString Error;
+	TestTrue(TEXT("selected blackboard key is writable through a dotted path"),
+		FGameplayHandlers::WriteBTNodeProperty(Decorator, TEXT("BlackboardKey.SelectedKeyName"),
+			MakeShared<FJsonValueString>(TEXT("TargetActor")), Error));
+	TestEqual(TEXT("no error writing the selected key"), Error, FString());
+
+#if WITH_EDITORONLY_DATA
+	// The comparison operation is authored data, so the engine declares it
+	// editor-only. It is the field that says whether the branch tests for
+	// "is set" or "is not set".
+	TestTrue(TEXT("basic operation is writable by enumerator name"),
+		FGameplayHandlers::WriteBTNodeProperty(Decorator, TEXT("BasicOperation"),
+			MakeShared<FJsonValueString>(TEXT("NotSet")), Error));
+#endif
+	TestTrue(TEXT("flow abort mode is writable by enumerator name"),
+		FGameplayHandlers::WriteBTNodeProperty(Decorator, TEXT("FlowAbortMode"),
+			MakeShared<FJsonValueString>(TEXT("LowerPriority")), Error));
+	TestTrue(TEXT("notify observer is writable by enumerator name"),
+		FGameplayHandlers::WriteBTNodeProperty(Decorator, TEXT("NotifyObserver"),
+			MakeShared<FJsonValueString>(TEXT("ResultChange")), Error));
+
+	const TSharedPtr<FJsonObject> Described = FGameplayHandlers::DescribeBTNode(
+		Decorator, TEXT("Root.Children[0].Decorators[0]"), TEXT("Root.Children[0]"),
+		/*bIncludeProperties*/ false, /*bIncludeInherited*/ false, TSet<FString>());
+
+	TestEqual(TEXT("kind"), MCPBTTestGetString(Described, TEXT("kind")), FString(TEXT("decorator")));
+	TestEqual(TEXT("path"), MCPBTTestGetString(Described, TEXT("path")), FString(TEXT("Root.Children[0].Decorators[0]")));
+	TestEqual(TEXT("parentPath"), MCPBTTestGetString(Described, TEXT("parentPath")), FString(TEXT("Root.Children[0]")));
+	TestEqual(TEXT("class"), MCPBTTestGetString(Described, TEXT("class")), FString(TEXT("BTDecorator_Blackboard")));
+	TestTrue(TEXT("inverseCondition is reported"), Described->HasField(TEXT("inverseCondition")));
+	TestEqual(TEXT("flowAbortMode"), MCPBTTestGetString(Described, TEXT("flowAbortMode")), FString(TEXT("LowerPriority")));
+	TestEqual(TEXT("notifyObserver"), MCPBTTestGetString(Described, TEXT("notifyObserver")), FString(TEXT("ResultChange")));
+#if WITH_EDITORONLY_DATA
+	TestEqual(TEXT("basicOperation"), MCPBTTestGetString(Described, TEXT("basicOperation")), FString(TEXT("NotSet")));
+#endif
+
+	const TSharedPtr<FJsonObject>* BlackboardKey = nullptr;
+	TestTrue(TEXT("blackboardKey is reported"), Described->TryGetObjectField(TEXT("blackboardKey"), BlackboardKey));
+	if (BlackboardKey && (*BlackboardKey).IsValid())
+	{
+		TestEqual(TEXT("selectedKeyName"),
+			MCPBTTestGetString(*BlackboardKey, TEXT("selectedKeyName")), FString(TEXT("TargetActor")));
+	}
+
+	// A null node is answered, not dereferenced.
+	const TSharedPtr<FJsonObject> Empty = FGameplayHandlers::DescribeBTNode(
+		nullptr, TEXT("Root"), FString(), false, false, TSet<FString>());
+	TestTrue(TEXT("a null node yields an empty object"), Empty.IsValid() && Empty->Values.Num() == 0);
+	return true;
+}
+
+// #940: on UE 5.8 BTTask_MoveTo::FilterClass is a FValueOrBBKey_Class, so the
+// class lives in DefaultValue and get_editor_property reads the field as empty.
+// #889 is the same struct shape one field over: AcceptableRadius is a
+// FValueOrBBKey_Float, so the number a caller sends has to reach DefaultValue
+// rather than bounce off the struct's export-text importer.
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FMCPBehaviorTreeMoveToFilterClassTest,
+	"UE.MCP.Gameplay.BehaviorTree.MoveToFilterClass",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FMCPBehaviorTreeMoveToFilterClassTest::RunTest(const FString& Parameters)
+{
+	UBTNode* MoveTo = MCPBTTestMakeNode(TEXT("/Script/AIModule.BTTask_MoveTo"));
+	if (!MoveTo)
+	{
+		AddInfo(TEXT("BTTask_MoveTo is not present in this build; skipping."));
+		return true;
+	}
+
+	FString Error;
+
+	// A JSON number aimed at the struct lands on its DefaultValue.
+	TestTrue(TEXT("AcceptableRadius accepts a bare JSON number"),
+		FGameplayHandlers::WriteBTNodeProperty(MoveTo, TEXT("AcceptableRadius"),
+			MakeShared<FJsonValueNumber>(60.0), Error));
+	TestEqual(TEXT("no error writing AcceptableRadius"), Error, FString());
+
+	TSharedPtr<FJsonValue> Radius = FGameplayHandlers::ReadBTNodeProperty(MoveTo, TEXT("AcceptableRadius"), Error);
+	TestTrue(TEXT("AcceptableRadius reads back as an object"), Radius.IsValid() && Radius->Type == EJson::Object);
+	if (Radius.IsValid() && Radius->Type == EJson::Object)
+	{
+		double Stored = 0.0;
+		Radius->AsObject()->TryGetNumberField(TEXT("defaultValue"), Stored);
+		TestEqual(TEXT("AcceptableRadius DefaultValue"), Stored, 60.0);
+	}
+
+	// #919: the filtered property read names what it wants and gets that, with
+	// the FValueOrBBKey_* struct already unpacked.
+	TSet<FString> Filter;
+	Filter.Add(TEXT("acceptableradius"));
+	const TSharedPtr<FJsonObject> Filtered = FGameplayHandlers::DescribeBTNode(
+		MoveTo, TEXT("Root.Children[0]"), TEXT("Root"),
+		/*bIncludeProperties*/ true, /*bIncludeInherited*/ false, Filter);
+	const TSharedPtr<FJsonObject>* Properties = nullptr;
+	TestTrue(TEXT("a filtered read reports properties"), Filtered->TryGetObjectField(TEXT("properties"), Properties));
+	if (Properties && (*Properties).IsValid())
+	{
+		TestEqual(TEXT("only the named property is reported"), (*Properties)->Values.Num(), 1);
+		TestTrue(TEXT("the named property is the one asked for"), (*Properties)->HasField(TEXT("AcceptableRadius")));
+	}
+
+	// FilterClass is the same shape holding a class.
+	UClass* FilterClass = MCPBTTestFindClass(TEXT("/Script/NavigationSystem.RecastFilter_UseDefaultArea"));
+	if (!FilterClass)
+	{
+		AddInfo(TEXT("RecastFilter_UseDefaultArea is not present in this build; skipping the class half."));
+		return true;
+	}
+	const FString FilterClassPath = FilterClass->GetPathName();
+
+	TestTrue(TEXT("FilterClass accepts a class path"),
+		FGameplayHandlers::WriteBTNodeProperty(MoveTo, TEXT("FilterClass"),
+			MakeShared<FJsonValueString>(FilterClassPath), Error));
+	TestEqual(TEXT("no error writing FilterClass"), Error, FString());
+
+	TSharedPtr<FJsonValue> FilterValue = FGameplayHandlers::ReadBTNodeProperty(MoveTo, TEXT("FilterClass"), Error);
+	TestTrue(TEXT("FilterClass reads back as an object"), FilterValue.IsValid() && FilterValue->Type == EJson::Object);
+	if (FilterValue.IsValid() && FilterValue->Type == EJson::Object)
+	{
+		TestEqual(TEXT("FilterClass DefaultValue is the class that was written"),
+			MCPBTTestGetString(FilterValue->AsObject(), TEXT("defaultValue")), FilterClassPath);
+		bool bBound = true;
+		FilterValue->AsObject()->TryGetBoolField(TEXT("isBound"), bBound);
+		TestFalse(TEXT("a literal class is not a blackboard binding"), bBound);
+	}
+
+	// An object value writes the struct's own fields, which is how the field
+	// is bound to a blackboard key instead of pinned to a literal.
+	TSharedPtr<FJsonObject> Binding = MakeShared<FJsonObject>();
+	Binding->SetStringField(TEXT("Key"), TEXT("NavFilter"));
+	TestTrue(TEXT("FilterClass accepts a blackboard key binding"),
+		FGameplayHandlers::WriteBTNodeProperty(MoveTo, TEXT("FilterClass"),
+			MakeShared<FJsonValueObject>(Binding), Error));
+
+	FilterValue = FGameplayHandlers::ReadBTNodeProperty(MoveTo, TEXT("FilterClass"), Error);
+	if (FilterValue.IsValid() && FilterValue->Type == EJson::Object)
+	{
+		TestEqual(TEXT("bound key name"),
+			MCPBTTestGetString(FilterValue->AsObject(), TEXT("key")), FString(TEXT("NavFilter")));
+		bool bBound = false;
+		FilterValue->AsObject()->TryGetBoolField(TEXT("isBound"), bBound);
+		TestTrue(TEXT("a key name reads as bound"), bBound);
+	}
+
+	// Null clears the class without touching the binding.
+	TestTrue(TEXT("FilterClass accepts null to clear the class"),
+		FGameplayHandlers::WriteBTNodeProperty(MoveTo, TEXT("FilterClass"),
+			MakeShared<FJsonValueNull>(), Error));
+	FilterValue = FGameplayHandlers::ReadBTNodeProperty(MoveTo, TEXT("FilterClass"), Error);
+	if (FilterValue.IsValid() && FilterValue->Type == EJson::Object)
+	{
+		TestEqual(TEXT("cleared DefaultValue"),
+			MCPBTTestGetString(FilterValue->AsObject(), TEXT("defaultValueName")), FString());
+	}
+
+	// A property the node does not declare is a structured error, never a
+	// silent no-op and never a dereference.
+	TestFalse(TEXT("an unknown property is rejected"),
+		FGameplayHandlers::WriteBTNodeProperty(MoveTo, TEXT("NotAProperty"),
+			MakeShared<FJsonValueNumber>(1.0), Error));
+	TestTrue(TEXT("the rejection names the property"), Error.Contains(TEXT("NotAProperty")));
+
+	// A null node is answered, not dereferenced.
+	TestFalse(TEXT("a null node is rejected"),
+		FGameplayHandlers::WriteBTNodeProperty(nullptr, TEXT("AcceptableRadius"),
+			MakeShared<FJsonValueNumber>(1.0), Error));
+	return true;
+}
+
+// The BT actions have to be reachable by the names the TypeScript schema
+// advertises, and each has to answer a call with no parameters with a
+// structured error rather than a crash.
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FMCPBehaviorTreeRegistrationTest,
+	"UE.MCP.Gameplay.BehaviorTree.RegistrationAndPreflight",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FMCPBehaviorTreeRegistrationTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FGameplayHandlers::RegisterHandlers(Registry);
+
+	const TCHAR* Methods[] = {
+		TEXT("get_behavior_tree_info"),
+		TEXT("read_behavior_tree_graph"),
+		TEXT("read_bt_node_properties"),
+		TEXT("list_bt_tasks"),
+		TEXT("set_bt_node_property"),
+		TEXT("set_bt_task_property"),
+	};
+	for (const TCHAR* Method : Methods)
+	{
+		TestTrue(FString::Printf(TEXT("%s is registered"), Method), Registry.HasHandler(Method));
+	}
+
+	// Every action that needs an asset path says so, and list_bt_tasks answers
+	// without one because a directory sweep is its whole point.
+	const TCHAR* NeedAssetPath[] = {
+		TEXT("get_behavior_tree_info"),
+		TEXT("read_behavior_tree_graph"),
+		TEXT("read_bt_node_properties"),
+		TEXT("set_bt_node_property"),
+		TEXT("set_bt_task_property"),
+	};
+	for (const TCHAR* Method : NeedAssetPath)
+	{
+		const TSharedPtr<FJsonValue> Response = Registry.ExecuteHandler(Method, MakeShared<FJsonObject>());
+		TestTrue(FString::Printf(TEXT("%s returns an object"), Method),
+			Response.IsValid() && Response->Type == EJson::Object);
+		if (!Response.IsValid() || Response->Type != EJson::Object) continue;
+
+		const TSharedPtr<FJsonObject> Object = Response->AsObject();
+		TestFalse(FString::Printf(TEXT("%s rejects an empty call"), Method), Object->GetBoolField(TEXT("success")));
+		TestTrue(FString::Printf(TEXT("%s names assetPath"), Method),
+			Object->GetStringField(TEXT("error")).Contains(TEXT("assetPath")));
+	}
+	return true;
+}
+
+#endif