@mflrevan/ucp 0.5.2 → 0.6.1

package/bridge/com.ucp.bridge/Tests/Editor/ControllerSmokeTests.cs

@@ -307,10 +307,48 @@ namespace UCP.Bridge.Tests
             var status = _router.Dispatch("logs/status", 1, "{}");
             Assert.That(status.error, Is.Null);
 
-            var result = (Dictionary<string, object>)status.result;
-            var byLevel = (Dictionary<string, object>)result["byLevel"];
-            Assert.That(Convert.ToInt32(byLevel["error"]), Is.EqualTo(0));
-            Assert.That(Convert.ToInt32(byLevel["exception"]), Is.EqualTo(0));
+            Assert.That(status.result, Is.InstanceOf<Dictionary<string, object>>());
+
+            // Assert on the specific regression this test exists for -- `asset/search` loading
+            // `.unity` files through LoadAllAssetsAtPath, which makes Unity emit
+            // "Do not use ReadObjectThreaded on scene objects!" -- rather than on "zero errors of
+            // any kind". A blanket count also catches unrelated editor noise: on a cold Library the
+            // search pulls in lazy imports whose URP shader-fallback errors have nothing to do with
+            // this code path, which made the whole release matrix red on every Unity version.
+            var problems = BufferedProblems();
+            var threadedReadErrors = problems
+                .FindAll(entry => entry.Contains("ReadObjectThreaded"));
+
+            Assert.That(
+                threadedReadErrors,
+                Is.Empty,
+                () => "asset/search emitted threaded scene-read errors:" + NewLineIndent
+                    + string.Join(NewLineIndent, threadedReadErrors));
+        }
+
+        private const string NewLineIndent = "\n  ";
+
+        /// Buffered error/exception entries, as "[level] message" strings.
+        private List<string> BufferedProblems()
+        {
+            var lines = new List<string>();
+            var tail = _router.Dispatch("logs/tail", 1, "{\"count\":200}");
+            if (tail.error != null || tail.result is not Dictionary<string, object> payload)
+                return lines;
+
+            if (!payload.TryGetValue("logs", out var logsObj) || logsObj is not List<object> logs)
+                return lines;
+
+            foreach (var item in logs)
+            {
+                if (item is not Dictionary<string, object> entry) continue;
+                var level = entry.TryGetValue("level", out var l) ? l?.ToString() : null;
+                if (level != "error" && level != "exception") continue;
+                var message = entry.TryGetValue("messagePreview", out var m) ? m?.ToString() : "";
+                lines.Add($"[{level}] {message}");
+            }
+
+            return lines;
         }
 
         [Test]
@@ -544,7 +582,7 @@ namespace UCP.Bridge.Tests
             );
             Assert.That(getPosition.error, Is.Null);
 
-            var updated = EditorUtility.InstanceIDToObject(instanceId) as GameObject;
+            var updated = UnityObjectCompat.ResolveByInstanceId(instanceId) as GameObject;
             Assert.That(updated, Is.Not.Null);
             var localPosition = updated.transform.localPosition;
             Assert.That(localPosition.x, Is.EqualTo(1f).Within(0.001f));
@@ -556,7 +594,7 @@ namespace UCP.Bridge.Tests
 
             var delete = _router.Dispatch("object/delete", 1, "{\"instanceId\":" + instanceId + "}");
             Assert.That(delete.error, Is.Null);
-            Assert.That(EditorUtility.InstanceIDToObject(instanceId), Is.Null);
+            Assert.That(UnityObjectCompat.ResolveByInstanceId(instanceId), Is.Null);
         }
 
         [Test]
@@ -573,7 +611,7 @@ namespace UCP.Bridge.Tests
             var response = _router.Dispatch(
                 "object/set-property",
                 1,
-                "{\"instanceId\":" + go.GetInstanceID() + ",\"component\":\"ReferenceComponent\",\"property\":\"referenceAsset\",\"value\":{\"path\":\"" + TempReferenceAssetPath + "\"}}"
+                "{\"instanceId\":" + go.GetId() + ",\"component\":\"ReferenceComponent\",\"property\":\"referenceAsset\",\"value\":{\"path\":\"" + TempReferenceAssetPath + "\"}}"
             );
 
             Assert.That(response.error, Is.Null);
@@ -598,7 +636,7 @@ namespace UCP.Bridge.Tests
             var response = _router.Dispatch(
                 "object/set-property",
                 1,
-                "{\"instanceId\":" + cube.GetInstanceID() + ",\"component\":\"MeshRenderer\",\"property\":\"m_Materials\",\"value\":[{\"path\":\"" + TempMaterialPath + "\"}]}"
+                "{\"instanceId\":" + cube.GetId() + ",\"component\":\"MeshRenderer\",\"property\":\"m_Materials\",\"value\":[{\"path\":\"" + TempMaterialPath + "\"}]}"
             );
 
             Assert.That(response.error, Is.Null);
@@ -616,7 +654,7 @@ namespace UCP.Bridge.Tests
             var response = _router.Dispatch(
                 "object/set-property",
                 1,
-                "{\"instanceId\":" + go.GetInstanceID() + ",\"component\":\"ReferenceComponent\",\"property\":\"referenceAsset\",\"value\":{\"path\":\"Assets/Missing.asset\"}}"
+                "{\"instanceId\":" + go.GetId() + ",\"component\":\"ReferenceComponent\",\"property\":\"referenceAsset\",\"value\":{\"path\":\"Assets/Missing.asset\"}}"
             );
 
             Assert.That(response.error, Is.Not.Null);
@@ -990,6 +1028,62 @@ namespace UCP.Bridge.Tests
             Assert.That(UnityEngine.SceneManagement.SceneManager.GetSceneByPath(TempSceneBPath).isLoaded, Is.True);
         }
 
+        [Test]
+        public void ModalGuard_AutoSavesDirtyTitledScene_WithoutPrompting()
+        {
+            var scene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
+            Assert.That(EditorSceneManager.SaveScene(scene, TempScenePath), Is.True);
+            new GameObject("ModalGuardDirtyMaker");
+            EditorSceneManager.MarkSceneDirty(scene);
+            Assert.That(scene.isDirty, Is.True);
+
+            EditorModalGuard.SaveOpenDirtyScenes(true, true);
+
+            Assert.That(scene.isDirty, Is.False);
+            Assert.That(string.IsNullOrEmpty(scene.path), Is.False);
+        }
+
+        [Test]
+        public void ModalGuard_DiscardsDirtyUntitledScene_WhenDiscardAllowed()
+        {
+            var scene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
+            new GameObject("ModalGuardUntitledDirtyMaker");
+            EditorSceneManager.MarkSceneDirty(scene);
+            Assert.That(string.IsNullOrEmpty(scene.path), Is.True);
+            Assert.That(scene.isDirty, Is.True);
+
+            EditorModalGuard.SaveOpenDirtyScenes(true, true);
+
+            var active = UnityEngine.SceneManagement.SceneManager.GetActiveScene();
+            Assert.That(string.IsNullOrEmpty(active.path), Is.True);
+            Assert.That(active.isDirty, Is.False);
+            Assert.That(GameObject.Find("ModalGuardUntitledDirtyMaker"), Is.Null);
+        }
+
+        [Test]
+        public void ModalGuard_ThrowsOnDirtyUntitledScene_WhenDiscardDisallowed()
+        {
+            var scene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
+            new GameObject("ModalGuardUntitledDirtyMaker");
+            EditorSceneManager.MarkSceneDirty(scene);
+
+            Assert.That(
+                () => EditorModalGuard.SaveOpenDirtyScenes(true, false),
+                Throws.TypeOf<System.InvalidOperationException>());
+        }
+
+        [Test]
+        public void ModalGuard_LeavesSceneUntouched_WhenSavingDisabled()
+        {
+            var scene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
+            new GameObject("ModalGuardUntitledDirtyMaker");
+            EditorSceneManager.MarkSceneDirty(scene);
+            Assert.That(scene.isDirty, Is.True);
+
+            Assert.That(() => EditorModalGuard.SaveOpenDirtyScenes(false, false), Throws.Nothing);
+            Assert.That(UnityEngine.SceneManagement.SceneManager.GetActiveScene().isDirty, Is.True);
+        }
+
         [Test]
         public void PackagesController_DependencySetInfoAndRemove_LocalFilePackage()
         {
@@ -1071,7 +1165,7 @@ namespace UCP.Bridge.Tests
             var response = _router.Dispatch(
                 "scene/focus",
                 1,
-                "{\"instanceId\":" + cube.GetInstanceID() + ",\"axis\":[1,0,1]}"
+                "{\"instanceId\":" + cube.GetId() + ",\"axis\":[1,0,1]}"
             );
 
             Assert.That(response.error, Is.Null);
@@ -1086,9 +1180,33 @@ namespace UCP.Bridge.Tests
                 System.Convert.ToSingle(axisData[0]),
                 System.Convert.ToSingle(axisData[1]),
                 System.Convert.ToSingle(axisData[2]));
-            var actualForward = sceneView.camera.transform.forward;
             Assert.That(Vector3.Dot(returnedAxis.normalized, expectedDirection), Is.GreaterThan(0.98f));
-            Assert.That(Mathf.Abs(Vector3.Dot(actualForward.normalized, expectedDirection)), Is.GreaterThan(0.98f));
+
+            // Assert against the Scene view's own state and the reported pose, not
+            // `sceneView.camera.transform`: that transform is only synced when the view repaints,
+            // so in batch mode it still holds the pre-focus pose and this check used to fail.
+            var viewForward = sceneView.rotation * Vector3.forward;
+            Assert.That(Mathf.Abs(Vector3.Dot(viewForward.normalized, expectedDirection)), Is.GreaterThan(0.98f));
+
+            var eulerData = (List<object>)result["cameraRotationEuler"];
+            var reportedForward = Quaternion.Euler(
+                System.Convert.ToSingle(eulerData[0]),
+                System.Convert.ToSingle(eulerData[1]),
+                System.Convert.ToSingle(eulerData[2])) * Vector3.forward;
+            Assert.That(
+                Mathf.Abs(Vector3.Dot(reportedForward.normalized, expectedDirection)),
+                Is.GreaterThan(0.98f),
+                "scene/focus must report the pose it just applied, not the last rendered one");
+
+            // The reported camera must sit behind the pivot along its own forward axis.
+            var positionData = (List<object>)result["cameraPosition"];
+            var reportedPosition = new Vector3(
+                System.Convert.ToSingle(positionData[0]),
+                System.Convert.ToSingle(positionData[1]),
+                System.Convert.ToSingle(positionData[2]));
+            Assert.That(Vector3.Dot((sceneView.pivot - reportedPosition).normalized, reportedForward.normalized),
+                Is.GreaterThan(0.98f));
+
             Assert.That(Vector3.Distance(sceneView.pivot, cube.transform.position), Is.LessThan(2f));
         }
 
@@ -1102,7 +1220,7 @@ namespace UCP.Bridge.Tests
             var response = _router.Dispatch(
                 "scene/focus",
                 1,
-                "{\"instanceId\":" + cube.GetInstanceID() + ",\"axis\":[0,0,0]}"
+                "{\"instanceId\":" + cube.GetId() + ",\"axis\":[0,0,0]}"
             );
 
             Assert.That(response.error, Is.Not.Null);

package/bridge/com.ucp.bridge/Tests/Editor/MiniJsonSerializerTests.cs

@@ -0,0 +1,221 @@
+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace UCP.Bridge.Tests
+{
+    /// <summary>
+    /// Regression coverage for the serializer that turns arbitrary <see cref="IUCPScript"/> return
+    /// values into JSON. The reflection walk used to be unbounded, so returning anything holding a
+    /// UnityEngine math struct (Vector3.normalized returns another Vector3, forever) overflowed the
+    /// stack -- which .NET cannot catch and which killed the editor process outright.
+    /// </summary>
+    public class MiniJsonSerializerTests
+    {
+        private static Dictionary<string, object> Roundtrip(object value)
+        {
+            var json = MiniJson.Serialize(new { value });
+            var parsed = MiniJson.Deserialize(json) as Dictionary<string, object>;
+            Assert.IsNotNull(parsed, $"Serializer produced unparseable JSON: {json}");
+            return parsed;
+        }
+
+        [Test]
+        public void SerializesVector3WithoutStackOverflow()
+        {
+            // The original crash repro: `return new { pos = Vector3.zero }` from a UCP script.
+            var json = MiniJson.Serialize(new { pos = Vector3.zero });
+
+            Assert.AreEqual("{\"pos\":{\"x\":0,\"y\":0,\"z\":0}}", json);
+        }
+
+        [Test]
+        public void SerializesUnityMathStructsAsPlainShapes()
+        {
+            Assert.AreEqual("{\"x\":1,\"y\":2}", MiniJson.Serialize(new Vector2(1f, 2f)));
+            Assert.AreEqual("{\"x\":1,\"y\":2,\"z\":3,\"w\":4}", MiniJson.Serialize(new Vector4(1f, 2f, 3f, 4f)));
+            Assert.AreEqual("{\"x\":0,\"y\":0,\"z\":0,\"w\":1}", MiniJson.Serialize(Quaternion.identity));
+            Assert.AreEqual("{\"r\":1,\"g\":0,\"b\":0,\"a\":1}", MiniJson.Serialize(Color.red));
+            Assert.AreEqual("{\"x\":1,\"y\":2,\"z\":3}", MiniJson.Serialize(new Vector3Int(1, 2, 3)));
+            Assert.AreEqual(
+                "{\"x\":1,\"y\":2,\"width\":3,\"height\":4}",
+                MiniJson.Serialize(new Rect(1f, 2f, 3f, 4f)));
+            Assert.AreEqual(
+                "{\"center\":{\"x\":0,\"y\":0,\"z\":0},\"size\":{\"x\":2,\"y\":2,\"z\":2}}",
+                MiniJson.Serialize(new Bounds(Vector3.zero, Vector3.one * 2f)));
+        }
+
+        [Test]
+        public void SerializesQuaternionNestedInAnonymousResult()
+        {
+            var parsed = Roundtrip(new { rot = Quaternion.Euler(0f, 90f, 0f), pos = Vector3.one });
+            Assert.IsInstanceOf<Dictionary<string, object>>(parsed["value"]);
+        }
+
+        [Test]
+        public void SerializesUnityObjectAsIdentityInsteadOfWalkingTheSceneGraph()
+        {
+            var go = new GameObject("MiniJsonProbe");
+            try
+            {
+                // GameObject.transform.gameObject is a cycle; walking it never terminates.
+                var parsed = Roundtrip(go);
+                var identity = (Dictionary<string, object>)parsed["value"];
+
+                Assert.AreEqual("MiniJsonProbe", identity["name"]);
+                Assert.AreEqual("GameObject", identity["type"]);
+                Assert.IsTrue(identity.ContainsKey("instanceId"));
+
+                // Components are the same story via Component.gameObject.
+                var componentJson = MiniJson.Serialize(go.transform);
+                Assert.IsTrue(componentJson.Contains("\"type\":\"Transform\""), componentJson);
+            }
+            finally
+            {
+                UnityEngine.Object.DestroyImmediate(go);
+            }
+        }
+
+        [Test]
+        public void DestroyedUnityObjectSerializesAsNull()
+        {
+            var go = new GameObject("MiniJsonDestroyed");
+            UnityEngine.Object.DestroyImmediate(go);
+
+            Assert.AreEqual("{\"value\":null}", MiniJson.Serialize(new { value = go }));
+        }
+
+        [Test]
+        public void ReferenceCyclesAreBrokenInsteadOfRecursingForever()
+        {
+            var a = new Node { Label = "a" };
+            var b = new Node { Label = "b", Next = a };
+            a.Next = b;
+
+            var json = MiniJson.Serialize(a);
+
+            Assert.IsTrue(json.Contains("<ucp:cycle>"), json);
+            Assert.IsNotNull(MiniJson.Deserialize(json));
+        }
+
+        [Test]
+        public void SelfReferencingDictionaryIsBroken()
+        {
+            var dict = new Dictionary<string, object> { ["name"] = "root" };
+            dict["self"] = dict;
+
+            var json = MiniJson.Serialize(dict);
+
+            Assert.IsTrue(json.Contains("<ucp:cycle>"), json);
+            Assert.IsNotNull(MiniJson.Deserialize(json));
+        }
+
+        [Test]
+        public void UnboundedComputedPropertyRecursionIsDepthCapped()
+        {
+            // Mirrors the Vector3.normalized shape for a type the serializer has no special case
+            // for: every read allocates a fresh instance, so reference tracking cannot help and
+            // only the depth cap prevents a stack overflow.
+            var json = MiniJson.Serialize(new Fractal());
+
+            Assert.IsTrue(json.Contains("<ucp:max-depth>"), json);
+            Assert.IsNotNull(MiniJson.Deserialize(json));
+        }
+
+        [Test]
+        public void ThrowingGetterDoesNotCorruptTheDocument()
+        {
+            var json = MiniJson.Serialize(new Explosive());
+
+            Assert.IsFalse(json.Contains("boom"), json);
+            var parsed = MiniJson.Deserialize(json) as Dictionary<string, object>;
+            Assert.IsNotNull(parsed, json);
+            Assert.AreEqual("ok", parsed["safe"]);
+        }
+
+        [Test]
+        public void NonFiniteFloatsSerializeAsNullRatherThanInvalidJson()
+        {
+            // Degenerate bounds and zero-length normalize hand out NaN routinely; raw NaN/Infinity
+            // are not valid JSON and made the whole response unparseable on the CLI side.
+            var json = MiniJson.Serialize(new { a = float.NaN, b = float.PositiveInfinity, c = double.NaN });
+
+            Assert.AreEqual("{\"a\":null,\"b\":null,\"c\":null}", json);
+            Assert.IsNotNull(MiniJson.Deserialize(json));
+        }
+
+        [Test]
+        public void UnsignedAndWideIntegersSerializeAsNumbers()
+        {
+            var json = MiniJson.Serialize(new { a = (uint)7, b = (ushort)8, c = (byte)9, d = 10UL });
+
+            Assert.AreEqual("{\"a\":7,\"b\":8,\"c\":9,\"d\":10}", json);
+        }
+
+        [Test]
+        public void NonListEnumerablesSerializeAsArrays()
+        {
+            var json = MiniJson.Serialize(new { items = new HashSet<int> { 1 } });
+
+            Assert.AreEqual("{\"items\":[1]}", json);
+        }
+
+        [Test]
+        public void EnumsStillSerializeAsIntegers()
+        {
+            Assert.AreEqual("{\"value\":2}", MiniJson.Serialize(new { value = SampleEnum.Two }));
+        }
+
+        [Test]
+        public void ParserRejectsTruncatedInputInsteadOfHanging()
+        {
+            // A truncated string literal used to spin the reader on end-of-input forever, wedging
+            // the editor's main thread.
+            Assert.Throws<FormatException>(() => MiniJson.Deserialize("{\"a\": \"unterminated"));
+        }
+
+        [Test]
+        public void ParserRejectsPathologicallyNestedInput()
+        {
+            var deep = new string('[', 1000);
+            Assert.Throws<FormatException>(() => MiniJson.Deserialize(deep));
+        }
+
+        [Test]
+        public void OrdinaryPayloadsAreUnchanged()
+        {
+            var json = MiniJson.Serialize(new Dictionary<string, object>
+            {
+                ["name"] = "cube",
+                ["active"] = true,
+                ["children"] = new List<object> { 1L, 2.5, null },
+            });
+
+            Assert.AreEqual("{\"name\":\"cube\",\"active\":true,\"children\":[1,2.5,null]}", json);
+        }
+
+        private enum SampleEnum
+        {
+            One = 1,
+            Two = 2,
+        }
+
+        private sealed class Node
+        {
+            public string Label;
+            public Node Next;
+        }
+
+        private sealed class Fractal
+        {
+            public Fractal Child => new Fractal();
+        }
+
+        private sealed class Explosive
+        {
+            public string Safe => "ok";
+            public string Boom => throw new InvalidOperationException("boom");
+        }
+    }
+}

package/bridge/com.ucp.bridge/Tests/Editor/MiniJsonSerializerTests.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 5082955dbcce78c4986000348e3a5d92