@otakit/capacitor-updater 2.3.3 → 3.0.0

package/ios/Tests/UpdaterPluginTests/EventDeliveryTests.swift

@@ -0,0 +1,56 @@
+import Foundation
+import XCTest
+@testable import UpdaterPlugin
+
+final class EventDeliveryTests: XCTestCase {
+  func testURLSessionRetryPreservesBodyAndDeletesOnlyAfterAcceptance() async throws {
+    let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+    defer { try? FileManager.default.removeItem(at: directory) }
+    let outbox = try EventOutbox(directory: directory)
+    let body = try JSONSerialization.data(withJSONObject: ["eventId": UUID().uuidString, "action": "applied"])
+    let accepted = expectation(description: "HTTP retry accepted")
+    let lock = NSLock()
+    var requests: [Data] = []
+    EventHTTPProtocol.respond = { request in
+      var bytes = request.httpBody ?? Data()
+      if let stream = request.httpBodyStream {
+        stream.open(); defer { stream.close() }
+        var buffer = [UInt8](repeating: 0, count: 1024)
+        while stream.hasBytesAvailable {
+          let count = stream.read(&buffer, maxLength: buffer.count)
+          if count <= 0 { break }
+          bytes.append(contentsOf: buffer.prefix(count))
+        }
+      }
+      XCTAssertEqual(request.value(forHTTPHeaderField: "X-App-Id"), "app-a")
+      lock.lock(); requests.append(bytes); let count = requests.count; lock.unlock()
+      if count == 2 { accepted.fulfill() }
+      return count == 1 ? 503 : 202
+    }
+    defer { EventHTTPProtocol.respond = nil }
+    let configuration = URLSessionConfiguration.ephemeral
+    configuration.protocolClasses = [EventHTTPProtocol.self]
+    let delivery = EventDelivery(outbox: outbox, configuration: configuration)
+    delivery.enqueue(url: URL(string: "https://ingest.example/events")!, appId: "app-a", body: body)
+    await fulfillment(of: [accepted], timeout: 15)
+    let deadline = Date().addingTimeInterval(3)
+    while outbox.wait(now: Date().timeIntervalSince1970) != nil && Date() < deadline {
+      try await Task.sleep(nanoseconds: 20_000_000)
+    }
+    XCTAssertNil(try EventOutbox(directory: directory).wait(now: Date().timeIntervalSince1970))
+    XCTAssertEqual(requests, [body, body])
+  }
+}
+
+private final class EventHTTPProtocol: URLProtocol {
+  static var respond: ((URLRequest) -> Int)?
+  override class func canInit(with request: URLRequest) -> Bool { true }
+  override class func canonicalRequest(for request: URLRequest) -> URLRequest { request }
+  override func startLoading() {
+    let status = Self.respond?(request) ?? 500
+    let response = HTTPURLResponse(url: request.url!, statusCode: status, httpVersion: "HTTP/1.1", headerFields: [:])!
+    client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
+    client?.urlProtocolDidFinishLoading(self)
+  }
+  override func stopLoading() {}
+}

package/ios/Tests/UpdaterPluginTests/EventOutboxTests.swift

@@ -0,0 +1,86 @@
+import Foundation
+import XCTest
+@testable import UpdaterPlugin
+
+final class EventOutboxTests: XCTestCase {
+  private var directory: URL!
+  override func setUpWithError() throws {
+    directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+  }
+  override func tearDownWithError() throws { try? FileManager.default.removeItem(at: directory) }
+  private func body(_ id: String) throws -> Data {
+    try JSONSerialization.data(withJSONObject: ["eventId": id, "sentAt": "2026-09-20T12:00:00Z", "action": "applied"], options: .sortedKeys)
+  }
+  private func enqueue(_ queue: EventOutbox, _ id: String, _ now: TimeInterval = 0) throws {
+    try queue.enqueue(url: URL(string: "https://ingest.example/events")!, appId: "app-a", body: body(id), now: now)
+  }
+  func testRestartAndLostResponsePreserveOriginalIdentityAndBody() throws {
+    let queue = try EventOutbox(directory: directory)
+    try enqueue(queue, "original-id", 1)
+    try queue.complete(id: "original-id", status: 0, retryAfter: nil, now: 1, random: 0.5)
+    let reopened = try EventOutbox(directory: directory)
+    XCTAssertNil(try reopened.ready(now: 5.999))
+    let retry = try XCTUnwrap(reopened.ready(now: 6))
+    XCTAssertEqual(retry.id, "original-id")
+    XCTAssertEqual(retry.body, try body("original-id"))
+    XCTAssertEqual(retry.appId, "app-a")
+    XCTAssertEqual(retry.attempts, 1)
+    try reopened.complete(id: retry.id, status: 202, retryAfter: nil, now: 6, random: 0.5)
+    XCTAssertNil(try EventOutbox(directory: directory).ready(now: 6))
+  }
+  func testRateLimitSurvivesRestartAndDoesNotBlockOtherEvents() throws {
+    let queue = try EventOutbox(directory: directory)
+    try enqueue(queue, "limited", 1)
+    try queue.complete(id: "limited", status: 429, retryAfter: "120", now: 1, random: 0.5)
+    try enqueue(queue, "other", 2)
+    let reopened = try EventOutbox(directory: directory)
+    XCTAssertEqual(try reopened.ready(now: 2)?.id, "other")
+    try reopened.complete(id: "other", status: 200, retryAfter: nil, now: 2, random: 0.5)
+    XCTAssertNil(try reopened.ready(now: 120.999))
+    XCTAssertEqual(try reopened.ready(now: 121)?.id, "limited")
+  }
+  func testPermanentRejectionIsDroppedAndServerFailuresRetry() throws {
+    let queue = try EventOutbox(directory: directory)
+    try enqueue(queue, "invalid")
+    try queue.complete(id: "invalid", status: 400, retryAfter: nil, now: 0, random: 0.5)
+    XCTAssertNil(queue.wait(now: 0))
+    for status in [408, 425, 429, 500, 502, 503, 504] {
+      try enqueue(queue, "retry-\(status)")
+      try queue.complete(id: "retry-\(status)", status: status, retryAfter: nil, now: 0, random: 0.5)
+    }
+    XCTAssertNil(try queue.ready(now: 4.999))
+    XCTAssertNotNil(try queue.ready(now: 5))
+  }
+  func testQueueIsBoundedAndExpiresWithoutRetryingLongDelayEarly() throws {
+    let queue = try EventOutbox(directory: directory)
+    for index in 0...EventOutbox.limit { try enqueue(queue, "event-\(index)") }
+    XCTAssertEqual(try queue.ready(now: 0)?.id, "event-1")
+    try queue.complete(id: "event-1", status: 429, retryAfter: String(repeating: "9", count: 500), now: 0, random: 0.5)
+    XCTAssertEqual(try queue.ready(now: 0)?.id, "event-2")
+    XCTAssertNil(try queue.ready(now: EventOutbox.ttl))
+    XCTAssertNil(queue.wait(now: EventOutbox.ttl))
+  }
+  func testFailedSaveKeepsUnacknowledgedEventInMemoryAndOnDisk() throws {
+    let queue = try EventOutbox(directory: directory)
+    try enqueue(queue, "keep")
+    let file = directory.appendingPathComponent("events.json")
+    let original = try Data(contentsOf: file)
+    let backup = directory.appendingPathComponent("backup.json")
+    try FileManager.default.moveItem(at: file, to: backup)
+    try FileManager.default.createDirectory(at: file, withIntermediateDirectories: false)
+    try Data([1]).write(to: file.appendingPathComponent("block"))
+    XCTAssertThrowsError(try queue.complete(id: "keep", status: 200, retryAfter: nil, now: 0, random: 0.5))
+    XCTAssertEqual(try queue.ready(now: 0)?.id, "keep")
+    try FileManager.default.removeItem(at: file)
+    try FileManager.default.moveItem(at: backup, to: file)
+    XCTAssertEqual(try Data(contentsOf: file), original)
+    XCTAssertEqual(try EventOutbox(directory: directory).ready(now: 0)?.id, "keep")
+  }
+  func testCorruptJSONDoesNotPermanentlyDisableDelivery() throws {
+    _ = try EventOutbox(directory: directory)
+    try Data("{".utf8).write(to: directory.appendingPathComponent("events.json"))
+    let queue = try EventOutbox(directory: directory)
+    try enqueue(queue, "new")
+    XCTAssertEqual(try EventOutbox(directory: directory).ready(now: 0)?.id, "new")
+  }
+}

package/ios/Tests/UpdaterPluginTests/ForegroundDeadlineTests.swift

@@ -0,0 +1,144 @@
+import Foundation
+import UIKit
+import XCTest
+@testable import UpdaterPlugin
+
+final class ForegroundDeadlineTests: XCTestCase {
+  func testBackgroundTimeDoesNotConsumeRemainingBudget() {
+    let clock = DeadlineClock()
+    let deadline = clock.makeDeadline()
+    var expirations = 0
+    deadline.setForeground(true)
+    deadline.start(timeout: 10) { expirations += 1 }
+    let originalCallback = clock.jobs.last!.callback
+    clock.now = 3
+    deadline.setForeground(false)
+    clock.now = 3603
+    originalCallback() // Simulate an already queued callback despite cancellation.
+    XCTAssertEqual(expirations, 0)
+    deadline.setForeground(true)
+    XCTAssertEqual(clock.jobs.last!.delay, 7)
+    clock.now += 7
+    clock.jobs.last!.callback()
+    XCTAssertEqual(expirations, 1)
+    originalCallback()
+    XCTAssertEqual(expirations, 1)
+  }
+
+  func testTrialStartedInBackgroundWaitsForForeground() {
+    let clock = DeadlineClock()
+    let deadline = clock.makeDeadline()
+    var expired = false
+    deadline.start(timeout: 10) { expired = true }
+    clock.now = 1000
+    XCTAssertTrue(clock.jobs.isEmpty)
+    deadline.setForeground(true)
+    XCTAssertEqual(clock.jobs.last!.delay, 10)
+    XCTAssertFalse(expired)
+    clock.now += 10
+    clock.jobs.last!.callback()
+    XCTAssertTrue(expired)
+  }
+
+  func testRepeatedLifecycleEventsDoNotResetBudget() {
+    let clock = DeadlineClock()
+    let deadline = clock.makeDeadline()
+    deadline.setForeground(true)
+    deadline.start(timeout: 10) {}
+    clock.now = 2
+    deadline.setForeground(true)
+    deadline.setForeground(false)
+    clock.now = 50
+    deadline.setForeground(false)
+    deadline.setForeground(true)
+    XCTAssertEqual(clock.jobs.last!.delay, 8)
+    clock.now = 54
+    deadline.setForeground(false)
+    clock.now = 90
+    deadline.setForeground(true)
+    XCTAssertEqual(clock.jobs.last!.delay, 4)
+  }
+
+  func testCancelledAndReplacedCallbacksCannotExpireNewTrial() {
+    let clock = DeadlineClock()
+    let deadline = clock.makeDeadline()
+    var expired = "none"
+    deadline.setForeground(true)
+    deadline.start(timeout: 10) { expired = "A" }
+    let old = clock.jobs.last!.callback
+    deadline.cancel()
+    deadline.start(timeout: 10) { expired = "B" }
+    clock.now = 10
+    old()
+    XCTAssertEqual(expired, "none")
+    let current = clock.jobs.last!.callback
+    current()
+    current()
+    XCTAssertEqual(expired, "B")
+    deadline.start(timeout: 10) { expired = "C" }
+    let cancelled = clock.jobs.last!.callback
+    deadline.cancel()
+    clock.now = 20
+    cancelled()
+    XCTAssertEqual(expired, "B")
+  }
+
+  func testEarlySchedulerCallbackWaitsForRemainder() {
+    let clock = DeadlineClock()
+    let deadline = clock.makeDeadline()
+    var expired = false
+    deadline.setForeground(true)
+    deadline.start(timeout: 10) { expired = true }
+    clock.now = 3
+    clock.jobs.last!.callback()
+    XCTAssertFalse(expired)
+    XCTAssertEqual(clock.jobs.last!.delay, 7)
+    clock.now = 10
+    clock.jobs.last!.callback()
+    XCTAssertTrue(expired)
+  }
+
+  @MainActor
+  func testApplicationNotificationsPauseRealTrialBeforeRollback() throws {
+    let fixture = try CoordinatorFixture()
+    defer { try? fixture.cleanup() }
+    try fixture.installHealthy("A")
+    try fixture.apply("B")
+    let trial = try XCTUnwrap(fixture.trial)
+    let clock = DeadlineClock()
+    let deadline = clock.makeDeadline()
+    let center = NotificationCenter()
+    deadline.observe(center: center, active: UIApplication.didBecomeActiveNotification,
+      inactive: UIApplication.willResignActiveNotification, initiallyActive: true)
+    deadline.start(timeout: 10) {
+      do {
+        let rollback = try fixture.coordinator.prepareRollback(expectedTrial: trial,
+          reason: "notify_timeout", isBundleUsable: fixture.isUsable)
+        fixture.coordinator.cleanupBundles(rollback.cleanupBundleIds)
+      } catch { XCTFail("Rollback failed: \(error)") }
+    }
+    clock.now = 4
+    center.post(name: UIApplication.willResignActiveNotification, object: nil)
+    clock.now = 600
+    clock.jobs.last!.callback()
+    XCTAssertEqual(fixture.store.getCurrentBundle().id, "B")
+    XCTAssertTrue(fixture.indexExists("A"))
+    center.post(name: UIApplication.didBecomeActiveNotification, object: nil)
+    XCTAssertEqual(clock.jobs.last!.delay, 6)
+    clock.now = 606
+    clock.jobs.last!.callback()
+    XCTAssertEqual(fixture.store.getCurrentBundle().id, "A")
+    XCTAssertFalse(fixture.indexExists("B"))
+  }
+}
+
+private final class DeadlineClock {
+  var now: TimeInterval = 0
+  var jobs: [(delay: TimeInterval, callback: () -> Void)] = []
+  func makeDeadline() -> ForegroundDeadline {
+    ForegroundDeadline(now: { [unowned self] in self.now }, schedule: { [unowned self] delay, callback in
+      self.jobs.append((delay, callback))
+      return {} // Deliberately allow tests to deliver stale callbacks.
+    })
+  }
+}

package/ios/Tests/UpdaterPluginTests/ManifestKeyConfigTests.swift

@@ -0,0 +1,48 @@
+import Foundation
+import XCTest
+@testable import UpdaterPlugin
+
+final class ManifestKeyConfigTests: XCTestCase {
+  func testMalformedExplicitConfigRejectsUnsignedHTTPManifest() async throws {
+    let body = Data(#"{"version":"1.0","sha256":"hash","size":1,"releaseId":"release-a","url":"https://example.test/bundle.zip"}"#.utf8)
+    let server = try DownloadHTTPServer(responses: [.init(status: 200, retryAfter: nil, body: body, advertisedLength: body.count)])
+    let url = try await server.start()
+    defer { server.stop() }
+    // Intentional self-hosted unsigned mode remains available without explicit keys.
+    let unsigned = try await ManifestClient.fetchLatest(cdnUrl: url.absoluteString, appId: "app",
+      channel: nil, runtimeVersion: nil, allowInsecureUrls: true)
+    XCTAssertNotNil(unsigned)
+    let keys = ManifestKeyConfig.parse(["manifestKeys": "mistyped"]).map { ManifestKey(kid: $0.kid, derData: $0.key) }
+    do {
+      _ = try await ManifestClient.fetchLatest(cdnUrl: url.absoluteString, appId: "app",
+        channel: nil, runtimeVersion: nil, allowInsecureUrls: true, manifestKeys: keys)
+      XCTFail("Malformed explicit keys must not accept an unsigned update")
+    } catch ManifestVerifierError.missingSignature {} // Expected fail-closed result.
+    XCTAssertEqual(server.requestCount, 2)
+  }
+
+  func testWrongTypeCannotSilentlyDisableVerification() {
+    for value: Any in ["mistyped", [String: String](), 123, true, NSNull()] {
+      XCTAssertFalse(ManifestKeyConfig.parse(["manifestKeys": value]).isEmpty, "\(value)")
+    }
+  }
+
+  func testAbsentAndEmptyRetainIntentionalDefaults() {
+    XCTAssertTrue(ManifestKeyConfig.parse([:]).isEmpty)
+    XCTAssertTrue(ManifestKeyConfig.parse(["manifestKeys": [Any]()]).isEmpty)
+  }
+
+  func testMalformedEntriesRemainFailClosed() {
+    for value: Any in [[[:]], [123], [["kid": "key"]]] {
+      XCTAssertFalse(ManifestKeyConfig.parse(["manifestKeys": value]).isEmpty)
+    }
+  }
+
+  func testValidConfiguredKeyIsPreserved() throws {
+    let key = try XCTUnwrap(HostedManifestKeys.defaults.first)
+    let parsed = ManifestKeyConfig.parse(["manifestKeys": [["kid": key.kid, "key": key.key.base64EncodedString()]]])
+    XCTAssertEqual(parsed.count, 1)
+    XCTAssertEqual(parsed.first?.kid, key.kid)
+    XCTAssertEqual(parsed.first?.key, key.key)
+  }
+}

package/ios/Tests/UpdaterPluginTests/UpdateOwnerTests.swift

@@ -0,0 +1,34 @@
+import Foundation
+import XCTest
+@testable import UpdaterPlugin
+
+final class UpdateOwnerTests: XCTestCase {
+  func testLostBridgeCannotPublishOrActivateAnUpdate() throws {
+    let fixture = try CoordinatorFixture()
+    defer { try? fixture.cleanup() }
+    try fixture.installHealthy("A")
+    try fixture.stage("B")
+    var bridgeAvailable = true
+    let owner = UpdateOwner(isAvailable: { bridgeAvailable })
+    // A worker may have started before the bridge disappeared.
+    try owner.run {}
+    bridgeAvailable = false
+    XCTAssertThrowsError(try owner.run {
+      try fixture.coordinator.prepareApplyStaged(isCompatibleRuntime: { _ in true }, isBundleUsable: fixture.isUsable)
+    }) { XCTAssertTrue($0 is CancellationError) }
+    XCTAssertThrowsError(try owner.run { try fixture.stage("C") })
+    XCTAssertEqual(fixture.store.getCurrentBundle().id, "A")
+    XCTAssertEqual(fixture.store.getFallbackBundleId(), "A")
+    XCTAssertEqual(fixture.store.getStagedBundleId(), "B")
+    XCTAssertTrue(fixture.indexExists("A"))
+    XCTAssertFalse(fixture.indexExists("C"))
+  }
+
+  func testLiveOwnerCanStageActivateAndConfirm() throws {
+    let fixture = try CoordinatorFixture()
+    defer { try? fixture.cleanup() }
+    let owner = UpdateOwner(isAvailable: { true })
+    try owner.run { try fixture.installHealthy("A") }
+    XCTAssertEqual(fixture.store.getCurrentBundle().status, .success)
+  }
+}