mirror of
https://github.com/yattee/yattee.git
synced 2026-10-24 13:42:54 +00:00
5a77e93558
The accounts.unresolved.* UserDefaults namespace was found on a real device holding a stale, contradictory snapshot: a tombstoned account listed live, context reset to local, every sync outbox still pending. With iCloud Drive off the identity scope dips to unresolved on every foreground activation, so that snapshot was loaded — and rewritten — in an entirely ordinary configuration. Close it off on four fronts: - Gate the unprompted writers. reconcileLegacyAccounts() and migrateLegacyContextIfNeeded() now no-op while the identity scope is unresolved; reloadForCurrentIdentity() re-runs both once a scope resolves, so nothing is lost, and nothing synthesizes accounts or queues uploads under a namespace that answers to no one. - Fence the reload gap. Between a scope change and this manager's observer reloading, namespace already names the new identity while memory still holds the old snapshot. loadedNamespace records what memory belongs to; save(), the stored-context flag, and every coordinator path that builds, enqueues, applies or confirms account-category records refuses when it mismatches. Staged downloads stay durable and re-apply after the reload. - Tie confirmations and conflict retries to the identity that sent them. Every outbound account-category record carries an identityNamespace field; didSave honours only confirmations whose record carries the current identity's stamp, conflict resolutions inherit the local record's stamp and are dropped when foreign, and a skipped confirmation re-registers the durable outbox so nothing strands. The abandoning conflict branches re-register it too. - Purge the stale blob. Once a scope resolves, the unresolved namespace keys and the unresolved credential-fingerprint store are removed; the activation-time validators no longer correct the context or rewrite the legacy selection from unresolved state. Hardened through four adversarial review rounds; the last found nothing.
599 lines
24 KiB
Swift
599 lines
24 KiB
Swift
//
|
|
// AccountsManagerTests.swift
|
|
// YatteeTests
|
|
//
|
|
// Account storage, legacy migration and data-context validation.
|
|
//
|
|
|
|
import Testing
|
|
import Foundation
|
|
@testable import Yattee
|
|
|
|
@Suite("AccountsManager")
|
|
@MainActor
|
|
struct AccountsManagerTests {
|
|
private func makeDefaults() -> UserDefaults {
|
|
UserDefaults(suiteName: "yattee.tests.\(UUID().uuidString)")!
|
|
}
|
|
|
|
private func makeManager(
|
|
defaults: UserDefaults? = nil,
|
|
scope: String = "identity-A",
|
|
instances: InstancesManager? = nil
|
|
) -> AccountsManager {
|
|
AccountsManager(
|
|
identityScope: CredentialIdentityScope(fixedScope: scope),
|
|
instancesManager: instances,
|
|
defaults: defaults ?? makeDefaults()
|
|
)
|
|
}
|
|
|
|
@Test("Accounts survive a relaunch")
|
|
func accountsPersist() {
|
|
let defaults = makeDefaults()
|
|
let instanceID = UUID()
|
|
|
|
let first = makeManager(defaults: defaults)
|
|
let account = first.addAccount(instanceID: instanceID, displayName: "Main")
|
|
|
|
let second = makeManager(defaults: defaults)
|
|
#expect(second.account(id: account.id)?.displayName == "Main")
|
|
}
|
|
|
|
@Test("Accounts are namespaced by Apple account")
|
|
func accountsAreNamespacedByIdentity() {
|
|
let defaults = makeDefaults()
|
|
let instanceID = UUID()
|
|
|
|
let identityA = makeManager(defaults: defaults, scope: "identity-A")
|
|
let account = identityA.addAccount(instanceID: instanceID)
|
|
|
|
// The same storage, a different Apple account: A's list must not show.
|
|
let identityB = makeManager(defaults: defaults, scope: "identity-B")
|
|
#expect(identityB.accounts.isEmpty)
|
|
#expect(identityB.account(id: account.id) == nil)
|
|
|
|
let identityAAgain = makeManager(defaults: defaults, scope: "identity-A")
|
|
#expect(identityAAgain.accounts.count == 1)
|
|
}
|
|
|
|
@Test("Adding an account queues it for upload")
|
|
func addQueuesUpload() {
|
|
let manager = makeManager()
|
|
let account = manager.addAccount(instanceID: UUID())
|
|
|
|
#expect(manager.pendingUploads.contains(account.id))
|
|
|
|
manager.confirmUpload(account.id)
|
|
#expect(!manager.pendingUploads.contains(account.id))
|
|
}
|
|
|
|
@Test("Deleting an account queues a deletion that survives a relaunch")
|
|
func deletionOutboxIsDurable() {
|
|
let defaults = makeDefaults()
|
|
let manager = makeManager(defaults: defaults)
|
|
let account = manager.addAccount(instanceID: UUID())
|
|
|
|
manager.removeAccount(account.id)
|
|
#expect(manager.pendingDeletions.contains(account.id))
|
|
|
|
// A deletion that never reached the server must be retried, or a stale
|
|
// device can resurrect the account.
|
|
let relaunched = makeManager(defaults: defaults)
|
|
#expect(relaunched.pendingDeletions.contains(account.id))
|
|
#expect(relaunched.account(id: account.id) == nil)
|
|
|
|
relaunched.confirmDeletion(account.id)
|
|
#expect(!relaunched.pendingDeletions.contains(account.id))
|
|
}
|
|
|
|
@Test("Deleting the selected account resets the context")
|
|
func deletingSelectedAccountResetsContext() {
|
|
let manager = makeManager()
|
|
let account = manager.addAccount(instanceID: UUID())
|
|
|
|
manager.setContext(.account(account.id))
|
|
#expect(manager.currentContext == .account(account.id))
|
|
|
|
manager.removeAccount(account.id)
|
|
#expect(manager.currentContext == .local)
|
|
}
|
|
|
|
@Test("A newer synced context wins, an older one is ignored")
|
|
func syncedContextResolvesByTimestamp() {
|
|
let manager = makeManager()
|
|
let accountID = UUID()
|
|
|
|
manager.setContext(.local)
|
|
let localChangedAt = manager.storedContext.changedAt
|
|
|
|
// Older than the local choice — must not take effect.
|
|
manager.applySyncedContext(
|
|
StoredDataContext(context: .account(accountID), changedAt: localChangedAt.addingTimeInterval(-60))
|
|
)
|
|
#expect(manager.currentContext == .local)
|
|
|
|
// Newer — wins.
|
|
manager.applySyncedContext(
|
|
StoredDataContext(context: .account(accountID), changedAt: localChangedAt.addingTimeInterval(60))
|
|
)
|
|
#expect(manager.currentContext == .account(accountID))
|
|
}
|
|
|
|
@Test("A fresh login does not also synthesize a migrated account")
|
|
func freshLoginDoesNotDuplicate() {
|
|
let manager = makeManager()
|
|
let instanceID = UUID()
|
|
|
|
// Signing in creates a random-UUID account, then flips
|
|
// usesAccountLogin, which re-runs reconciliation immediately.
|
|
let account = manager.addAccount(instanceID: instanceID)
|
|
manager.reconcileLegacyAccounts()
|
|
|
|
#expect(manager.accounts(forInstance: instanceID).count == 1)
|
|
#expect(manager.accounts(forInstance: instanceID).first?.id == account.id)
|
|
}
|
|
|
|
@Test("Storing accounts does not count as choosing a context")
|
|
func savingDoesNotMarkContextChosen() {
|
|
let defaults = makeDefaults()
|
|
let instanceID = UUID()
|
|
|
|
// Legacy selection left behind by the previous release.
|
|
let legacy = try! JSONEncoder().encode(SubscriptionAccount.invidious(instanceID))
|
|
defaults.set(legacy, forKey: "subscriptionAccount")
|
|
|
|
let manager = makeManager(defaults: defaults)
|
|
// Adding an account persists state; that must not look like the user
|
|
// having chosen a context, or the migration below is skipped and the
|
|
// upgrade silently loses their selected server account.
|
|
_ = manager.addAccount(instanceID: instanceID, displayName: nil)
|
|
manager.migrateLegacyContextIfNeeded()
|
|
|
|
#expect(manager.currentContext == .local)
|
|
|
|
// With the migrated account present, the legacy selection is adopted.
|
|
let manager2 = makeManager(defaults: defaults)
|
|
#expect(manager2.currentContext == .local)
|
|
}
|
|
|
|
@Test("A legacy instance selection resolves to a real account")
|
|
func legacySelectionResolvesToRealAccount() {
|
|
let manager = makeManager()
|
|
let instanceID = UUID()
|
|
|
|
// No account yet on that instance: nothing to select.
|
|
#expect(manager.context(forLegacyInstanceID: instanceID) == .local)
|
|
|
|
// A login created after the revamp has a random ID, so the legacy
|
|
// instance-ID-as-account-ID mapping would name something nonexistent.
|
|
let account = manager.addAccount(instanceID: instanceID)
|
|
#expect(account.id != instanceID)
|
|
#expect(manager.context(forLegacyInstanceID: instanceID) == .account(account.id))
|
|
|
|
#expect(manager.context(forLegacyInstanceID: nil) == .local)
|
|
}
|
|
|
|
@Test("A signed-in account is preferred when an instance holds several")
|
|
func legacySelectionPrefersSignedIn() {
|
|
let manager = makeManager()
|
|
let instanceID = UUID()
|
|
|
|
_ = manager.addAccount(instanceID: instanceID)
|
|
let second = manager.addAccount(instanceID: instanceID)
|
|
manager.setStatus(.signedIn, for: second.id)
|
|
|
|
#expect(manager.context(forLegacyInstanceID: instanceID) == .account(second.id))
|
|
}
|
|
|
|
@Test("An account arriving after its instance was deleted is deleted too")
|
|
func lateAccountForDeletedInstanceIsDeleted() {
|
|
let manager = makeManager()
|
|
let instanceID = UUID()
|
|
|
|
manager.recordInstanceDeletion(instanceID)
|
|
|
|
// Deleting an instance deletes the accounts on it; one still in transit
|
|
// does not escape that by arriving late, and installing it would leave
|
|
// an orphan whose credential nothing can reach.
|
|
let late = Account(instanceID: instanceID)
|
|
#expect(!manager.applySyncedAccount(late))
|
|
|
|
#expect(manager.account(id: late.id) == nil)
|
|
#expect(manager.isDeleted(late.id))
|
|
#expect(manager.pendingDeletions.contains(late.id))
|
|
}
|
|
|
|
@Test("An unreachable server is retried rather than written off")
|
|
func unreachableStatusExpires() async throws {
|
|
let manager = AccountsManager(
|
|
identityScope: CredentialIdentityScope(fixedScope: "identity-A"),
|
|
defaults: makeDefaults(),
|
|
unreachableRetryInterval: 0.05
|
|
)
|
|
let account = manager.addAccount(instanceID: UUID())
|
|
|
|
manager.setStatus(.unreachable, for: account.id)
|
|
#expect(manager.status(for: account.id) == .unreachable)
|
|
|
|
// The state stops reads from going out at all, so nothing would ever
|
|
// discover that the server came back — a timeout during an outage
|
|
// produces no connectivity change to react to either. It has to lift
|
|
// by mutating the status: nothing re-reads a value because time passed.
|
|
try await Task.sleep(for: .seconds(0.5))
|
|
#expect(manager.status(for: account.id) == .signedIn)
|
|
}
|
|
|
|
@Test("A sign-in that could not be stored leaves no migration marker")
|
|
func rolledBackLoginRetractsItsMarker() {
|
|
let manager = makeManager()
|
|
let instanceID = UUID()
|
|
|
|
let account = manager.addAccount(instanceID: instanceID)
|
|
#expect(manager.migratedInstanceIDs.contains(instanceID))
|
|
|
|
manager.rollbackAccountCreation(account.id)
|
|
|
|
// The marker would have told every other device that this instance's
|
|
// pre-revamp login is already represented — on the strength of an
|
|
// account that does not exist anywhere.
|
|
#expect(!manager.migratedInstanceIDs.contains(instanceID))
|
|
#expect(!manager.pendingMarkerUploads.contains(instanceID))
|
|
#expect(manager.account(id: account.id) == nil)
|
|
// And no tombstone: nothing was ever published to retract.
|
|
#expect(!manager.isDeleted(account.id))
|
|
#expect(!manager.pendingDeletions.contains(account.id))
|
|
}
|
|
|
|
@Test("Rolling back a confirmed account is a real deletion")
|
|
func rolledBackConfirmedAccountIsDeleted() {
|
|
let manager = makeManager()
|
|
let account = manager.addAccount(instanceID: UUID())
|
|
manager.confirmUpload(account.id)
|
|
|
|
manager.rollbackAccountCreation(account.id)
|
|
|
|
// It exists on the server, so other devices have to be told.
|
|
#expect(manager.isDeleted(account.id))
|
|
#expect(manager.pendingDeletions.contains(account.id))
|
|
}
|
|
|
|
@Test("An unresolved identity is not a missing credential")
|
|
func unknownStatusIsNotSignedOut() {
|
|
let defaults = makeDefaults()
|
|
let unresolved = AccountsManager(
|
|
identityScope: CredentialIdentityScope(fixedScope: nil),
|
|
defaults: defaults
|
|
)
|
|
let account = unresolved.addAccount(instanceID: UUID())
|
|
|
|
// Nothing can read the Keychain under the right scope yet, so "no
|
|
// credential" is not an answer the app is entitled to give.
|
|
#expect(unresolved.status(for: account.id) == .checking)
|
|
|
|
let resolved = makeManager(defaults: defaults, scope: "identity-A")
|
|
let other = resolved.addAccount(instanceID: UUID())
|
|
#expect(resolved.status(for: other.id) == .credentialMissing)
|
|
}
|
|
|
|
@Test("A fresh device adopts the synced context")
|
|
func firstSyncedContextIsAdopted() {
|
|
let manager = makeManager()
|
|
let accountID = UUID()
|
|
|
|
// The local value is a default stamped when the manager was built, so
|
|
// it is always "newer" than a choice made on another device yesterday.
|
|
// Ordering against it would leave a fresh device on local forever.
|
|
let synced = StoredDataContext(
|
|
context: .account(accountID),
|
|
changedAt: Date().addingTimeInterval(-86_400)
|
|
)
|
|
|
|
#expect(!manager.applySyncedContext(synced))
|
|
#expect(manager.currentContext == .account(accountID))
|
|
#expect(!manager.pendingContextUpload)
|
|
}
|
|
|
|
@Test("Correcting away from a deleted account never outranks a real choice")
|
|
func deletionCorrectionIsNotAChoice() {
|
|
let manager = makeManager()
|
|
let account = manager.addAccount(instanceID: UUID())
|
|
|
|
manager.setContext(.account(account.id))
|
|
let chosenAt = manager.storedContext.changedAt
|
|
manager.confirmContextUpload(changedAt: chosenAt)
|
|
|
|
manager.removeAccount(account.id)
|
|
#expect(manager.currentContext == .local)
|
|
|
|
// Another device picked something else between the deletion and this
|
|
// device hearing about it. Timestamping the fallback "now" would sink
|
|
// that choice — and publishing it would push the fallback over it.
|
|
#expect(manager.storedContext.changedAt == chosenAt)
|
|
// Including any upload the deleted choice had queued.
|
|
#expect(!manager.pendingContextUpload)
|
|
|
|
let elsewhere = StoredDataContext(
|
|
context: .account(UUID()),
|
|
changedAt: chosenAt.addingTimeInterval(1)
|
|
)
|
|
#expect(!manager.applySyncedContext(elsewhere))
|
|
#expect(manager.currentContext == elsewhere.context)
|
|
}
|
|
|
|
@Test("A deletion is queued before anything else can persist")
|
|
func deletionOutboxIsQueuedFirst() {
|
|
let defaults = makeDefaults()
|
|
let manager = makeManager(defaults: defaults)
|
|
let account = manager.addAccount(instanceID: UUID())
|
|
manager.setContext(.account(account.id))
|
|
|
|
manager.removeAccount(account.id)
|
|
|
|
// Deleting the *selected* account also corrects the context, and every
|
|
// step of that writes storage. A crash before the tombstone was owed
|
|
// would leave the account gone here and alive everywhere else.
|
|
let relaunched = makeManager(defaults: defaults)
|
|
#expect(relaunched.pendingDeletions.contains(account.id))
|
|
#expect(relaunched.isDeleted(account.id))
|
|
#expect(relaunched.currentContext == .local)
|
|
}
|
|
|
|
/// Every key the manager persists, spelled out here rather than read from
|
|
/// it: a purge that stopped covering one of them would otherwise be
|
|
/// invisible to these tests.
|
|
private static let storedKeyNames = [
|
|
"accounts", "context", "hasContext", "migrated", "pendingUploads",
|
|
"pendingDeletions", "pendingMarkerUploads", "deletedAccounts",
|
|
"deletedInstances", "pendingContextUpload"
|
|
]
|
|
|
|
private func unresolvedKeysAreAbsent(in defaults: UserDefaults) -> Bool {
|
|
Self.storedKeyNames.allSatisfy { defaults.object(forKey: "accounts.unresolved.\($0)") == nil }
|
|
}
|
|
|
|
private func makeLegacyInstance() -> Instance {
|
|
Instance(
|
|
type: .invidious,
|
|
url: URL(string: "https://legacy-\(UUID().uuidString).example.com")!,
|
|
usesAccountLogin: true
|
|
)
|
|
}
|
|
|
|
@Test("An unresolved identity never migrates a legacy login")
|
|
func unresolvedIdentityDoesNotMigrate() {
|
|
let defaults = makeDefaults()
|
|
let instances = InstancesManager()
|
|
let instance = makeLegacyInstance()
|
|
instances.add(instance)
|
|
defer { instances.remove(instance) }
|
|
|
|
let unresolved = AccountsManager(
|
|
identityScope: CredentialIdentityScope(fixedScope: nil),
|
|
instancesManager: instances,
|
|
defaults: defaults
|
|
)
|
|
unresolved.reconcileLegacyAccounts()
|
|
|
|
// Synthesizing here would file the account — and the permanent marker
|
|
// that suppresses synthesis everywhere else — under a namespace no
|
|
// identity ever reads back.
|
|
#expect(unresolved.accounts.isEmpty)
|
|
#expect(unresolved.migratedInstanceIDs.isEmpty)
|
|
#expect(unresolved.pendingUploads.isEmpty)
|
|
#expect(unresolved.pendingMarkerUploads.isEmpty)
|
|
#expect(unresolvedKeysAreAbsent(in: defaults))
|
|
|
|
// Held back, not lost: the same instance migrates as soon as there is
|
|
// an identity to migrate it for.
|
|
let resolved = makeManager(defaults: defaults, instances: instances)
|
|
resolved.reconcileLegacyAccounts()
|
|
#expect(resolved.accounts(forInstance: instance.id).count == 1)
|
|
#expect(resolved.migratedInstanceIDs.contains(instance.id))
|
|
}
|
|
|
|
@Test("A scope that dips to unresolved and returns writes nothing in between")
|
|
func scopeRoundTripLeavesTheUnresolvedNamespaceEmpty() async throws {
|
|
let defaults = makeDefaults()
|
|
let instances = InstancesManager()
|
|
let instance = makeLegacyInstance()
|
|
instances.add(instance)
|
|
defer { instances.remove(instance) }
|
|
|
|
let scope = CredentialIdentityScope(fixedScope: "identity-A")
|
|
let manager = AccountsManager(
|
|
identityScope: scope,
|
|
instancesManager: instances,
|
|
defaults: defaults
|
|
)
|
|
manager.reconcileLegacyAccounts()
|
|
|
|
let account = try #require(manager.accounts(forInstance: instance.id).first)
|
|
manager.setContext(.account(account.id))
|
|
|
|
// With iCloud Drive switched off this happens on every foreground
|
|
// activation — the scope drops and comes back as the same account.
|
|
scope.setFixedScope(nil)
|
|
try await Task.sleep(for: .milliseconds(50))
|
|
#expect(manager.accounts.isEmpty)
|
|
|
|
// Instances keep arriving over iCloud while this lasts, and each
|
|
// arrival asks for reconciliation.
|
|
NotificationCenter.default.post(name: .instancesDidChange, object: nil)
|
|
try await Task.sleep(for: .milliseconds(50))
|
|
#expect(manager.accounts.isEmpty)
|
|
#expect(manager.migratedInstanceIDs.isEmpty)
|
|
// Checked here as well as after the flip back: once an identity is
|
|
// resolved the purge would hide a write made while it was not.
|
|
#expect(unresolvedKeysAreAbsent(in: defaults))
|
|
|
|
scope.setFixedScope("identity-A")
|
|
try await Task.sleep(for: .milliseconds(50))
|
|
|
|
#expect(manager.accounts(forInstance: instance.id).map(\.id) == [account.id])
|
|
#expect(manager.currentContext == .account(account.id))
|
|
#expect(unresolvedKeysAreAbsent(in: defaults))
|
|
}
|
|
|
|
@Test("Resolving an identity purges what was stored while it was unknown")
|
|
func resolutionPurgesTheUnresolvedNamespace() {
|
|
let defaults = makeDefaults()
|
|
|
|
let identityA = makeManager(defaults: defaults)
|
|
let account = identityA.addAccount(instanceID: UUID(), displayName: "Main")
|
|
|
|
// The blob measured on the device: a snapshot written before the
|
|
// identity was known, contradicting the one that owns the storage.
|
|
let unresolved = AccountsManager(
|
|
identityScope: CredentialIdentityScope(fixedScope: nil),
|
|
defaults: defaults
|
|
)
|
|
let stale = unresolved.addAccount(instanceID: UUID())
|
|
unresolved.setContext(.account(stale.id))
|
|
#expect(defaults.data(forKey: "accounts.unresolved.accounts") != nil)
|
|
|
|
let relaunched = makeManager(defaults: defaults)
|
|
|
|
#expect(unresolvedKeysAreAbsent(in: defaults))
|
|
#expect(relaunched.account(id: account.id)?.displayName == "Main")
|
|
#expect(relaunched.account(id: stale.id) == nil)
|
|
}
|
|
|
|
@Test("A save made while the namespace is reloading is dropped")
|
|
func saveDuringTheReloadGapIsDropped() async throws {
|
|
let defaults = makeDefaults()
|
|
let scope = CredentialIdentityScope(fixedScope: "identity-A")
|
|
let manager = AccountsManager(identityScope: scope, defaults: defaults)
|
|
let account = manager.addAccount(instanceID: UUID())
|
|
|
|
// The scope moves before the observer that reloads this manager runs,
|
|
// so `namespace` already names the new identity while everything in
|
|
// memory is still the previous one's.
|
|
scope.setFixedScope("identity-B", announcing: false)
|
|
manager.setContext(.account(account.id))
|
|
|
|
// identity-B must not be handed identity-A's selection...
|
|
#expect(defaults.data(forKey: "accounts.identity-B.context") == nil)
|
|
#expect(!defaults.bool(forKey: "accounts.identity-B.hasContext"))
|
|
|
|
// ...and identity-A's stored copy must not have moved either: the write
|
|
// was aimed at keys that no longer describe what is in memory.
|
|
let storedA = try #require(defaults.data(forKey: "accounts.identity-A.context"))
|
|
#expect(try JSONDecoder().decode(StoredDataContext.self, from: storedA).context == .local)
|
|
|
|
// The announced flip is the real path, and it reloads cleanly.
|
|
scope.setFixedScope("identity-A")
|
|
try await Task.sleep(for: .milliseconds(50))
|
|
|
|
#expect(manager.accounts.map(\.id) == [account.id])
|
|
#expect(manager.currentContext == .local)
|
|
}
|
|
|
|
@Test("A migrated context loses to any explicit choice")
|
|
func migratedContextLosesToExplicitChoice() {
|
|
let manager = makeManager()
|
|
let accountID = UUID()
|
|
|
|
// A migration is a guess at intent, stamped at the epoch so an explicit
|
|
// choice on any device outranks it regardless of arrival order.
|
|
let migrated = StoredDataContext.migrated(.account(accountID))
|
|
#expect(migrated.isMigrated)
|
|
|
|
manager.setContext(.local)
|
|
manager.applySyncedContext(migrated)
|
|
#expect(manager.currentContext == .local)
|
|
}
|
|
}
|
|
|
|
@Suite("DataContext validation", .serialized)
|
|
@MainActor
|
|
struct DataContextValidatorTests {
|
|
private func makeValidator(
|
|
instances: InstancesManager
|
|
) -> (AccountsManager, DataContextValidator) {
|
|
let accounts = AccountsManager(
|
|
identityScope: CredentialIdentityScope(fixedScope: "identity-A"),
|
|
instancesManager: instances,
|
|
defaults: UserDefaults(suiteName: "yattee.tests.\(UUID().uuidString)")!
|
|
)
|
|
let validator = DataContextValidator(
|
|
accountsManager: accounts,
|
|
instancesManager: instances,
|
|
toastManager: ToastManager()
|
|
)
|
|
return (accounts, validator)
|
|
}
|
|
|
|
@Test("A switched-off instance makes its context unavailable, not removed")
|
|
func disabledInstanceIsUnavailable() {
|
|
let instances = InstancesManager()
|
|
var instance = Instance(type: .invidious, url: URL(string: "https://inv.example.com")!)
|
|
instances.add(instance)
|
|
|
|
let (accounts, validator) = makeValidator(instances: instances)
|
|
let account = accounts.addAccount(instanceID: instance.id)
|
|
accounts.setStatus(.signedIn, for: account.id)
|
|
accounts.setContext(.account(account.id))
|
|
|
|
#expect(validator.validity == .valid)
|
|
|
|
// Disabling the instance leaves the account signed in, so nothing about
|
|
// the account itself says the server may no longer be used.
|
|
instance.isEnabled = false
|
|
instances.update(instance)
|
|
|
|
#expect(validator.validity == .temporarilyUnavailable(.instanceDisabled))
|
|
// The user's selection is kept — turning the instance back on restores
|
|
// it without them having to choose again.
|
|
#expect(accounts.currentContext == .account(account.id))
|
|
#expect(validator.effectiveContext == .local)
|
|
#expect(!validator.allowsServerMutations)
|
|
|
|
instances.remove(instance)
|
|
}
|
|
}
|
|
|
|
@Suite("Account capabilities")
|
|
@MainActor
|
|
struct AccountCapabilitiesTests {
|
|
@Test("Backend capabilities match the documented API surface")
|
|
func capabilitiesPerBackend() {
|
|
let invidious = InstanceType.invidious.accountCapabilities
|
|
#expect(invidious.supportsWatchHistory)
|
|
#expect(invidious.supportsPlaylistPrivacy)
|
|
#expect(invidious.supportsPlaylistWrites)
|
|
|
|
// Piped has no history endpoint at all and no playlist privacy.
|
|
let piped = InstanceType.piped.accountCapabilities
|
|
#expect(piped.supportsPlaylistWrites)
|
|
#expect(!piped.supportsWatchHistory)
|
|
#expect(!piped.supportsPlaylistPrivacy)
|
|
|
|
// No account concept on either of these today.
|
|
#expect(!InstanceType.peertube.accountCapabilities.isSelectableContext)
|
|
#expect(!InstanceType.yatteeServer.accountCapabilities.isSelectableContext)
|
|
}
|
|
}
|
|
|
|
@Suite("DataContext legacy migration")
|
|
@MainActor
|
|
struct DataContextMigrationTests {
|
|
@Test("Legacy subscription accounts map onto contexts")
|
|
func legacyMappingIsIdentity() {
|
|
let instanceID = UUID()
|
|
|
|
#expect(DataContext(legacy: .local) == .local)
|
|
|
|
// Migrated accounts reuse their instance UUID, so this is an identity
|
|
// mapping rather than a lookup that could fail.
|
|
#expect(DataContext(legacy: .invidious(instanceID)) == .account(instanceID))
|
|
#expect(DataContext(legacy: .piped(instanceID)) == .account(instanceID))
|
|
}
|
|
|
|
@Test("A legacy account without an instance falls back to local")
|
|
func legacyWithoutInstanceIsLocal() {
|
|
let malformed = SubscriptionAccount(type: .invidious, instanceID: nil)
|
|
#expect(DataContext(legacy: malformed) == .local)
|
|
}
|
|
}
|