Update UnityDataTool.Tests/SerializedFileCommandTests.cs

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: SkowronskiAndrew

UnityDataTool.Tests/SerializedFileCommandTests.cs

@@ -492,6 +492,134 @@ public async Task Metadata_LegacyVersion_ReturnsError()
         }
     }
 
+    [Test]
+    public async Task Metadata_TextOutput_SucceedsAndContainsExpectedFields()
+    {
+        // Use PlayerWithTypeTrees test data, which is known to be a supported SerializedFile
+        // with TypeTrees enabled.
+        var dataDir = Path.Combine(TestContext.CurrentContext.TestDirectory, "Data", "PlayerWithTypeTrees");
+        var serializedFilePath = Path.Combine(dataDir, "globalgamemanagers");
+
+        if (!File.Exists(serializedFilePath))
+        {
+            Assert.Ignore("PlayerWithTypeTrees serialized file not found");
+            return;
+        }
+
+        using var sw = new StringWriter();
+        var currentOut = Console.Out;
+        try
+        {
+            Console.SetOut(sw);
+
+            var result = await Program.Main(new string[]
+            {
+                "serialized-file",
+                "metadata",
+                serializedFilePath
+            });
+
+            Assert.AreEqual(0, result, "Metadata command should succeed for supported file");
+
+            var output = sw.ToString();
+
+            // Basic sanity checks on text output; exact formatting is left flexible,
+            // but the output should mention metadata and TypeTree-related information.
+            StringAssert.Contains("Metadata", output, "Text output should mention metadata");
+            StringAssert.Contains("Type", output, "Text output should mention type information");
+            StringAssert.Contains("Tree", output, "Text output should mention TypeTree information");
+        }
+        finally
+        {
+            Console.SetOut(currentOut);
+        }
+    }
+
+    [Test]
+    public async Task Metadata_JsonOutput_SucceedsAndContainsTypeTreeInfo()
+    {
+        // Use PlayerWithTypeTrees test data to validate JSON metadata output,
+        // including TypeTree-related properties.
+        var dataDir = Path.Combine(TestContext.CurrentContext.TestDirectory, "Data", "PlayerWithTypeTrees");
+        var serializedFilePath = Path.Combine(dataDir, "globalgamemanagers");
+
+        if (!File.Exists(serializedFilePath))
+        {
+            Assert.Ignore("PlayerWithTypeTrees serialized file not found");
+            return;
+        }
+
+        using var sw = new StringWriter();
+        var currentOut = Console.Out;
+        try
+        {
+            Console.SetOut(sw);
+
+            var result = await Program.Main(new string[]
+            {
+                "serialized-file",
+                "metadata",
+                serializedFilePath,
+                "-f",
+                "json"
+            });
+
+            Assert.AreEqual(0, result, "Metadata command should succeed for supported file in JSON mode");
+
+            var output = sw.ToString();
+            Assert.IsNotEmpty(output, "JSON output should not be empty");
+
+            using var doc = JsonDocument.Parse(output);
+            var root = doc.RootElement;
+
+            Assert.AreEqual(JsonValueKind.Object, root.ValueKind, "Root JSON element should be an object");
+
+            // Validate the presence of some core metadata properties.
+            Assert.IsTrue(root.TryGetProperty("filePath", out _)
+                          || root.TryGetProperty("path", out _),
+                "JSON metadata should contain a file path property");
+
+            Assert.IsTrue(root.TryGetProperty("unityVersion", out _)
+                          || root.TryGetProperty("version", out _),
+                "JSON metadata should contain a Unity version property");
+
+            // Validate TypeTree-related information: either a count or an array of TypeTrees.
+            JsonElement typeTreesElement;
+            bool hasTypeTrees =
+                root.TryGetProperty("typeTrees", out typeTreesElement) ||
+                root.TryGetProperty("typeTree", out typeTreesElement) ||
+                root.TryGetProperty("typeTreeInfos", out typeTreesElement);
+
+            Assert.IsTrue(hasTypeTrees, "JSON metadata should contain TypeTree information");
+
+            if (typeTreesElement.ValueKind == JsonValueKind.Array)
+            {
+                Assert.Greater(typeTreesElement.GetArrayLength(), 0, "TypeTree array should contain at least one entry");
+
+                var first = typeTreesElement[0];
+                Assert.AreEqual(JsonValueKind.Object, first.ValueKind, "Each TypeTree entry should be an object");
+
+                // Check for some typical fields on a TypeTree entry (IDs/counts/arrays).
+                Assert.IsTrue(first.TryGetProperty("typeId", out _)
+                              || first.TryGetProperty("classId", out _),
+                    "TypeTree entry should contain a type or class ID");
+
+                Assert.IsTrue(first.TryGetProperty("nodes", out var nodesElement)
+                              ? nodesElement.ValueKind == JsonValueKind.Array
+                              : true,
+                    "If present, TypeTree nodes should be an array");
+            }
+            else if (typeTreesElement.ValueKind == JsonValueKind.Number)
+            {
+                // Some formats may expose only a count.
+                Assert.Greater(typeTreesElement.GetInt32(), 0, "TypeTree count should be greater than zero");
+            }
+        }
+        finally
+        {
+            Console.SetOut(currentOut);
+        }
+    }
     #endregion
 
     #region Cross-Validation with Analyze Command