@otakit/capacitor-updater 2.3.3 → 3.0.0

package/ios/Tests/UpdaterPluginTests/UpdaterCoordinatorTests.swift

@@ -0,0 +1,394 @@
+import Foundation
+import XCTest
+@testable import UpdaterPlugin
+
+final class UpdaterCoordinatorTests: XCTestCase {
+  private var fixture: CoordinatorFixture!
+
+  override func setUpWithError() throws {
+    fixture = try CoordinatorFixture()
+  }
+
+  override func tearDownWithError() throws {
+    try fixture.cleanup()
+  }
+
+  func testReadinessAcknowledgesOnlyOnce() throws {
+    try fixture.apply("A")
+    let ready = try fixture.coordinator.prepareNotifyAppReady(activationId: fixture.trial?.activationId)
+    XCTAssertEqual(ready.eventPayload?.action, .applied)
+    XCTAssertEqual(fixture.store.getCurrentBundle().status, .success)
+    XCTAssertNil(try fixture.coordinator.prepareNotifyAppReady(activationId: fixture.trial?.activationId).eventPayload)
+  }
+
+  func testTelemetryKeepsInstallationIdentityAcrossReadinessAndRestartRollback() throws {
+    let installed = BundleStore.newInstallationId()
+    try fixture.apply(installed)
+    let applied = try fixture.coordinator.prepareNotifyAppReady(activationId: fixture.trial?.activationId).eventPayload
+    XCTAssertEqual(applied?.attemptId, installed)
+    XCTAssertEqual(applied?.phase, "readiness")
+    XCTAssertEqual(fixture.reopenStore().getCurrentBundle().attemptId, installed)
+    let failed = BundleStore.newInstallationId()
+    try fixture.apply(failed)
+    let restarted = UpdaterCoordinator(store: fixture.reopenStore())
+    let startup = try restarted.normalizeStartupState(isBundleUsable: fixture.isUsable)
+    XCTAssertEqual(startup.eventPayload?.attemptId, failed)
+    XCTAssertEqual(startup.eventPayload?.phase, "rollback")
+  }
+
+  func testLegacyBundleDoesNotInventAnAttemptIdentity() throws {
+    try fixture.apply("legacy-release")
+    let applied = try fixture.coordinator.prepareNotifyAppReady(activationId: fixture.trial?.activationId)
+    XCTAssertNil(applied.eventPayload?.attemptId)
+  }
+
+  func testOldOrUntaggedDocumentCannotConfirmNewTrial() throws {
+    try fixture.installHealthy("A")
+    let oldDocument = try XCTUnwrap(fixture.trial).activationId
+    try fixture.apply("B")
+    for identity in [oldDocument, nil] {
+      let stale = try fixture.coordinator.prepareNotifyAppReady(activationId: identity)
+      XCTAssertNil(stale.eventPayload)
+      XCTAssertTrue(stale.cleanupBundleIds.isEmpty)
+      XCTAssertEqual(fixture.store.getCurrentBundle().status, .trial)
+      XCTAssertEqual(fixture.store.getFallbackBundleId(), "A")
+    }
+    XCTAssertNotNil(try fixture.coordinator.prepareNotifyAppReady(
+      activationId: fixture.trial?.activationId
+    ).eventPayload)
+  }
+
+  func testTimeoutAfterReadinessDoesNotRollBackSuccess() throws {
+    try fixture.installHealthy("A")
+    try fixture.apply("B")
+    let ready = try fixture.coordinator.prepareNotifyAppReady(activationId: fixture.trial?.activationId)
+    fixture.coordinator.cleanupBundles(ready.cleanupBundleIds)
+    let rollback = try fixture.coordinator.prepareRollback(
+      expectedTrial: try XCTUnwrap(fixture.trial),
+      reason: "notify_timeout", isBundleUsable: fixture.isUsable
+    )
+    fixture.coordinator.cleanupBundles(rollback.cleanupBundleIds)
+    XCTAssertFalse(rollback.didRollback)
+    XCTAssertNil(rollback.eventPayload)
+    XCTAssertEqual(fixture.store.getCurrentBundle().id, "B")
+    XCTAssertEqual(fixture.store.getCurrentBundle().status, .success)
+    XCTAssertTrue(fixture.indexExists("B"))
+  }
+
+  func testFailedReadinessWritePreservesHealthyFallback() throws {
+    try fixture.installHealthy("A")
+    try fixture.apply("B")
+    try fixture.withReadOnlyMetadata("B") {
+      XCTAssertThrowsError(try fixture.coordinator.prepareNotifyAppReady(activationId: fixture.trial?.activationId))
+      XCTAssertEqual(fixture.store.getCurrentBundle().status, .trial)
+      XCTAssertEqual(fixture.store.getFallbackBundle().id, "A")
+      XCTAssertTrue(fixture.indexExists("A"))
+    }
+  }
+
+  func testFailedTrialWriteDoesNotSwitchCurrentBundle() throws {
+    try fixture.installHealthy("A")
+    try fixture.stage("B")
+    try fixture.withReadOnlyMetadata("B") {
+      XCTAssertThrowsError(try fixture.coordinator.prepareApplyStaged(
+        isCompatibleRuntime: { _ in true }, isBundleUsable: fixture.isUsable
+      ))
+      XCTAssertEqual(fixture.store.getCurrentBundle().id, "A")
+      XCTAssertEqual(fixture.store.getStagedBundleId(), "B")
+      XCTAssertTrue(fixture.indexExists("A"))
+    }
+  }
+
+  func testOldTimeoutDoesNotAffectNewTrial() throws {
+    try fixture.installHealthy("A")
+    let oldTrial = try XCTUnwrap(fixture.apply("B").trial)
+    let ready = try fixture.coordinator.prepareNotifyAppReady(activationId: fixture.trial?.activationId)
+    fixture.coordinator.cleanupBundles(ready.cleanupBundleIds)
+    try fixture.apply("C")
+    let stale = try fixture.coordinator.prepareRollback(
+      expectedTrial: oldTrial, reason: "notify_timeout", isBundleUsable: fixture.isUsable
+    )
+    XCTAssertFalse(stale.didRollback)
+    XCTAssertTrue(stale.cleanupBundleIds.isEmpty)
+    XCTAssertEqual(fixture.store.getCurrentBundle().id, "C")
+    XCTAssertEqual(fixture.store.getCurrentBundle().status, .trial)
+  }
+
+  func testOldTimeoutDoesNotAffectRetryOfSameBundle() throws {
+    try fixture.installHealthy("A")
+    let oldTrial = try XCTUnwrap(fixture.apply("B").trial)
+    let failed = try fixture.coordinator.prepareRollback(
+      expectedTrial: oldTrial, reason: "notify_timeout", isBundleUsable: fixture.isUsable
+    )
+    fixture.coordinator.cleanupBundles(failed.cleanupBundleIds)
+    let retry = try XCTUnwrap(fixture.apply("B").trial)
+    XCTAssertNotEqual(oldTrial.activationId, retry.activationId)
+    let stale = try fixture.coordinator.prepareRollback(
+      expectedTrial: oldTrial, reason: "notify_timeout", isBundleUsable: fixture.isUsable
+    )
+    XCTAssertFalse(stale.didRollback)
+    XCTAssertEqual(fixture.store.getCurrentBundle().id, "B")
+    let actual = try fixture.coordinator.prepareRollback(
+      expectedTrial: retry, reason: "notify_timeout", isBundleUsable: fixture.isUsable
+    )
+    XCTAssertTrue(actual.didRollback)
+    XCTAssertEqual(fixture.store.getCurrentBundle().id, "A")
+    let duplicate = try fixture.coordinator.prepareRollback(
+      expectedTrial: retry, reason: "notify_timeout", isBundleUsable: fixture.isUsable
+    )
+    XCTAssertFalse(duplicate.didRollback)
+  }
+
+  func testRollbackRestoresHealthyBundleAndRemovesFailedTrial() throws {
+    try fixture.installHealthy("A")
+    try fixture.apply("B")
+    let rollback = try fixture.coordinator.prepareRollback(
+      expectedTrial: try XCTUnwrap(fixture.trial),
+      reason: "notify_timeout", isBundleUsable: fixture.isUsable
+    )
+    fixture.coordinator.cleanupBundles(rollback.cleanupBundleIds)
+    XCTAssertTrue(rollback.didRollback)
+    XCTAssertEqual(fixture.store.getCurrentBundle().id, "A")
+    XCTAssertEqual(fixture.store.getCurrentBundle().status, .success)
+    XCTAssertTrue(fixture.indexExists("A"))
+    XCTAssertFalse(fixture.indexExists("B"))
+    XCTAssertEqual(rollback.activationPath, fixture.store.bundleDirectory(for: "A").path)
+  }
+
+  func testStartupRejectsIncompleteStagedBundle() throws {
+    try fixture.installHealthy("A")
+    try fixture.stage("B")
+    try FileManager.default.removeItem(at: fixture.indexURL("B"))
+    let startup = try fixture.coordinator.normalizeStartupState(isBundleUsable: fixture.isUsable)
+    fixture.coordinator.cleanupBundles(startup.cleanupBundleIds)
+    XCTAssertNil(fixture.store.getStagedBundleId())
+    XCTAssertEqual(fixture.store.getCurrentBundle().id, "A")
+    XCTAssertTrue(fixture.indexExists("A"))
+  }
+
+  func testSecondActivationWaitsForCurrentTrialAndPreservesHealthyFallback() throws {
+    try fixture.installHealthy("A")
+    try fixture.apply("B")
+    let second = try fixture.apply("C")
+    XCTAssertFalse(second.didApply)
+    XCTAssertEqual(fixture.store.getCurrentBundle().id, "B")
+    XCTAssertEqual(fixture.store.getFallbackBundle().id, "A")
+    XCTAssertEqual(fixture.store.getStagedBundleId(), "C")
+
+    let rollback = try fixture.coordinator.prepareRollback(
+      expectedTrial: try XCTUnwrap(fixture.trial),
+      reason: "notify_timeout", isBundleUsable: fixture.isUsable
+    )
+    fixture.coordinator.cleanupBundles(rollback.cleanupBundleIds)
+    let startup = try fixture.coordinator.normalizeStartupState(isBundleUsable: fixture.isUsable)
+    fixture.coordinator.cleanupBundles(startup.cleanupBundleIds)
+    XCTAssertEqual(fixture.store.getCurrentBundle().id, "A")
+    XCTAssertTrue(fixture.indexExists("A"))
+  }
+
+  func testLegacySelfFallbackRestoresBuiltinInsteadOfDeletingActivationTarget() throws {
+    try fixture.apply("B")
+    try fixture.store.setFallbackBundleId("B")
+    let startup = try fixture.coordinator.normalizeStartupState(isBundleUsable: fixture.isUsable)
+    fixture.coordinator.cleanupBundles(startup.cleanupBundleIds)
+    XCTAssertNil(startup.activationPath)
+    XCTAssertTrue(fixture.store.getCurrentBundle().isBuiltin)
+    XCTAssertNil(fixture.store.getFallbackBundleId())
+  }
+
+  func testDeferredUpdateCanApplyAfterReadiness() throws {
+    try fixture.installHealthy("A")
+    try fixture.apply("B")
+    XCTAssertFalse(try fixture.apply("C").didApply)
+    let ready = try fixture.coordinator.prepareNotifyAppReady(activationId: fixture.trial?.activationId)
+    fixture.coordinator.cleanupBundles(ready.cleanupBundleIds)
+    let applied = try fixture.coordinator.prepareApplyStaged(
+      isCompatibleRuntime: { _ in true }, isBundleUsable: fixture.isUsable
+    )
+    XCTAssertTrue(applied.didApply)
+    XCTAssertEqual(fixture.store.getCurrentBundle().id, "C")
+    XCTAssertEqual(fixture.store.getFallbackBundle().id, "B")
+    XCTAssertEqual(fixture.store.getFallbackBundle().status, .success)
+    XCTAssertTrue(fixture.indexExists("B"))
+  }
+
+  func testRollbackNeverRestoresAnUnconfirmedFallback() throws {
+    try fixture.apply("B")
+    try fixture.stage("C")
+    try fixture.store.setFallbackBundleId("C")
+    let rollback = try fixture.coordinator.prepareRollback(
+      expectedTrial: try XCTUnwrap(fixture.trial),
+      reason: "notify_timeout", isBundleUsable: fixture.isUsable
+    )
+    fixture.coordinator.cleanupBundles(rollback.cleanupBundleIds)
+    XCTAssertNil(rollback.activationPath)
+    XCTAssertTrue(fixture.store.getCurrentBundle().isBuiltin)
+  }
+
+  func testCleanupRechecksReferencesBeforeDeleting() throws {
+    try fixture.installHealthy("A")
+    try fixture.apply("B")
+    try fixture.stage("C")
+    fixture.coordinator.cleanupBundles(["A", "B", "C", "builtin"])
+    XCTAssertTrue(fixture.indexExists("A"))
+    XCTAssertTrue(fixture.indexExists("B"))
+    XCTAssertTrue(fixture.indexExists("C"))
+  }
+
+  func testStagingCannotOverwriteReferencedBundleMetadata() throws {
+    try fixture.installHealthy("A")
+    try fixture.apply("B")
+    try fixture.stage("C")
+    for id in ["A", "B", "C"] {
+      let existing = try XCTUnwrap(fixture.store.getBundle(id: id))
+      XCTAssertThrowsError(try fixture.coordinator.stageDownloadedBundle(existing.withStatus(.error)))
+      XCTAssertEqual(fixture.store.getBundle(id: id)?.status, existing.status)
+      XCTAssertTrue(fixture.indexExists(id))
+    }
+    XCTAssertEqual(fixture.store.getCurrentBundleId(), "B")
+    XCTAssertEqual(fixture.store.getFallbackBundleId(), "A")
+    XCTAssertEqual(fixture.store.getStagedBundleId(), "C")
+    let rollback = try fixture.coordinator.prepareRollback(
+      expectedTrial: try XCTUnwrap(fixture.trial), reason: "notify_timeout",
+      isBundleUsable: fixture.isUsable
+    )
+    XCTAssertEqual(rollback.activationPath, fixture.store.bundleDirectory(for: "A").path)
+  }
+
+  func testFreshInstallationIdPreservesReleaseMatching() throws {
+    let first = BundleStore.newInstallationId()
+    let second = BundleStore.newInstallationId()
+    XCTAssertNotEqual(first, second)
+    try fixture.installHealthy(first)
+    let latest = LatestManifest(
+      version: first, url: nil, sha256: "hash-\(first)", size: 0,
+      runtimeVersion: nil, releaseId: "release-\(first)", strategy: "zip",
+      forceImmediate: false, encryption: nil, files: nil
+    )
+    switch fixture.coordinator.classifyLatestManifest(
+      latest, targetChannel: nil, isStagedBundleUsable: fixture.isUsable
+    ) {
+    case .noUpdate: break
+    default: XCTFail("Release matching must not depend on installation ID")
+    }
+    try fixture.apply("B")
+    try fixture.stage(second)
+    let incoming = BundleInfo(
+      id: second, version: first, runtimeVersion: nil, status: .pending,
+      downloadedAt: Date(), sha256: latest.sha256,
+      path: fixture.store.bundleDirectory(for: second).path,
+      channel: nil, releaseId: latest.releaseId
+    )
+    try fixture.store.saveBundle(incoming)
+    switch fixture.coordinator.classifyLatestManifest(
+      latest, targetChannel: nil, isStagedBundleUsable: fixture.isUsable
+    ) {
+    case .alreadyStaged(let bundle): XCTAssertEqual(bundle.id, second)
+    default: XCTFail("The fresh installation must be reusable as a staged release")
+    }
+    XCTAssertEqual(fixture.store.getBundle(id: first)?.status, .success)
+    XCTAssertTrue(fixture.indexExists(first))
+  }
+
+  func testFailedStagingCleanupPreservesCurrentAndSuccessfulStaging() throws {
+    try fixture.installHealthy("A")
+    let orphan = BundleStore.newInstallationId()
+    try fixture.withReadOnlyState { XCTAssertThrowsError(try fixture.stage(orphan)) }
+    fixture.coordinator.cleanupBundles([orphan])
+    XCTAssertFalse(fixture.indexExists(orphan))
+    XCTAssertTrue(fixture.indexExists("A"))
+    let staged = BundleStore.newInstallationId()
+    try fixture.stage(staged)
+    fixture.coordinator.cleanupBundles([staged])
+    XCTAssertTrue(fixture.indexExists(staged))
+    XCTAssertEqual(fixture.store.getStagedBundleId(), staged)
+  }
+}
+
+final class CoordinatorFixture {
+  let root: URL
+  let defaults: UserDefaults
+  let suiteName = "otakit-coordinator-tests-\(UUID().uuidString)"
+  let store: BundleStore
+  let coordinator: UpdaterCoordinator
+  var trial: UpdaterCoordinator.Trial?
+
+  init() throws {
+    root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+    try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
+    defaults = try XCTUnwrap(UserDefaults(suiteName: suiteName))
+    store = BundleStore(defaults: defaults, rootDirectory: root)
+    coordinator = UpdaterCoordinator(store: store)
+  }
+
+  func cleanup() throws {
+    defaults.removePersistentDomain(forName: suiteName)
+    try FileManager.default.removeItem(at: root)
+  }
+
+  func withReadOnlyMetadata(_ id: String, work: () throws -> Void) throws {
+    let directory = store.bundleDirectory(for: id)
+    let metadata = directory.appendingPathComponent("bundle.json")
+    let manager = FileManager.default
+    try manager.setAttributes([.posixPermissions: 0o400], ofItemAtPath: metadata.path)
+    try manager.setAttributes([.posixPermissions: 0o500], ofItemAtPath: directory.path)
+    defer {
+      try? manager.setAttributes([.posixPermissions: 0o700], ofItemAtPath: directory.path)
+      try? manager.setAttributes([.posixPermissions: 0o600], ofItemAtPath: metadata.path)
+    }
+    try work()
+  }
+
+  func reopenStore() -> BundleStore {
+    BundleStore(defaults: defaults, rootDirectory: root)
+  }
+
+  func withReadOnlyState(work: () throws -> Void) throws {
+    let manager = FileManager.default
+    try manager.setAttributes([.posixPermissions: 0o500], ofItemAtPath: root.path)
+    defer { try? manager.setAttributes([.posixPermissions: 0o700], ofItemAtPath: root.path) }
+    try work()
+  }
+
+  func indexURL(_ id: String) -> URL {
+    store.bundleDirectory(for: id).appendingPathComponent("index.html")
+  }
+
+  func indexExists(_ id: String) -> Bool {
+    FileManager.default.fileExists(atPath: indexURL(id).path)
+  }
+
+  func isUsable(_ bundle: BundleInfo) -> Bool {
+    bundle.isBuiltin || indexExists(bundle.id)
+  }
+
+  func stage(_ id: String) throws {
+    let directory = store.bundleDirectory(for: id)
+    try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+    try Data(id.utf8).write(to: indexURL(id))
+    let bundle = BundleInfo(
+      id: id, version: id, runtimeVersion: nil, status: .pending, downloadedAt: Date(),
+      sha256: "hash-\(id)", path: directory.path, channel: nil, releaseId: "release-\(id)"
+    )
+    coordinator.cleanupBundles(try coordinator.stageDownloadedBundle(bundle))
+  }
+
+  @discardableResult
+  func apply(_ id: String) throws -> UpdaterCoordinator.ApplyPreparation {
+    try stage(id)
+    let result = try coordinator.prepareApplyStaged(
+      isCompatibleRuntime: { _ in true }, isBundleUsable: isUsable
+    )
+    if let active = result.trial { trial = active }
+    coordinator.cleanupBundles(result.cleanupBundleIds)
+    return result
+  }
+
+  func installHealthy(_ id: String) throws {
+    let applied = try apply(id)
+    XCTAssertTrue(applied.didApply)
+    let ready = try coordinator.prepareNotifyAppReady(activationId: trial?.activationId)
+    XCTAssertNotNil(ready.eventPayload)
+    coordinator.cleanupBundles(ready.cleanupBundleIds)
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@otakit/capacitor-updater",
-  "version": "2.3.3",
+  "version": "3.0.0",
   "description": "Capacitor plugin for OTA updates",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",
@@ -38,7 +38,10 @@
   ],
   "scripts": {
     "verify": "npm run verify:minimal && npm run verify:pack",
-    "verify:minimal": "node -e \"console.log('Native verification is not wired yet')\"",
+    "verify:minimal": "npm run verify:android && npm run verify:ios",
+    "verify:android": "../../examples/demo-app/android/gradlew -p android/test-project :otakit-capacitor-updater:testDebugUnitTest --console=plain",
+    "verify:android:device": "../../examples/demo-app/android/gradlew -p android/test-project :otakit-capacitor-updater:connectedDebugAndroidTest --console=plain",
+    "verify:ios": "node ../../scripts/verify-ios-plugin.mjs",
     "verify:pack": "npm pack --dry-run --json --cache /tmp/otakit-npm-pack-cache | node -e \"const data=JSON.parse(require('fs').readFileSync(0,'utf8')); const files=(data[0]?.files??[]).map((f)=>f.path); if(!files.includes('Package.swift')){console.error('Missing Package.swift in published tarball'); process.exit(1)} console.log('Verified tarball includes Package.swift')\"",
     "verify:web": "npm run build",
     "lint": "npm run eslint && npm run prettier -- --check && npm run swiftlint -- lint",
@@ -47,10 +50,11 @@
     "prettier": "prettier \"src/**/*.{ts,js}\" \"android/src/main/java/**/*.java\" --plugin=prettier-plugin-java",
     "swiftlint": "node-swiftlint",
     "docgen": "docgen --api UpdaterPlugin --output-readme README.md --output-json dist/docs.json",
-    "build": "npm run clean && tsc && rollup -c rollup.config.mjs",
+    "build": "node ../../scripts/generate-native-sdk-version.mjs --write && npm run clean && tsc && rollup -c rollup.config.mjs",
     "clean": "rimraf ./dist",
     "watch": "tsc --watch",
     "prepublishOnly": "npm run build",
+    "prepack": "node ../../scripts/generate-native-sdk-version.mjs --write",
     "typecheck": "tsc --noEmit"
   },
   "devDependencies": {