汉秋
be9c844bd3
恢复 USB 相机连接、边拍边传、三品牌驱动与 SwiftUI 历史导入页，通过适配层对接现有本地上传与 OSS 管道。 Co-authored-by: Cursor <cursoragent@cursor.com>
602 lines
25 KiB
Swift
602 lines
25 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 {
|
||
/// 测试 start 被取消时会 detach UI 回调。
|
||
func testStartCancellationDetachesFromUI() async {
|
||
let context = WiredTransferContext(
|
||
albumId: 6603,
|
||
albumName: "测试相册",
|
||
phone: "",
|
||
orderNumber: ""
|
||
)
|
||
let viewModel = WiredCameraTransferViewModel(context: context)
|
||
let account = AccountContext()
|
||
account.applyLogin(profile: AccountProfile(userId: "101", displayName: "测试"))
|
||
|
||
let startTask = Task {
|
||
await viewModel.start(
|
||
api: MockTravelAlbumAPIForWiredTransfer(),
|
||
ossService: WiredTransferMockOSSUploadService(),
|
||
scenicID: 1,
|
||
accountContext: account
|
||
)
|
||
}
|
||
|
||
try? await Task.sleep(nanoseconds: 100_000_000)
|
||
startTask.cancel()
|
||
try? await Task.sleep(nanoseconds: 200_000_000)
|
||
|
||
XCTAssertEqual(viewModel.connectionState, .disconnected)
|
||
}
|
||
|
||
/// 测试批量上传按钮三态流转。
|
||
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: "")
|
||
)
|
||
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)
|
||
}
|
||
|
||
/// 测试拍后传输模式下重传会从持久化记录恢复上传。
|
||
func testRetryPhotoInPostShootModeUploadsPersistedFile() async throws {
|
||
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)
|
||
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: "")
|
||
)
|
||
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 store = makeTransferModeTestStore(account: account)
|
||
let viewModel = WiredCameraTransferViewModel(
|
||
context: WiredTransferContext(albumId: 1, albumName: "相册", phone: "", orderNumber: "")
|
||
)
|
||
await viewModel.start(
|
||
api: MockTravelAlbumAPIForWiredTransfer(),
|
||
ossService: WiredTransferMockOSSUploadService(),
|
||
scenicID: 1,
|
||
accountContext: account
|
||
)
|
||
|
||
viewModel.selectTransferMode(
|
||
WiredCameraTransferViewModel.modePostShootTransfer,
|
||
api: MockTravelAlbumAPIForWiredTransfer(),
|
||
ossService: WiredTransferMockOSSUploadService(),
|
||
scenicID: 1
|
||
)
|
||
|
||
XCTAssertEqual(store.loadTransferModeOption(), WiredCameraTransferViewModel.modePostShootTransfer)
|
||
}
|
||
|
||
/// 测试 ConnectionState 映射为 CameraConnectionState。
|
||
func testConnectionStateMapsToCameraConnectionState() {
|
||
XCTAssertEqual(ConnectionState.idle.cameraConnectionState, .disconnected)
|
||
XCTAssertEqual(ConnectionState.disconnected.cameraConnectionState, .disconnected)
|
||
XCTAssertEqual(ConnectionState.searching.cameraConnectionState, .searching)
|
||
XCTAssertEqual(ConnectionState.connecting(deviceName: "EOS R5").cameraConnectionState, .connecting)
|
||
XCTAssertEqual(
|
||
ConnectionState.connected(platform: .sony, deviceName: "ILCE-7M4").cameraConnectionState,
|
||
.connected(deviceName: "ILCE-7M4")
|
||
)
|
||
XCTAssertEqual(
|
||
ConnectionState.failed(message: "授权被拒绝").cameraConnectionState,
|
||
.error("授权被拒绝")
|
||
)
|
||
}
|
||
|
||
/// 测试边拍边传 ingest 会触发管道自动上传。
|
||
func testPipelineIngestAutoUploadUploadsAsset() async throws {
|
||
let scope = CameraDownloadStorage.Scope(accountKey: "otg-pipe", albumID: 42)
|
||
let fileURL = CameraDownloadStorage.uniqueLocalURL(for: "otg_live.JPG", scope: scope)
|
||
try Data(repeating: 0xAA, count: 32).write(to: fileURL)
|
||
defer { CameraDownloadStorage.removeScopeDirectory(for: scope) }
|
||
|
||
let pipeline = WiredCameraTransferPipeline()
|
||
let sink = MockCameraAssetUploadSink()
|
||
let relativePath = CameraDownloadStorage.relativePath(for: fileURL)
|
||
|
||
pipeline.configure(uploadSink: sink, uploadEnabled: true, downloadScope: scope)
|
||
pipeline.ingestDownloadedAsset(
|
||
assetID: "obj-1",
|
||
filename: "otg_live.JPG",
|
||
localPath: relativePath,
|
||
capturedAt: Date(),
|
||
autoUpload: true
|
||
)
|
||
|
||
try await Task.sleep(nanoseconds: 800_000_000)
|
||
XCTAssertEqual(sink.uploadedFileNames, ["otg_live.JPG"])
|
||
XCTAssertEqual(pipeline.task(forAssetID: "obj-1")?.status, .uploaded)
|
||
}
|
||
|
||
/// 测试进入页面时会恢复缓存的传输模式。
|
||
func testStartRestoresCachedTransferModeOption() async {
|
||
let account = makeTransferModeTestAccount()
|
||
let store = makeTransferModeTestStore(account: account)
|
||
store.saveTransferModeOption(WiredCameraTransferViewModel.modePostShootTransfer)
|
||
|
||
let viewModel = WiredCameraTransferViewModel(
|
||
context: WiredTransferContext(albumId: 1, albumName: "相册", phone: "", orderNumber: "")
|
||
)
|
||
await viewModel.start(
|
||
api: MockTravelAlbumAPIForWiredTransfer(),
|
||
ossService: WiredTransferMockOSSUploadService(),
|
||
scenicID: 1,
|
||
accountContext: account
|
||
)
|
||
|
||
XCTAssertEqual(viewModel.transferModeOption, WiredCameraTransferViewModel.modePostShootTransfer)
|
||
}
|
||
|
||
/// 测试旧记录没有缩略图时列表先占位，但仍保留原图预览能力。
|
||
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: "")
|
||
)
|
||
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 storeURL = CameraDownloadStorage.uniqueLocalURL(for: "store_photo.JPG", scope: scope)
|
||
let otherURL = CameraDownloadStorage.uniqueLocalURL(for: "other_photo.JPG", scope: otherScope)
|
||
try makeJPEGData().write(to: storeURL)
|
||
try makeJPEGData().write(to: otherURL)
|
||
|
||
let store = WiredTransferPhotoStore(
|
||
accountPrefixProvider: { account.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
|
||
)
|
||
])
|
||
store.clearAlbum(albumID: albumID)
|
||
|
||
XCTAssertFalse(FileManager.default.fileExists(atPath: scopeDirectoryPath))
|
||
XCTAssertTrue(FileManager.default.fileExists(atPath: otherScopeDirectoryPath))
|
||
}
|
||
|
||
/// 测试同手机号不同账号类型的本地记录与物理目录隔离。
|
||
func testSameUserIDDifferentAccountTypesAreIsolated() throws {
|
||
let userID = "same-user-id"
|
||
let albumID = 9901
|
||
|
||
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 makeJPEGData().write(to: storeURL)
|
||
try makeJPEGData().write(to: photographerURL)
|
||
|
||
let storeStore = WiredTransferPhotoStore(
|
||
accountPrefixProvider: { storeAccount.accountCachePrefix ?? "guest_" },
|
||
userIDProvider: { userID }
|
||
)
|
||
let photographerStore = WiredTransferPhotoStore(
|
||
accountPrefixProvider: { photographerAccount.accountCachePrefix ?? "guest_" },
|
||
userIDProvider: { userID }
|
||
)
|
||
storeStore.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(storeStore.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: "")
|
||
)
|
||
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 MockCameraAssetUploadSink: CameraAssetUploadSink {
|
||
private(set) var uploadedFileNames: [String] = []
|
||
|
||
func upload(
|
||
localURL: URL,
|
||
fileName: String,
|
||
fileType: Int,
|
||
progress: @escaping @Sendable (Int) -> Void
|
||
) async throws -> String {
|
||
uploadedFileNames.append(fileName)
|
||
progress(100)
|
||
return "https://cdn/mock/\(fileName)"
|
||
}
|
||
}
|
||
|
||
@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 ?? "" }
|
||
)
|
||
}
|