eric / piclead-client

import XCTest
@testable import Card2vcf

/// Port of android `sync/SyncSchemaDaoTest.kt` against an in-memory database.
final class SyncSchemaDaoTest: XCTestCase {
    private var db: Card2vcfDatabase!

    override func setUp() {
        super.setUp()
        db = Card2vcfDatabase(inMemory: true)
    }

    override func tearDown() {
        db = nil
        super.tearDown()
    }

    func testSyncOpInsertAndList() async throws {
        let dao = db.syncOpDao
        let id = try await dao.insert(
            SyncOpEntity(
                entityType: "contact",
                op: "create",
                payloadJson: #"{"fullName":"Ada"}"#,
                localId: 42,
                createdAt: 1000
            )
        )
        let ops = try await dao.listAll()
        XCTAssertEqual(1, ops.count)
        XCTAssertEqual(id, ops[0].id)
        XCTAssertEqual("contact", ops[0].entityType)
        XCTAssertEqual("create", ops[0].op)
        XCTAssertEqual(42, ops[0].localId)
        let fetched = try await dao.getById(id)
        XCTAssertNotNil(fetched)
        try await dao.deleteById(id)
        let afterDelete = try await dao.getById(id)
        XCTAssertNil(afterDelete)
        let empty = try await dao.listAll()
        XCTAssertEqual(0, empty.count)
    }

    func testSyncOpMarkFailurePersistsAttemptsAndLastError() async throws {
        let dao = db.syncOpDao
        let id = try await dao.insert(
            SyncOpEntity(
                entityType: "contact",
                op: "create",
                payloadJson: #"{"fullName":"Ada"}"#,
                localId: 42,
                createdAt: 1000
            )
        )

        try await dao.markFailure(id: id, error: "Erreur interne.")

        let op = try await dao.getById(id)
        XCTAssertEqual(1, op?.attempts)
        XCTAssertEqual("Erreur interne.", op?.lastError)

        try await dao.markFailure(id: id, error: nil)
        let again = try await dao.getById(id)
        XCTAssertEqual(2, again?.attempts)
        XCTAssertNil(again?.lastError)
    }

    func testTacheUpsertAndGetByServerId() async throws {
        let dao = db.tacheDao
        let localId = try await dao.upsert(
            TacheEntity(
                serverId: "tache-1",
                projetServerId: "projet-1",
                titre: "Préparer démo",
                colonneId: "col-a",
                ordre: 2,
                assigneA: "alice",
                auteur: "bob",
                createdAt: 500,
                updatedAt: 600
            )
        )
        var found = try await dao.getByServerId("tache-1")
        XCTAssertNotNil(found)
        XCTAssertEqual(localId, found!.localId)
        XCTAssertEqual("Préparer démo", found!.titre)
        XCTAssertEqual("projet-1", found!.projetServerId)
        XCTAssertEqual(2, found!.ordre)
        XCTAssertEqual("alice", found!.assigneA)

        found!.titre = "Démo prête"
        found!.updatedAt = 700
        try await dao.upsert(found!)
        let updated = try await dao.getByServerId("tache-1")
        XCTAssertEqual("Démo prête", updated!.titre)

        let byProjet = try await dao.listByProjetServerId("projet-1")
        XCTAssertEqual(1, byProjet.count)
        try await dao.deleteByServerId("tache-1")
        let afterDelete = try await dao.getByServerId("tache-1")
        XCTAssertNil(afterDelete)
    }
}