multi-simadmin/apps/ios/Tests/MultiSimAdminTests/FleetViewModelTests.swift

import XCTest

@testable import MultiSimAdmin

@MainActor
final class FleetViewModelTests: XCTestCase {
    func testRefreshSortsByNameAndReportsStatus() async throws {
        let repository = MemoryInstanceRepository()
        let model = FleetViewModel(
            repository: repository,
            probe: ConnectionProbe(client: AlwaysOnlineClient()),
            credentials: NoopCredentialStore()
        )
        try await model.add(InstanceInput(
            name: "Zulu",
            origin: URL(string: "http://192.168.1.30:3000")!,
            tags: ["lab"],
            password: nil
        ))
        try await model.add(InstanceInput(
            name: "Alpha",
            origin: URL(string: "http://192.168.1.20:3000")!,
            tags: [],
            password: nil
        ))

        await model.refresh()

        XCTAssertEqual(model.rows.map(\.instance.name), ["Alpha", "Zulu"])
        XCTAssertEqual(model.rows.map(\.status), [.online, .online])
        XCTAssertTrue(model.rows.allSatisfy { $0.latencyMilliseconds != nil })
    }

    func testVisibleRowsAndGroupModesUseFilteredResults() async throws {
        let repository = MemoryInstanceRepository()
        let model = FleetViewModel(
            repository: repository,
            probe: ConnectionProbe(client: AlwaysOnlineClient()),
            credentials: NoopCredentialStore()
        )
        try await model.add(InstanceInput(name: "Home", origin: URL(string: "http://192.168.1.70:3000")!, tags: ["home"]))
        try await model.add(InstanceInput(name: "Lab", origin: URL(string: "http://192.168.1.71:3000")!, tags: []))

        await model.refresh()
        model.searchText = "home"

        XCTAssertEqual(model.visibleRows.map(\.instance.name), ["Home"])
        XCTAssertEqual(model.groupedRows.flatMap(\.rows).map(\.instance.name), ["Home"])

        model.searchText = ""
        model.groupMode = .tags
        XCTAssertEqual(model.groupedRows.map(\.title), ["home", "未打标签"])
        XCTAssertEqual(model.groupedRows.map(\.rows.count), [1, 1])

        model.groupMode = .status
        XCTAssertEqual(model.groupedRows.map(\.title), ["在线"])
    }

    func testGroupModeKeepsUngroupedInstancesVisible() async throws {
        let repository = MemoryInstanceRepository()
        let model = FleetViewModel(
            repository: repository,
            probe: ConnectionProbe(client: AlwaysOnlineClient()),
            credentials: NoopCredentialStore()
        )
        try await model.add(InstanceInput(name: "Ungrouped", origin: URL(string: "http://192.168.1.72:3000")!))

        await model.refresh()
        model.groupMode = .groups

        XCTAssertEqual(model.groupedRows.map(\.title), ["未分组"])
        XCTAssertEqual(model.groupedRows.first?.rows.map(\.instance.name), ["Ungrouped"])
    }

    func testStoredGroupsResolveNamesAndCanUpdateInstance() async throws {
        let location = FileManager.default.temporaryDirectory
            .appendingPathComponent(UUID().uuidString)
            .appendingPathComponent("groups.json")
        let groupStore = FileInstanceGroupStore(location: location)
        let repository = MemoryInstanceRepository()
        let model = FleetViewModel(
            repository: repository,
            probe: ConnectionProbe(client: AlwaysOnlineClient()),
            credentials: NoopCredentialStore(),
            groupStore: groupStore
        )

        let createdGroup = try await groupStore.create(InstanceGroupInput(name: "外场"))
        try await model.add(InstanceInput(
            name: "Van",
            origin: URL(string: "http://192.168.1.80:3000")!,
            groupId: createdGroup.id
        ))

        await model.refresh()
        model.groupMode = .groups

        XCTAssertEqual(model.groups.map(\.name), ["外场"])
        XCTAssertEqual(model.groupedRows.map(\.title), ["外场"])
        XCTAssertEqual(model.groupedRows.first?.rows.map(\.instance.name), ["Van"])

        let row = try XCTUnwrap(model.rows.first)
        try await model.update(row.id, InstanceInput(
            name: "Van Pro",
            origin: row.instance.origin,
            tags: ["field"],
            groupId: createdGroup.id
        ))

        XCTAssertEqual(model.rows.first?.instance.name, "Van Pro")
        XCTAssertEqual(model.rows.first?.instance.tags, ["field"])
    }

    func testAssignMovesSelectedInstancesIntoAndOutOfGroup() async throws {
        let location = FileManager.default.temporaryDirectory
            .appendingPathComponent(UUID().uuidString)
            .appendingPathComponent("groups.json")
        let groupStore = FileInstanceGroupStore(location: location)
        let repository = MemoryInstanceRepository()
        let model = FleetViewModel(
            repository: repository,
            probe: ConnectionProbe(client: AlwaysOnlineClient()),
            credentials: NoopCredentialStore(),
            groupStore: groupStore
        )
        let first = try await model.add(InstanceInput(
            name: "First",
            origin: URL(string: "http://192.168.1.90:3000")!
        ))
        let second = try await model.add(InstanceInput(
            name: "Second",
            origin: URL(string: "http://192.168.1.91:3000")!
        ))
        let group = try await model.createGroup(named: "外场")

        try await model.assign(groupID: group.id, to: [first.id, second.id])
        XCTAssertEqual(model.rows.map(\.instance.groupId), [group.id, group.id])

        try await model.assign(groupID: nil, to: [first.id])
        XCTAssertEqual(model.rows.first?.instance.groupId, nil)
        XCTAssertEqual(model.rows.last?.instance.groupId, group.id)
    }

    func testAddValidatesPasswordAndDeleteRemovesCredential() async throws {
        let repository = MemoryInstanceRepository()
        let credentials = NoopCredentialStore()
        let model = FleetViewModel(
            repository: repository,
            probe: ConnectionProbe(client: AlwaysOnlineClient()),
            credentials: credentials
        )
        try await model.add(InstanceInput(
            name: "Secret",
            origin: URL(string: "http://192.168.1.40:3000")!,
            password: "pass"
        ))

        let row = try XCTUnwrap(model.rows.first)
        XCTAssertTrue(row.instance.credentialConfigured)
        XCTAssertEqual(credentials.saved[row.instance.id], "pass")

        await model.delete([row.instance.id])
        XCTAssertTrue(model.rows.isEmpty)
        XCTAssertNil(credentials.saved[row.instance.id])
    }

    func testDeleteSelectedClearsSelectionAndCredential() async throws {
        let repository = MemoryInstanceRepository()
        let credentials = NoopCredentialStore()
        let model = FleetViewModel(
            repository: repository,
            probe: ConnectionProbe(client: AlwaysOnlineClient()),
            credentials: credentials
        )
        try await model.add(InstanceInput(
            name: "Selected",
            origin: URL(string: "http://192.168.1.50:3000")!,
            password: "pass"
        ))
        try await model.add(InstanceInput(
            name: "Other",
            origin: URL(string: "http://192.168.1.60:3000")!,
            password: nil
        ))
        let selectedID = model.rows[0].id
        model.selectionMode = true
        model.selectedIDs = [selectedID]

        await model.deleteSelected()

        XCTAssertEqual(model.rows.map(\.instance.name), ["Selected"])
        XCTAssertEqual(credentials.removed, [selectedID])
        XCTAssertFalse(model.selectionMode)
        XCTAssertTrue(model.selectedIDs.isEmpty)
    }
}

struct AlwaysOnlineClient: SimAdminClientProtocol {
    func send(_: UpstreamRoute, baseURL: URL, cookie: String?) async throws -> UpstreamResponse {
        UpstreamResponse(status: 200, data: Data("{}".utf8))
    }
}

final class NoopCredentialStore: @unchecked Sendable, CredentialStore {
    private let lock = NSLock()
    private var savedStorage: [UUID: String] = [:]
    private var removedStorage: [UUID] = []

    var saved: [UUID: String] {
        lock.withLock { savedStorage }
    }

    var removed: [UUID] {
        lock.withLock { removedStorage }
    }

    func get(instanceID: UUID) throws -> String? {
        saved[instanceID]
    }

    func set(instanceID: UUID, password: String) throws {
        lock.withLock { savedStorage[instanceID] = password }
    }

    func remove(instanceID: UUID) throws {
        lock.withLock {
            savedStorage[instanceID] = nil
            removedStorage.append(instanceID)
        }
    }
}

final class MemoryInstanceRepository: @unchecked Sendable, InstanceRepository {
    private let lock = NSLock()
    private var itemsStorage: [Instance] = []

    private var items: [Instance] {
        get { lock.withLock { itemsStorage } }
        set { lock.withLock { itemsStorage = newValue } }
    }

    func list(_: InstanceQuery) async throws -> [Instance] {
        items.sorted { $0.name.localizedCompare($1.name) == .orderedAscending }
    }

    func get(_ id: UUID) async throws -> Instance? {
        items.first { $0.id == id }
    }

    func create(_ input: InstanceInput) async throws -> Instance {
        let now = Date()
        let instance = Instance(
            id: UUID(),
            name: input.name,
            origin: input.origin,
            tags: input.tags,
            groupId: input.groupId,
            credentialConfigured: !(input.password ?? "").isEmpty,
            configRevision: 1,
            createdAt: now,
            updatedAt: now
        )
        items.append(instance)
        return instance
    }

    func update(_ id: UUID, expectedRevision: Int, _ patch: InstancePatch) async throws -> Instance {
        guard let index = items.firstIndex(where: { $0.id == id }) else {
            throw RepositoryError.notFound
        }
        guard items[index].configRevision == expectedRevision else {
            throw RepositoryError.revisionConflict
        }
        var instance = items[index]
        if let name = patch.name { instance.name = name }
        if let origin = patch.origin { instance.origin = origin }
        if let tags = patch.tags { instance.tags = tags }
        if patch.groupId != nil || instance.groupId != nil { instance.groupId = patch.groupId }
        if let password = patch.password {
            instance.credentialConfigured = !password.isEmpty
        }
        instance.updatedAt = Date()
        instance.configRevision += 1
        items[index] = instance
        return instance
    }

    func delete(_ id: UUID, expectedRevision: Int) async throws {
        items.removeAll { $0.id == id }
    }
}