using System;
using System.IO;
using System.Linq;
using Newtonsoft.Json.Linq;
using NUnit.Framework;
using UnityEditor;
using UnityEditor.Animations;
using UnityEngine;
using MCPForUnity.Editor.Tools.Animation;
using static MCPForUnityTests.Editor.TestUtilities;
namespace MCPForUnityTests.Editor.Tools
{
public class ManageAnimationTests
{
private const string TempRoot = "Assets/Temp/ManageAnimationTests";
[SetUp]
public void SetUp()
{
EnsureFolder(TempRoot);
}
[TearDown]
public void TearDown()
{
// Clean up scene objects
foreach (var go in UnityEngine.Object.FindObjectsOfType<GameObject>())
{
if (go.name.StartsWith("AnimTest_"))
{
UnityEngine.Object.DestroyImmediate(go);
}
}
if (AssetDatabase.IsValidFolder(TempRoot))
{
AssetDatabase.DeleteAsset(TempRoot);
}
CleanupEmptyParentFolders(TempRoot);
}
// =============================================================================
// Dispatch / Error Handling
// =============================================================================
[Test]
public void HandleCommand_MissingAction_ReturnsError()
{
var paramsObj = new JObject();
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsFalse(result.Value<bool>("success"));
Assert.That(result["message"].ToString(), Does.Contain("Action is required"));
}
[Test]
public void HandleCommand_UnknownAction_ReturnsError()
{
var paramsObj = new JObject { ["action"] = "bogus_action" };
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsFalse(result.Value<bool>("success"));
Assert.That(result["message"].ToString(), Does.Contain("Unknown action"));
}
[Test]
public void HandleCommand_UnknownAnimatorAction_ReturnsError()
{
var paramsObj = new JObject { ["action"] = "animator_nonexistent" };
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsFalse(result.Value<bool>("success"));
Assert.That(result["message"].ToString(), Does.Contain("Unknown animator action"));
}
[Test]
public void HandleCommand_UnknownClipAction_ReturnsError()
{
var paramsObj = new JObject { ["action"] = "clip_nonexistent" };
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsFalse(result.Value<bool>("success"));
Assert.That(result["message"].ToString(), Does.Contain("Unknown clip action"));
}
// =============================================================================
// Animator: Get Info
// =============================================================================
[Test]
public void AnimatorGetInfo_NoTarget_ReturnsError()
{
var paramsObj = new JObject { ["action"] = "animator_get_info" };
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsFalse(result.Value<bool>("success"));
}
[Test]
public void AnimatorGetInfo_NoAnimator_ReturnsError()
{
var go = new GameObject("AnimTest_NoAnimator");
try
{
var paramsObj = new JObject
{
["action"] = "animator_get_info",
["target"] = "AnimTest_NoAnimator"
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsFalse(result.Value<bool>("success"));
Assert.That(result["message"].ToString(), Does.Contain("No Animator"));
}
finally
{
UnityEngine.Object.DestroyImmediate(go);
}
}
[Test]
public void AnimatorGetInfo_WithAnimator_ReturnsData()
{
var go = new GameObject("AnimTest_WithAnimator");
go.AddComponent<Animator>();
try
{
var paramsObj = new JObject
{
["action"] = "animator_get_info",
["target"] = "AnimTest_WithAnimator"
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsTrue(result.Value<bool>("success"), result.ToString());
var data = result["data"] as JObject;
Assert.IsNotNull(data);
Assert.AreEqual("AnimTest_WithAnimator", data["gameObject"].ToString());
Assert.IsNotNull(data["enabled"]);
Assert.IsNotNull(data["speed"]);
}
finally
{
UnityEngine.Object.DestroyImmediate(go);
}
}
// =============================================================================
// Animator: Set Speed / Set Enabled
// =============================================================================
[Test]
public void AnimatorSetSpeed_ChangesSpeed()
{
var go = new GameObject("AnimTest_Speed");
var animator = go.AddComponent<Animator>();
try
{
var paramsObj = new JObject
{
["action"] = "animator_set_speed",
["target"] = "AnimTest_Speed",
["speed"] = 2.5f
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsTrue(result.Value<bool>("success"), result.ToString());
Assert.AreEqual(2.5f, animator.speed, 0.001f);
}
finally
{
UnityEngine.Object.DestroyImmediate(go);
}
}
[Test]
public void AnimatorSetEnabled_DisablesAnimator()
{
var go = new GameObject("AnimTest_Enabled");
var animator = go.AddComponent<Animator>();
Assert.IsTrue(animator.enabled);
try
{
var paramsObj = new JObject
{
["action"] = "animator_set_enabled",
["target"] = "AnimTest_Enabled",
["enabled"] = false
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsTrue(result.Value<bool>("success"), result.ToString());
Assert.IsFalse(animator.enabled);
}
finally
{
UnityEngine.Object.DestroyImmediate(go);
}
}
// =============================================================================
// Clip: Create
// =============================================================================
[Test]
public void ClipCreate_CreatesAsset()
{
string clipPath = $"{TempRoot}/TestClip_{Guid.NewGuid():N}.anim";
var paramsObj = new JObject
{
["action"] = "clip_create",
["clipPath"] = clipPath,
["length"] = 2.0f,
["loop"] = true
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsTrue(result.Value<bool>("success"), result.ToString());
var clip = AssetDatabase.LoadAssetAtPath<AnimationClip>(clipPath);
Assert.IsNotNull(clip, "Clip asset should exist");
var settings = AnimationUtility.GetAnimationClipSettings(clip);
Assert.IsTrue(settings.loopTime, "Clip should be looping");
Assert.AreEqual(2.0f, settings.stopTime, 0.01f);
}
[Test]
public void ClipCreate_DuplicatePath_ReturnsError()
{
string clipPath = $"{TempRoot}/DuplicateClip.anim";
// Create first
var clip = new AnimationClip { name = "DuplicateClip" };
AssetDatabase.CreateAsset(clip, clipPath);
AssetDatabase.SaveAssets();
// Try to create again
var paramsObj = new JObject
{
["action"] = "clip_create",
["clipPath"] = clipPath,
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsFalse(result.Value<bool>("success"));
Assert.That(result["message"].ToString(), Does.Contain("already exists"));
}
[Test]
public void ClipCreate_MissingPath_ReturnsError()
{
var paramsObj = new JObject { ["action"] = "clip_create" };
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsFalse(result.Value<bool>("success"));
Assert.That(result["message"].ToString(), Does.Contain("clipPath"));
}
// =============================================================================
// Clip: Get Info
// =============================================================================
[Test]
public void ClipGetInfo_ReturnsClipData()
{
string clipName = $"InfoClip_{Guid.NewGuid():N}";
string clipPath = $"{TempRoot}/{clipName}.anim";
var clip = new AnimationClip { name = clipName, frameRate = 30f };
var settings = AnimationUtility.GetAnimationClipSettings(clip);
settings.loopTime = true;
settings.stopTime = 1.5f;
AnimationUtility.SetAnimationClipSettings(clip, settings);
AssetDatabase.CreateAsset(clip, clipPath);
AssetDatabase.SaveAssets();
var paramsObj = new JObject
{
["action"] = "clip_get_info",
["clipPath"] = clipPath
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsTrue(result.Value<bool>("success"), result.ToString());
var data = result["data"] as JObject;
Assert.IsNotNull(data);
Assert.AreEqual(clipName, data["name"].ToString());
Assert.AreEqual(30f, data.Value<float>("frameRate"), 0.01f);
Assert.IsTrue(data.Value<bool>("isLooping"));
}
[Test]
public void ClipGetInfo_NotFound_ReturnsError()
{
var paramsObj = new JObject
{
["action"] = "clip_get_info",
["clipPath"] = "Assets/Nonexistent.anim"
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsFalse(result.Value<bool>("success"));
Assert.That(result["message"].ToString(), Does.Contain("not found"));
}
// =============================================================================
// Clip: Add / Set Curve
// =============================================================================
[Test]
public void ClipAddCurve_AddsKeyframes()
{
string clipPath = $"{TempRoot}/CurveClip_{Guid.NewGuid():N}.anim";
var clip = new AnimationClip { name = "CurveClip" };
AssetDatabase.CreateAsset(clip, clipPath);
AssetDatabase.SaveAssets();
var paramsObj = new JObject
{
["action"] = "clip_add_curve",
["clipPath"] = clipPath,
["propertyPath"] = "localPosition.y",
["type"] = "Transform",
["keys"] = new JArray(
new JArray(0f, 0f),
new JArray(0.5f, 2f),
new JArray(1f, 0f)
)
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsTrue(result.Value<bool>("success"), result.ToString());
// Verify curve was added
clip = AssetDatabase.LoadAssetAtPath<AnimationClip>(clipPath);
var bindings = AnimationUtility.GetCurveBindings(clip);
Assert.AreEqual(1, bindings.Length);
Assert.AreEqual("localPosition.y", bindings[0].propertyName);
var curve = AnimationUtility.GetEditorCurve(clip, bindings[0]);
Assert.AreEqual(3, curve.length);
}
[Test]
public void ClipSetCurve_ReplacesKeyframes()
{
string clipPath = $"{TempRoot}/SetCurveClip_{Guid.NewGuid():N}.anim";
var clip = new AnimationClip { name = "SetCurveClip" };
// Add initial curve
var initialCurve = new AnimationCurve(new Keyframe(0, 0), new Keyframe(1, 1));
var binding = EditorCurveBinding.FloatCurve("", typeof(Transform), "localPosition.x");
AnimationUtility.SetEditorCurve(clip, binding, initialCurve);
AssetDatabase.CreateAsset(clip, clipPath);
AssetDatabase.SaveAssets();
// Replace with new keyframes
var paramsObj = new JObject
{
["action"] = "clip_set_curve",
["clipPath"] = clipPath,
["propertyPath"] = "localPosition.x",
["type"] = "Transform",
["keys"] = new JArray(
new JArray(0f, 5f),
new JArray(2f, 10f)
)
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsTrue(result.Value<bool>("success"), result.ToString());
clip = AssetDatabase.LoadAssetAtPath<AnimationClip>(clipPath);
var curve = AnimationUtility.GetEditorCurve(clip, binding);
Assert.AreEqual(2, curve.length);
Assert.AreEqual(5f, curve.keys[0].value, 0.01f);
Assert.AreEqual(10f, curve.keys[1].value, 0.01f);
}
[Test]
public void ClipAddCurve_WithObjectFormat_ParsesKeyframes()
{
string clipPath = $"{TempRoot}/ObjFormatClip_{Guid.NewGuid():N}.anim";
var clip = new AnimationClip { name = "ObjFormatClip" };
AssetDatabase.CreateAsset(clip, clipPath);
AssetDatabase.SaveAssets();
var paramsObj = new JObject
{
["action"] = "clip_add_curve",
["clipPath"] = clipPath,
["propertyPath"] = "localPosition.z",
["type"] = "Transform",
["keys"] = new JArray(
new JObject { ["time"] = 0f, ["value"] = 0f, ["inTangent"] = 0f, ["outTangent"] = 1f },
new JObject { ["time"] = 1f, ["value"] = 5f }
)
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsTrue(result.Value<bool>("success"), result.ToString());
clip = AssetDatabase.LoadAssetAtPath<AnimationClip>(clipPath);
var bindings = AnimationUtility.GetCurveBindings(clip);
Assert.AreEqual(1, bindings.Length);
var curve = AnimationUtility.GetEditorCurve(clip, bindings[0]);
Assert.AreEqual(2, curve.length);
Assert.AreEqual(1f, curve.keys[0].outTangent, 0.01f);
}
[Test]
public void ClipAddCurve_MissingKeys_ReturnsError()
{
string clipPath = $"{TempRoot}/NoKeysClip_{Guid.NewGuid():N}.anim";
var clip = new AnimationClip { name = "NoKeysClip" };
AssetDatabase.CreateAsset(clip, clipPath);
AssetDatabase.SaveAssets();
var paramsObj = new JObject
{
["action"] = "clip_add_curve",
["clipPath"] = clipPath,
["propertyPath"] = "localPosition.y",
["type"] = "Transform",
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsFalse(result.Value<bool>("success"));
Assert.That(result["message"].ToString(), Does.Contain("keys"));
}
// =============================================================================
// Clip: Assign
// =============================================================================
[Test]
public void ClipAssign_AddsAnimationComponent()
{
string clipPath = $"{TempRoot}/AssignClip_{Guid.NewGuid():N}.anim";
var clip = new AnimationClip { name = "AssignClip" };
clip.legacy = true;
AssetDatabase.CreateAsset(clip, clipPath);
AssetDatabase.SaveAssets();
var go = new GameObject("AnimTest_Assign");
try
{
Assert.IsNull(go.GetComponent<UnityEngine.Animation>());
Assert.IsNull(go.GetComponent<Animator>());
var paramsObj = new JObject
{
["action"] = "clip_assign",
["target"] = "AnimTest_Assign",
["clipPath"] = clipPath
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsTrue(result.Value<bool>("success"), result.ToString());
var anim = go.GetComponent<UnityEngine.Animation>();
Assert.IsNotNull(anim, "Should have added Animation component");
Assert.IsNotNull(anim.clip, "Should have assigned clip");
}
finally
{
UnityEngine.Object.DestroyImmediate(go);
}
}
[Test]
public void ClipAssign_MissingClip_ReturnsError()
{
var go = new GameObject("AnimTest_AssignMissing");
try
{
var paramsObj = new JObject
{
["action"] = "clip_assign",
["target"] = "AnimTest_AssignMissing",
["clipPath"] = "Assets/Nonexistent.anim"
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsFalse(result.Value<bool>("success"));
Assert.That(result["message"].ToString(), Does.Contain("not found"));
}
finally
{
UnityEngine.Object.DestroyImmediate(go);
}
}
// =============================================================================
// Parameter Normalization
// =============================================================================
[Test]
public void HandleCommand_SnakeCaseParams_Normalized()
{
// Test that snake_case parameters like clip_path get normalized to clipPath
string clipPath = $"{TempRoot}/SnakeCase_{Guid.NewGuid():N}.anim";
var paramsObj = new JObject
{
["action"] = "clip_create",
["clip_path"] = clipPath,
["length"] = 1.0f
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsTrue(result.Value<bool>("success"), result.ToString());
var clip = AssetDatabase.LoadAssetAtPath<AnimationClip>(clipPath);
Assert.IsNotNull(clip);
}
[Test]
public void HandleCommand_PropertiesDict_Flattened()
{
// Test that properties dict is flattened into top-level params
string clipPath = $"{TempRoot}/PropsFlat_{Guid.NewGuid():N}.anim";
var paramsObj = new JObject
{
["action"] = "clip_create",
["properties"] = new JObject
{
["clipPath"] = clipPath,
["length"] = 1.5f,
["loop"] = true
}
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsTrue(result.Value<bool>("success"), result.ToString());
var clip = AssetDatabase.LoadAssetAtPath<AnimationClip>(clipPath);
Assert.IsNotNull(clip);
var settings = AnimationUtility.GetAnimationClipSettings(clip);
Assert.IsTrue(settings.loopTime);
}
// =============================================================================
// Controller: Dispatch
// =============================================================================
[Test]
public void HandleCommand_UnknownControllerAction_ReturnsError()
{
var paramsObj = new JObject { ["action"] = "controller_nonexistent" };
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsFalse(result.Value<bool>("success"));
Assert.That(result["message"].ToString(), Does.Contain("Unknown controller action"));
}
// =============================================================================
// Controller: Create
// =============================================================================
[Test]
public void ControllerCreate_CreatesAsset()
{
string controllerPath = $"{TempRoot}/TestController_{Guid.NewGuid():N}.controller";
var paramsObj = new JObject
{
["action"] = "controller_create",
["controllerPath"] = controllerPath
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsTrue(result.Value<bool>("success"), result.ToString());
var controller = AssetDatabase.LoadAssetAtPath<AnimatorController>(controllerPath);
Assert.IsNotNull(controller, "Controller asset should exist");
}
[Test]
public void ControllerCreate_DuplicatePath_ReturnsError()
{
string controllerPath = $"{TempRoot}/DuplicateController.controller";
var controller = AnimatorController.CreateAnimatorControllerAtPath(controllerPath);
AssetDatabase.SaveAssets();
var paramsObj = new JObject
{
["action"] = "controller_create",
["controllerPath"] = controllerPath
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsFalse(result.Value<bool>("success"));
Assert.That(result["message"].ToString(), Does.Contain("already exists"));
}
[Test]
public void ControllerCreate_MissingPath_ReturnsError()
{
var paramsObj = new JObject { ["action"] = "controller_create" };
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsFalse(result.Value<bool>("success"));
Assert.That(result["message"].ToString(), Does.Contain("controllerPath"));
}
// =============================================================================
// Controller: Add State
// =============================================================================
[Test]
public void ControllerAddState_AddsState()
{
string controllerPath = $"{TempRoot}/StateController_{Guid.NewGuid():N}.controller";
AnimatorController.CreateAnimatorControllerAtPath(controllerPath);
AssetDatabase.SaveAssets();
var paramsObj = new JObject
{
["action"] = "controller_add_state",
["controllerPath"] = controllerPath,
["stateName"] = "Walk"
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsTrue(result.Value<bool>("success"), result.ToString());
var controller = AssetDatabase.LoadAssetAtPath<AnimatorController>(controllerPath);
var states = controller.layers[0].stateMachine.states;
Assert.IsTrue(states.Any(s => s.state.name == "Walk"), "State 'Walk' should exist");
}
[Test]
public void ControllerAddState_DuplicateName_ReturnsError()
{
string controllerPath = $"{TempRoot}/DupStateController_{Guid.NewGuid():N}.controller";
var controller = AnimatorController.CreateAnimatorControllerAtPath(controllerPath);
controller.layers[0].stateMachine.AddState("Idle");
AssetDatabase.SaveAssets();
var paramsObj = new JObject
{
["action"] = "controller_add_state",
["controllerPath"] = controllerPath,
["stateName"] = "Idle"
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsFalse(result.Value<bool>("success"));
Assert.That(result["message"].ToString(), Does.Contain("already exists"));
}
[Test]
public void ControllerAddState_WithClip_AssignsMotion()
{
string controllerPath = $"{TempRoot}/MotionController_{Guid.NewGuid():N}.controller";
AnimatorController.CreateAnimatorControllerAtPath(controllerPath);
string clipPath = $"{TempRoot}/MotionClip_{Guid.NewGuid():N}.anim";
var clip = new AnimationClip { name = "MotionClip" };
AssetDatabase.CreateAsset(clip, clipPath);
AssetDatabase.SaveAssets();
var paramsObj = new JObject
{
["action"] = "controller_add_state",
["controllerPath"] = controllerPath,
["stateName"] = "Run",
["clipPath"] = clipPath
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsTrue(result.Value<bool>("success"), result.ToString());
var controller = AssetDatabase.LoadAssetAtPath<AnimatorController>(controllerPath);
var state = controller.layers[0].stateMachine.states.First(s => s.state.name == "Run").state;
Assert.IsNotNull(state.motion, "State should have motion assigned");
}
// =============================================================================
// Controller: Add Transition
// =============================================================================
[Test]
public void ControllerAddTransition_AddsTransition()
{
string controllerPath = $"{TempRoot}/TransController_{Guid.NewGuid():N}.controller";
var controller = AnimatorController.CreateAnimatorControllerAtPath(controllerPath);
var sm = controller.layers[0].stateMachine;
sm.AddState("Idle");
sm.AddState("Walk");
AssetDatabase.SaveAssets();
var paramsObj = new JObject
{
["action"] = "controller_add_transition",
["controllerPath"] = controllerPath,
["fromState"] = "Idle",
["toState"] = "Walk",
["hasExitTime"] = false,
["duration"] = 0.1f
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsTrue(result.Value<bool>("success"), result.ToString());
controller = AssetDatabase.LoadAssetAtPath<AnimatorController>(controllerPath);
var idleState = controller.layers[0].stateMachine.states.First(s => s.state.name == "Idle").state;
Assert.AreEqual(1, idleState.transitions.Length);
Assert.AreEqual("Walk", idleState.transitions[0].destinationState.name);
Assert.IsFalse(idleState.transitions[0].hasExitTime);
}
[Test]
public void ControllerAddTransition_WithConditions_AddsConditions()
{
string controllerPath = $"{TempRoot}/CondController_{Guid.NewGuid():N}.controller";
var controller = AnimatorController.CreateAnimatorControllerAtPath(controllerPath);
controller.AddParameter("Speed", AnimatorControllerParameterType.Float);
var sm = controller.layers[0].stateMachine;
sm.AddState("Idle");
sm.AddState("Walk");
AssetDatabase.SaveAssets();
var paramsObj = new JObject
{
["action"] = "controller_add_transition",
["controllerPath"] = controllerPath,
["fromState"] = "Idle",
["toState"] = "Walk",
["conditions"] = new JArray(
new JObject
{
["parameter"] = "Speed",
["mode"] = "greater",
["threshold"] = 0.1f
}
)
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsTrue(result.Value<bool>("success"), result.ToString());
controller = AssetDatabase.LoadAssetAtPath<AnimatorController>(controllerPath);
var idleState = controller.layers[0].stateMachine.states.First(s => s.state.name == "Idle").state;
Assert.AreEqual(1, idleState.transitions[0].conditions.Length);
Assert.AreEqual("Speed", idleState.transitions[0].conditions[0].parameter);
}
[Test]
public void ControllerAddTransition_MissingState_ReturnsError()
{
string controllerPath = $"{TempRoot}/MissStateController_{Guid.NewGuid():N}.controller";
var controller = AnimatorController.CreateAnimatorControllerAtPath(controllerPath);
controller.layers[0].stateMachine.AddState("Idle");
AssetDatabase.SaveAssets();
var paramsObj = new JObject
{
["action"] = "controller_add_transition",
["controllerPath"] = controllerPath,
["fromState"] = "Idle",
["toState"] = "Nonexistent"
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsFalse(result.Value<bool>("success"));
Assert.That(result["message"].ToString(), Does.Contain("not found"));
}
// =============================================================================
// Controller: Add Parameter
// =============================================================================
[Test]
public void ControllerAddParameter_AddsParameter()
{
string controllerPath = $"{TempRoot}/ParamController_{Guid.NewGuid():N}.controller";
AnimatorController.CreateAnimatorControllerAtPath(controllerPath);
AssetDatabase.SaveAssets();
var paramsObj = new JObject
{
["action"] = "controller_add_parameter",
["controllerPath"] = controllerPath,
["parameterName"] = "Speed",
["parameterType"] = "float",
["defaultValue"] = 1.5f
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsTrue(result.Value<bool>("success"), result.ToString());
var controller = AssetDatabase.LoadAssetAtPath<AnimatorController>(controllerPath);
Assert.IsTrue(controller.parameters.Any(p => p.name == "Speed"), "Parameter 'Speed' should exist");
var param = controller.parameters.First(p => p.name == "Speed");
Assert.AreEqual(AnimatorControllerParameterType.Float, param.type);
Assert.AreEqual(1.5f, param.defaultFloat, 0.01f);
}
[Test]
public void ControllerAddParameter_DuplicateName_ReturnsError()
{
string controllerPath = $"{TempRoot}/DupParamController_{Guid.NewGuid():N}.controller";
var controller = AnimatorController.CreateAnimatorControllerAtPath(controllerPath);
controller.AddParameter("Speed", AnimatorControllerParameterType.Float);
AssetDatabase.SaveAssets();
var paramsObj = new JObject
{
["action"] = "controller_add_parameter",
["controllerPath"] = controllerPath,
["parameterName"] = "Speed",
["parameterType"] = "float"
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsFalse(result.Value<bool>("success"));
Assert.That(result["message"].ToString(), Does.Contain("already exists"));
}
[Test]
public void ControllerAddParameter_AllTypes()
{
string controllerPath = $"{TempRoot}/AllTypesController_{Guid.NewGuid():N}.controller";
AnimatorController.CreateAnimatorControllerAtPath(controllerPath);
AssetDatabase.SaveAssets();
string[] types = { "float", "int", "bool", "trigger" };
foreach (var t in types)
{
var paramsObj = new JObject
{
["action"] = "controller_add_parameter",
["controllerPath"] = controllerPath,
["parameterName"] = $"Param_{t}",
["parameterType"] = t
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsTrue(result.Value<bool>("success"), $"Failed for type {t}: {result}");
}
var controller = AssetDatabase.LoadAssetAtPath<AnimatorController>(controllerPath);
Assert.AreEqual(4, controller.parameters.Length);
}
// =============================================================================
// Controller: Get Info
// =============================================================================
[Test]
public void ControllerGetInfo_ReturnsData()
{
string controllerPath = $"{TempRoot}/InfoController_{Guid.NewGuid():N}.controller";
var controller = AnimatorController.CreateAnimatorControllerAtPath(controllerPath);
controller.AddParameter("Speed", AnimatorControllerParameterType.Float);
var sm = controller.layers[0].stateMachine;
sm.AddState("Idle");
sm.AddState("Walk");
AssetDatabase.SaveAssets();
var paramsObj = new JObject
{
["action"] = "controller_get_info",
["controllerPath"] = controllerPath
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsTrue(result.Value<bool>("success"), result.ToString());
var data = result["data"] as JObject;
Assert.IsNotNull(data);
Assert.AreEqual(1, data.Value<int>("parameterCount"));
Assert.AreEqual(1, data.Value<int>("layerCount"));
var layers = data["layers"] as JArray;
Assert.IsNotNull(layers);
Assert.AreEqual(1, layers.Count);
}
[Test]
public void ControllerGetInfo_NotFound_ReturnsError()
{
var paramsObj = new JObject
{
["action"] = "controller_get_info",
["controllerPath"] = "Assets/Nonexistent.controller"
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsFalse(result.Value<bool>("success"));
}
// =============================================================================
// Controller: Assign
// =============================================================================
[Test]
public void ControllerAssign_AddsAnimatorAndAssigns()
{
string controllerPath = $"{TempRoot}/AssignController_{Guid.NewGuid():N}.controller";
AnimatorController.CreateAnimatorControllerAtPath(controllerPath);
AssetDatabase.SaveAssets();
var go = new GameObject("AnimTest_ControllerAssign");
try
{
Assert.IsNull(go.GetComponent<Animator>());
var paramsObj = new JObject
{
["action"] = "controller_assign",
["controllerPath"] = controllerPath,
["target"] = "AnimTest_ControllerAssign"
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsTrue(result.Value<bool>("success"), result.ToString());
var animator = go.GetComponent<Animator>();
Assert.IsNotNull(animator, "Should have added Animator component");
Assert.IsNotNull(animator.runtimeAnimatorController, "Should have assigned controller");
}
finally
{
UnityEngine.Object.DestroyImmediate(go);
}
}
// =============================================================================
// Clip: Set Vector Curve
// =============================================================================
[Test]
public void ClipSetVectorCurve_Sets3Curves()
{
string clipPath = $"{TempRoot}/VectorClip_{Guid.NewGuid():N}.anim";
var clip = new AnimationClip { name = "VectorClip" };
AssetDatabase.CreateAsset(clip, clipPath);
AssetDatabase.SaveAssets();
var paramsObj = new JObject
{
["action"] = "clip_set_vector_curve",
["clipPath"] = clipPath,
["property"] = "localPosition",
["keys"] = new JArray(
new JObject { ["time"] = 0f, ["value"] = new JArray(0f, 1f, -10f) },
new JObject { ["time"] = 1f, ["value"] = new JArray(2f, 1f, -10f) }
)
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsTrue(result.Value<bool>("success"), result.ToString());
clip = AssetDatabase.LoadAssetAtPath<AnimationClip>(clipPath);
var bindings = AnimationUtility.GetCurveBindings(clip);
// clip.SetCurve doesn't populate EditorCurve bindings — it uses legacy runtime curves
// Verify via the data response
var data = result["data"] as JObject;
Assert.IsNotNull(data);
Assert.AreEqual(2, data.Value<int>("keyframeCount"));
var curves = data["curves"] as JArray;
Assert.IsNotNull(curves);
Assert.AreEqual(3, curves.Count);
}
[Test]
public void ClipSetVectorCurve_MissingProperty_ReturnsError()
{
string clipPath = $"{TempRoot}/NoPropertyClip_{Guid.NewGuid():N}.anim";
var clip = new AnimationClip { name = "NoPropertyClip" };
AssetDatabase.CreateAsset(clip, clipPath);
AssetDatabase.SaveAssets();
var paramsObj = new JObject
{
["action"] = "clip_set_vector_curve",
["clipPath"] = clipPath,
["keys"] = new JArray(
new JObject { ["time"] = 0f, ["value"] = new JArray(0f, 0f, 0f) }
)
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsFalse(result.Value<bool>("success"));
Assert.That(result["message"].ToString(), Does.Contain("property"));
}
[Test]
public void ClipSetVectorCurve_InvalidValueFormat_ReturnsError()
{
string clipPath = $"{TempRoot}/BadValueClip_{Guid.NewGuid():N}.anim";
var clip = new AnimationClip { name = "BadValueClip" };
AssetDatabase.CreateAsset(clip, clipPath);
AssetDatabase.SaveAssets();
var paramsObj = new JObject
{
["action"] = "clip_set_vector_curve",
["clipPath"] = clipPath,
["property"] = "localPosition",
["keys"] = new JArray(
new JObject { ["time"] = 0f, ["value"] = new JArray(0f, 1f) } // Only 2 elements
)
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsFalse(result.Value<bool>("success"));
Assert.That(result["message"].ToString(), Does.Contain("3-element"));
}
// =============================================================================
// Clip: Create Preset
// =============================================================================
[Test]
public void ClipCreatePreset_Bounce_CreatesClip()
{
string clipPath = $"{TempRoot}/BouncePreset_{Guid.NewGuid():N}.anim";
var paramsObj = new JObject
{
["action"] = "clip_create_preset",
["clipPath"] = clipPath,
["preset"] = "bounce",
["duration"] = 2.0f,
["amplitude"] = 0.5f,
["loop"] = true
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsTrue(result.Value<bool>("success"), result.ToString());
var clip = AssetDatabase.LoadAssetAtPath<AnimationClip>(clipPath);
Assert.IsNotNull(clip, "Bounce preset clip should exist");
var settings = AnimationUtility.GetAnimationClipSettings(clip);
Assert.IsTrue(settings.loopTime, "Should be looping");
}
[Test]
public void ClipCreatePreset_AllPresetsCreateSuccessfully()
{
string[] presets = { "bounce", "rotate", "pulse", "fade", "shake", "hover", "spin" };
foreach (var preset in presets)
{
string clipPath = $"{TempRoot}/{preset}Preset_{Guid.NewGuid():N}.anim";
var paramsObj = new JObject
{
["action"] = "clip_create_preset",
["clipPath"] = clipPath,
["preset"] = preset
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsTrue(result.Value<bool>("success"), $"Preset '{preset}' failed: {result}");
var clip = AssetDatabase.LoadAssetAtPath<AnimationClip>(clipPath);
Assert.IsNotNull(clip, $"Clip for preset '{preset}' should exist");
}
}
[Test]
public void ClipCreatePreset_InvalidPreset_ReturnsError()
{
string clipPath = $"{TempRoot}/BadPreset_{Guid.NewGuid():N}.anim";
var paramsObj = new JObject
{
["action"] = "clip_create_preset",
["clipPath"] = clipPath,
["preset"] = "nonexistent"
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsFalse(result.Value<bool>("success"));
Assert.That(result["message"].ToString(), Does.Contain("Unknown preset"));
}
[Test]
public void ClipCreatePreset_MissingPreset_ReturnsError()
{
string clipPath = $"{TempRoot}/NoPreset_{Guid.NewGuid():N}.anim";
var paramsObj = new JObject
{
["action"] = "clip_create_preset",
["clipPath"] = clipPath
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsFalse(result.Value<bool>("success"));
Assert.That(result["message"].ToString(), Does.Contain("preset"));
}
[Test]
public void ClipCreatePreset_DuplicatePath_ReturnsError()
{
string clipPath = $"{TempRoot}/ExistingPreset.anim";
var clip = new AnimationClip { name = "ExistingPreset" };
AssetDatabase.CreateAsset(clip, clipPath);
AssetDatabase.SaveAssets();
var paramsObj = new JObject
{
["action"] = "clip_create_preset",
["clipPath"] = clipPath,
["preset"] = "bounce"
};
var result = ToJObject(ManageAnimation.HandleCommand(paramsObj));
Assert.IsFalse(result.Value<bool>("success"));
Assert.That(result["message"].ToString(), Does.Contain("already exists"));
}
}
}
