capacitor-launchdarkly 0.0.0-stage → 0.1.1

package/ios/Sources/LaunchDarklyPlugin/LaunchDarklyPlugin.swift

@@ -0,0 +1,169 @@
+import Foundation
+import Capacitor
+import LaunchDarkly
+
+@objc(LaunchDarklyPlugin)
+public class LaunchDarklyPlugin: CAPPlugin, CAPBridgedPlugin, ClientEvents {
+    public let identifier = "LaunchDarklyPlugin"
+    public let jsName = "LaunchDarkly"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "initialize", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "waitForInitialization", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getState", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "identify", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "variation", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "allFlags", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setStreaming", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setOnline", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "flush", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "close", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "clearStoredContext", returnType: CAPPluginReturnPromise)
+    ]
+
+    private let store: ContextStore = UserDefaultsContextStore()
+    private var client: LaunchDarklyClient { LaunchDarklyClient.shared }
+
+    /// Runs as the bridge is created, before the web view loads the app. With a `mobileKey` in `plugins.LaunchDarkly` of
+    /// capacitor.config the client starts here, with the stored context or else `initialContext`, so the flags are on their way
+    /// before any app code asks for them. Without one nothing starts, and `initialize()` does it.
+    override public func load() {
+        let config = getConfig().getConfigJSON() as [String: Any]
+        let autoStart = PluginConfiguration.autoStart(config)
+        LaunchDarklyClient.onMain { [weak self] in
+            guard let self else { return }
+            self.client.events = self
+            guard let autoStart else { return }
+            let context = StartContext.choose(stored: self.store.read(), initialContext: autoStart.initialContext)
+            self.client.start(autoStart.options, context: context)
+        }
+    }
+
+    @objc func initialize(_ call: CAPPluginCall) {
+        guard let mobileKey = nonBlank(call.getString("mobileKey")) else {
+            return call.reject("initialize needs a mobileKey on iOS.")
+        }
+        guard let given = readContext(call) else { return }
+        let options = StartOptions(mobileKey: mobileKey, options: call.getObject("options"))
+        LaunchDarklyClient.onMain { [store, client] in
+            // One client per process: the same key changes nothing and answers the state once the start is done.
+            if client.options?.mobileKey == mobileKey {
+                return client.afterStart { call.resolve(Self.state(client)) }
+            }
+            // The given context plays the part of initialContext: a context an earlier identify() stored wins over it.
+            let context = StartContext.choose(stored: store.read(), initialContext: given.json)
+            client.start(options, context: context) { call.resolve(Self.state(client)) }
+        }
+    }
+
+    @objc func waitForInitialization(_ call: CAPPluginCall) {
+        let timeout = StartOptions.seconds(call.options["timeoutSeconds"])
+        LaunchDarklyClient.onMain { [client] in
+            client.waitForInitialization(timeout: timeout) { call.resolve(["initialized": $0]) }
+        }
+    }
+
+    @objc func getState(_ call: CAPPluginCall) {
+        LaunchDarklyClient.onMain { [client] in
+            client.afterStart { call.resolve(Self.state(client)) }
+        }
+    }
+
+    @objc func identify(_ call: CAPPluginCall) {
+        guard let context = readContext(call) else { return }
+        let timeout = StartOptions.seconds(call.options["timeoutSeconds"])
+        LaunchDarklyClient.onMain { [store, client] in
+            client.identify(context, timeout: timeout, store: store) { result in
+                switch result {
+                case .success(let timedOut): call.resolve(["timedOut": timedOut])
+                case .failure(let error): call.reject(error.localizedDescription, nil, error)
+                }
+            }
+        }
+    }
+
+    @objc func variation(_ call: CAPPluginCall) {
+        guard let key = call.getString("key") else { return call.reject("variation needs a key.") }
+        let defaultValue = JSValues.toLDValue(call.options["defaultValue"])
+        LaunchDarklyClient.onMain { [client] in
+            call.resolve(["value": JSValues.toJS(client.variation(key, defaultValue: defaultValue))])
+        }
+    }
+
+    @objc func allFlags(_ call: CAPPluginCall) {
+        LaunchDarklyClient.onMain { [client] in
+            call.resolve(["flags": JSValues.flags(client.allFlags)])
+        }
+    }
+
+    @objc func setStreaming(_ call: CAPPluginCall) {
+        guard let enabled = call.getBool("enabled") else { return call.reject("setStreaming needs enabled.") }
+        LaunchDarklyClient.onMain { [client] in
+            client.restart({ options in
+                var next = options
+                next.streaming = enabled
+                return next
+            }, done: { error in
+                if let error { call.reject(error.localizedDescription, nil, error) } else { call.resolve() }
+            })
+        }
+    }
+
+    @objc func setOnline(_ call: CAPPluginCall) {
+        guard let online = call.getBool("online") else { return call.reject("setOnline needs online.") }
+        LaunchDarklyClient.onMain { [client] in
+            client.setOnline(online) { call.resolve() }
+        }
+    }
+
+    @objc func flush(_ call: CAPPluginCall) {
+        LaunchDarklyClient.onMain { [client] in
+            client.flush()
+            call.resolve()
+        }
+    }
+
+    @objc func close(_ call: CAPPluginCall) {
+        LaunchDarklyClient.onMain { [client] in
+            client.close()
+            call.resolve()
+        }
+    }
+
+    @objc func clearStoredContext(_ call: CAPPluginCall) {
+        store.clear()
+        call.resolve()
+    }
+
+    func flagChanged(key: String, value: LDValue, previous: LDValue?) {
+        var change: [String: Any] = ["key": key, "value": JSValues.toJS(value)]
+        if let previous { change["previous"] = JSValues.toJS(previous) }
+        notifyListeners("flagChange", data: change)
+    }
+
+    func connectionModeChanged(_ mode: String) {
+        notifyListeners("connectionModeChange", data: ["mode": mode])
+    }
+
+    private func readContext(_ call: CAPPluginCall) -> ContextChoice? {
+        guard let object = call.getObject("context") else {
+            call.reject("A context is needed.")
+            return nil
+        }
+        do {
+            let json = try Contexts.json(from: object)
+            return ContextChoice(context: try Contexts.parse(json), json: json)
+        } catch {
+            call.reject(error.localizedDescription, nil, error)
+            return nil
+        }
+    }
+
+    static func state(_ client: LaunchDarklyClient) -> [String: Any] {
+        var state: [String: Any] = ["initialized": client.isInitialized, "flags": JSValues.flags(client.allFlags)]
+        if let json = client.contextJSON,
+           let context = try? JSONSerialization.jsonObject(with: Data(json.utf8)) {
+            state["context"] = context
+        }
+        return state
+    }
+}

package/ios/Sources/LaunchDarklyPlugin/PrivacyInfo.xcprivacy

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>NSPrivacyAccessedAPITypes</key>
+	<array>
+		<dict>
+			<key>NSPrivacyAccessedAPIType</key>
+			<string>NSPrivacyAccessedAPICategoryUserDefaults</string>
+			<key>NSPrivacyAccessedAPITypeReasons</key>
+			<array>
+				<string>CA92.1</string>
+			</array>
+		</dict>
+	</array>
+	<key>NSPrivacyCollectedDataTypes</key>
+	<array/>
+	<key>NSPrivacyTrackingDomains</key>
+	<array/>
+	<key>NSPrivacyTracking</key>
+	<false/>
+</dict>
+</plist>

package/ios/Sources/LaunchDarklyPlugin/StartOptions.swift

@@ -0,0 +1,79 @@
+import Foundation
+
+/// Application metadata sent with every request. It describes the app; it is not a context.
+public struct ApplicationMetadata: Equatable {
+    public var id: String?
+    public var name: String?
+    public var version: String?
+    public var versionName: String?
+}
+
+/// How the client is started: from `plugins.LaunchDarkly` in capacitor.config, or from `initialize()`.
+public struct StartOptions: Equatable {
+    public static let defaultWaitSeconds: TimeInterval = 5
+
+    public var mobileKey: String
+    public var streaming = true
+    public var evaluationReasons = false
+    public var offline = false
+    public var startWaitSeconds: TimeInterval = StartOptions.defaultWaitSeconds
+    public var application: ApplicationMetadata?
+
+    public init(mobileKey: String) {
+        self.mobileKey = mobileKey
+    }
+
+    /// The options of `initialize()` or of the config block, everything but the key and the context.
+    public init(mobileKey: String, options config: [String: Any]?) {
+        self.mobileKey = mobileKey
+        let config = config ?? [:]
+        streaming = config["streaming"] as? Bool ?? true
+        evaluationReasons = config["evaluationReasons"] as? Bool ?? false
+        offline = config["offline"] as? Bool ?? false
+        startWaitSeconds = StartOptions.seconds(config["startWaitSeconds"])
+        if let app = config["application"] as? [String: Any] {
+            application = ApplicationMetadata(
+                id: nonBlank(app["id"]),
+                name: nonBlank(app["name"]),
+                version: nonBlank(app["version"]),
+                versionName: nonBlank(app["versionName"])
+            )
+        }
+    }
+
+    /// A wait in seconds as given, or the default when it is not a usable number.
+    public static func seconds(_ value: Any?, default fallback: TimeInterval = defaultWaitSeconds) -> TimeInterval {
+        // A JavaScript boolean arrives as an NSNumber too; it is not a number of seconds.
+        guard let number = value as? NSNumber, CFGetTypeID(number) != CFBooleanGetTypeID() else { return fallback }
+        let seconds = number.doubleValue
+        return seconds.isFinite && seconds >= 0 ? seconds : fallback
+    }
+}
+
+/// What the native start-up does when the app launches: start with `options` and `initialContext` unless a context was stored.
+public struct AutoStart: Equatable {
+    public var options: StartOptions
+    public var initialContext: String
+}
+
+public enum PluginConfiguration {
+    /// The context of a native start-up that has neither a stored context nor an `initialContext`.
+    public static let defaultInitialContext = #"{"kind":"user","key":"anonymous_user","anonymous":true}"#
+
+    /// Reads the `plugins.LaunchDarkly` block of capacitor.config. Without a `mobileKey` there is no native start-up, and the
+    /// answer is nil: the app starts the client with `initialize()` instead.
+    public static func autoStart(_ config: [String: Any]?) -> AutoStart? {
+        guard let config, let mobileKey = nonBlank(config["mobileKey"]) else { return nil }
+        var initialContext = defaultInitialContext
+        if let context = config["initialContext"] as? [String: Any], let json = JSONText.from(context) {
+            initialContext = json
+        }
+        return AutoStart(options: StartOptions(mobileKey: mobileKey, options: config), initialContext: initialContext)
+    }
+}
+
+/// A string value, or nil when it is absent, not a string, or blank.
+func nonBlank(_ value: Any?) -> String? {
+    guard let string = value as? String, !string.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else { return nil }
+    return string
+}

package/ios/Sources/LaunchDarklyPlugin/StoredContext.swift

@@ -0,0 +1,43 @@
+import Foundation
+import LaunchDarkly
+
+/// Where the context of the last `identify()` is kept between launches.
+public protocol ContextStore: AnyObject {
+    func read() -> String?
+    func write(_ json: String)
+    func clear()
+}
+
+/// `ContextStore` in `UserDefaults`, under a key of the plugin's own.
+public final class UserDefaultsContextStore: ContextStore {
+    public static let key = "CapacitorLaunchDarkly.context"
+    private let defaults: UserDefaults
+
+    public init(defaults: UserDefaults = .standard) {
+        self.defaults = defaults
+    }
+
+    public func read() -> String? { defaults.string(forKey: Self.key) }
+    public func write(_ json: String) { defaults.set(json, forKey: Self.key) }
+    public func clear() { defaults.removeObject(forKey: Self.key) }
+}
+
+/// A context and the JSON it was read from, which is what the plugin stores and answers in `getState()`.
+public struct ContextChoice {
+    public let context: LDContext
+    public let json: String
+}
+
+public enum StartContext {
+    /// The context a native start-up begins with: the stored one when there is a valid one, so the app does not flip to the
+    /// initial (usually anonymous) context for a moment and the SDK uses its flag cache for that context; else
+    /// `initialContext`; else the default anonymous context.
+    public static func choose(stored: String?, initialContext: String) -> ContextChoice {
+        for json in [stored, initialContext, PluginConfiguration.defaultInitialContext] {
+            if let json, let context = Contexts.parseOrNil(json) {
+                return ContextChoice(context: context, json: json)
+            }
+        }
+        fatalError("the default context is not valid")
+    }
+}

package/ios/Tests/LaunchDarklyPluginTests/BillingSafetyTests.swift

@@ -0,0 +1,53 @@
+import XCTest
+import LaunchDarkly
+@testable import LaunchDarklyPlugin
+
+// LaunchDarkly bills client-side SDKs by unique context keys. The plugin keeps the count at the keys the app passes: no
+// automatic environment contexts (ld_application, ld_device), and no key generated for an anonymous context.
+final class BillingSafetyTests: XCTestCase {
+    func testAutomaticEnvironmentAttributesAreDisabled() {
+        XCTAssertFalse(ConfigFactory.make(StartOptions(mobileKey: "mob-test")).autoEnvAttributes)
+    }
+
+    func testTheNativeStartPathBuildsTheSameSafeConfig() throws {
+        let start = try XCTUnwrap(PluginConfiguration.autoStart(["mobileKey": "mob-test"]))
+        XCTAssertFalse(ConfigFactory.make(start.options).autoEnvAttributes)
+    }
+
+    func testTheNativeStartPathBeginsWithTheSharedAnonymousKey() throws {
+        let start = try XCTUnwrap(PluginConfiguration.autoStart(["mobileKey": "mob-test"]))
+        let context = StartContext.choose(stored: nil, initialContext: start.initialContext).context
+        XCTAssertEqual(context.contextKeys(), ["user": "anonymous_user"])
+        XCTAssertEqual(context.getValue(Reference("anonymous")), .bool(true))
+    }
+
+    func testAnAnonymousContextKeepsItsKey() throws {
+        let context = try Contexts.parse(#"{"kind":"user","key":"anonymous_user","anonymous":true}"#)
+        XCTAssertEqual(context.fullyQualifiedKey(), "anonymous_user")
+        XCTAssertEqual(context.getValue(Reference("anonymous")), .bool(true))
+    }
+
+    func testAnAnonymousKindInAMultiContextKeepsItsKey() throws {
+        let context = try Contexts.parse(#"{"kind":"multi","user":{"key":"anonymous_user","anonymous":true},"org":{"key":"o1"}}"#)
+        XCTAssertEqual(context.contextKeys(), ["user": "anonymous_user", "org": "o1"])
+    }
+
+    func testAContextWithoutAKeyIsRejectedRatherThanGivenOne() {
+        XCTAssertThrowsError(try Contexts.parse(#"{"kind":"user","anonymous":true}"#))
+    }
+
+    func testOptionsArePassedOn() {
+        var options = StartOptions(mobileKey: "mob-test")
+        options.streaming = false
+        options.evaluationReasons = true
+        options.offline = true
+        options.application = ApplicationMetadata(id: "app")
+        let config = ConfigFactory.make(options)
+        XCTAssertEqual(config.mobileKey, "mob-test")
+        XCTAssertEqual(config.streamingMode, .polling)
+        XCTAssertTrue(config.evaluationReasons)
+        XCTAssertFalse(config.startOnline)
+        XCTAssertNotNil(config.applicationInfo)
+        XCTAssertFalse(config.autoEnvAttributes)
+    }
+}

package/ios/Tests/LaunchDarklyPluginTests/JSONValuesTests.swift

@@ -0,0 +1,67 @@
+import XCTest
+import LaunchDarkly
+@testable import LaunchDarklyPlugin
+
+final class JSONValuesTests: XCTestCase {
+    func testReadsNameCustomAttributesNestedObjectsAndPrivateAttributes() throws {
+        let context = try Contexts.parse("""
+        {"kind":"user","key":"u1","name":"Ann","plan":"pro","seats":3,"beta":true,"tags":["a","b"],
+         "address":{"country":"IE","city":"Cork"},"_meta":{"privateAttributes":["email","/address/city"]}}
+        """)
+        XCTAssertEqual(context.getValue(Reference("name")), .string("Ann"))
+        XCTAssertEqual(context.getValue(Reference("plan")), .string("pro"))
+        XCTAssertEqual(context.getValue(Reference("seats")), .number(3))
+        XCTAssertEqual(context.getValue(Reference("beta")), .bool(true))
+        XCTAssertEqual(context.getValue(Reference("tags")), .array([.string("a"), .string("b")]))
+        XCTAssertEqual(context.getValue(Reference("/address/city")), .string("Cork"))
+        XCTAssertEqual(context.getValue(Reference("anonymous")), .bool(false))
+        // The SDK encodes a context for events with its private attributes redacted: the private city is gone, the rest stays.
+        let encoded = try XCTUnwrap(String(data: try JSONEncoder().encode(context), encoding: .utf8))
+        XCTAssertTrue(encoded.contains("redactedAttributes"), encoded)
+        XCTAssertFalse(encoded.contains("Cork"), encoded)
+        XCTAssertTrue(encoded.contains("IE"), encoded)
+    }
+
+    func testReadsAMultiContext() throws {
+        let context = try Contexts.parse(#"{"kind":"multi","user":{"key":"u1"},"org":{"key":"o1","name":"Farm"}}"#)
+        XCTAssertTrue(context.isMulti())
+        XCTAssertEqual(context.contextKeys(), ["user": "u1", "org": "o1"])
+    }
+
+    func testAnInvalidKindIsRejected() {
+        XCTAssertThrowsError(try Contexts.parse(#"{"kind":"kind","key":"k"}"#))
+    }
+
+    func testTheJSONOfADictionaryRoundTrips() throws {
+        let json = try Contexts.json(from: ["kind": "user", "key": "u1", "anonymous": true, "seats": 3])
+        let context = try Contexts.parse(json)
+        XCTAssertEqual(context.getValue(Reference("anonymous")), .bool(true))
+        XCTAssertEqual(context.getValue(Reference("seats")), .number(3))
+    }
+
+    func testValuesOfEveryJSONTypeGoBothWays() {
+        XCTAssertEqual(JSValues.toLDValue(true), .bool(true))
+        XCTAssertEqual(JSValues.toLDValue(3), .number(3))
+        XCTAssertEqual(JSValues.toLDValue(2.5), .number(2.5))
+        XCTAssertEqual(JSValues.toLDValue("text"), .string("text"))
+        XCTAssertEqual(JSValues.toLDValue(["a": 1]), .object(["a": .number(1)]))
+        XCTAssertEqual(JSValues.toLDValue([1, "two"]), .array([.number(1), .string("two")]))
+        XCTAssertEqual(JSValues.toJS(.bool(true)) as? Bool, true)
+        XCTAssertEqual(JSValues.toJS(.string("text")) as? String, "text")
+        XCTAssertEqual((JSValues.toJS(.object(["a": .number(1)])) as? [String: Any])?["a"] as? Int, 1)
+    }
+
+    func testABooleanStaysABoolean() {
+        // NSNumber carries both; a true that became 1 would compare unequal to true in JavaScript.
+        XCTAssertEqual(JSValues.toLDValue(NSNumber(value: true)), .bool(true))
+        let data = try? JSONSerialization.data(withJSONObject: ["v": JSValues.toJS(.bool(false))])
+        XCTAssertEqual(data.flatMap { String(data: $0, encoding: .utf8) }, #"{"v":false}"#)
+    }
+
+    func testNullAndAbsentAreJSONNull() {
+        XCTAssertEqual(JSValues.toLDValue(nil), .null)
+        XCTAssertEqual(JSValues.toLDValue(NSNull()), .null)
+        XCTAssertTrue(JSValues.toJS(.null) is NSNull)
+        XCTAssertTrue(JSValues.toJS(nil) is NSNull)
+    }
+}

package/ios/Tests/LaunchDarklyPluginTests/LaunchDarklyPluginTests.swift

@@ -0,0 +1,37 @@
+import XCTest
+import Capacitor
+@testable import LaunchDarklyPlugin
+
+// The JavaScript reaches the plugin by jsName and the method by its name; a rename on either side fails only at run time on a
+// phone, so it is pinned here. jsName is also the name of the config block, plugins.LaunchDarkly.
+final class LaunchDarklyPluginTests: XCTestCase {
+    private let methods = [
+        "initialize", "waitForInitialization", "getState", "identify", "variation", "allFlags", "setStreaming", "setOnline",
+        "flush", "close", "clearStoredContext"
+    ]
+
+    func testIsRegisteredUnderTheNameTheJavaScriptUses() {
+        XCTAssertEqual(LaunchDarklyPlugin().jsName, "LaunchDarkly")
+    }
+
+    func testExposesEveryMethodAsAPromiseMethodAndNothingElse() {
+        let registered = LaunchDarklyPlugin().pluginMethods
+        XCTAssertEqual(registered.map { $0.name }, methods)
+        XCTAssertTrue(registered.allSatisfy { $0.returnType == CAPPluginReturnPromise })
+    }
+
+    func testEveryMethodNameHasAnObjectiveCSelector() {
+        // Capacitor calls a method through the selector "<name>:"; a missing @objc compiles fine and fails on the phone.
+        for name in methods {
+            XCTAssertTrue(LaunchDarklyPlugin().responds(to: NSSelectorFromString("\(name):")), name)
+        }
+    }
+
+    func testShipsAPrivacyManifestDeclaringUserDefaults() throws {
+        let bundle = Bundle.module
+        let url = try XCTUnwrap(bundle.url(forResource: "PrivacyInfo", withExtension: "xcprivacy"))
+        let text = try String(contentsOf: url, encoding: .utf8)
+        XCTAssertTrue(text.contains("NSPrivacyAccessedAPICategoryUserDefaults"))
+        XCTAssertTrue(text.contains("CA92.1"))
+    }
+}

package/ios/Tests/LaunchDarklyPluginTests/PluginConfigurationTests.swift

@@ -0,0 +1,52 @@
+import XCTest
+@testable import LaunchDarklyPlugin
+
+final class PluginConfigurationTests: XCTestCase {
+    func testNoConfigBlockMeansNoNativeStart() {
+        XCTAssertNil(PluginConfiguration.autoStart(nil))
+        XCTAssertNil(PluginConfiguration.autoStart([:]))
+    }
+
+    func testAMissingBlankOrNonStringMobileKeyMeansNoNativeStart() {
+        XCTAssertNil(PluginConfiguration.autoStart(["streaming": false]))
+        XCTAssertNil(PluginConfiguration.autoStart(["mobileKey": "  "]))
+        XCTAssertNil(PluginConfiguration.autoStart(["mobileKey": 42]))
+    }
+
+    func testAMobileKeyAloneStartsWithTheDefaults() throws {
+        let start = try XCTUnwrap(PluginConfiguration.autoStart(["mobileKey": "mob-test"]))
+        XCTAssertEqual(start.options, StartOptions(mobileKey: "mob-test"))
+        XCTAssertTrue(start.options.streaming)
+        XCTAssertFalse(start.options.evaluationReasons)
+        XCTAssertFalse(start.options.offline)
+        XCTAssertEqual(start.options.startWaitSeconds, 5)
+        XCTAssertEqual(start.initialContext, PluginConfiguration.defaultInitialContext)
+    }
+
+    func testReadsEveryOption() throws {
+        let start = try XCTUnwrap(PluginConfiguration.autoStart([
+            "mobileKey": "mob-test",
+            "streaming": false,
+            "evaluationReasons": true,
+            "offline": true,
+            "startWaitSeconds": 2.5,
+            "application": ["id": "app", "name": "App", "version": "1.2.3", "versionName": "1.2"],
+            "initialContext": ["kind": "device", "key": "shared", "anonymous": true]
+        ]))
+        var expected = StartOptions(mobileKey: "mob-test")
+        expected.streaming = false
+        expected.evaluationReasons = true
+        expected.offline = true
+        expected.startWaitSeconds = 2.5
+        expected.application = ApplicationMetadata(id: "app", name: "App", version: "1.2.3", versionName: "1.2")
+        XCTAssertEqual(start.options, expected)
+        XCTAssertEqual(try Contexts.parse(start.initialContext).contextKeys()["device"], "shared")
+    }
+
+    func testAWaitThatIsNotAUsableNumberFallsBackToTheDefault() {
+        XCTAssertEqual(StartOptions.seconds(-1), 5)
+        XCTAssertEqual(StartOptions.seconds(true), 5)
+        XCTAssertEqual(StartOptions.seconds("3"), 5)
+        XCTAssertEqual(StartOptions.seconds(3), 3)
+    }
+}

package/ios/Tests/LaunchDarklyPluginTests/StartContextTests.swift

@@ -0,0 +1,36 @@
+import XCTest
+@testable import LaunchDarklyPlugin
+
+final class StartContextTests: XCTestCase {
+    private let initial = #"{"kind":"user","key":"anonymous_user","anonymous":true}"#
+    private let stored = #"{"kind":"user","key":"user-42","name":"Ann"}"#
+
+    func testAStoredContextWinsOverTheInitialOne() {
+        let choice = StartContext.choose(stored: stored, initialContext: initial)
+        XCTAssertEqual(choice.context.fullyQualifiedKey(), "user-42")
+        XCTAssertEqual(choice.json, stored)
+    }
+
+    func testWithoutAStoredContextTheInitialOneIsUsed() {
+        XCTAssertEqual(StartContext.choose(stored: nil, initialContext: initial).context.fullyQualifiedKey(), "anonymous_user")
+    }
+
+    func testAnInvalidStoredContextFallsBackToTheInitialOne() {
+        XCTAssertEqual(StartContext.choose(stored: #"{"kind":"user"}"#, initialContext: initial).json, initial)
+        XCTAssertEqual(StartContext.choose(stored: "not json", initialContext: initial).json, initial)
+    }
+
+    func testAnInvalidInitialContextFallsBackToTheDefault() {
+        XCTAssertEqual(StartContext.choose(stored: nil, initialContext: #"{"kind":"multi"}"#).json, PluginConfiguration.defaultInitialContext)
+    }
+
+    func testTheUserDefaultsStoreKeepsWritesAndClears() throws {
+        let defaults = try XCTUnwrap(UserDefaults(suiteName: "StartContextTests-\(UUID().uuidString)"))
+        let store = UserDefaultsContextStore(defaults: defaults)
+        XCTAssertNil(store.read())
+        store.write(stored)
+        XCTAssertEqual(UserDefaultsContextStore(defaults: defaults).read(), stored)
+        store.clear()
+        XCTAssertNil(store.read())
+    }
+}