apple_kit

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

RadrootsCaptureIntakeTests.swift (5595B)

      1 import Foundation
      2 import Testing
      3 
      4 @testable import RadrootsKit
      5 
      6 @Test func mediaImportRequestNormalizesKindsAndSelectionLimit() throws {
      7     let request = try RadrootsMediaImportRequest(
      8         allowedMediaKinds: [.image, .image],
      9         selectionLimit: 2,
     10         destinationScope: .data
     11     )
     12 
     13     #expect(request.allowedMediaKinds == [.image])
     14     #expect(request.selectionLimit == 2)
     15     #expect(request.destinationScope == .data)
     16 }
     17 
     18 @Test func mediaImportRequestRejectsInvalidSelectionLimits() {
     19     #expect(throws: RadrootsCaptureIntakeError.invalidRequest) {
     20         _ = try RadrootsMediaImportRequest(selectionLimit: 0)
     21     }
     22     #expect(throws: RadrootsCaptureIntakeError.invalidRequest) {
     23         _ = try RadrootsMediaImportRequest(selectionLimit: 101)
     24     }
     25 }
     26 
     27 @Test func mediaPickerSupportOmitsKindsWhenUnavailable() throws {
     28     let support = try RadrootsMediaPickerSupport(
     29         importAvailable: false,
     30         cameraCaptureAvailable: false,
     31         supportedImportKinds: [.image],
     32         supportedCaptureKinds: [.image],
     33         multipleSelectionSupported: true
     34     )
     35 
     36     #expect(!support.importAvailable)
     37     #expect(!support.cameraCaptureAvailable)
     38     #expect(support.supportedImportKinds.isEmpty)
     39     #expect(support.supportedCaptureKinds.isEmpty)
     40     #expect(support.multipleSelectionSupported)
     41 }
     42 
     43 @Test func mediaAssetNormalizesMetadata() throws {
     44     let asset = try RadrootsMediaAsset(
     45         source: .libraryImport,
     46         kind: .image,
     47         file: RadrootsFileReference(scope: .temporary, relativePath: "capture/photo.jpg"),
     48         mediaType: " Image/JPEG ",
     49         suggestedFilename: " photo.jpg ",
     50         sizeBytes: 12,
     51         pixelWidth: 640,
     52         pixelHeight: 480,
     53         capturedAt: Date(timeIntervalSince1970: 10)
     54     )
     55 
     56     #expect(asset.mediaType == "image/jpeg")
     57     #expect(asset.suggestedFilename == "photo.jpg")
     58     #expect(asset.pixelWidth == 640)
     59     #expect(asset.pixelHeight == 480)
     60     #expect(asset.capturedAt == Date(timeIntervalSince1970: 10))
     61 }
     62 
     63 @Test func mediaAssetRejectsUnsafeMetadata() {
     64     #expect(throws: RadrootsCaptureIntakeError.invalidRequest) {
     65         _ = try RadrootsMediaAsset(
     66             source: .libraryImport,
     67             kind: .image,
     68             file: RadrootsFileReference(scope: .temporary, relativePath: "capture/photo.jpg"),
     69             mediaType: "image/jpeg",
     70             suggestedFilename: "../photo.jpg",
     71             sizeBytes: 12,
     72             capturedAt: Date(timeIntervalSince1970: 10)
     73         )
     74     }
     75     #expect(throws: RadrootsCaptureIntakeError.invalidRequest) {
     76         _ = try RadrootsMediaAsset(
     77             source: .libraryImport,
     78             kind: .image,
     79             file: RadrootsFileReference(scope: .temporary, relativePath: "capture/photo.jpg"),
     80             mediaType: "image",
     81             suggestedFilename: "photo.jpg",
     82             sizeBytes: 12,
     83             capturedAt: Date(timeIntervalSince1970: 10)
     84         )
     85     }
     86     #expect(throws: RadrootsCaptureIntakeError.invalidRequest) {
     87         _ = try RadrootsMediaAsset(
     88             source: .libraryImport,
     89             kind: .image,
     90             file: RadrootsFileReference(scope: .temporary, relativePath: "capture/photo.jpg"),
     91             mediaType: "image/jpeg",
     92             suggestedFilename: "photo.jpg",
     93             sizeBytes: 12,
     94             pixelWidth: 640,
     95             capturedAt: Date(timeIntervalSince1970: 10)
     96         )
     97     }
     98 }
     99 
    100 @Test func mediaImportResultRequiresAtLeastOneItem() throws {
    101     let asset = try testMediaAsset()
    102     let result = try RadrootsMediaImportResult(items: [asset])
    103 
    104     #expect(result.items == [asset])
    105     #expect(throws: RadrootsCaptureIntakeError.invalidRequest) {
    106         _ = try RadrootsMediaImportResult(items: [])
    107     }
    108 }
    109 
    110 @Test func scannerSupportOmitsOutputKindsWhenUnavailable() throws {
    111     let support = try RadrootsDocumentScannerSupport(
    112         interactiveScanAvailable: false,
    113         multiPageSupported: true,
    114         supportedOutputKinds: [.pdf]
    115     )
    116 
    117     #expect(!support.interactiveScanAvailable)
    118     #expect(!support.multiPageSupported)
    119     #expect(support.supportedOutputKinds.isEmpty)
    120 }
    121 
    122 @Test func scannedDocumentNormalizesPdfMetadata() throws {
    123     let document = try RadrootsScannedDocument(
    124         file: RadrootsFileReference(scope: .temporary, relativePath: "capture/scan.pdf"),
    125         outputKind: .pdf,
    126         suggestedFilename: " scan.pdf ",
    127         mediaType: " Application/PDF ",
    128         pageCount: 2,
    129         sizeBytes: 2048,
    130         capturedAt: Date(timeIntervalSince1970: 11)
    131     )
    132 
    133     #expect(document.suggestedFilename == "scan.pdf")
    134     #expect(document.mediaType == "application/pdf")
    135     #expect(document.pageCount == 2)
    136     #expect(document.sizeBytes == 2048)
    137 }
    138 
    139 @Test func scannedDocumentRejectsEmptyPageCount() {
    140     #expect(throws: RadrootsCaptureIntakeError.invalidRequest) {
    141         _ = try RadrootsScannedDocument(
    142             file: RadrootsFileReference(scope: .temporary, relativePath: "capture/scan.pdf"),
    143             outputKind: .pdf,
    144             suggestedFilename: "scan.pdf",
    145             mediaType: "application/pdf",
    146             pageCount: 0,
    147             sizeBytes: 2048,
    148             capturedAt: Date(timeIntervalSince1970: 11)
    149         )
    150     }
    151 }
    152 
    153 private func testMediaAsset() throws -> RadrootsMediaAsset {
    154     try RadrootsMediaAsset(
    155         source: .libraryImport,
    156         kind: .image,
    157         file: RadrootsFileReference(scope: .temporary, relativePath: "capture/photo.jpg"),
    158         mediaType: "image/jpeg",
    159         suggestedFilename: "photo.jpg",
    160         sizeBytes: 12,
    161         capturedAt: Date(timeIntervalSince1970: 10)
    162     )
    163 }