ue-mcp 1.2.4 → 1.3.0

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

@@ -0,0 +1,362 @@
+// Engine-side coverage for the Blueprint category surface 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. Nothing below creates, compiles, saves or deletes an
+// asset: every case is registration, argument validation, or a question asked
+// of the engine's own reflection data. The behaviour that needs real assets is
+// covered by the smoke suite against the dedicated test project instead.
+
+#if WITH_DEV_AUTOMATION_TESTS
+
+#include "HandlerRegistry.h"
+#include "Handlers/BlueprintHandlers.h"
+#include "Misc/AutomationTest.h"
+#include "Dom/JsonObject.h"
+#include "Dom/JsonValue.h"
+#include "EdGraphSchema_K2.h"
+#include "BehaviorTree/Tasks/BTTask_BlueprintBase.h"
+#include "UObject/UnrealType.h"
+
+namespace
+{
+	TSharedPtr<FJsonObject> BlueprintTestResponseObject(const TSharedPtr<FJsonValue>& Response)
+	{
+		return (Response.IsValid() && Response->Type == EJson::Object) ? Response->AsObject() : nullptr;
+	}
+}
+
+// ---------------------------------------------------------------------------
+// #942: a World/umap path now resolves to that map's level script Blueprint.
+// The half of that contract which needs no assets is the other half: a path
+// that is neither a Blueprint nor a World must still report the plain
+// "Blueprint not found" message, so the level-script hint cannot leak into an
+// ordinary typo and send a caller looking for a map that was never named.
+// ---------------------------------------------------------------------------
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FBlueprintNotFoundReportingTest,
+	"UE.MCP.Blueprint.Surface.NotFoundReporting",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FBlueprintNotFoundReportingTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FBlueprintHandlers::RegisterHandlers(Registry);
+
+	// Every action named in #942 shares one lookup, so they share one message.
+	const TCHAR* SharedLookupActions[] = {
+		TEXT("read_blueprint"),
+		TEXT("list_blueprint_graphs"),
+		TEXT("read_blueprint_graph"),
+		TEXT("get_blueprint_execution_flow"),
+	};
+
+	for (const TCHAR* Action : SharedLookupActions)
+	{
+		TestTrue(*FString::Printf(TEXT("%s is registered"), Action), Registry.HasHandler(Action));
+
+		TSharedPtr<FJsonObject> BadPath = MakeShared<FJsonObject>();
+		BadPath->SetStringField(TEXT("assetPath"), TEXT("/Game/UEMCPTests/BP_ThisAssetDoesNotExist"));
+		BadPath->SetStringField(TEXT("graphName"), TEXT("EventGraph"));
+
+		const TSharedPtr<FJsonObject> Response = BlueprintTestResponseObject(
+			Registry.ExecuteHandler(Action, BadPath));
+		if (!TestTrue(*FString::Printf(TEXT("%s returns an object"), Action), Response.IsValid()))
+		{
+			continue;
+		}
+		TestFalse(*FString::Printf(TEXT("%s rejects an unknown path"), Action),
+			Response->GetBoolField(TEXT("success")));
+		TestTrue(*FString::Printf(TEXT("%s reports a missing Blueprint, not a missing level script"), Action),
+			Response->GetStringField(TEXT("error")).Contains(TEXT("Blueprint not found")));
+	}
+
+	// The lookup is also what rejects a request with no path at all, and that
+	// has to stay a parameter error rather than becoming the World hint.
+	{
+		const TSharedPtr<FJsonObject> Response = BlueprintTestResponseObject(
+			Registry.ExecuteHandler(TEXT("list_blueprint_graphs"), MakeShared<FJsonObject>()));
+		if (TestTrue(TEXT("missing path returns an object"), Response.IsValid()))
+		{
+			TestFalse(TEXT("missing path is unsuccessful"), Response->GetBoolField(TEXT("success")));
+			TestFalse(TEXT("missing path is not reported as a level script miss"),
+				Response->GetStringField(TEXT("error")).Contains(TEXT("PersistentLevel")));
+		}
+	}
+
+	return true;
+}
+
+// ---------------------------------------------------------------------------
+// #902: get_variable_default has to be reachable by name and has to reject a
+// malformed request rather than throw. A handler that fails to register reports
+// "Unknown method" at runtime with a clean build behind it, which is the
+// failure mode this asserts away. The value path itself needs a real compiled
+// Blueprint and is covered by the smoke suite.
+// ---------------------------------------------------------------------------
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FBlueprintVariableDefaultRegistrationTest,
+	"UE.MCP.Blueprint.VariableDefault.RegistrationAndValidation",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FBlueprintVariableDefaultRegistrationTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FBlueprintHandlers::RegisterHandlers(Registry);
+
+	TestTrue(TEXT("get_blueprint_variable_default is registered"),
+		Registry.HasHandler(TEXT("get_blueprint_variable_default")));
+
+	// assetPath is required.
+	{
+		TSharedPtr<FJsonObject> MissingPath = MakeShared<FJsonObject>();
+		MissingPath->SetStringField(TEXT("name"), TEXT("Health"));
+		const TSharedPtr<FJsonObject> Response = BlueprintTestResponseObject(
+			Registry.ExecuteHandler(TEXT("get_blueprint_variable_default"), MissingPath));
+		if (TestTrue(TEXT("missing assetPath returns an object"), Response.IsValid()))
+		{
+			TestFalse(TEXT("missing assetPath is unsuccessful"), Response->GetBoolField(TEXT("success")));
+		}
+	}
+
+	// name is required, and is checked before the asset is touched so a caller
+	// that forgot it is told which field it forgot.
+	{
+		TSharedPtr<FJsonObject> MissingName = MakeShared<FJsonObject>();
+		MissingName->SetStringField(TEXT("assetPath"), TEXT("/Game/UEMCPTests/BP_ThisAssetDoesNotExist"));
+		const TSharedPtr<FJsonObject> Response = BlueprintTestResponseObject(
+			Registry.ExecuteHandler(TEXT("get_blueprint_variable_default"), MissingName));
+		if (TestTrue(TEXT("missing name returns an object"), Response.IsValid()))
+		{
+			TestFalse(TEXT("missing name is unsuccessful"), Response->GetBoolField(TEXT("success")));
+			TestTrue(TEXT("missing name identifies the field"),
+				Response->GetStringField(TEXT("error")).Contains(TEXT("name")));
+		}
+	}
+
+	// An unknown asset reports the shared Blueprint lookup failure, not a
+	// property failure: the two are different problems with different fixes.
+	{
+		TSharedPtr<FJsonObject> UnknownAsset = MakeShared<FJsonObject>();
+		UnknownAsset->SetStringField(TEXT("assetPath"), TEXT("/Game/UEMCPTests/BP_ThisAssetDoesNotExist"));
+		UnknownAsset->SetStringField(TEXT("name"), TEXT("Health"));
+		const TSharedPtr<FJsonObject> Response = BlueprintTestResponseObject(
+			Registry.ExecuteHandler(TEXT("get_blueprint_variable_default"), UnknownAsset));
+		if (TestTrue(TEXT("unknown asset returns an object"), Response.IsValid()))
+		{
+			TestFalse(TEXT("unknown asset is unsuccessful"), Response->GetBoolField(TEXT("success")));
+			TestTrue(TEXT("unknown asset reports a missing Blueprint"),
+				Response->GetStringField(TEXT("error")).Contains(TEXT("Blueprint not found")));
+		}
+	}
+
+	// list_variables keeps its default payload: includeValues is opt-in, so a
+	// request without it must not start resolving CDO values.
+	{
+		TSharedPtr<FJsonObject> MissingPath = MakeShared<FJsonObject>();
+		const TSharedPtr<FJsonObject> Response = BlueprintTestResponseObject(
+			Registry.ExecuteHandler(TEXT("list_blueprint_variables"), MissingPath));
+		if (TestTrue(TEXT("list_variables with no path returns an object"), Response.IsValid()))
+		{
+			TestFalse(TEXT("list_variables with no path is unsuccessful"),
+				Response->GetBoolField(TEXT("success")));
+		}
+	}
+
+	return true;
+}
+
+// ---------------------------------------------------------------------------
+// #886: authoring a BTTask Blueprint's event graph needs ReceiveExecuteAI and
+// ReceiveAbortAI as override events and FinishExecute / FinishAbort as call
+// nodes. The existing override_function and add_node surface already places
+// all four; what makes that true is the shape those two actions test for on
+// the engine side, so that shape is what is asserted here. If Epic ever
+// changes one of these functions, the recipe the skill documents becomes wrong
+// here first, in a test, rather than in somebody's build.
+// ---------------------------------------------------------------------------
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FBlueprintBTTaskEventShapeTest,
+	"UE.MCP.Blueprint.BTTask.EventShape",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FBlueprintBTTaskEventShapeTest::RunTest(const FString& Parameters)
+{
+	UClass* TaskBase = UBTTask_BlueprintBase::StaticClass();
+	if (!TestNotNull(TEXT("UBTTask_BlueprintBase resolves"), TaskBase))
+	{
+		return false;
+	}
+
+	// override_function accepts a name only when GetOverrideFunctionClass can
+	// resolve it, which needs CanKismetOverrideFunction; it places an override
+	// EVENT rather than a function graph only when FunctionCanBePlacedAsEvent
+	// agrees. Both have to hold for the documented call sequence to work.
+	const TCHAR* OverrideEvents[] = {
+		TEXT("ReceiveExecuteAI"), TEXT("ReceiveAbortAI"), TEXT("ReceiveTickAI"),
+		TEXT("ReceiveExecute"), TEXT("ReceiveAbort"), TEXT("ReceiveTick"),
+	};
+	for (const TCHAR* EventName : OverrideEvents)
+	{
+		UFunction* Function = TaskBase->FindFunctionByName(FName(EventName));
+		if (!TestNotNull(*FString::Printf(TEXT("%s exists on UBTTask_BlueprintBase"), EventName), Function))
+		{
+			continue;
+		}
+		TestTrue(*FString::Printf(TEXT("%s is overridable from Kismet"), EventName),
+			UEdGraphSchema_K2::CanKismetOverrideFunction(Function));
+		TestTrue(*FString::Printf(TEXT("%s can be placed as an override event"), EventName),
+			UEdGraphSchema_K2::FunctionCanBePlacedAsEvent(Function));
+	}
+
+	// add_node(nodeClass="CallFunction") binds a K2Node_CallFunction to a
+	// UFUNCTION resolved by name on the named class, and only a
+	// BlueprintCallable function yields a usable node.
+	const TCHAR* CallableFinishers[] = { TEXT("FinishExecute"), TEXT("FinishAbort") };
+	for (const TCHAR* CallName : CallableFinishers)
+	{
+		UFunction* Function = TaskBase->FindFunctionByName(FName(CallName));
+		if (!TestNotNull(*FString::Printf(TEXT("%s exists on UBTTask_BlueprintBase"), CallName), Function))
+		{
+			continue;
+		}
+		TestTrue(*FString::Printf(TEXT("%s is BlueprintCallable"), CallName),
+			Function->HasAnyFunctionFlags(FUNC_BlueprintCallable));
+	}
+
+	// The skill documents setting bSuccess as a pin default on FinishExecute,
+	// which only holds while the parameter is there and is a bool.
+	if (UFunction* FinishExecute = TaskBase->FindFunctionByName(TEXT("FinishExecute")))
+	{
+		FProperty* SuccessParam = FinishExecute->FindPropertyByName(TEXT("bSuccess"));
+		if (TestNotNull(TEXT("FinishExecute exposes bSuccess"), SuccessParam))
+		{
+			TestTrue(TEXT("FinishExecute's bSuccess is a bool"), SuccessParam->IsA<FBoolProperty>());
+		}
+	}
+
+	return true;
+}
+
+// ---------------------------------------------------------------------------
+// #945: search_call_sites runs against an unknown-sized project, so its
+// argument validation is what stops a malformed request turning into a
+// full-project package load. Everything asserted here rejects before a single
+// asset is touched. The matching itself needs real Blueprints and belongs to
+// the smoke suite.
+// ---------------------------------------------------------------------------
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FBlueprintSearchCallSitesValidationTest,
+	"UE.MCP.Blueprint.SearchCallSites.RegistrationAndValidation",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FBlueprintSearchCallSitesValidationTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FBlueprintHandlers::RegisterHandlers(Registry);
+
+	TestTrue(TEXT("search_blueprint_call_sites is registered"),
+		Registry.HasHandler(TEXT("search_blueprint_call_sites")));
+	// A sweep that pays for package loads cannot finish inside the default
+	// request timeout, so it has to carry its own.
+	TestTrue(TEXT("search_blueprint_call_sites carries its own timeout"),
+		Registry.GetHandlerTimeout(TEXT("search_blueprint_call_sites")) > 0.0f);
+
+	// functionNames is required. Without it there is nothing to search for, and
+	// defaulting to "everything" would load the whole project.
+	{
+		const TSharedPtr<FJsonObject> Response = BlueprintTestResponseObject(
+			Registry.ExecuteHandler(TEXT("search_blueprint_call_sites"), MakeShared<FJsonObject>()));
+		if (TestTrue(TEXT("missing functionNames returns an object"), Response.IsValid()))
+		{
+			TestFalse(TEXT("missing functionNames is unsuccessful"), Response->GetBoolField(TEXT("success")));
+			TestTrue(TEXT("missing functionNames identifies the field"),
+				Response->GetStringField(TEXT("error")).Contains(TEXT("functionNames")));
+		}
+	}
+
+	// An empty array, and an array of nothing but blanks, are the same mistake.
+	{
+		TSharedPtr<FJsonObject> EmptyNames = MakeShared<FJsonObject>();
+		EmptyNames->SetArrayField(TEXT("functionNames"), TArray<TSharedPtr<FJsonValue>>());
+		const TSharedPtr<FJsonObject> Response = BlueprintTestResponseObject(
+			Registry.ExecuteHandler(TEXT("search_blueprint_call_sites"), EmptyNames));
+		if (TestTrue(TEXT("empty functionNames returns an object"), Response.IsValid()))
+		{
+			TestFalse(TEXT("empty functionNames is unsuccessful"), Response->GetBoolField(TEXT("success")));
+		}
+	}
+	{
+		TSharedPtr<FJsonObject> BlankNames = MakeShared<FJsonObject>();
+		TArray<TSharedPtr<FJsonValue>> Blanks;
+		Blanks.Add(MakeShared<FJsonValueString>(TEXT("   ")));
+		BlankNames->SetArrayField(TEXT("functionNames"), Blanks);
+		const TSharedPtr<FJsonObject> Response = BlueprintTestResponseObject(
+			Registry.ExecuteHandler(TEXT("search_blueprint_call_sites"), BlankNames));
+		if (TestTrue(TEXT("whitespace-only functionNames returns an object"), Response.IsValid()))
+		{
+			TestFalse(TEXT("whitespace-only functionNames is unsuccessful"),
+				Response->GetBoolField(TEXT("success")));
+		}
+	}
+
+	// The batch cap: over it, the caller is told to split rather than being
+	// handed a sweep that will not finish.
+	{
+		TSharedPtr<FJsonObject> TooMany = MakeShared<FJsonObject>();
+		TArray<TSharedPtr<FJsonValue>> Names;
+		for (int32 Index = 0; Index < 51; ++Index)
+		{
+			Names.Add(MakeShared<FJsonValueString>(FString::Printf(TEXT("Function_%d"), Index)));
+		}
+		TooMany->SetArrayField(TEXT("functionNames"), Names);
+		const TSharedPtr<FJsonObject> Response = BlueprintTestResponseObject(
+			Registry.ExecuteHandler(TEXT("search_blueprint_call_sites"), TooMany));
+		if (TestTrue(TEXT("oversized functionNames returns an object"), Response.IsValid()))
+		{
+			TestFalse(TEXT("oversized functionNames is unsuccessful"), Response->GetBoolField(TEXT("success")));
+			TestTrue(TEXT("oversized functionNames reports the bound"),
+				Response->GetStringField(TEXT("error")).Contains(TEXT("50")));
+		}
+	}
+
+	// An unresolvable className is a typo, and matching nothing would read as
+	// "no call sites" - the wrong answer to an audit.
+	{
+		TSharedPtr<FJsonObject> BadClass = MakeShared<FJsonObject>();
+		TArray<TSharedPtr<FJsonValue>> Names;
+		Names.Add(MakeShared<FJsonValueString>(TEXT("FinishExecute")));
+		BadClass->SetArrayField(TEXT("functionNames"), Names);
+		BadClass->SetStringField(TEXT("className"), TEXT("ThisClassDoesNotExistAnywhere_UEMCP"));
+		const TSharedPtr<FJsonObject> Response = BlueprintTestResponseObject(
+			Registry.ExecuteHandler(TEXT("search_blueprint_call_sites"), BadClass));
+		if (TestTrue(TEXT("unknown className returns an object"), Response.IsValid()))
+		{
+			TestFalse(TEXT("unknown className is unsuccessful"), Response->GetBoolField(TEXT("success")));
+			TestEqual(TEXT("unknown className is reported as a class miss"),
+				Response->GetStringField(TEXT("reason")), FString(TEXT("class_not_found")));
+		}
+	}
+
+	// A directory that is not mount-rooted would silently match nothing.
+	{
+		TSharedPtr<FJsonObject> BadDirectory = MakeShared<FJsonObject>();
+		TArray<TSharedPtr<FJsonValue>> Names;
+		Names.Add(MakeShared<FJsonValueString>(TEXT("FinishExecute")));
+		BadDirectory->SetArrayField(TEXT("functionNames"), Names);
+		BadDirectory->SetStringField(TEXT("directory"), TEXT("Content/AI"));
+		const TSharedPtr<FJsonObject> Response = BlueprintTestResponseObject(
+			Registry.ExecuteHandler(TEXT("search_blueprint_call_sites"), BadDirectory));
+		if (TestTrue(TEXT("relative directory returns an object"), Response.IsValid()))
+		{
+			TestFalse(TEXT("relative directory is unsuccessful"), Response->GetBoolField(TEXT("success")));
+			TestTrue(TEXT("relative directory says what a directory looks like"),
+				Response->GetStringField(TEXT("error")).Contains(TEXT("/Game")));
+		}
+	}
+
+	return true;
+}
+
+#endif // WITH_DEV_AUTOMATION_TESTS

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

@@ -628,6 +628,20 @@ bool FMCPBridgeCapabilitiesTest::RunTest(const FString& Parameters)
 	double ActionCount = 0.0;
 	TestTrue(TEXT("the registered action count is reported"), Payload->TryGetNumberField(TEXT("actionCount"), ActionCount));
 	TestTrue(TEXT("the binary registered some actions"), ActionCount > 0);
+	const TArray<TSharedPtr<FJsonValue>>* Actions = nullptr;
+	TestTrue(TEXT("the registered actions are reported"), Payload->TryGetArrayField(TEXT("actions"), Actions));
+	if (Actions)
+	{
+		TSet<FString> ActionNames;
+		for (const TSharedPtr<FJsonValue>& Value : *Actions)
+		{
+			ActionNames.Add(Value->AsString());
+		}
+		TestTrue(TEXT("runtime visibility set is advertised"),
+			ActionNames.Contains(TEXT("set_runtime_visibility")));
+		TestTrue(TEXT("runtime visibility restore is advertised"),
+			ActionNames.Contains(TEXT("restore_runtime_visibility")));
+	}
 
 	// Advertised whether or not it is recording, so a caller can tell a bridge
 	// that cannot from a bridge that is switched off.

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

@@ -0,0 +1,288 @@
+// Coverage for #925.
+//
+// blueprint(read_component_properties) exports BodyInstance as text, and that
+// text carries CollisionProfileName plus the ResponseArray of overrides that
+// DIFFER from the profile. A response inherited from the profile is not in it,
+// so "does this capsule block ECC_Camera" was unanswerable from the dump, and
+// editor(get_object_properties) has the same limit.
+//
+// These assertions run against ACharacter's own capsule, which every engine
+// ships with the Pawn profile, so they check the exact thing the issue asked
+// for: an EFFECTIVE response that the component itself never overrides and that
+// therefore only exists in the profile. Nothing is created, loaded from the
+// attached project, or written.
+
+#if WITH_DEV_AUTOMATION_TESTS
+
+#include "HandlerRegistry.h"
+#include "HandlerUtils.h"
+#include "Handlers/BlueprintHandlers_Collision.h"
+
+#include "Components/CapsuleComponent.h"
+#include "Dom/JsonObject.h"
+#include "Dom/JsonValue.h"
+#include "Engine/CollisionProfile.h"
+#include "GameFramework/Character.h"
+#include "Misc/AutomationTest.h"
+
+namespace
+{
+	TSharedPtr<FJsonObject> CollisionResponseObject(const TSharedPtr<FJsonValue>& Response)
+	{
+		return (Response.IsValid() && Response->Type == EJson::Object)
+			? Response->AsObject()
+			: TSharedPtr<FJsonObject>();
+	}
+
+	bool CollisionResponseBool(const TSharedPtr<FJsonValue>& Response, const TCHAR* Field, bool bDefault = false)
+	{
+		const TSharedPtr<FJsonObject> Obj = CollisionResponseObject(Response);
+		if (!Obj.IsValid()) return bDefault;
+		bool bValue = bDefault;
+		Obj->TryGetBoolField(Field, bValue);
+		return bValue;
+	}
+
+	FString CollisionResponseString(const TSharedPtr<FJsonValue>& Response, const TCHAR* Field)
+	{
+		const TSharedPtr<FJsonObject> Obj = CollisionResponseObject(Response);
+		if (!Obj.IsValid()) return FString();
+		FString Value;
+		Obj->TryGetStringField(Field, Value);
+		return Value;
+	}
+
+	/** Pull one channel's entry out of a `responses` array by its enumName,
+	 *  which is the identifier that does not move when a project renames a
+	 *  channel. Returns an unset pointer when the channel is not listed. */
+	TSharedPtr<FJsonObject> FindChannelEntry(const TSharedPtr<FJsonValue>& Response, const TCHAR* EnumName)
+	{
+		const TSharedPtr<FJsonObject> Obj = CollisionResponseObject(Response);
+		if (!Obj.IsValid()) return TSharedPtr<FJsonObject>();
+
+		const TArray<TSharedPtr<FJsonValue>>* Entries = nullptr;
+		if (!Obj->TryGetArrayField(TEXT("responses"), Entries) || !Entries)
+		{
+			return TSharedPtr<FJsonObject>();
+		}
+		for (const TSharedPtr<FJsonValue>& Entry : *Entries)
+		{
+			if (!Entry.IsValid() || Entry->Type != EJson::Object) continue;
+			const TSharedPtr<FJsonObject> EntryObj = Entry->AsObject();
+			FString Name;
+			if (EntryObj->TryGetStringField(TEXT("enumName"), Name) && Name == EnumName)
+			{
+				return EntryObj;
+			}
+		}
+		return TSharedPtr<FJsonObject>();
+	}
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FMCPResolveCollisionProfileTest,
+	"UE.MCP.Project.ResolveCollisionProfile.ReportsPerChannelResponses",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FMCPResolveCollisionProfileTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FCollisionQueryHandlers::RegisterHandlers(Registry);
+	if (!TestTrue(TEXT("resolve_collision_profile is registered"),
+		Registry.HasHandler(TEXT("resolve_collision_profile")))) return false;
+
+	{
+		TSharedPtr<FJsonObject> Params = MakeShared<FJsonObject>();
+		Params->SetStringField(TEXT("profileName"), TEXT("Pawn"));
+
+		const TSharedPtr<FJsonValue> Response = Registry.ExecuteHandler(TEXT("resolve_collision_profile"), Params);
+		TestTrue(FString::Printf(TEXT("the Pawn profile resolves (%s)"),
+			*CollisionResponseString(Response, TEXT("error"))),
+			CollisionResponseBool(Response, TEXT("success")));
+		TestEqual(TEXT("the profile answers under its own name"),
+			CollisionResponseString(Response, TEXT("profileName")), FString(TEXT("Pawn")));
+		TestFalse(TEXT("the profile names its collision mode"),
+			CollisionResponseString(Response, TEXT("collisionEnabled")).IsEmpty());
+
+		// The eight engine channels are always reported, which is the set a
+		// caller asking about Camera or Visibility means.
+		const TSharedPtr<FJsonObject> Camera = FindChannelEntry(Response, TEXT("ECC_Camera"));
+		if (TestTrue(TEXT("the Camera channel is listed"), Camera.IsValid()))
+		{
+			FString CameraResponse;
+			Camera->TryGetStringField(TEXT("response"), CameraResponse);
+			TestTrue(TEXT("the Camera response is one of the three collision responses"),
+				CameraResponse == TEXT("Block") || CameraResponse == TEXT("Overlap") || CameraResponse == TEXT("Ignore"));
+
+			double ChannelIndex = -1.0;
+			Camera->TryGetNumberField(TEXT("channelIndex"), ChannelIndex);
+			TestEqual(TEXT("the Camera channel reports its container index"), ChannelIndex, 4.0);
+		}
+	}
+
+	// One channel asked for, one channel back.
+	{
+		TSharedPtr<FJsonObject> Params = MakeShared<FJsonObject>();
+		Params->SetStringField(TEXT("profileName"), TEXT("Pawn"));
+		Params->SetStringField(TEXT("channel"), TEXT("ECC_Camera"));
+
+		const TSharedPtr<FJsonValue> Response = Registry.ExecuteHandler(TEXT("resolve_collision_profile"), Params);
+		TestTrue(TEXT("a single-channel query succeeds"), CollisionResponseBool(Response, TEXT("success")));
+
+		const TSharedPtr<FJsonObject> Obj = CollisionResponseObject(Response);
+		if (TestTrue(TEXT("the single-channel query answered"), Obj.IsValid()))
+		{
+			double Count = -1.0;
+			Obj->TryGetNumberField(TEXT("responseCount"), Count);
+			TestEqual(TEXT("exactly one channel comes back"), Count, 1.0);
+			TestTrue(TEXT("the one channel is lifted to the top level"), Obj->HasField(TEXT("channel")));
+		}
+	}
+
+	// A miss names what does exist rather than answering with nothing.
+	{
+		TSharedPtr<FJsonObject> Params = MakeShared<FJsonObject>();
+		Params->SetStringField(TEXT("profileName"), TEXT("NoSuchProfileNameAnywhere"));
+
+		const TSharedPtr<FJsonValue> Response = Registry.ExecuteHandler(TEXT("resolve_collision_profile"), Params);
+		TestFalse(TEXT("an unknown profile is not a success"),
+			CollisionResponseBool(Response, TEXT("success"), true));
+		TestEqual(TEXT("an unknown profile says why"),
+			CollisionResponseString(Response, TEXT("reason")), FString(TEXT("profile_not_found")));
+
+		const TSharedPtr<FJsonObject> Obj = CollisionResponseObject(Response);
+		if (Obj.IsValid())
+		{
+			const TArray<TSharedPtr<FJsonValue>>* Known = nullptr;
+			if (TestTrue(TEXT("an unknown profile lists the known ones"),
+				Obj->TryGetArrayField(TEXT("knownProfiles"), Known) && Known != nullptr))
+			{
+				TestTrue(TEXT("the project defines at least one profile"), Known->Num() > 0);
+			}
+		}
+	}
+
+	return true;
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FMCPGetComponentCollisionTest,
+	"UE.MCP.Blueprint.GetComponentCollision.ReportsTheEffectiveResponse",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FMCPGetComponentCollisionTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FCollisionQueryHandlers::RegisterHandlers(Registry);
+	if (!TestTrue(TEXT("get_component_collision is registered"),
+		Registry.HasHandler(TEXT("get_component_collision")))) return false;
+
+	const FString CapsuleName = ACharacter::CapsuleComponentName.ToString();
+
+	// The native-class route. This is the shape #925 was reported from:
+	// checking whether a C++ constructor's collision call reached the CDO.
+	{
+		TSharedPtr<FJsonObject> Params = MakeShared<FJsonObject>();
+		Params->SetStringField(TEXT("assetPath"), TEXT("/Script/Engine.Character"));
+		Params->SetStringField(TEXT("componentName"), CapsuleName);
+
+		const TSharedPtr<FJsonValue> Response = Registry.ExecuteHandler(TEXT("get_component_collision"), Params);
+		if (!TestTrue(FString::Printf(TEXT("the Character CDO capsule resolves (%s)"),
+			*CollisionResponseString(Response, TEXT("error"))),
+			CollisionResponseBool(Response, TEXT("success")))) return false;
+
+		TestEqual(TEXT("the answer says it came from a class rather than a Blueprint"),
+			CollisionResponseString(Response, TEXT("source")), FString(TEXT("class")));
+		TestEqual(TEXT("the capsule's profile is Pawn"),
+			CollisionResponseString(Response, TEXT("profileName")), FString(TEXT("Pawn")));
+		TestTrue(TEXT("the profile resolved to a real profile"),
+			CollisionResponseBool(Response, TEXT("profileResolved")));
+		TestFalse(TEXT("the answer names the collision mode"),
+			CollisionResponseString(Response, TEXT("collisionEnabled")).IsEmpty());
+
+		// The assertion the issue exists for. ACharacter's capsule never
+		// overrides Camera, so the only place its answer can come from is the
+		// Pawn profile, and the text dump the old actions produce does not
+		// contain it at all.
+		const TSharedPtr<FJsonObject> Camera = FindChannelEntry(Response, TEXT("ECC_Camera"));
+		if (TestTrue(TEXT("the Camera channel is reported"), Camera.IsValid()))
+		{
+			FString Effective;
+			Camera->TryGetStringField(TEXT("response"), Effective);
+			FString FromProfile;
+			Camera->TryGetStringField(TEXT("profileResponse"), FromProfile);
+
+			TestFalse(TEXT("the effective Camera response is reported"), Effective.IsEmpty());
+			TestEqual(TEXT("an inherited response equals the profile's own"), Effective, FromProfile);
+
+			bool bOverrides = true;
+			Camera->TryGetBoolField(TEXT("overridesProfile"), bOverrides);
+			TestFalse(TEXT("an inherited response is not reported as an override"), bOverrides);
+
+			// And it agrees with the engine's own evaluator, which is the
+			// definition of "effective".
+			if (UClass* CharacterClass = ACharacter::StaticClass())
+			{
+				if (ACharacter* CDO = Cast<ACharacter>(CharacterClass->GetDefaultObject()))
+				{
+					if (UCapsuleComponent* Capsule = CDO->GetCapsuleComponent())
+					{
+						const ECollisionResponse Engine = Capsule->GetCollisionResponseToChannel(ECC_Camera);
+						const FString EngineName =
+							Engine == ECR_Block ? TEXT("Block") :
+							Engine == ECR_Overlap ? TEXT("Overlap") :
+							Engine == ECR_Ignore ? TEXT("Ignore") : TEXT("Unknown");
+						TestEqual(TEXT("the reported response is what the engine evaluator returns"),
+							Effective, EngineName);
+					}
+				}
+			}
+		}
+	}
+
+	// A channel name the project does not have is an error naming the ones it
+	// does, not an empty response.
+	{
+		TSharedPtr<FJsonObject> Params = MakeShared<FJsonObject>();
+		Params->SetStringField(TEXT("assetPath"), TEXT("/Script/Engine.Character"));
+		Params->SetStringField(TEXT("componentName"), CapsuleName);
+		Params->SetStringField(TEXT("channel"), TEXT("NoSuchChannelName"));
+
+		const TSharedPtr<FJsonValue> Response = Registry.ExecuteHandler(TEXT("get_component_collision"), Params);
+		TestFalse(TEXT("an unknown channel is not a success"),
+			CollisionResponseBool(Response, TEXT("success"), true));
+		TestTrue(TEXT("an unknown channel lists the known ones"),
+			CollisionResponseString(Response, TEXT("error")).Contains(TEXT("Camera")));
+	}
+
+	// A component with no BodyInstance says so rather than answering with an
+	// empty channel list.
+	{
+		TSharedPtr<FJsonObject> Params = MakeShared<FJsonObject>();
+		Params->SetStringField(TEXT("assetPath"), TEXT("/Script/Engine.Character"));
+		Params->SetStringField(TEXT("componentName"), ACharacter::CharacterMovementComponentName.ToString());
+
+		const TSharedPtr<FJsonValue> Response = Registry.ExecuteHandler(TEXT("get_component_collision"), Params);
+		TestFalse(TEXT("a non-primitive component is not a success"),
+			CollisionResponseBool(Response, TEXT("success"), true));
+		TestTrue(TEXT("a non-primitive component says it carries no collision"),
+			CollisionResponseString(Response, TEXT("error")).Contains(TEXT("carries no collision")));
+	}
+
+	// A component name that does not exist lists what does.
+	{
+		TSharedPtr<FJsonObject> Params = MakeShared<FJsonObject>();
+		Params->SetStringField(TEXT("assetPath"), TEXT("/Script/Engine.Character"));
+		Params->SetStringField(TEXT("componentName"), TEXT("NoSuchComponent"));
+
+		const TSharedPtr<FJsonValue> Response = Registry.ExecuteHandler(TEXT("get_component_collision"), Params);
+		TestFalse(TEXT("a missing component is not a success"),
+			CollisionResponseBool(Response, TEXT("success"), true));
+		TestTrue(TEXT("a missing component lists the available ones"),
+			CollisionResponseString(Response, TEXT("error")).Contains(CapsuleName));
+	}
+
+	return true;
+}
+
+#endif