fix: Report all-private attribute names as references in redactedAttributes

LaunchDarkly/LaunchDarkly/Models/Context/LDContext.swift

@@ -119,7 +119,7 @@ public struct LDContext: Encodable, Equatable {
         for key in optionalAttributeNames {
             if let value = context.getTopLevelAddressableAttributeSingleKind(key) {
                 if redactAll {
-                    redactedAttributes.append(key)
+                    redactedAttributes.append(Reference(literal: key).raw())
                     continue
                 }
 

LaunchDarkly/LaunchDarkly/Models/Context/LDContextJSONWriter.swift

@@ -60,7 +60,7 @@ extension LDContext {
             else { continue }
 
             if redactAll {
-                redaction.redactedAttributes.append(name)
+                redaction.redactedAttributes.append(Reference(literal: name).raw())
                 continue
             }
 

LaunchDarkly/LaunchDarklyTests/EventJSONWriterTests.swift

@@ -432,11 +432,14 @@ final class EventJSONWriterTests: XCTestCase {
     }
 
     /// An attribute name is a literal name, not an attribute reference: `/foo` names an attribute called `/foo`, not the
-    /// path `foo`. Only private attributes are references, and they match the name as one component.
+    /// path `foo`. Private attributes and `redactedAttributes` are references, so a name starting with a slash is
+    /// listed as the one-component path that refers to it, `/~1foo`.
     func testAttributeNamesStartingWithASlashAreWrittenAndRedactedByName() throws {
         var builder = LDContextBuilder(key: "user-key")
         _ = builder.trySetValue("/foo", "bar")
         _ = builder.trySetValue("/secret", "hidden")
+        _ = builder.trySetValue("/a~b/c", true)
+        _ = builder.trySetValue("x/y", 2)
         _ = builder.trySetValue("plain", 1)
         builder.addPrivateAttribute(Reference("/~1secret"))
         builder.addPrivateAttribute(Reference("/foo"))
@@ -465,14 +468,20 @@ final class EventJSONWriterTests: XCTestCase {
                 if allAttributesPrivate {
                     XCTAssertNil(written["/foo"], label)
                     XCTAssertNil(written["plain"], label)
-                    XCTAssertEqual(Set(redacted(written)), ["/foo", "/secret", "plain"], label)
+                    XCTAssertEqual(Set(redacted(written)), ["/~1foo", "/~1secret", "/~1a~0b~1c", "x/y", "plain"], label)
                 } else {
                     // `Reference("/foo")` is the path `foo`, which names no attribute here.
                     XCTAssertEqual(written["/foo"] as? String, "bar", label)
                     XCTAssertEqual(written["plain"] as? Int, 1, label)
                     XCTAssertEqual(redacted(written), ["/~1secret"], label)
                 }
                 XCTAssertNil(written["/secret"], label)
+                // Each entry, parsed back as a reference, refers to an attribute that was left out.
+                for entry in redacted(written) {
+                    let reference = Reference(entry)
+                    XCTAssertTrue(reference.isValid(), "\(label): \(entry)")
+                    XCTAssertNotNil(context.getValue(reference), "\(label): \(entry)")
+                }
             }
         }