apple_kit

Apple-native services for Radroots iOS and macOS apps
git clone https://radroots.dev/git/apple_kit.git
Log | Files | Refs | README

RadrootsCaptureIntakeTestingTests.swift (4537B)

      1 import Foundation
      2 import Testing
      3 import RadrootsKit
      4 import RadrootsKitTesting
      5 
      6 @Test func fakeMediaPickerReturnsConfiguredSupportAndResults() async throws {
      7     let asset = try testMediaAsset()
      8     let importResult = try RadrootsMediaImportResult(items: [asset])
      9     let captureResult = RadrootsMediaCaptureResult(item: asset)
     10     let picker = RadrootsFakeMediaPicker(
     11         support: try RadrootsMediaPickerSupport(
     12             importAvailable: true,
     13             cameraCaptureAvailable: true,
     14             supportedImportKinds: [.image],
     15             supportedCaptureKinds: [.image],
     16             multipleSelectionSupported: true
     17         ),
     18         importOutcome: .success(importResult),
     19         captureOutcome: .success(captureResult)
     20     )
     21     let importRequest = try RadrootsMediaImportRequest(selectionLimit: 1)
     22     let captureRequest = try RadrootsMediaCaptureRequest()
     23 
     24     #expect(try await picker.currentSupport().supportedImportKinds == [.image])
     25     #expect(try await picker.importMedia(importRequest) == importResult)
     26     #expect(try await picker.captureMedia(captureRequest) == captureResult)
     27     #expect(await picker.supportRequestCount == 1)
     28     #expect(await picker.importRequestCount == 1)
     29     #expect(await picker.captureRequestCount == 1)
     30     #expect(await picker.lastImportRequest == importRequest)
     31     #expect(await picker.lastCaptureRequest == captureRequest)
     32 }
     33 
     34 @Test func fakeMediaPickerReturnsTypedFailures() async throws {
     35     let asset = try testMediaAsset()
     36     let picker = RadrootsFakeMediaPicker(
     37         support: try RadrootsMediaPickerSupport(
     38             importAvailable: true,
     39             cameraCaptureAvailable: true,
     40             supportedImportKinds: [.image],
     41             supportedCaptureKinds: [.image],
     42             multipleSelectionSupported: false
     43         ),
     44         importOutcome: .failure(.userCancelled("media import was cancelled")),
     45         captureOutcome: .success(RadrootsMediaCaptureResult(item: asset))
     46     )
     47 
     48     await #expect(throws: RadrootsCaptureIntakeError.userCancelled("media import was cancelled")) {
     49         _ = try await picker.importMedia(try RadrootsMediaImportRequest())
     50     }
     51 
     52     await picker.setCaptureOutcome(.failure(.permissionDenied("camera access is denied")))
     53 
     54     await #expect(throws: RadrootsCaptureIntakeError.permissionDenied("camera access is denied")) {
     55         _ = try await picker.captureMedia(try RadrootsMediaCaptureRequest())
     56     }
     57 }
     58 
     59 @Test func fakeDocumentScannerReturnsConfiguredSupportAndResults() async throws {
     60     let document = try testScannedDocument()
     61     let scanner = RadrootsFakeDocumentScanner(
     62         support: try RadrootsDocumentScannerSupport(
     63             interactiveScanAvailable: true,
     64             multiPageSupported: true,
     65             supportedOutputKinds: [.pdf]
     66         ),
     67         scanOutcome: .success(document)
     68     )
     69     let request = RadrootsDocumentScanRequest()
     70 
     71     #expect(try await scanner.currentSupport().supportedOutputKinds == [.pdf])
     72     #expect(try await scanner.scanDocument(request) == document)
     73     #expect(await scanner.supportRequestCount == 1)
     74     #expect(await scanner.scanRequestCount == 1)
     75     #expect(await scanner.lastScanRequest == request)
     76 }
     77 
     78 @Test func fakeDocumentScannerReturnsTypedFailures() async throws {
     79     let scanner = RadrootsFakeDocumentScanner(
     80         support: try RadrootsDocumentScannerSupport(
     81             interactiveScanAvailable: false,
     82             multiPageSupported: false,
     83             supportedOutputKinds: []
     84         ),
     85         scanOutcome: .failure(.unavailable("document scanner unavailable"))
     86     )
     87 
     88     await #expect(throws: RadrootsCaptureIntakeError.unavailable("document scanner unavailable")) {
     89         _ = try await scanner.scanDocument(RadrootsDocumentScanRequest())
     90     }
     91 }
     92 
     93 private func testMediaAsset() throws -> RadrootsMediaAsset {
     94     try RadrootsMediaAsset(
     95         source: .libraryImport,
     96         kind: .image,
     97         file: RadrootsFileReference(scope: .temporary, relativePath: "capture/photo.jpg"),
     98         mediaType: "image/jpeg",
     99         suggestedFilename: "photo.jpg",
    100         sizeBytes: 12,
    101         capturedAt: Date(timeIntervalSince1970: 10)
    102     )
    103 }
    104 
    105 private func testScannedDocument() throws -> RadrootsScannedDocument {
    106     try RadrootsScannedDocument(
    107         file: RadrootsFileReference(scope: .temporary, relativePath: "capture/scan.pdf"),
    108         outputKind: .pdf,
    109         suggestedFilename: "scan.pdf",
    110         mediaType: "application/pdf",
    111         pageCount: 2,
    112         sizeBytes: 2048,
    113         capturedAt: Date(timeIntervalSince1970: 11)
    114     )
    115 }