test(audience-sdk,sample): Unity-only DeviceCollector and UXML alignment drafts

Two Unity-only test fixtures the dotnet test runner cannot reach
(DeviceCollector depends on UnityEngine.SystemInfo / Application;
SampleAppUxml needs Unity test framework gating). Both run under the
Unity Test Framework once the project is opened in the editor.

DeviceCollectorTests (src/Packages/Audience/Tests/Editor/, excluded
from the headless dotnet build by Audience.Tests.csproj's
Compile Remove="Editor/**/*.cs" rule) pin DeviceCollector's emitted
key sets against GameLaunchPropertyKeys and ContextKeys, assert that
no unknown keys leak in either direction, and verify every
string-typed value is capped at Constants.MaxFieldLength.

SampleAppUxmlAlignmentTests (examples/audience/Assets/SampleApp/Tests/
Runtime/, gated by the existing UNITY_INCLUDE_TESTS define on the
SampleApp.Tests asmdef) reads Resources/AudienceSample.uxml as XML
and asserts every SampleAppUi name and Css constant that is
slug-shaped (lowercase / dashes / no spaces) appears as a name= or
class= attribute somewhere in the markup. Runtime-only CSS toggles
(state-warn, copied, narrow, has-value, etc.) are filtered by the
slug-shape heuristic so the test only flags constants that look like
they should map directly to UXML.

Both files compile cleanly. They will not run under dotnet test.
Run them via Unity Test Runner.

Follow-up to SDK-272 (centralisation of duplicated literals).

Author: ImmutableJeffrey

examples/audience/Assets/SampleApp/Tests/Runtime/SampleAppUxmlAlignmentTests.cs

@@ -0,0 +1,125 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Xml.Linq;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Immutable.Audience.Samples.SampleApp.Tests
+{
+    // Pins SampleAppUi name/class strings against AudienceSample.uxml so a rename on either side fails the test.
+    // Unity-only (UNITY_INCLUDE_TESTS gated).
+    [TestFixture]
+    internal class SampleAppUxmlAlignmentTests
+    {
+        // Names synthesised at runtime; not expected as static UXML attributes.
+        private static readonly HashSet<string> NamesNotInStaticUxml = new HashSet<string>
+        {
+            // Typed-event button/field names are built per-spec at runtime, not present as static UXML.
+        };
+
+        [Test]
+        public void EveryNameConstant_AppearsInUxmlNameAttribute()
+        {
+            var uxmlNames = ExtractAttributeValues(LoadUxmlDocument(), "name");
+            var missing = new List<string>();
+            foreach (var (path, value) in CollectStringConstants(typeof(SampleAppUi)))
+            {
+                if (NamesNotInStaticUxml.Contains(value)) continue;
+                if (!IsLikelyElementName(value)) continue;
+                if (!uxmlNames.Contains(value))
+                    missing.Add($"{path} = \"{value}\"");
+            }
+            Assert.IsEmpty(missing,
+                "SampleAppUi element-name constants missing from UXML name= attributes:\n  "
+                + string.Join("\n  ", missing));
+        }
+
+        [Test]
+        public void EveryCssClassConstant_AppearsInUxmlClassAttribute()
+        {
+            var uxmlClasses = ExtractClassTokens(LoadUxmlDocument());
+            var missing = new List<string>();
+            foreach (var (path, value) in CollectStringConstants(typeof(SampleAppUi.Css)))
+            {
+                if (!IsLikelyCssClass(value)) continue;
+                if (!uxmlClasses.Contains(value))
+                    missing.Add($"{path} = \"{value}\"");
+            }
+            // Runtime-toggled CSS classes are not in the static UXML class attributes.
+            Assert.IsEmpty(missing,
+                "SampleAppUi.Css constants are runtime-only or missing from UXML class= attributes:\n  "
+                + string.Join("\n  ", missing));
+        }
+
+        // Helpers.
+
+        private static XDocument LoadUxmlDocument()
+        {
+            // Walk up from the test binary to find the sample-app Resources directory.
+            var current = new DirectoryInfo(TestContext.CurrentContext.TestDirectory);
+            while (current != null)
+            {
+                var candidate = Path.Combine(
+                    current.FullName,
+                    "examples", "audience", "Assets", "SampleApp",
+                    "Resources", "AudienceSample.uxml");
+                if (File.Exists(candidate)) return XDocument.Load(candidate);
+                current = current.Parent;
+            }
+            throw new FileNotFoundException(
+                $"AudienceSample.uxml not found by walking up from {TestContext.CurrentContext.TestDirectory}");
+        }
+
+        private static HashSet<string> ExtractAttributeValues(XDocument doc, string attrName)
+        {
+            return new HashSet<string>(
+                doc.Descendants()
+                   .Select(e => e.Attribute(attrName)?.Value)
+                   .Where(v => !string.IsNullOrEmpty(v))
+                   .Cast<string>(),
+                StringComparer.Ordinal);
+        }
+
+        private static HashSet<string> ExtractClassTokens(XDocument doc)
+        {
+            var tokens = new HashSet<string>(StringComparer.Ordinal);
+            foreach (var attr in doc.Descendants().Select(e => e.Attribute("class")?.Value))
+                if (!string.IsNullOrEmpty(attr))
+                    foreach (var t in attr!.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries))
+                        tokens.Add(t);
+            return tokens;
+        }
+
+        // Recursively yield every public/internal const string and its dot-path
+        // identifier from the given type and any nested types.
+        private static IEnumerable<(string Path, string Value)> CollectStringConstants(Type type, string? prefix = null)
+        {
+            prefix ??= type.Name;
+            foreach (var f in type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static))
+            {
+                if (!f.IsLiteral || f.IsInitOnly) continue;
+                if (f.FieldType != typeof(string)) continue;
+                var raw = f.GetRawConstantValue();
+                if (raw is string s) yield return ($"{prefix}.{f.Name}", s);
+            }
+            foreach (var nested in type.GetNestedTypes(BindingFlags.Public | BindingFlags.NonPublic))
+                foreach (var entry in CollectStringConstants(nested, $"{prefix}.{nested.Name}"))
+                    yield return entry;
+        }
+
+        // Heuristic: UXML element names are slug-shaped (lowercase, dashes).
+        // Skip values that are clearly something else (URLs, labels,
+        // glyphs, formats, env-var names, log labels with parens, etc.).
+        private static bool IsLikelyElementName(string value) =>
+            !string.IsNullOrEmpty(value)
+            && value.IndexOfAny(new[] { ' ', '/', ':', '(', ')', '.', '"' }) < 0
+            && value.All(c => char.IsLower(c) || char.IsDigit(c) || c == '-' || c == '_');
+
+        private static bool IsLikelyCssClass(string value) => IsLikelyElementName(value);
+    }
+}

src/Packages/Audience/Tests/Editor/DeviceCollectorTests.cs

@@ -0,0 +1,113 @@
+#nullable enable
+
+using System.Collections.Generic;
+using NUnit.Framework;
+using Immutable.Audience.Unity;
+
+namespace Immutable.Audience.Tests.Editor
+{
+    // Editor-only (DeviceCollector needs a Unity domain; skipped by the headless dotnet build).
+    // Pins emitted payload keys against GameLaunchPropertyKeys and ContextKeys.
+    [TestFixture]
+    internal class DeviceCollectorTests
+    {
+        [Test]
+        public void CollectGameLaunchProperties_EmitsTheExpectedKeySet()
+        {
+            var props = DeviceCollector.CollectGameLaunchProperties();
+
+            // Always-present keys. ScreenDpi is conditional (0 on some Linux WMs).
+            CollectionAssert.Contains(props.Keys, GameLaunchPropertyKeys.Platform);
+            CollectionAssert.Contains(props.Keys, GameLaunchPropertyKeys.Version);
+            CollectionAssert.Contains(props.Keys, GameLaunchPropertyKeys.BuildGuid);
+            CollectionAssert.Contains(props.Keys, GameLaunchPropertyKeys.UnityVersion);
+            CollectionAssert.Contains(props.Keys, GameLaunchPropertyKeys.OsFamily);
+            CollectionAssert.Contains(props.Keys, GameLaunchPropertyKeys.DeviceModel);
+            CollectionAssert.Contains(props.Keys, GameLaunchPropertyKeys.Gpu);
+            CollectionAssert.Contains(props.Keys, GameLaunchPropertyKeys.GpuVendor);
+            CollectionAssert.Contains(props.Keys, GameLaunchPropertyKeys.Cpu);
+            CollectionAssert.Contains(props.Keys, GameLaunchPropertyKeys.CpuCores);
+            CollectionAssert.Contains(props.Keys, GameLaunchPropertyKeys.RamMb);
+        }
+
+        [Test]
+        public void CollectGameLaunchProperties_EmitsNoUnknownKeys()
+        {
+            // Confirms the payload only carries known GameLaunchPropertyKeys entries.
+            var allowed = new HashSet<string>
+            {
+                GameLaunchPropertyKeys.Platform,
+                GameLaunchPropertyKeys.Version,
+                GameLaunchPropertyKeys.BuildGuid,
+                GameLaunchPropertyKeys.UnityVersion,
+                GameLaunchPropertyKeys.OsFamily,
+                GameLaunchPropertyKeys.DeviceModel,
+                GameLaunchPropertyKeys.Gpu,
+                GameLaunchPropertyKeys.GpuVendor,
+                GameLaunchPropertyKeys.Cpu,
+                GameLaunchPropertyKeys.CpuCores,
+                GameLaunchPropertyKeys.RamMb,
+                GameLaunchPropertyKeys.ScreenDpi,
+            };
+
+            var props = DeviceCollector.CollectGameLaunchProperties();
+            foreach (var key in props.Keys)
+                Assert.IsTrue(allowed.Contains(key),
+                    $"DeviceCollector.CollectGameLaunchProperties emitted unknown key '{key}' "
+                    + "with no matching GameLaunchPropertyKeys constant");
+        }
+
+        [Test]
+        public void CollectGameLaunchProperties_TruncatesStringValuesToMaxFieldLength()
+        {
+            // Every string value respects MaxFieldLength; an untruncated .ToString() would fail here.
+            var props = DeviceCollector.CollectGameLaunchProperties();
+            foreach (var kv in props)
+            {
+                if (kv.Value is string s)
+                    Assert.LessOrEqual(s.Length, Constants.MaxFieldLength,
+                        $"GameLaunchPropertyKeys.{kv.Key} value exceeds Constants.MaxFieldLength");
+            }
+        }
+
+        [Test]
+        public void CollectContext_EmitsTheExpectedKeySet()
+        {
+            var ctx = DeviceCollector.CollectContext();
+
+            // UserAgent is unconditional. Timezone / Locale / Screen are
+            // best-effort and may be absent under unusual hosts.
+            CollectionAssert.Contains(ctx.Keys, ContextKeys.UserAgent);
+        }
+
+        [Test]
+        public void CollectContext_EmitsNoUnknownKeys()
+        {
+            var allowed = new HashSet<string>
+            {
+                ContextKeys.UserAgent,
+                ContextKeys.Timezone,
+                ContextKeys.Locale,
+                ContextKeys.Screen,
+            };
+
+            var ctx = DeviceCollector.CollectContext();
+            foreach (var key in ctx.Keys)
+                Assert.IsTrue(allowed.Contains(key),
+                    $"DeviceCollector.CollectContext emitted unknown key '{key}' "
+                    + "with no matching ContextKeys constant");
+        }
+
+        [Test]
+        public void CollectContext_TruncatesStringValuesToMaxFieldLength()
+        {
+            var ctx = DeviceCollector.CollectContext();
+            foreach (var kv in ctx)
+            {
+                if (kv.Value is string s)
+                    Assert.LessOrEqual(s.Length, Constants.MaxFieldLength,
+                        $"ContextKeys.{kv.Key} value exceeds Constants.MaxFieldLength");
+            }
+        }
+    }
+}