761 lines
32 KiB
Swift
761 lines
32 KiB
Swift
//
|
||
// WiredCameraTransferViewModelTests.swift
|
||
// suixinkanTests
|
||
//
|
||
// Created by Codex on 2026/6/30.
|
||
//
|
||
|
||
import XCTest
|
||
import UIKit
|
||
@testable import suixinkan
|
||
|
||
@MainActor
|
||
/// 有线传图 ViewModel 测试。
|
||
final class WiredCameraTransferViewModelTests: XCTestCase {
|
||
/// 测试相机管道回调的首张新照片应出现在列表中。
|
||
func testFirstNewPipelineTaskAppearsInPhotos() async throws {
|
||
let camera = MockWiredCameraService()
|
||
let context = WiredTransferContext(
|
||
albumId: 6603,
|
||
albumName: "测试相册",
|
||
phone: "",
|
||
orderNumber: ""
|
||
)
|
||
let viewModel = WiredCameraTransferViewModel(context: context, cameraService: camera)
|
||
let account = AccountContext()
|
||
account.applyLogin(profile: AccountProfile(userId: "101", displayName: "测试"))
|
||
|
||
await viewModel.start(
|
||
api: MockTravelAlbumAPIForWiredTransfer(),
|
||
ossService: WiredTransferMockOSSUploadService(),
|
||
scenicID: 1,
|
||
accountContext: account
|
||
)
|
||
|
||
let tempURL = FileManager.default.temporaryDirectory.appendingPathComponent("DSC_NEW.JPG")
|
||
try Data(repeating: 0xFF, count: 16).write(to: tempURL)
|
||
defer { try? FileManager.default.removeItem(at: tempURL) }
|
||
|
||
let asset = CameraAsset(id: "ptp_new_001", filename: "DSC_NEW.JPG", fileSize: 16)
|
||
camera.downloadURL = tempURL
|
||
camera.onNewAsset?(asset)
|
||
try await Task.sleep(nanoseconds: 500_000_000)
|
||
|
||
XCTAssertEqual(viewModel.photos.count, 1)
|
||
XCTAssertEqual(viewModel.photos.first?.id, "ptp_new_001")
|
||
XCTAssertEqual(viewModel.photos.first?.fileName, "DSC_NEW.JPG")
|
||
}
|
||
|
||
/// 测试绑定到其他相册的照片不会出现在当前相册列表。
|
||
func testPhotoBoundToOtherAlbumIsFilteredOut() async throws {
|
||
let bindingStore = WiredTransferPhotoStore(
|
||
accountPrefixProvider: { "user_101" },
|
||
userIDProvider: { "101" }
|
||
)
|
||
bindingStore.bindPhotoToAlbum(photoID: "ptp_other_album", albumID: 99)
|
||
defer { bindingStore.bindPhotoToAlbum(photoID: "ptp_other_album", albumID: 1) }
|
||
|
||
let camera = MockWiredCameraService()
|
||
let context = WiredTransferContext(
|
||
albumId: 1,
|
||
albumName: "当前相册",
|
||
phone: "",
|
||
orderNumber: ""
|
||
)
|
||
let viewModel = WiredCameraTransferViewModel(context: context, cameraService: camera)
|
||
let account = AccountContext()
|
||
account.applyLogin(profile: AccountProfile(userId: "101", displayName: "测试"), accountType: "user")
|
||
|
||
await viewModel.start(
|
||
api: MockTravelAlbumAPIForWiredTransfer(),
|
||
ossService: WiredTransferMockOSSUploadService(),
|
||
scenicID: 1,
|
||
accountContext: account
|
||
)
|
||
|
||
let tempURL = FileManager.default.temporaryDirectory.appendingPathComponent("DSC_OTHER.JPG")
|
||
try Data(repeating: 0xAA, count: 8).write(to: tempURL)
|
||
defer { try? FileManager.default.removeItem(at: tempURL) }
|
||
|
||
camera.downloadURL = tempURL
|
||
camera.onNewAsset?(CameraAsset(id: "ptp_other_album", filename: "DSC_OTHER.JPG", fileSize: 8))
|
||
try await Task.sleep(nanoseconds: 500_000_000)
|
||
|
||
XCTAssertTrue(viewModel.photos.isEmpty)
|
||
}
|
||
|
||
/// 测试批量上传按钮三态流转。
|
||
func testBatchUploadButtonThreeStateFlow() async {
|
||
let viewModel = makeViewModelWithPendingPhotos()
|
||
let api = MockTravelAlbumAPIForWiredTransfer()
|
||
let oss = WiredTransferMockOSSUploadService()
|
||
|
||
XCTAssertFalse(viewModel.selectUploadMode)
|
||
await viewModel.onBatchUploadButtonClick(api: api, ossService: oss, scenicID: 1)
|
||
XCTAssertTrue(viewModel.selectUploadMode)
|
||
XCTAssertTrue(viewModel.selectedPhotoIDs.isEmpty)
|
||
|
||
viewModel.togglePhotoSelection(id: "pending-1")
|
||
XCTAssertEqual(viewModel.selectedPhotoIDs, ["pending-1"])
|
||
|
||
await viewModel.onBatchUploadButtonClick(api: api, ossService: oss, scenicID: 1)
|
||
XCTAssertFalse(viewModel.selectUploadMode)
|
||
XCTAssertTrue(viewModel.selectedPhotoIDs.isEmpty)
|
||
}
|
||
|
||
/// 测试全选 pending 与取消全选。
|
||
func testToggleSelectAllPendingInVisible() {
|
||
let viewModel = makeViewModelWithPendingPhotos()
|
||
viewModel.selectUploadMode = true
|
||
|
||
viewModel.toggleSelectAllPendingInVisible()
|
||
XCTAssertEqual(viewModel.selectedPhotoIDs, ["pending-1", "pending-2"])
|
||
|
||
viewModel.toggleSelectAllPendingInVisible()
|
||
XCTAssertTrue(viewModel.selectedPhotoIDs.isEmpty)
|
||
}
|
||
|
||
/// 测试指定上传今日拍摄筛选。
|
||
func testUploadAllTodayCapturedFiltersByDate() async {
|
||
let formatter = DateFormatter()
|
||
formatter.dateFormat = "yyyy-MM-dd HH:mm:ss"
|
||
formatter.locale = Locale(identifier: "zh_CN")
|
||
let today = formatter.string(from: Date())
|
||
|
||
let viewModel = WiredCameraTransferViewModel(
|
||
context: WiredTransferContext(albumId: 1, albumName: "相册", phone: "", orderNumber: ""),
|
||
cameraService: MockWiredCameraService()
|
||
)
|
||
viewModel.replacePhotos([
|
||
makePendingPhoto(id: "today", capturedAt: today),
|
||
makePendingPhoto(id: "old", capturedAt: "2020-01-01 09:00:00"),
|
||
])
|
||
|
||
await viewModel.onSpecifyUploadOptionSelected(
|
||
WiredCameraTransferViewModel.specifyUploadTodayCaptured,
|
||
api: MockTravelAlbumAPIForWiredTransfer(),
|
||
ossService: WiredTransferMockOSSUploadService(),
|
||
scenicID: 1
|
||
)
|
||
XCTAssertNil(viewModel.errorMessage)
|
||
}
|
||
|
||
/// 测试上传进度更新时保留 capturedAt，避免列表分组抖动。
|
||
func testPipelineProgressUpdatePreservesCapturedAt() async throws {
|
||
let camera = MockWiredCameraService()
|
||
let context = WiredTransferContext(
|
||
albumId: 1,
|
||
albumName: "测试相册",
|
||
phone: "",
|
||
orderNumber: ""
|
||
)
|
||
let viewModel = WiredCameraTransferViewModel(context: context, cameraService: camera)
|
||
let account = AccountContext()
|
||
account.applyLogin(profile: AccountProfile(userId: "101", displayName: "测试"))
|
||
|
||
await viewModel.start(
|
||
api: MockTravelAlbumAPIForWiredTransfer(),
|
||
ossService: WiredTransferMockOSSUploadService(),
|
||
scenicID: 1,
|
||
accountContext: account
|
||
)
|
||
let originalCapturedAt = "2026-05-20 12:05:18"
|
||
viewModel.replacePhotos([
|
||
WiredTransferPhotoItem(
|
||
id: "ptp_progress",
|
||
fileName: "DSC_PROGRESS.JPG",
|
||
thumbnailURL: "",
|
||
previewURL: "",
|
||
capturedAt: originalCapturedAt,
|
||
fileSizeText: "2 MB",
|
||
status: .uploading,
|
||
progress: 10
|
||
),
|
||
])
|
||
|
||
let scope = downloadScope(account: account, albumID: context.albumId)
|
||
let fileURL = CameraDownloadStorage.uniqueLocalURL(for: "DSC_PROGRESS.JPG", scope: scope)
|
||
try Data(repeating: 0xAB, count: 16).write(to: fileURL)
|
||
defer { CameraDownloadStorage.removeScopeDirectory(for: scope) }
|
||
|
||
camera.downloadURL = fileURL
|
||
camera.onNewAsset?(CameraAsset(id: "ptp_progress", filename: "DSC_PROGRESS.JPG", fileSize: 16))
|
||
try await Task.sleep(nanoseconds: 300_000_000)
|
||
|
||
XCTAssertEqual(viewModel.photos.first?.capturedAt, originalCapturedAt)
|
||
}
|
||
|
||
/// 测试较新拍摄时间的照片排在列表前面。
|
||
func testNewerCapturedPhotoAppearsFirst() async throws {
|
||
let camera = MockWiredCameraService()
|
||
let context = WiredTransferContext(
|
||
albumId: 6604,
|
||
albumName: "测试相册",
|
||
phone: "",
|
||
orderNumber: ""
|
||
)
|
||
let viewModel = WiredCameraTransferViewModel(context: context, cameraService: camera)
|
||
let account = AccountContext()
|
||
account.applyLogin(profile: AccountProfile(userId: "101", displayName: "测试"))
|
||
|
||
await viewModel.start(
|
||
api: MockTravelAlbumAPIForWiredTransfer(),
|
||
ossService: WiredTransferMockOSSUploadService(),
|
||
scenicID: 1,
|
||
accountContext: account
|
||
)
|
||
|
||
let fileURL = FileManager.default.temporaryDirectory
|
||
let olderURL = fileURL.appendingPathComponent("OLDER.JPG")
|
||
let newerURL = fileURL.appendingPathComponent("NEWER.JPG")
|
||
try Data(repeating: 0xAA, count: 8).write(to: olderURL)
|
||
try Data(repeating: 0xBB, count: 8).write(to: newerURL)
|
||
defer {
|
||
try? FileManager.default.removeItem(at: olderURL)
|
||
try? FileManager.default.removeItem(at: newerURL)
|
||
}
|
||
|
||
camera.downloadURL = olderURL
|
||
camera.onNewAsset?(
|
||
CameraAsset(
|
||
id: "ptp_old",
|
||
filename: "OLDER.JPG",
|
||
fileSize: 8,
|
||
creationDate: Date(timeIntervalSince1970: 1_700_000_000)
|
||
)
|
||
)
|
||
try await Task.sleep(nanoseconds: 400_000_000)
|
||
|
||
camera.downloadURL = newerURL
|
||
camera.onNewAsset?(
|
||
CameraAsset(
|
||
id: "ptp_new",
|
||
filename: "NEWER.JPG",
|
||
fileSize: 8,
|
||
creationDate: Date(timeIntervalSince1970: 1_800_000_000)
|
||
)
|
||
)
|
||
try await Task.sleep(nanoseconds: 400_000_000)
|
||
|
||
XCTAssertEqual(viewModel.photos.count, 2)
|
||
XCTAssertEqual(viewModel.photos[0].id, "ptp_new")
|
||
XCTAssertEqual(viewModel.photos[1].id, "ptp_old")
|
||
}
|
||
|
||
/// 测试拍后传输模式下重传会从持久化记录恢复上传。
|
||
func testRetryPhotoInPostShootModeUploadsPersistedFile() async throws {
|
||
let camera = MockWiredCameraService()
|
||
let context = WiredTransferContext(
|
||
albumId: 1,
|
||
albumName: "测试相册",
|
||
phone: "",
|
||
orderNumber: ""
|
||
)
|
||
let account = AccountContext()
|
||
account.applyLogin(profile: AccountProfile(userId: "101", displayName: "测试"))
|
||
|
||
let scope = downloadScope(account: account, albumID: context.albumId)
|
||
let fileURL = CameraDownloadStorage.uniqueLocalURL(for: "retry_failed.JPG", scope: scope)
|
||
try Data(repeating: 0xCD, count: 32).write(to: fileURL)
|
||
defer { CameraDownloadStorage.removeScopeDirectory(for: scope) }
|
||
|
||
let photoID = "persist_failed_001"
|
||
let record = WiredTransferPhotoRecord(
|
||
id: photoID,
|
||
sourceId: photoID,
|
||
fileName: "retry_failed.JPG",
|
||
localPath: CameraDownloadStorage.relativePath(for: fileURL),
|
||
thumbnailPath: "",
|
||
capturedAt: "2026-05-20 12:05:18",
|
||
fileSizeBytes: 32,
|
||
status: WiredTransferUploadStatus.failed.rawValue,
|
||
progress: 0,
|
||
errorMessage: "upload failed",
|
||
albumId: 1,
|
||
userId: "101",
|
||
remoteURL: "",
|
||
updatedAt: Date().timeIntervalSince1970
|
||
)
|
||
let store = WiredTransferPhotoStore(
|
||
accountPrefixProvider: { account.accountCachePrefix ?? "guest_" },
|
||
userIDProvider: { "101" }
|
||
)
|
||
store.save(albumID: 1, records: [record])
|
||
|
||
let viewModel = WiredCameraTransferViewModel(context: context, cameraService: camera)
|
||
viewModel.transferModeOption = WiredCameraTransferViewModel.modePostShootTransfer
|
||
|
||
let api = MockTravelAlbumAPIForWiredTransfer()
|
||
let oss = WiredTransferMockOSSUploadService()
|
||
await viewModel.start(api: api, ossService: oss, scenicID: 1, accountContext: account)
|
||
|
||
XCTAssertEqual(viewModel.photos.first?.id, photoID)
|
||
XCTAssertEqual(viewModel.photos.first?.status, .failed)
|
||
|
||
await viewModel.retryPhoto(id: photoID, api: api, ossService: oss, scenicID: 1)
|
||
try await Task.sleep(nanoseconds: 500_000_000)
|
||
|
||
XCTAssertEqual(viewModel.photos.first?.status, .uploaded)
|
||
}
|
||
|
||
/// 测试指定上传“所有未上传”会恢复本地持久化照片并全部上传。
|
||
func testBatchUploadAllUploadsPersistedPendingFiles() async throws {
|
||
let albumID = 7711
|
||
let userID = "batch-persist-user"
|
||
let account = AccountContext()
|
||
account.applyLogin(profile: AccountProfile(userId: userID, displayName: "测试"))
|
||
|
||
let fileURLs = try (1 ... 5).map { index in
|
||
let scope = downloadScope(account: account, albumID: albumID)
|
||
let url = CameraDownloadStorage.uniqueLocalURL(for: "batch_persist_\(index).JPG", scope: scope)
|
||
try Data(repeating: UInt8(0xA0 + index), count: 32).write(to: url)
|
||
return url
|
||
}
|
||
defer {
|
||
CameraDownloadStorage.removeScopeDirectory(for: downloadScope(account: account, albumID: albumID))
|
||
}
|
||
|
||
let records = fileURLs.enumerated().map { offset, url in
|
||
let index = offset + 1
|
||
return makePhotoRecord(
|
||
id: "batch_persist_\(index)",
|
||
fileName: "batch_persist_\(index).JPG",
|
||
localPath: CameraDownloadStorage.relativePath(for: url),
|
||
albumID: albumID,
|
||
userID: userID
|
||
)
|
||
}
|
||
let store = WiredTransferPhotoStore(
|
||
accountPrefixProvider: { account.accountCachePrefix ?? "guest_" },
|
||
userIDProvider: { userID }
|
||
)
|
||
store.save(albumID: albumID, records: records)
|
||
|
||
let viewModel = WiredCameraTransferViewModel(
|
||
context: WiredTransferContext(albumId: albumID, albumName: "批量上传", phone: "", orderNumber: ""),
|
||
cameraService: MockWiredCameraService()
|
||
)
|
||
let oss = WiredTransferMockOSSUploadService()
|
||
oss.uploadDelayNanoseconds = 150_000_000
|
||
await viewModel.start(
|
||
api: MockTravelAlbumAPIForWiredTransfer(),
|
||
ossService: oss,
|
||
scenicID: 1,
|
||
accountContext: account
|
||
)
|
||
|
||
XCTAssertEqual(viewModel.photos.filter(\.isNotUploaded).count, 5)
|
||
|
||
await viewModel.batchUploadAll(
|
||
api: MockTravelAlbumAPIForWiredTransfer(),
|
||
ossService: oss,
|
||
scenicID: 1
|
||
)
|
||
|
||
XCTAssertEqual(Set(oss.uploadedFileNames), Set((1 ... 5).map { "batch_persist_\($0).JPG" }))
|
||
XCTAssertGreaterThan(oss.maxActiveUploads, 1)
|
||
XCTAssertLessThanOrEqual(oss.maxActiveUploads, 3)
|
||
XCTAssertTrue(viewModel.photos.allSatisfy { $0.status == .uploaded })
|
||
}
|
||
|
||
/// 测试切换传输模式后会按账号缓存选项。
|
||
func testSelectTransferModePersistsOption() async {
|
||
let account = makeTransferModeTestAccount()
|
||
let context = WiredTransferContext(albumId: 7701, albumName: "模式缓存", phone: "", orderNumber: "")
|
||
let viewModel = WiredCameraTransferViewModel(context: context, cameraService: MockWiredCameraService())
|
||
let api = MockTravelAlbumAPIForWiredTransfer()
|
||
let oss = WiredTransferMockOSSUploadService()
|
||
|
||
await viewModel.start(api: api, ossService: oss, scenicID: 1, accountContext: account)
|
||
viewModel.selectTransferMode(
|
||
WiredCameraTransferViewModel.modePostShootTransfer,
|
||
api: api,
|
||
ossService: oss,
|
||
scenicID: 1
|
||
)
|
||
|
||
let store = makeTransferModeTestStore(account: account)
|
||
XCTAssertEqual(store.loadTransferModeOption(), WiredCameraTransferViewModel.modePostShootTransfer)
|
||
}
|
||
|
||
/// 测试再次进入有线传图页时会恢复上次选择的传输模式。
|
||
func testStartRestoresCachedTransferModeOption() async {
|
||
let account = makeTransferModeTestAccount()
|
||
let store = makeTransferModeTestStore(account: account)
|
||
store.saveTransferModeOption(WiredCameraTransferViewModel.modePostShootTransfer)
|
||
|
||
let context = WiredTransferContext(albumId: 7702, albumName: "模式恢复", phone: "", orderNumber: "")
|
||
let viewModel = WiredCameraTransferViewModel(context: context, cameraService: MockWiredCameraService())
|
||
|
||
await viewModel.start(
|
||
api: MockTravelAlbumAPIForWiredTransfer(),
|
||
ossService: WiredTransferMockOSSUploadService(),
|
||
scenicID: 1,
|
||
accountContext: account
|
||
)
|
||
|
||
XCTAssertEqual(viewModel.transferModeOption, WiredCameraTransferViewModel.modePostShootTransfer)
|
||
}
|
||
|
||
/// 测试下载完成后生成本地缩略图，并优先用于列表展示。
|
||
func testDownloadedPhotoGeneratesThumbnailForList() async throws {
|
||
let camera = MockWiredCameraService()
|
||
let albumID = 6601
|
||
let context = WiredTransferContext(albumId: albumID, albumName: "缩略图相册", phone: "", orderNumber: "")
|
||
let viewModel = WiredCameraTransferViewModel(context: context, cameraService: camera)
|
||
let account = AccountContext()
|
||
account.applyLogin(profile: AccountProfile(userId: "thumb-user", displayName: "测试"))
|
||
|
||
await viewModel.start(
|
||
api: MockTravelAlbumAPIForWiredTransfer(),
|
||
ossService: WiredTransferMockOSSUploadService(),
|
||
scenicID: 1,
|
||
accountContext: account
|
||
)
|
||
|
||
let scope = downloadScope(account: account, albumID: albumID)
|
||
let imageURL = CameraDownloadStorage.uniqueLocalURL(for: "thumb_source.JPG", scope: scope)
|
||
try makeJPEGData().write(to: imageURL)
|
||
defer { CameraDownloadStorage.removeScopeDirectory(for: scope) }
|
||
|
||
camera.downloadURL = imageURL
|
||
camera.onNewAsset?(CameraAsset(id: "thumb_asset_001", filename: "thumb_source.JPG", fileSize: 128))
|
||
try await Task.sleep(nanoseconds: 900_000_000)
|
||
|
||
let photo = try XCTUnwrap(viewModel.photos.first { $0.id == "thumb_asset_001" })
|
||
XCTAssertTrue(photo.thumbnailURL.contains("/CameraDownloads/\(scope.accountDirectoryName)/\(albumID)/thumbnails/"))
|
||
XCTAssertTrue(photo.previewURL.contains("/CameraDownloads/"))
|
||
XCTAssertFalse(photo.previewURL.contains("/thumbnails/"))
|
||
}
|
||
|
||
/// 测试旧记录没有缩略图时列表先占位，但仍保留原图预览能力。
|
||
func testLegacyRecordWithoutThumbnailKeepsPreviewURL() async throws {
|
||
let albumID = 6602
|
||
let account = AccountContext()
|
||
account.applyLogin(profile: AccountProfile(userId: "legacy-user", displayName: "测试"))
|
||
let scope = downloadScope(account: account, albumID: albumID)
|
||
let fileURL = CameraDownloadStorage.uniqueLocalURL(for: "legacy_only.JPG", scope: scope)
|
||
try makeJPEGData().write(to: fileURL)
|
||
defer { CameraDownloadStorage.removeScopeDirectory(for: scope) }
|
||
|
||
let record = WiredTransferPhotoRecord(
|
||
id: "legacy_photo_001",
|
||
sourceId: "legacy_photo_001",
|
||
fileName: "legacy_only.JPG",
|
||
localPath: CameraDownloadStorage.relativePath(for: fileURL),
|
||
thumbnailPath: "",
|
||
capturedAt: "2026-05-20 12:05:18",
|
||
fileSizeBytes: 128,
|
||
status: WiredTransferUploadStatus.pending.rawValue,
|
||
progress: 0,
|
||
errorMessage: nil,
|
||
albumId: albumID,
|
||
userId: "legacy-user",
|
||
remoteURL: "",
|
||
updatedAt: Date().timeIntervalSince1970
|
||
)
|
||
let store = WiredTransferPhotoStore(
|
||
accountPrefixProvider: { account.accountCachePrefix ?? "guest_" },
|
||
userIDProvider: { "legacy-user" }
|
||
)
|
||
store.save(albumID: albumID, records: [record])
|
||
|
||
let viewModel = WiredCameraTransferViewModel(
|
||
context: WiredTransferContext(albumId: albumID, albumName: "旧记录", phone: "", orderNumber: ""),
|
||
cameraService: MockWiredCameraService()
|
||
)
|
||
await viewModel.start(
|
||
api: MockTravelAlbumAPIForWiredTransfer(),
|
||
ossService: WiredTransferMockOSSUploadService(),
|
||
scenicID: 1,
|
||
accountContext: account
|
||
)
|
||
|
||
let photo = try XCTUnwrap(viewModel.photos.first)
|
||
XCTAssertEqual(photo.thumbnailURL, "")
|
||
XCTAssertFalse(photo.previewURL.isEmpty)
|
||
}
|
||
|
||
/// 测试清空相册时只删除当前账号当前相册的物理目录。
|
||
func testClearAlbumRemovesOnlyCurrentAlbumScopedDirectory() throws {
|
||
let userID = "clear-scope-user"
|
||
let account = AccountContext()
|
||
account.applyLogin(profile: AccountProfile(userId: userID, displayName: "测试"), accountType: "store")
|
||
let albumID = 8801
|
||
let otherAlbumID = 8802
|
||
let scope = downloadScope(account: account, albumID: albumID)
|
||
let otherScope = downloadScope(account: account, albumID: otherAlbumID)
|
||
let scopeDirectoryPath = CameraDownloadStorage.scopeDirectory(for: scope).path
|
||
let otherScopeDirectoryPath = CameraDownloadStorage.scopeDirectory(for: otherScope).path
|
||
defer {
|
||
CameraDownloadStorage.removeScopeDirectory(for: scope)
|
||
CameraDownloadStorage.removeScopeDirectory(for: otherScope)
|
||
}
|
||
|
||
let fileURL = CameraDownloadStorage.uniqueLocalURL(for: "clear_target.JPG", scope: scope)
|
||
let otherFileURL = CameraDownloadStorage.uniqueLocalURL(for: "clear_other.JPG", scope: otherScope)
|
||
try Data(repeating: 0x01, count: 8).write(to: fileURL)
|
||
try Data(repeating: 0x02, count: 8).write(to: otherFileURL)
|
||
|
||
let store = WiredTransferPhotoStore(
|
||
accountPrefixProvider: { account.accountCachePrefix ?? "guest_" },
|
||
userIDProvider: { userID }
|
||
)
|
||
store.save(albumID: albumID, records: [
|
||
makePhotoRecord(
|
||
id: "clear_target",
|
||
fileName: "clear_target.JPG",
|
||
localPath: CameraDownloadStorage.relativePath(for: fileURL),
|
||
albumID: albumID,
|
||
userID: userID
|
||
)
|
||
])
|
||
store.save(albumID: otherAlbumID, records: [
|
||
makePhotoRecord(
|
||
id: "clear_other",
|
||
fileName: "clear_other.JPG",
|
||
localPath: CameraDownloadStorage.relativePath(for: otherFileURL),
|
||
albumID: otherAlbumID,
|
||
userID: userID
|
||
)
|
||
])
|
||
|
||
let deletedIDs = store.clearAlbum(albumID: albumID)
|
||
|
||
XCTAssertEqual(deletedIDs, Set(["clear_target"]))
|
||
XCTAssertFalse(FileManager.default.fileExists(atPath: fileURL.path))
|
||
XCTAssertFalse(FileManager.default.fileExists(atPath: scopeDirectoryPath))
|
||
XCTAssertTrue(FileManager.default.fileExists(atPath: otherFileURL.path))
|
||
XCTAssertTrue(FileManager.default.fileExists(atPath: otherScopeDirectoryPath))
|
||
}
|
||
|
||
/// 测试同一用户 ID 在不同账号类型下的有线传图记录与物理目录隔离。
|
||
func testSameUserIDDifferentAccountTypesAreIsolated() throws {
|
||
let userID = "multi-account-user"
|
||
let albumID = 8803
|
||
let storeAccount = AccountContext()
|
||
storeAccount.applyLogin(profile: AccountProfile(userId: userID, displayName: "门店"), accountType: "store")
|
||
let photographerAccount = AccountContext()
|
||
photographerAccount.applyLogin(profile: AccountProfile(userId: userID, displayName: "摄影师"), accountType: "photographer")
|
||
let storeScope = downloadScope(account: storeAccount, albumID: albumID)
|
||
let photographerScope = downloadScope(account: photographerAccount, albumID: albumID)
|
||
defer {
|
||
CameraDownloadStorage.removeScopeDirectory(for: storeScope)
|
||
CameraDownloadStorage.removeScopeDirectory(for: photographerScope)
|
||
}
|
||
|
||
let storeURL = CameraDownloadStorage.uniqueLocalURL(for: "store_photo.JPG", scope: storeScope)
|
||
let photographerURL = CameraDownloadStorage.uniqueLocalURL(for: "photographer_photo.JPG", scope: photographerScope)
|
||
try Data(repeating: 0x03, count: 8).write(to: storeURL)
|
||
try Data(repeating: 0x04, count: 8).write(to: photographerURL)
|
||
|
||
let store = WiredTransferPhotoStore(
|
||
accountPrefixProvider: { storeAccount.accountCachePrefix ?? "guest_" },
|
||
userIDProvider: { userID }
|
||
)
|
||
let photographerStore = WiredTransferPhotoStore(
|
||
accountPrefixProvider: { photographerAccount.accountCachePrefix ?? "guest_" },
|
||
userIDProvider: { userID }
|
||
)
|
||
store.save(albumID: albumID, records: [
|
||
makePhotoRecord(
|
||
id: "store_photo",
|
||
fileName: "store_photo.JPG",
|
||
localPath: CameraDownloadStorage.relativePath(for: storeURL),
|
||
albumID: albumID,
|
||
userID: userID
|
||
)
|
||
])
|
||
photographerStore.save(albumID: albumID, records: [
|
||
makePhotoRecord(
|
||
id: "photographer_photo",
|
||
fileName: "photographer_photo.JPG",
|
||
localPath: CameraDownloadStorage.relativePath(for: photographerURL),
|
||
albumID: albumID,
|
||
userID: userID
|
||
)
|
||
])
|
||
|
||
XCTAssertEqual(store.load(albumID: albumID).map(\.id), ["store_photo"])
|
||
XCTAssertEqual(photographerStore.load(albumID: albumID).map(\.id), ["photographer_photo"])
|
||
XCTAssertNotEqual(
|
||
CameraDownloadStorage.scopeDirectory(for: storeScope).path,
|
||
CameraDownloadStorage.scopeDirectory(for: photographerScope).path
|
||
)
|
||
}
|
||
|
||
private func makeViewModelWithPendingPhotos() -> WiredCameraTransferViewModel {
|
||
let viewModel = WiredCameraTransferViewModel(
|
||
context: WiredTransferContext(albumId: 1, albumName: "相册", phone: "", orderNumber: ""),
|
||
cameraService: MockWiredCameraService()
|
||
)
|
||
viewModel.replacePhotos([
|
||
makePendingPhoto(id: "pending-1", capturedAt: "2026-05-20 12:05:18"),
|
||
makePendingPhoto(id: "pending-2", capturedAt: "2026-05-20 12:18:06"),
|
||
WiredTransferPhotoItem(
|
||
id: "uploaded-1",
|
||
fileName: "uploaded.JPG",
|
||
thumbnailURL: "",
|
||
previewURL: "",
|
||
capturedAt: "2026-05-20 12:20:00",
|
||
fileSizeText: "1 MB",
|
||
status: .uploaded
|
||
),
|
||
])
|
||
return viewModel
|
||
}
|
||
|
||
private func makePendingPhoto(id: String, capturedAt: String) -> WiredTransferPhotoItem {
|
||
WiredTransferPhotoItem(
|
||
id: id,
|
||
fileName: "\(id).JPG",
|
||
thumbnailURL: "",
|
||
capturedAt: capturedAt,
|
||
fileSizeText: "1 MB",
|
||
status: .pending
|
||
)
|
||
}
|
||
|
||
private func makePhotoRecord(
|
||
id: String,
|
||
fileName: String,
|
||
localPath: String,
|
||
albumID: Int,
|
||
userID: String,
|
||
status: WiredTransferUploadStatus = .pending
|
||
) -> WiredTransferPhotoRecord {
|
||
WiredTransferPhotoRecord(
|
||
id: id,
|
||
sourceId: id,
|
||
fileName: fileName,
|
||
localPath: localPath,
|
||
thumbnailPath: "",
|
||
capturedAt: "2026-05-20 12:05:18",
|
||
fileSizeBytes: 32,
|
||
status: status.rawValue,
|
||
progress: 0,
|
||
errorMessage: nil,
|
||
albumId: albumID,
|
||
userId: userID,
|
||
remoteURL: "",
|
||
updatedAt: Date().timeIntervalSince1970
|
||
)
|
||
}
|
||
|
||
private func makeJPEGData() -> Data {
|
||
let renderer = UIGraphicsImageRenderer(size: CGSize(width: 8, height: 8))
|
||
return renderer.jpegData(withCompressionQuality: 0.9) { context in
|
||
UIColor.systemBlue.setFill()
|
||
context.fill(CGRect(x: 0, y: 0, width: 8, height: 8))
|
||
}
|
||
}
|
||
|
||
private func downloadScope(account: AccountContext, albumID: Int) -> CameraDownloadStorage.Scope {
|
||
CameraDownloadStorage.Scope(accountKey: account.accountCachePrefix ?? "guest_", albumID: albumID)
|
||
}
|
||
}
|
||
|
||
@MainActor
|
||
private final class MockWiredCameraService: CameraServiceProtocol {
|
||
let brand: CameraBrand = .sony
|
||
var connectionState: CameraConnectionState = .connected(deviceName: "Mock")
|
||
var onConnectionStateChange: ((CameraConnectionState) -> Void)?
|
||
var onNewAsset: ((CameraAsset) -> Void)?
|
||
var downloadURL: URL?
|
||
|
||
func connect() async {}
|
||
func disconnect() async {}
|
||
|
||
func listAssets() async throws -> [CameraAsset] {
|
||
[]
|
||
}
|
||
|
||
func downloadAsset(_ asset: CameraAsset) async throws -> URL {
|
||
if let downloadURL {
|
||
return downloadURL
|
||
}
|
||
let url = FileManager.default.temporaryDirectory.appendingPathComponent(asset.filename)
|
||
if !FileManager.default.fileExists(atPath: url.path) {
|
||
try Data(repeating: 0xFF, count: 8).write(to: url)
|
||
}
|
||
return url
|
||
}
|
||
}
|
||
|
||
@MainActor
|
||
private final class MockTravelAlbumAPIForWiredTransfer: TravelAlbumServing {
|
||
func availableOrders() async throws -> [TravelAlbumAvailableOrder] { [] }
|
||
func createAlbum(_ request: TravelAlbumCreateRequest) async throws -> TravelAlbumCreateResponse {
|
||
TravelAlbumCreateResponse(id: 1)
|
||
}
|
||
func albumList(page: Int, pageSize: Int) async throws -> ListPayload<TravelAlbumItem> {
|
||
ListPayload(total: 0, list: [])
|
||
}
|
||
func albumInfo(id: Int) async throws -> TravelAlbumItem { throw APIError.emptyData }
|
||
func editAlbum(_ request: TravelAlbumEditRequest) async throws {}
|
||
func deleteAlbum(_ request: TravelAlbumDeleteRequest) async throws {}
|
||
func materialList(
|
||
userEquityTravelId: Int,
|
||
page: Int,
|
||
pageSize: Int,
|
||
orderBy: Int,
|
||
isPurchased: Int?
|
||
) async throws -> ListPayload<TravelAlbumMaterial> {
|
||
ListPayload(total: 0, list: [])
|
||
}
|
||
func uploadMaterial(_ request: TravelAlbumUploadMaterialRequest) async throws -> TravelAlbumMaterial {
|
||
let data = Data(
|
||
#"{"code":100000,"msg":"success","data":{"id":"11","user_equity_travel_id":"8","status":"1","order_number":"","user_id":"100","file_name":"DSC_001.JPG","file_type":"2","file_url":"https://cdn/a.jpg","file_size":"2048","cover_url":"","is_purchased":"0","created_at":"2026","updated_at":"2026"}}"#.utf8
|
||
)
|
||
let envelope = try JSONDecoder().decode(APIEnvelope<TravelAlbumMaterial>.self, from: data)
|
||
return try XCTUnwrap(envelope.data)
|
||
}
|
||
func deleteMaterial(_ request: TravelAlbumDeleteMaterialRequest) async throws {}
|
||
func mpCode(id: Int) async throws -> TravelAlbumMpCodeResponse {
|
||
TravelAlbumMpCodeResponse(mpCodeOssURL: "")
|
||
}
|
||
}
|
||
|
||
@MainActor
|
||
private final class WiredTransferMockOSSUploadService: OSSUploadServing {
|
||
private(set) var uploadedFileNames: [String] = []
|
||
var uploadDelayNanoseconds: UInt64 = 0
|
||
private(set) var activeUploads = 0
|
||
private(set) var maxActiveUploads = 0
|
||
|
||
func uploadUserAvatar(data: Data, fileName: String, scenicId: Int, onProgress: @escaping (Int) -> Void) async throws -> String { "" }
|
||
func uploadRealNameImage(data: Data, fileName: String, scenicId: Int, onProgress: @escaping (Int) -> Void) async throws -> String { "" }
|
||
func uploadCloudFile(data: Data, fileName: String, fileType: Int, scenicId: Int, onProgress: @escaping (Int) -> Void) async throws -> String { "" }
|
||
func uploadAlbumFile(data: Data, fileName: String, fileType: Int, scenicId: Int, onProgress: @escaping (Int) -> Void) async throws -> String {
|
||
activeUploads += 1
|
||
maxActiveUploads = max(maxActiveUploads, activeUploads)
|
||
if uploadDelayNanoseconds > 0 {
|
||
try await Task.sleep(nanoseconds: uploadDelayNanoseconds)
|
||
}
|
||
activeUploads -= 1
|
||
uploadedFileNames.append(fileName)
|
||
onProgress(100)
|
||
return "https://cdn/mock/\(fileName)"
|
||
}
|
||
func uploadTaskFile(data: Data, fileName: String, fileType: Int, scenicId: Int, onProgress: @escaping (Int) -> Void) async throws -> String { "" }
|
||
func uploadProjectImage(data: Data, fileName: String, scenicId: Int, onProgress: @escaping (Int) -> Void) async throws -> String { "" }
|
||
func uploadPunchPointImage(data: Data, fileName: String, scenicId: Int, onProgress: @escaping (Int) -> Void) async throws -> String { "" }
|
||
func uploadScenicApplicationImage(data: Data, fileName: String, scenicId: Int, onProgress: @escaping (Int) -> Void) async throws -> String { "" }
|
||
func uploadBankCardImage(data: Data, fileName: String, scenicId: Int, onProgress: @escaping (Int) -> Void) async throws -> String { "" }
|
||
}
|
||
|
||
@MainActor
|
||
private func makeTransferModeTestAccount() -> AccountContext {
|
||
let account = AccountContext()
|
||
account.applyLogin(profile: AccountProfile(userId: "transfer-mode-user", displayName: "测试"))
|
||
return account
|
||
}
|
||
|
||
@MainActor
|
||
private func makeTransferModeTestStore(account: AccountContext) -> WiredTransferPhotoStore {
|
||
WiredTransferPhotoStore(
|
||
accountPrefixProvider: { account.accountCachePrefix ?? "guest_" },
|
||
userIDProvider: { account.profile?.userId ?? "" }
|
||
)
|
||
}
|