Add Unity Pipeline package support

2026-07-31 17:34:04 +08:00
parent d1a526094e
commit 786b7ffff9
590 changed files with 51995 additions and 2 deletions
@@ -0,0 +1,177 @@
+using System.Linq;
+using NUnit.Framework;
+using Unity.Pipeline.Editor.Authoring;
+using Unity.Pipeline.Editor.Commands.Materials;
+using Unity.Pipeline.Models;
+using UnityEditor;
+using UnityEngine;
+
+namespace Unity.Pipeline.Tests.Editor.Materials
+{
+    /// <summary>
+    /// Tests for the CLI-213 shader discovery / introspection commands (list_shaders /
+    /// get_shader_properties). URP-specific assertions are guarded with Assert.Ignore so the suite runs
+    /// on a Built-in RP project too.
+    /// </summary>
+    public class ShaderCommandsTests
+    {
+        private bool m_HasUrpLit;
+
+        [SetUp]
+        public void SetUp()
+        {
+            ProjectPaths.ResetAuthoringRoot();
+            m_HasUrpLit = Shader.Find("Universal Render Pipeline/Lit") != null;
+        }
+
+        [TearDown]
+        public void TearDown() => ProjectPaths.ResetAuthoringRoot();
+
+        // ---- list_shaders -------------------------------------------------------------------------
+
+        [Test]
+        public void ListShaders_FilterLit_ReturnsTheLitShader()
+        {
+            var results = ShaderCommands.ListShaders(filter: "Lit");
+
+            Assert.IsNotEmpty(results, "filtering by 'Lit' should return at least one shader");
+            Assert.IsTrue(results.All(s => s.Name.IndexOf("Lit", System.StringComparison.OrdinalIgnoreCase) >= 0),
+                "every result should contain the filter substring");
+
+            // Only assert the specific shader name when URP/Lit is present; this branch never runs
+            // otherwise, so a plain constant keeps the intent clear.
+            if (m_HasUrpLit)
+                Assert.IsTrue(results.Any(s => s.Name == "Universal Render Pipeline/Lit"),
+                    "the active pipeline's Lit shader should be listed (AC #10)");
+        }
+
+        [Test]
+        public void ListShaders_ReportsIsSupportedAndName()
+        {
+            var results = ShaderCommands.ListShaders(filter: "Lit", limit: 50);
+            if (results.Count == 0)
+                Assert.Ignore("No 'Lit' shaders in this project.");
+
+            foreach (var s in results)
+                Assert.IsFalse(string.IsNullOrEmpty(s.Name), "every shader entry must carry a name");
+            // isSupported is a bool that always serializes; just assert the field is meaningful for a known shader.
+            var known = results.FirstOrDefault();
+            Assert.IsNotNull(known);
+        }
+
+        [Test]
+        public void ListShaders_RespectsLimit()
+        {
+            var results = ShaderCommands.ListShaders(limit: 3);
+            Assert.LessOrEqual(results.Count, 3, "limit should cap the result count");
+        }
+
+        [Test]
+        public void ListShaders_ExcludeBuiltin_DropsEngineShaders()
+        {
+            var withBuiltin = ShaderCommands.ListShaders(includeBuiltin: true);
+            var withoutBuiltin = ShaderCommands.ListShaders(includeBuiltin: false);
+
+            Assert.IsFalse(withoutBuiltin.Any(s => s.IsBuiltin),
+                "includeBuiltin=false must not return any built-in shaders");
+            Assert.GreaterOrEqual(withBuiltin.Count, withoutBuiltin.Count);
+        }
+
+        // ---- get_shader_properties ----------------------------------------------------------------
+
+        [Test]
+        public void GetShaderProperties_Urp_ReturnsBaseColorMetallicBaseMap()
+        {
+            if (!m_HasUrpLit)
+                Assert.Ignore("URP/Lit not available; skipping URP property introspection (AC #11).");
+
+            var result = ShaderCommands.GetShaderProperties(shader: "Universal Render Pipeline/Lit");
+            Assert.AreEqual("Universal Render Pipeline/Lit", result.Shader);
+
+            var baseColor = result.Properties.FirstOrDefault(p => p.Name == "_BaseColor");
+            Assert.IsNotNull(baseColor, "_BaseColor should be present");
+            Assert.AreEqual("Color", baseColor.Type);
+
+            var metallic = result.Properties.FirstOrDefault(p => p.Name == "_Metallic");
+            Assert.IsNotNull(metallic, "_Metallic should be present");
+            Assert.AreEqual("Range", metallic.Type);
+            Assert.IsNotNull(metallic.Range, "_Metallic should carry min/max");
+
+            var baseMap = result.Properties.FirstOrDefault(p => p.Name == "_BaseMap");
+            Assert.IsNotNull(baseMap, "_BaseMap should be present");
+            Assert.AreEqual("TexEnv", baseMap.Type);
+            Assert.AreEqual("Tex2D", baseMap.TextureDimension);
+        }
+
+        [Test]
+        public void GetShaderProperties_KnownShader_ReturnsProperties()
+        {
+            // Shader-agnostic: any real shader exposes a non-empty property list with names + types.
+            var shaderName = m_HasUrpLit ? "Universal Render Pipeline/Lit"
+                : (Shader.Find("Standard") != null ? "Standard" : "Sprites/Default");
+
+            var result = ShaderCommands.GetShaderProperties(shader: shaderName);
+            Assert.AreEqual(shaderName, result.Shader);
+            Assert.IsNotEmpty(result.Properties);
+            foreach (var p in result.Properties)
+            {
+                Assert.IsFalse(string.IsNullOrEmpty(p.Name));
+                Assert.IsFalse(string.IsNullOrEmpty(p.Type));
+                Assert.IsNotNull(p.Flags, "flags should never be null (empty list when None)");
+            }
+        }
+
+        [Test]
+        public void GetShaderProperties_FromMaterial_ReadsShaderOffMaterial()
+        {
+            var shaderName = Shader.Find("Standard") != null ? "Standard"
+                : (m_HasUrpLit ? "Universal Render Pipeline/Lit" : "Sprites/Default");
+
+            var folder = "Assets/__CLI213ShaderTest";
+            if (!AssetDatabase.IsValidFolder(folder))
+                AssetDatabase.CreateFolder("Assets", "__CLI213ShaderTest");
+            try
+            {
+                var path = $"{folder}/Mat.mat";
+                AssetDatabase.CreateAsset(new Material(Shader.Find(shaderName)), path);
+                AssetDatabase.SaveAssets();
+
+                var result = ShaderCommands.GetShaderProperties(material: new ObjectRef { Path = path });
+                Assert.AreEqual(shaderName, result.Shader);
+                Assert.IsNotEmpty(result.Properties);
+            }
+            finally
+            {
+                AssetDatabase.DeleteAsset(folder);
+                AssetDatabase.Refresh();
+            }
+        }
+
+        [Test]
+        public void GetShaderProperties_NotFound_Throws()
+        {
+            var ex = Assert.Throws<ShaderNotFoundException>(() =>
+                ShaderCommands.GetShaderProperties(shader: "No/Such/Shader__CLI213"));
+            StringAssert.Contains("shader_not_found", ex.Message);
+        }
+
+        [Test]
+        public void GetShaderProperties_NeitherArg_Throws()
+        {
+            Assert.Throws<System.ArgumentException>(() => ShaderCommands.GetShaderProperties());
+        }
+
+        // ---- ViaClient ----------------------------------------------------------------------------
+
+        [Test]
+        public void ListShaders_ViaClient_Succeeds()
+        {
+            using (var server = new PipelineTestServer())
+            {
+                var response = server.Execute("list_shaders", new { filter = "Lit", limit = 20 });
+                Assert.IsTrue(response.IsSuccess, $"list_shaders should succeed: {response.Error}");
+                Assert.IsTrue(response.HasValidJson, "response should be valid JSON");
+            }
+        }
+    }
+}