refactor(audience): identity and consent strings, SDK test pinning (SDK-277)

examples/audience/Assets/SampleApp/Scripts/SampleAppUi.cs

@@ -310,13 +310,13 @@ internal static class LogLabels
         }
 
         // ---- Consent dropdown / status values ----
-        // Mirrors ConsentLevel.ToLowercaseString().
+        // Mirrors ConsentLevel.ToLowercaseString() so the sample-app stays aligned with SDK output.
 
         internal static class Consent
         {
-            internal const string None = "none";
-            internal const string Anonymous = "anonymous";
-            internal const string Full = "full";
+            internal const string None = ConsentLevelWireFormat.None;
+            internal const string Anonymous = ConsentLevelWireFormat.Anonymous;
+            internal const string Full = ConsentLevelWireFormat.Full;
         }
 
         // Log payload JSON keys used by RunAndLog "Ok" row dictionaries.

src/Packages/Audience/Runtime/ConsentLevel.cs

@@ -28,13 +28,21 @@ public enum ConsentLevel
         Full
     }
 
+    // Strings the SDK emits for ConsentLevel.
+    internal static class ConsentLevelWireFormat
+    {
+        internal const string None = "none";
+        internal const string Anonymous = "anonymous";
+        internal const string Full = "full";
+    }
+
     internal static class ConsentLevelExtensions
     {
         internal static string ToLowercaseString(this ConsentLevel level) => level switch
         {
-            ConsentLevel.None => "none",
-            ConsentLevel.Anonymous => "anonymous",
-            ConsentLevel.Full => "full",
+            ConsentLevel.None => ConsentLevelWireFormat.None,
+            ConsentLevel.Anonymous => ConsentLevelWireFormat.Anonymous,
+            ConsentLevel.Full => ConsentLevelWireFormat.Full,
             _ => throw new System.ArgumentOutOfRangeException(
                 nameof(level), level, "Unhandled ConsentLevel"),
         };

src/Packages/Audience/Runtime/IdentityType.cs

@@ -37,6 +37,19 @@ public enum IdentityType
         Custom,
     }
 
+    // Strings emitted under MessageFields.IdentityType.
+    internal static class IdentityTypeWireFormat
+    {
+        internal const string Passport = "passport";
+        internal const string Steam = "steam";
+        internal const string Epic = "epic";
+        internal const string Google = "google";
+        internal const string Apple = "apple";
+        internal const string Discord = "discord";
+        internal const string Email = "email";
+        internal const string Custom = "custom";
+    }
+
     internal static class IdentityTypeExtensions
     {
         // Throws on unknown casts. Every identify / alias event must carry an
@@ -45,28 +58,28 @@ internal static class IdentityTypeExtensions
         // loudly rather than ship an event with a missing or empty namespace.
         internal static string ToLowercaseString(this IdentityType type) => type switch
         {
-            IdentityType.Passport => "passport",
-            IdentityType.Steam => "steam",
-            IdentityType.Epic => "epic",
-            IdentityType.Google => "google",
-            IdentityType.Apple => "apple",
-            IdentityType.Discord => "discord",
-            IdentityType.Email => "email",
-            IdentityType.Custom => "custom",
+            IdentityType.Passport => IdentityTypeWireFormat.Passport,
+            IdentityType.Steam => IdentityTypeWireFormat.Steam,
+            IdentityType.Epic => IdentityTypeWireFormat.Epic,
+            IdentityType.Google => IdentityTypeWireFormat.Google,
+            IdentityType.Apple => IdentityTypeWireFormat.Apple,
+            IdentityType.Discord => IdentityTypeWireFormat.Discord,
+            IdentityType.Email => IdentityTypeWireFormat.Email,
+            IdentityType.Custom => IdentityTypeWireFormat.Custom,
             _ => throw new System.ArgumentOutOfRangeException(nameof(type), type,
                 "Unknown IdentityType value; cast an out-of-range value."),
         };
 
         internal static IdentityType ParseLowercaseString(string? value) =>
             (value ?? string.Empty).ToLowerInvariant() switch
             {
-                "passport" => IdentityType.Passport,
-                "steam" => IdentityType.Steam,
-                "epic" => IdentityType.Epic,
-                "google" => IdentityType.Google,
-                "apple" => IdentityType.Apple,
-                "discord" => IdentityType.Discord,
-                "email" => IdentityType.Email,
+                IdentityTypeWireFormat.Passport => IdentityType.Passport,
+                IdentityTypeWireFormat.Steam => IdentityType.Steam,
+                IdentityTypeWireFormat.Epic => IdentityType.Epic,
+                IdentityTypeWireFormat.Google => IdentityType.Google,
+                IdentityTypeWireFormat.Apple => IdentityType.Apple,
+                IdentityTypeWireFormat.Discord => IdentityType.Discord,
+                IdentityTypeWireFormat.Email => IdentityType.Email,
                 _ => IdentityType.Custom,
             };
     }

src/Packages/Audience/Runtime/Utility/Log.cs

@@ -85,6 +85,10 @@ internal static string ConsentSyncThrew(Exception ex) =>
 
     internal static class AudienceLogs
     {
+        // Marker shared by Track / Identify / Alias dropped-event log messages.
+        internal const string DroppingMarker = "Dropping";
+
+
         // ---- Init / config validation ----
 
         internal const string InitCalledTwice =

src/Packages/Audience/Tests/Runtime/ConsentLevelTests.cs

@@ -6,14 +6,23 @@ namespace Immutable.Audience.Tests
     [TestFixture]
     internal class ConsentLevelTests
     {
-        [TestCase(ConsentLevel.None, "none")]
-        [TestCase(ConsentLevel.Anonymous, "anonymous")]
-        [TestCase(ConsentLevel.Full, "full")]
+        [TestCase(ConsentLevel.None, ConsentLevelWireFormat.None)]
+        [TestCase(ConsentLevel.Anonymous, ConsentLevelWireFormat.Anonymous)]
+        [TestCase(ConsentLevel.Full, ConsentLevelWireFormat.Full)]
         public void ToLowercaseString_MapsEachEnumValueToLowercaseBackendString(ConsentLevel level, string expected)
         {
             Assert.AreEqual(expected, level.ToLowercaseString());
         }
 
+        [Test]
+        public void ConsentLevelWireFormat_PinsExactStringValues()
+        {
+            // Pins each emitted string directly so a typo or backend rename fails the build.
+            Assert.AreEqual("none", ConsentLevelWireFormat.None);
+            Assert.AreEqual("anonymous", ConsentLevelWireFormat.Anonymous);
+            Assert.AreEqual("full", ConsentLevelWireFormat.Full);
+        }
+
         [Test]
         public void ToLowercaseString_UnknownValue_Throws()
         {

src/Packages/Audience/Tests/Runtime/ConsentSyncTests.cs

@@ -12,6 +12,10 @@ namespace Immutable.Audience.Tests
     [TestFixture]
     internal class ConsentSyncTests
     {
+        // Standard HTTP header name (RFC 7231) the mock CapturingHandler sets
+        // on 429 responses to override the SDK's default backoff.
+        private const string RetryAfterHeader = "Retry-After";
+
         private string _testDir;
 
         [SetUp]
@@ -223,7 +227,7 @@ protected override async Task<HttpResponseMessage> SendAsync(
                 var response = new HttpResponseMessage(status);
                 if ((int)status == 429 && RetryAfterSeconds.HasValue)
                 {
-                    response.Headers.Add("Retry-After", RetryAfterSeconds.Value.ToString());
+                    response.Headers.Add(RetryAfterHeader, RetryAfterSeconds.Value.ToString());
                 }
                 return response;
             }

src/Packages/Audience/Tests/Runtime/Core/SessionTests.cs

@@ -10,6 +10,9 @@ namespace Immutable.Audience.Tests
     [TestFixture]
     internal class SessionTests
     {
+        // Exception thrown by the ThrowingTrack sabotage delegate across four scenarios.
+        private const string TrackExplodeMessage = "track explode";
+
         private List<(string name, Dictionary<string, object> props)> _events;
 
         [SetUp]
@@ -546,7 +549,7 @@ public void OnHeartbeat_TrackCallbackThrows_DoesNotEscape()
                 void ThrowingTrack(string name, Dictionary<string, object> props)
                 {
                     if (name == EventNames.SessionHeartbeat)
-                        throw new InvalidOperationException("track explode");
+                        throw new InvalidOperationException(TrackExplodeMessage);
                 }
 
                 using var session = new Session(ThrowingTrack);
@@ -581,7 +584,7 @@ public void Start_TrackCallbackThrows_DoesNotEscape()
                 void ThrowingTrack(string name, Dictionary<string, object> props)
                 {
                     if (name == EventNames.SessionStart)
-                        throw new InvalidOperationException("track explode");
+                        throw new InvalidOperationException(TrackExplodeMessage);
                 }
 
                 using var session = new Session(ThrowingTrack);
@@ -616,7 +619,7 @@ public void End_TrackCallbackThrows_DoesNotEscape()
                 void ThrowingTrack(string name, Dictionary<string, object> props)
                 {
                     if (name == EventNames.SessionEnd)
-                        throw new InvalidOperationException("track explode");
+                        throw new InvalidOperationException(TrackExplodeMessage);
                 }
 
                 using var session = new Session(ThrowingTrack);
@@ -652,7 +655,7 @@ public void SafeTrack_LogWriterThrows_DoesNotEscape()
                 void ThrowingTrack(string name, Dictionary<string, object> props)
                 {
                     if (name == EventNames.SessionHeartbeat)
-                        throw new InvalidOperationException("track explode");
+                        throw new InvalidOperationException(TrackExplodeMessage);
                 }
 
                 using var session = new Session(ThrowingTrack);

src/Packages/Audience/Tests/Runtime/Events/TypedEventTests.cs

@@ -18,7 +18,7 @@ public void Progression_WithoutStatus_ThrowsOnToProperties()
             var evt = new Progression { World = TestFixtures.ProgressionWorldTutorial };
 
             var ex = Assert.Throws<ArgumentException>(() => evt.ToProperties());
-            Assert.That(ex!.Message, Does.Contain("Status"));
+            Assert.That(ex!.Message, Does.Contain(nameof(Progression.Status)));
         }
 
         [Test]
@@ -88,7 +88,7 @@ public void Resource_WithoutFlow_ThrowsOnToProperties()
             var evt = new Resource { Currency = TestFixtures.ResourceCurrency, Amount = 100 };
 
             var ex = Assert.Throws<ArgumentException>(() => evt.ToProperties());
-            Assert.That(ex!.Message, Does.Contain("Flow"));
+            Assert.That(ex!.Message, Does.Contain(nameof(Resource.Flow)));
         }
 
         [Test]
@@ -97,7 +97,7 @@ public void Resource_WithoutCurrency_ThrowsOnToProperties()
             var evt = new Resource { Flow = ResourceFlow.Source, Amount = 100 };
 
             var ex = Assert.Throws<ArgumentException>(() => evt.ToProperties());
-            Assert.That(ex!.Message, Does.Contain("Currency"));
+            Assert.That(ex!.Message, Does.Contain(nameof(Resource.Currency)));
         }
 
         [Test]
@@ -106,7 +106,7 @@ public void Resource_WithoutAmount_ThrowsOnToProperties()
             var evt = new Resource { Flow = ResourceFlow.Source, Currency = TestFixtures.ResourceCurrency };
 
             var ex = Assert.Throws<ArgumentException>(() => evt.ToProperties());
-            Assert.That(ex!.Message, Does.Contain("Amount"));
+            Assert.That(ex!.Message, Does.Contain(nameof(Resource.Amount)));
         }
 
         [Test]
@@ -157,7 +157,7 @@ public void Purchase_WithoutCurrency_ThrowsOnToProperties()
             var evt = new Purchase { Value = 9.99m };
 
             var ex = Assert.Throws<ArgumentException>(() => evt.ToProperties());
-            Assert.That(ex!.Message, Does.Contain("Currency"));
+            Assert.That(ex!.Message, Does.Contain(nameof(Purchase.Currency)));
         }
 
         [Test]
@@ -166,7 +166,7 @@ public void Purchase_WithoutValue_ThrowsOnToProperties()
             var evt = new Purchase { Currency = TestFixtures.UsdCurrency };
 
             var ex = Assert.Throws<ArgumentException>(() => evt.ToProperties());
-            Assert.That(ex!.Message, Does.Contain("Value"));
+            Assert.That(ex!.Message, Does.Contain(nameof(Purchase.Value)));
         }
 
         [Test]

src/Packages/Audience/Tests/Runtime/IdentityTypeTests.cs

@@ -6,35 +6,49 @@
     [TestFixture]
     internal class IdentityTypeTests
     {
-        [TestCase(IdentityType.Passport, "passport")]
-        [TestCase(IdentityType.Steam, "steam")]
-        [TestCase(IdentityType.Epic, "epic")]
-        [TestCase(IdentityType.Google, "google")]
-        [TestCase(IdentityType.Apple, "apple")]
-        [TestCase(IdentityType.Discord, "discord")]
-        [TestCase(IdentityType.Email, "email")]
-        [TestCase(IdentityType.Custom, "custom")]
+        [TestCase(IdentityType.Passport, IdentityTypeWireFormat.Passport)]
+        [TestCase(IdentityType.Steam, IdentityTypeWireFormat.Steam)]
+        [TestCase(IdentityType.Epic, IdentityTypeWireFormat.Epic)]
+        [TestCase(IdentityType.Google, IdentityTypeWireFormat.Google)]
+        [TestCase(IdentityType.Apple, IdentityTypeWireFormat.Apple)]
+        [TestCase(IdentityType.Discord, IdentityTypeWireFormat.Discord)]
+        [TestCase(IdentityType.Email, IdentityTypeWireFormat.Email)]
+        [TestCase(IdentityType.Custom, IdentityTypeWireFormat.Custom)]
         public void ToLowercaseString_MapsEachEnumValueToLowercaseBackendString(IdentityType type, string expected)
         {
             Assert.AreEqual(expected, type.ToLowercaseString());
         }
 
-        [TestCase("passport", IdentityType.Passport)]
-        [TestCase("steam", IdentityType.Steam)]
-        [TestCase("epic", IdentityType.Epic)]
-        [TestCase("google", IdentityType.Google)]
-        [TestCase("apple", IdentityType.Apple)]
-        [TestCase("discord", IdentityType.Discord)]
-        [TestCase("email", IdentityType.Email)]
-        [TestCase("custom", IdentityType.Custom)]
+        [TestCase(IdentityTypeWireFormat.Passport, IdentityType.Passport)]
+        [TestCase(IdentityTypeWireFormat.Steam, IdentityType.Steam)]
+        [TestCase(IdentityTypeWireFormat.Epic, IdentityType.Epic)]
+        [TestCase(IdentityTypeWireFormat.Google, IdentityType.Google)]
+        [TestCase(IdentityTypeWireFormat.Apple, IdentityType.Apple)]
+        [TestCase(IdentityTypeWireFormat.Discord, IdentityType.Discord)]
+        [TestCase(IdentityTypeWireFormat.Email, IdentityType.Email)]
+        [TestCase(IdentityTypeWireFormat.Custom, IdentityType.Custom)]
         public void ParseLowercaseString_MapsKnownStringToEnum(string wire, IdentityType expected)
         {
             Assert.AreEqual(expected, IdentityTypeExtensions.ParseLowercaseString(wire));
         }
 
-        [TestCase("Steam", IdentityType.Steam)]
-        [TestCase("STEAM", IdentityType.Steam)]
-        [TestCase("Passport", IdentityType.Passport)]
+        [Test]
+        public void IdentityTypeWireFormat_PinsExactStringValues()
+        {
+            // Pins each constant's exact string so a typo or backend rename fails the build.
+            Assert.AreEqual("passport", IdentityTypeWireFormat.Passport);
+            Assert.AreEqual("steam", IdentityTypeWireFormat.Steam);
+            Assert.AreEqual("epic", IdentityTypeWireFormat.Epic);
+            Assert.AreEqual("google", IdentityTypeWireFormat.Google);
+            Assert.AreEqual("apple", IdentityTypeWireFormat.Apple);
+            Assert.AreEqual("discord", IdentityTypeWireFormat.Discord);
+            Assert.AreEqual("email", IdentityTypeWireFormat.Email);
+            Assert.AreEqual("custom", IdentityTypeWireFormat.Custom);
+        }
+
+        [TestCase(TestFixtures.SteamPascalCase, IdentityType.Steam)]
+        [TestCase(TestFixtures.SteamUpperCase, IdentityType.Steam)]
+        [TestCase(TestFixtures.PassportPascalCase, IdentityType.Passport)]
         public void ParseLowercaseString_AcceptsMixedCase(string wire, IdentityType expected)
         {
             Assert.AreEqual(expected, IdentityTypeExtensions.ParseLowercaseString(wire));
@@ -43,8 +57,8 @@
         [TestCase(null)]
         [TestCase("")]
         [TestCase(TestFixtures.UnknownProvider)]
-        [TestCase("steamX")]
+        [TestCase(TestFixtures.SteamSuffixed)]
         public void ParseLowercaseString_FallsBackToCustomForUnknownOrEmpty(string? wire)
         {
             // ParseLowercaseString never throws; unknown values map to Custom.
             Assert.AreEqual(IdentityType.Custom, IdentityTypeExtensions.ParseLowercaseString(wire));