ue-mcp 1.2.3 → 1.3.0

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

@@ -0,0 +1,147 @@
+// Coverage for foliage(batch_set_settings_where) (#988).
+//
+// run_automation_tests dispatches every EditorContext/EngineFilter test in the
+// process against whatever project the bridge is attached to, and this action
+// writes to FoliageType assets, so the assertions stay on argument rejection
+// and the dry run, both of which are specified to write nothing.
+
+#if WITH_DEV_AUTOMATION_TESTS
+
+#include "HandlerRegistry.h"
+#include "Handlers/FoliageHandlers.h"
+#include "Misc/AutomationTest.h"
+
+namespace
+{
+	TSharedPtr<FJsonObject> MCPFoliageBatchTestRun(
+		FMCPHandlerRegistry& Registry,
+		const TSharedPtr<FJsonObject>& Request)
+	{
+		const TSharedPtr<FJsonValue> Response =
+			Registry.ExecuteHandler(TEXT("batch_set_foliage_settings_where"), Request);
+		if (!Response.IsValid() || Response->Type != EJson::Object)
+		{
+			return nullptr;
+		}
+		return Response->AsObject();
+	}
+
+	TSharedPtr<FJsonObject> MCPFoliageBatchTestSettings()
+	{
+		TSharedPtr<FJsonObject> Settings = MakeShared<FJsonObject>();
+		Settings->SetBoolField(TEXT("bIncludeInHLOD"), false);
+		return Settings;
+	}
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FFoliageBatchSettingsContractTest,
+	"UE.MCP.Foliage.BatchSetSettingsWhere.Contract",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FFoliageBatchSettingsContractTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FFoliageHandlers::RegisterHandlers(Registry);
+
+	TestTrue(TEXT("batch_set_foliage_settings_where is registered"),
+		Registry.HasHandler(TEXT("batch_set_foliage_settings_where")));
+	TestTrue(TEXT("it carries its own timeout, because scanning and saving hundreds of assets is slow"),
+		Registry.GetHandlerTimeout(TEXT("batch_set_foliage_settings_where")) > 0.0f);
+
+	// No settings means there is nothing to write.
+	{
+		const TSharedPtr<FJsonObject> Response =
+			MCPFoliageBatchTestRun(Registry, MakeShared<FJsonObject>());
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("no settings fails"), Response->GetBoolField(TEXT("success")));
+			TestTrue(TEXT("and names the parameter"),
+				Response->GetStringField(TEXT("error")).Contains(TEXT("settings")));
+		}
+	}
+
+	// No predicate means "every foliage type in the project", which is not
+	// what anybody means by a conditional batch. The error points at the
+	// single-asset action for the case where one asset is what was wanted.
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetObjectField(TEXT("settings"), MCPFoliageBatchTestSettings());
+		const TSharedPtr<FJsonObject> Response = MCPFoliageBatchTestRun(Registry, Request);
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("no predicate fails"), Response->GetBoolField(TEXT("success")));
+			TestTrue(TEXT("and offers set_settings for the single-asset case"),
+				Response->GetStringField(TEXT("error")).Contains(TEXT("set_settings")));
+		}
+	}
+
+	// A predicate but no candidate source.
+	{
+		TSharedPtr<FJsonObject> Predicate = MakeShared<FJsonObject>();
+		Predicate->SetStringField(TEXT("field"), TEXT("CullDistance.Max"));
+		Predicate->SetStringField(TEXT("op"), TEXT("gt"));
+		Predicate->SetNumberField(TEXT("value"), 0);
+
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetObjectField(TEXT("settings"), MCPFoliageBatchTestSettings());
+		Request->SetArrayField(TEXT("where"), { MakeShared<FJsonValueObject>(Predicate) });
+		const TSharedPtr<FJsonObject> Response = MCPFoliageBatchTestRun(Registry, Request);
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("no candidate source fails"), Response->GetBoolField(TEXT("success")));
+			TestTrue(TEXT("and lists all three"),
+				Response->GetStringField(TEXT("error")).Contains(TEXT("fromLevel")));
+		}
+	}
+
+	return true;
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FFoliageBatchSettingsPreviewTest,
+	"UE.MCP.Foliage.BatchSetSettingsWhere.PreviewsByDefault",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FFoliageBatchSettingsPreviewTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FFoliageHandlers::RegisterHandlers(Registry);
+
+	// A complete, valid request against a directory that exists in every
+	// project. dryRun is not passed, so the default decides, and the default
+	// has to be the preview.
+	TSharedPtr<FJsonObject> Predicate = MakeShared<FJsonObject>();
+	Predicate->SetStringField(TEXT("field"), TEXT("CullDistance.Max"));
+	Predicate->SetStringField(TEXT("op"), TEXT("gt"));
+	Predicate->SetNumberField(TEXT("value"), 0);
+
+	TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+	Request->SetObjectField(TEXT("settings"), MCPFoliageBatchTestSettings());
+	Request->SetArrayField(TEXT("where"), { MakeShared<FJsonValueObject>(Predicate) });
+	Request->SetStringField(TEXT("directory"), TEXT("/Game"));
+
+	const TSharedPtr<FJsonObject> Response = MCPFoliageBatchTestRun(Registry, Request);
+	if (!Response.IsValid() || !Response->GetBoolField(TEXT("success")))
+	{
+		return true;
+	}
+
+	TestTrue(TEXT("dryRun defaults to true"), Response->GetBoolField(TEXT("dryRun")));
+	TestTrue(TEXT("a preview reports what it would update"), Response->HasField(TEXT("wouldUpdate")));
+	TestFalse(TEXT("and does not claim to have updated anything"), Response->HasField(TEXT("updated")));
+	TestFalse(TEXT("and saves nothing"), Response->HasField(TEXT("saved")));
+
+	// The zero-match note has to explain the interval trap, because
+	// CullDistance is an FInt32Interval and comparing it as a number is the
+	// mistake this action invites.
+	if (static_cast<int32>(Response->GetNumberField(TEXT("matched"))) == 0 &&
+		static_cast<int32>(Response->GetNumberField(TEXT("scanned"))) > 0)
+	{
+		TestTrue(TEXT("a zero match explains itself"), Response->HasField(TEXT("zeroMatchNote")));
+	}
+
+	return true;
+}
+
+#endif // WITH_DEV_AUTOMATION_TESTS

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

@@ -0,0 +1,82 @@
+#if WITH_DEV_AUTOMATION_TESTS
+
+#include "GameThreadExecutor.h"
+#include "Dom/JsonObject.h"
+#include "Dom/JsonValue.h"
+#include "Misc/AutomationTest.h"
+
+/**
+ * The readiness gate, and the one class of call it must never close in front of.
+ *
+ * #968: a modal raised during editor startup (the "Restore Packages" prompt
+ * after an unclean shutdown) blocks the game thread before the editor is ever
+ * marked ready. Every handler then answered "Editor is still initializing" -
+ * including respond_to_dialog and set_dialog_policy, the two calls that could
+ * have dismissed it. The gate was held shut by the very dialog those calls
+ * exist to clear, and the only escape was an OS kill, which discards whatever
+ * the user was being asked about. Meanwhile get_engine_state described the
+ * dialog down to its button labels, because it answers off the game thread.
+ *
+ * These run on the game thread, so ExecuteOnGameThread dispatches inline and
+ * the assertions are about the gate itself rather than about ticker timing.
+ */
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FMCPGameThreadReadyGateTest,
+	"UE.MCP.Bridge.GameThread.ReadyGate",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FMCPGameThreadReadyGateTest::RunTest(const FString& Parameters)
+{
+	FMCPGameThreadExecutor Executor;
+	TestFalse(TEXT("a fresh executor has not been told the editor is ready"), Executor.IsEditorReady());
+
+	bool bHandlerRan = false;
+	FMCPGameThreadExecutor::FHandlerFunction Handler =
+		[&bHandlerRan](const TSharedPtr<FJsonObject>&) -> TSharedPtr<FJsonValue>
+		{
+			bHandlerRan = true;
+			TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
+			Result->SetBoolField(TEXT("success"), true);
+			return MakeShared<FJsonValueObject>(Result);
+		};
+
+	const TSharedPtr<FJsonObject> Params = MakeShared<FJsonObject>();
+
+	// An ordinary handler still waits. Refusing work that needs a built editor
+	// is the whole point of the gate and none of this weakens it.
+	TSharedPtr<FJsonValue> Gated = Executor.ExecuteOnGameThread(Handler, Params, 5.0f, /*bModalSafe*/ false);
+	TestTrue(TEXT("an ordinary handler is refused before the editor is ready"), Gated.IsValid() && Gated->Type == EJson::Object);
+	FString GatedError;
+	if (Gated.IsValid() && Gated->Type == EJson::Object)
+	{
+		Gated->AsObject()->TryGetStringField(TEXT("error"), GatedError);
+	}
+	TestTrue(TEXT("and told why"), GatedError.Contains(TEXT("still initializing")));
+	TestFalse(TEXT("and never reached the handler"), bHandlerRan);
+
+	// A modal-safe handler runs. It is the escape hatch from a blocked game
+	// thread, so nothing the block causes may stand in front of it.
+	bHandlerRan = false;
+	TSharedPtr<FJsonValue> Exempt = Executor.ExecuteOnGameThread(Handler, Params, 5.0f, /*bModalSafe*/ true);
+	TestTrue(TEXT("a modal-safe handler runs before the editor is ready"), bHandlerRan);
+	TestTrue(TEXT("and returns its own result, not the gate's error"),
+		Exempt.IsValid() && Exempt->Type == EJson::Object && Exempt->AsObject()->HasField(TEXT("success")));
+
+	FString ExemptError;
+	if (Exempt.IsValid() && Exempt->Type == EJson::Object)
+	{
+		Exempt->AsObject()->TryGetStringField(TEXT("error"), ExemptError);
+	}
+	TestTrue(TEXT("with no initializing error attached"), ExemptError.IsEmpty());
+
+	// Once the editor is ready both go through, so the exemption is about the
+	// window before readiness and changes nothing after it.
+	Executor.SetEditorReady();
+	bHandlerRan = false;
+	Executor.ExecuteOnGameThread(Handler, Params, 5.0f, /*bModalSafe*/ false);
+	TestTrue(TEXT("an ordinary handler runs once the editor is ready"), bHandlerRan);
+
+	return true;
+}
+
+#endif

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

@@ -0,0 +1,183 @@
+#if WITH_DEV_AUTOMATION_TESTS
+
+#include "Handlers/GasHandlers.h"
+#include "HandlerRegistry.h"
+#include "Misc/AutomationTest.h"
+#include "AbilitySystemComponent.h"
+#include "AbilitySystemTestAttributeSet.h"
+#include "AttributeSet.h"
+#include "Engine/Engine.h"
+#include "Engine/World.h"
+#include "GameFramework/Actor.h"
+#include "Misc/ScopeExit.h"
+#include "UObject/UnrealType.h"
+
+/**
+ * #956: gas(get_live_attribute_value) / gas(set_live_attribute_value) must
+ * reach the attribute set instance REGISTERED on the actor's ASC, never a
+ * second one built alongside it.
+ *
+ * The case that makes this hard is the one these tests reproduce: an actor in
+ * a world that has not begun play never runs InitializeComponent, so its ASC
+ * has no registered sets at all even though the actor owns one. The only
+ * correct answer there is to register the actor's OWN instance. Constructing a
+ * fresh set instead compiles, runs, reports success, and writes to an object
+ * the gameplay code never reads, which is why the pointer-identity assertion
+ * below is the point of the whole file.
+ */
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FGasAdoptOwnerAttributeSetsTest,
+	"UE.MCP.Gas.LiveAttributes.AdoptsTheActorsOwnSet",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FGasAdoptOwnerAttributeSetsTest::RunTest(const FString& Parameters)
+{
+	// A private world, so nothing here touches whatever map the user has open.
+	UWorld* World = UWorld::CreateWorld(EWorldType::Editor, /*bInformEngineOfWorld=*/false);
+	if (!World)
+	{
+		AddError(TEXT("could not create a test world"));
+		return false;
+	}
+	ON_SCOPE_EXIT
+	{
+		World->DestroyWorld(false);
+	};
+
+	AActor* Actor = World->SpawnActor<AActor>();
+	if (!Actor)
+	{
+		AddError(TEXT("could not spawn the test actor"));
+		return false;
+	}
+
+	UAbilitySystemComponent* ASC = NewObject<UAbilitySystemComponent>(Actor);
+	ASC->RegisterComponent();
+
+	// The actor's own attribute set, outered to the actor exactly the way a
+	// CreateDefaultSubobject-created one is. This is the object the gameplay
+	// code would consult once the ASC knows about it.
+	// Constructed through the class pointer rather than the templated form:
+	// UAbilitySystemTestAttributeSet is MinimalAPI, so its class registration is
+	// exported and its constructor is not.
+	UAttributeSet* OwnSet = NewObject<UAttributeSet>(
+		Actor, UAbilitySystemTestAttributeSet::StaticClass());
+
+	// The whole premise: the world never began play, so nothing registered it.
+	TestNull(
+		TEXT("nothing is registered before adoption, even though the actor owns a set"),
+		ASC->GetAttributeSet(UAbilitySystemTestAttributeSet::StaticClass()));
+
+	TArray<FString> Adopted;
+	const int32 Count = MCPGas::AdoptOwnerAttributeSets(ASC, Actor, Adopted);
+	TestEqual(TEXT("one set was newly registered"), Count, 1);
+	TestEqual(TEXT("the registered set is named in the report"), Adopted.Num(), 1);
+
+	const UAttributeSet* Registered =
+		ASC->GetAttributeSet(UAbilitySystemTestAttributeSet::StaticClass());
+	TestNotNull(TEXT("the ASC now has a registered set"), Registered);
+
+	// THE assertion. A second, disconnected instance would satisfy every other
+	// check in this file and fail only this one.
+	TestTrue(
+		TEXT("the registered instance IS the actor's own object, not a copy"),
+		Registered == OwnSet);
+
+	// Idempotent: a second pass registers nothing and does not duplicate.
+	TArray<FString> Again;
+	TestEqual(TEXT("re-adopting registers nothing new"),
+		MCPGas::AdoptOwnerAttributeSets(ASC, Actor, Again), 0);
+	TestEqual(TEXT("the set appears exactly once"),
+		ASC->GetSpawnedAttributes().Num(), 1);
+
+	// A value written through the registered instance is the value the ASC's
+	// own accessor reads back, which is what "the gameplay code consults it"
+	// means in practice.
+	FStructProperty* ManaProp = MCPGas::FindAttributeDataProperty(
+		UAbilitySystemTestAttributeSet::StaticClass(), TEXT("Mana"));
+	TestNotNull(TEXT("Mana is found as an FGameplayAttributeData property"), ManaProp);
+	if (ManaProp)
+	{
+		const FGameplayAttribute Mana(ManaProp);
+		float NewValue = 42.0f;
+		Mana.SetNumericValueChecked(NewValue, const_cast<UAttributeSet*>(Registered));
+		// Read back through the ASC, which resolves the attribute's set on its
+		// own. It agreeing with the actor's object is the operational form of
+		// "the gameplay code consults this instance", and it is what a second,
+		// disconnected set would break.
+		TestEqual(TEXT("the ASC reads back what was written to the actor's own instance"),
+			ASC->GetNumericAttribute(Mana), Mana.GetNumericValue(OwnSet));
+		TestEqual(TEXT("the written value is what landed"),
+			Mana.GetNumericValue(OwnSet), 42.0f);
+	}
+
+	return true;
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FGasAttributeDataPropertyLookupTest,
+	"UE.MCP.Gas.LiveAttributes.AttributePropertyLookup",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FGasAttributeDataPropertyLookupTest::RunTest(const FString& Parameters)
+{
+	UClass* SetClass = UAbilitySystemTestAttributeSet::StaticClass();
+
+	TestNotNull(TEXT("bare property name resolves"),
+		MCPGas::FindAttributeDataProperty(SetClass, TEXT("Mana")));
+	TestNotNull(TEXT("Set.Property spelling resolves"),
+		MCPGas::FindAttributeDataProperty(SetClass, TEXT("AbilitySystemTestAttributeSet.Mana")));
+	TestNotNull(TEXT("Set:Property spelling resolves"),
+		MCPGas::FindAttributeDataProperty(SetClass, TEXT("AbilitySystemTestAttributeSet:Mana")));
+
+	// Plain float UPROPERTYs on an attribute set are not FGameplayAttributeData
+	// and are not what these actions address, so they must miss rather than
+	// resolve to something the caller cannot read a base value from.
+	TestNull(TEXT("a plain float property is not an attribute data property"),
+		MCPGas::FindAttributeDataProperty(SetClass, TEXT("Health")));
+	TestNull(TEXT("an unknown name misses"),
+		MCPGas::FindAttributeDataProperty(SetClass, TEXT("NoSuchAttribute")));
+	TestNull(TEXT("a null class misses rather than crashing"),
+		MCPGas::FindAttributeDataProperty(nullptr, TEXT("Mana")));
+
+	const FString Names = MCPGas::ListAttributeDataPropertyNames(SetClass);
+	TestTrue(TEXT("the miss message lists the real attribute names"), Names.Contains(TEXT("Mana")));
+	TestEqual(TEXT("a null class lists nothing"),
+		*MCPGas::ListAttributeDataPropertyNames(nullptr), TEXT("(none)"));
+
+	return true;
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FGasLiveAttributeRegistrationTest,
+	"UE.MCP.Gas.LiveAttributes.RegistrationAndPreflight",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FGasLiveAttributeRegistrationTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FGasHandlers::RegisterHandlers(Registry);
+
+	TestTrue(TEXT("get_live_attribute_value is registered"),
+		Registry.HasHandler(TEXT("get_live_attribute_value")));
+	TestTrue(TEXT("set_live_attribute_value is registered"),
+		Registry.HasHandler(TEXT("set_live_attribute_value")));
+
+	// Preflight runs before any world or actor lookup, so this is safe with no
+	// editor world and no PIE session.
+	const TSharedPtr<FJsonValue> Response =
+		Registry.ExecuteHandler(TEXT("get_live_attribute_value"), MakeShared<FJsonObject>());
+	TestTrue(TEXT("preflight returns an object"), Response.IsValid() && Response->Type == EJson::Object);
+	if (Response.IsValid() && Response->Type == EJson::Object)
+	{
+		const TSharedPtr<FJsonObject> Object = Response->AsObject();
+		TestFalse(TEXT("preflight is unsuccessful"), Object->GetBoolField(TEXT("success")));
+		TestTrue(TEXT("preflight names the first required field"),
+			Object->GetStringField(TEXT("error")).Contains(TEXT("attributeSet")));
+	}
+
+	return true;
+}
+
+#endif

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

@@ -0,0 +1,119 @@
+// Coverage for landscape(sample) parameter parity (#939).
+//
+// The action documented "Params: x, y" and the handler required an object
+// called `point`, so every documented call shape answered "Missing 'point'
+// parameter" and there was no working call at all. These assertions pin the
+// contract rather than the terrain: each accepted position shape gets PAST
+// parameter validation, and a request with no position at all is refused with
+// an error that names every shape that would have worked.
+//
+// The terrain half (heights, weights) needs a landscape in the level and is
+// exercised by the live smoke run; what regressed here was the parameter
+// handling, and that is checkable with no landscape at all.
+
+#if WITH_DEV_AUTOMATION_TESTS
+
+#include "HandlerRegistry.h"
+#include "Handlers/LandscapeHandlers.h"
+#include "Misc/AutomationTest.h"
+
+namespace
+{
+	TSharedPtr<FJsonObject> MCPLandscapeSampleTestRun(
+		FMCPHandlerRegistry& Registry,
+		const TSharedPtr<FJsonObject>& Request)
+	{
+		const TSharedPtr<FJsonValue> Response = Registry.ExecuteHandler(TEXT("sample_landscape"), Request);
+		if (!Response.IsValid() || Response->Type != EJson::Object)
+		{
+			return nullptr;
+		}
+		return Response->AsObject();
+	}
+
+	/** The error text a request is refused with, or empty when it succeeded. */
+	FString MCPLandscapeSampleTestError(const TSharedPtr<FJsonObject>& Response)
+	{
+		if (!Response.IsValid()) return FString();
+		if (Response->GetBoolField(TEXT("success"))) return FString();
+		return Response->GetStringField(TEXT("error"));
+	}
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FLandscapeSampleAcceptsItsDocumentedArgumentsTest,
+	"UE.MCP.Landscape.Sample.AcceptsItsDocumentedArguments",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FLandscapeSampleAcceptsItsDocumentedArgumentsTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FLandscapeHandlers::RegisterHandlers(Registry);
+	TestTrue(TEXT("sample_landscape is registered"), Registry.HasHandler(TEXT("sample_landscape")));
+
+	// No position at all is the one request that SHOULD be refused, and the
+	// refusal has to name every shape that works. The old message named only
+	// `point`, which is the shape the schema never advertised.
+	{
+		const TSharedPtr<FJsonObject> Response =
+			MCPLandscapeSampleTestRun(Registry, MakeShared<FJsonObject>());
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("a request with no position is refused"), Response->GetBoolField(TEXT("success")));
+			const FString Error = Response->GetStringField(TEXT("error"));
+			TestTrue(TEXT("and the refusal names the x/y shape"), Error.Contains(TEXT("x and y")));
+			TestTrue(TEXT("and the point shape"), Error.Contains(TEXT("point")));
+			TestTrue(TEXT("and the worldX/worldY shape"), Error.Contains(TEXT("worldX")));
+		}
+	}
+
+	// Every accepted shape must get past parameter validation. Whether a
+	// landscape exists in the level is a separate question, so the assertion is
+	// on the error NOT being the missing-position one.
+	auto TestShapeIsAccepted = [this, &Registry](const TCHAR* What, const TSharedPtr<FJsonObject>& Request)
+	{
+		const TSharedPtr<FJsonObject> Response = MCPLandscapeSampleTestRun(Registry, Request);
+		if (!Response.IsValid()) return;
+		const FString Error = MCPLandscapeSampleTestError(Response);
+		TestFalse(FString::Printf(TEXT("%s is not refused as a missing position"), What),
+			Error.Contains(TEXT("Missing sample position")));
+		TestFalse(FString::Printf(TEXT("%s is not refused for a missing 'point'"), What),
+			Error.Contains(TEXT("Missing 'point'")));
+	};
+
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetNumberField(TEXT("x"), 1000.0);
+		Request->SetNumberField(TEXT("y"), 2000.0);
+		TestShapeIsAccepted(TEXT("x + y"), Request);
+	}
+	{
+		TSharedPtr<FJsonObject> Point = MakeShared<FJsonObject>();
+		Point->SetNumberField(TEXT("x"), 1000.0);
+		Point->SetNumberField(TEXT("y"), 2000.0);
+		Point->SetNumberField(TEXT("z"), 0.0);
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetObjectField(TEXT("point"), Point);
+		TestShapeIsAccepted(TEXT("point {x, y, z}"), Request);
+	}
+	{
+		// The z is optional: the surface height is what the action answers, so
+		// requiring one as an input would be a riddle.
+		TSharedPtr<FJsonObject> Point = MakeShared<FJsonObject>();
+		Point->SetNumberField(TEXT("x"), 1000.0);
+		Point->SetNumberField(TEXT("y"), 2000.0);
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetObjectField(TEXT("point"), Point);
+		TestShapeIsAccepted(TEXT("point {x, y}"), Request);
+	}
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetNumberField(TEXT("worldX"), 1000.0);
+		Request->SetNumberField(TEXT("worldY"), 2000.0);
+		TestShapeIsAccepted(TEXT("worldX + worldY"), Request);
+	}
+
+	return true;
+}
+
+#endif // WITH_DEV_AUTOMATION_TESTS