/*
 * test_transaction.cj - 事务管理测试
 */

package tybb2026::tycj_orm

import std.unittest.*

// ============================================================================
// 事务定义测试
// ============================================================================

@test
func testTransactionDefinitionDefaultValues(): Unit {
    let def = TransactionDefinition()

    assert(def.propagation == Propagation.Required)
    assert(def.isolation == IsolationLevel.Default)
    assert(def.timeout == -1)
    assert(def.readOnly == false)
}

// ============================================================================
// 事务状态测试
// ============================================================================

@test
func testNewTransaction(): Unit {
    let status = DefaultTransactionStatus(newTransaction: true)

    assert(status.isNewTransaction())
    assert(!status.isRollbackOnly())
    assert(!status.isCompleted())
}

@test
func testSetRollbackOnly(): Unit {
    let status = DefaultTransactionStatus(newTransaction: true)

    status.setRollbackOnly()

    assert(status.isRollbackOnly())
}

@test
func testSetCompleted(): Unit {
    let status = DefaultTransactionStatus(newTransaction: true)

    status.setCompleted()

    assert(status.isCompleted())
}

// ============================================================================
// 事务模板测试
// ============================================================================

@test
func testExecuteSuccess(): Unit {
    // 创建一个简单的事务管理器实现用于测试
    let mockTm = MockTransactionManager()
    let template = TransactionTemplate(mockTm)

    let result = template.execute((status) => {
        "success"
    })

    assert(result == "success")
    assert(mockTm.committed)
}

@test
func testExecuteWithRollback(): Unit {
    let mockTm = MockTransactionManager()
    let template = TransactionTemplate(mockTm)

    try {
        template.execute<String>((status) => {
            status.setRollbackOnly()
            "should rollback"
        })
    } catch (_: Exception) {
        ()
    }

    assert(mockTm.rolledBack)
}

@test
func testExecuteWithException(): Unit {
    let mockTm = MockTransactionManager()
    let template = TransactionTemplate(mockTm)

    try {
        template.execute<String>((status) => {
            throw Exception("Test exception")
        })
        assert(false) // 应该抛出异常
    } catch (_: Exception) {
        assert(true)
    }

    assert(mockTm.rolledBack)
}

// 模拟事务管理器用于测试
class MockTransactionManager <: TransactionManager {
    public var committed: Bool = false
    public var rolledBack: Bool = false

    public func getTransaction(definition: TransactionDefinition): TransactionStatus {
        DefaultTransactionStatus(newTransaction: true)
    }

    public func commit(status: TransactionStatus): Unit {
        committed = true
    }

    public func rollback(status: TransactionStatus): Unit {
        rolledBack = true
    }
}

// ============================================================================
// 隔离级别测试
// ============================================================================

@test
func testIsolationLevelValues(): Unit {
    // 验证所有隔离级别都存在
    let defaultLevel = IsolationLevel.Default
    let readUncommitted = IsolationLevel.ReadUncommitted
    let readCommitted = IsolationLevel.ReadCommitted
    let repeatableRead = IsolationLevel.RepeatableRead
    let serializable = IsolationLevel.Serializable

    assert(true) // 如果能编译通过，说明枚举定义正确
}

// ============================================================================
// 传播行为测试
// ============================================================================

@test
func testPropagationValues(): Unit {
    // 验证所有传播行为都存在
    let required = Propagation.Required
    let supports = Propagation.Supports
    let mandatory = Propagation.Mandatory
    let requiresNew = Propagation.RequiresNew
    let notSupported = Propagation.NotSupported
    let never = Propagation.Never
    let nested = Propagation.Nested

    assert(true) // 如果能编译通过，说明枚举定义正确
}