field_ios

In-the-field app for Radroots on iOS
git clone https://radroots.dev/git/field_ios.git
Log | Files | Refs | README | LICENSE

TeraCapacityRecoveryTests.swift (4598B)


      1 import RadrootsKit
      2 @testable import TeraApp
      3 import XCTest
      4 
      5 final class TeraCapacityRecoveryTests: XCTestCase {
      6   @MainActor
      7   func testCacheCleanupReportsRecoveredFilesAndBoundedContinuationWithoutBytesClaim() async throws {
      8     let backend = try TeraScopeBackend()
      9     let client = try await TeraScopeFixtures.client(backend)
     10     let store = TeraSettingsStore(runtimeClient: client)
     11     let context = TeraLocalNetwork.defaultContext(snapshot: TeraScopeFixtures.snapshot())
     12     await backend.setCacheCleanupResult(.init(invalidatedEntries: 0, retainedCandidates: 0, remainingEntries: 0, recoveredOrphanFiles: 7, scanPending: true))
     13     await store.cleanupMediaCache(context: context)
     14     XCTAssertTrue(store.message?.contains("Recovered 7 unreferenced cache files") == true)
     15     XCTAssertTrue(store.message?.contains("run cleanup again") == true)
     16     XCTAssertFalse(store.message?.contains("bytes freed") == true)
     17     await backend.setCacheCleanupResult(.init(invalidatedEntries: 0, retainedCandidates: 0, remainingEntries: 0))
     18     await store.cleanupMediaCache(context: context)
     19     XCTAssertFalse(store.message?.contains("run cleanup again") == true)
     20     XCTAssertFalse(store.message?.contains("Recovered 7") == true)
     21     _ = try await client.stop()
     22   }
     23 
     24   func testTypedNativeCapacityAndReceiptQuotaRemainDistinctAndNeverPromiseSavedEditing() {
     25     let capacity: [Error] = [RadrootsAppleFileError.spaceInsufficient, RadrootsCaptureIntakeError.spaceInsufficient, RadrootsBackgroundTransferError.spaceInsufficient]
     26     for error in capacity {
     27       XCTAssertEqual(TeraUserMessages.key(for: error, fallback: .fileOperationFailed), .storageFull)
     28       XCTAssertEqual(TeraNativeRecoveryClassification.pause(error), .quota)
     29     }
     30     let quota = RadrootsBackgroundTransferError.receiptCapacityExceeded
     31     XCTAssertEqual(TeraUserMessages.key(for: quota, fallback: .fileOperationFailed), .receiptCapacityExceeded)
     32     XCTAssertEqual(TeraNativeRecoveryClassification.pause(quota), .receiptQuota)
     33     XCTAssertTrue(TeraUserMessages.text(.receiptCapacityExceeded).contains("does not resolve"))
     34     XCTAssertTrue(TeraUserMessages.text(.storageFull).contains("check the original work before retrying"))
     35     XCTAssertTrue(TeraUserMessages.text(.storageFull).contains("Saving may be unavailable"))
     36     for pause in [TeraNativeRecoveryPause.quota, .receiptQuota, .storageUnavailable] {
     37       XCTAssertFalse(pause.message.contains("Saved editing is still available"))
     38       XCTAssertTrue(pause.message.contains("new saves may be unavailable"))
     39     }
     40   }
     41 
     42   @MainActor
     43   func testCacheCleanupAdmissionSurvivesStopAndLateResultsCannotOverwritePresentation() async throws {
     44     let backend = try TeraScopeBackend()
     45     let client = try await TeraScopeFixtures.client(backend)
     46     let store = TeraSettingsStore(runtimeClient: client)
     47     let context = TeraLocalNetwork.defaultContext(snapshot: TeraScopeFixtures.snapshot())
     48     let pause = await backend.pause(.cacheCleanup)
     49     let owner = Task { await store.cleanupMediaCache(context: context) }
     50     await pause.entered.wait()
     51     store.stop()
     52     await store.cleanupMediaCache(context: context)
     53     let firstCount = await backend.counts[.cacheCleanup]
     54     XCTAssertEqual(firstCount, 1)
     55     await pause.resume.open()
     56     await owner.value
     57     XCTAssertNil(store.message)
     58     await store.cleanupMediaCache(context: context)
     59     let secondCount = await backend.counts[.cacheCleanup]
     60     XCTAssertEqual(secondCount, 2)
     61     XCTAssertTrue(store.message?.contains("1 shared or unverified") == true)
     62     XCTAssertFalse(store.message?.contains("bytes freed") == true)
     63     _ = try await client.stop()
     64   }
     65 
     66   @MainActor
     67   func testFailedCacheCleanupDoesNotReportSuccessOrDiscardEditing() async throws {
     68     let backend = try TeraScopeBackend()
     69     let client = try await TeraScopeFixtures.client(backend)
     70     let store = TeraSettingsStore(runtimeClient: client)
     71     store.profileName = "Unsaved profile"
     72     let context = TeraLocalNetwork.defaultContext(snapshot: TeraScopeFixtures.snapshot())
     73     let failure = TeraRuntimeFailure.local(operation: "test", code: "storage_space_insufficient", safeMessage: "space")
     74     let pause = await backend.pause(.cacheCleanup, failure: failure)
     75     let owner = Task { await store.cleanupMediaCache(context: context) }
     76     await pause.entered.wait()
     77     await pause.resume.open()
     78     await owner.value
     79     XCTAssertEqual(store.profileName, "Unsaved profile")
     80     XCTAssertEqual(store.failureCode, "storage_space_insufficient")
     81     XCTAssertEqual(store.message, TeraUserMessages.text(.storageFull))
     82     _ = try await client.stop()
     83   }
     84 }