cell/test.ce

var shop = use('internal/shop')
var pkg = use('package')
var fd = use('fd')
var time = use('time')
var json = use('json')
var blob = use('blob')
var dbg = use('js')

// run gc with dbg.gc()

if (!args) args = []

var target_pkg = null // null = current package
var target_test = null // null = all tests, otherwise specific test file
var all_pkgs = false
var gc_after_each_test = false

// Actor test support
def ACTOR_TEST_TIMEOUT = 30000 // 30 seconds timeout for actor tests
var pending_actor_tests = []
var actor_test_results = []

// Check if current directory is a valid cell package
function is_valid_package(dir) {
    if (!dir) dir = '.'
    return fd.is_file(dir + '/cell.toml')
}

// Get current package name from cell.toml or null
function get_current_package_name() {
    if (!is_valid_package('.')) return null
    try {
        var config = pkg.load_config(null)
        return config.package || 'local'
    } catch (e) {
        return 'local'
    }
}

// Parse arguments
// Usage:
//   cell test                          - run all tests for current package
//   cell test tests/suite              - run specific test file in current package
//   cell test all                      - run all tests for current package
//   cell test package <name>           - run all tests for named package
//   cell test package <name> <test>    - run specific test in named package
//   cell test package all              - run all tests from all packages

function parse_args() {
    var cleaned_args = []
    for (var i = 0; i < length(args); i++) {
        if (args[i] == '-g') {
            gc_after_each_test = true
        } else {
            push(cleaned_args, args[i])
        }
    }
    args = cleaned_args

    if (length(args) == 0) {
        // cell test - run all tests for current package
        if (!is_valid_package('.')) {
            log.console('No cell.toml found in current directory')
            return false
        }
        target_pkg = null
        return true
    }

    if (args[0] == 'all') {
        // cell test all - run all tests for current package
        if (!is_valid_package('.')) {
            log.console('No cell.toml found in current directory')
            return false
        }
        target_pkg = null
        return true
    }

    if (args[0] == 'package') {
        if (length(args) < 2) {
            log.console('Usage: cell test package <name> [test]')
            log.console('       cell test package all')
            return false
        }

        if (args[1] == 'all') {
            // cell test package all - run tests from all packages
            all_pkgs = true
            log.console('Testing all packages...')
            return true
        }

        // cell test package <name> [test]
        var name = args[1]

        // Check if package exists in lock or is a local path
        var lock = shop.load_lock()
        if (lock[name]) {
            target_pkg = name
        } else if (starts_with(name, '/') && is_valid_package(name)) {
            target_pkg = name
        } else {
            // Try to resolve as dependency alias from current package
            if (is_valid_package('.')) {
                var resolved = pkg.alias_to_package(null, name)
                if (resolved) {
                    target_pkg = resolved
                } else {
                    log.console(`Package not found: ${name}`)
                    return false
                }
            } else {
                log.console(`Package not found: ${name}`)
                return false
            }
        }

        if (length(args) >= 3) {
            // cell test package <name> <test>
            target_test = args[2]
        }

        log.console(`Testing package: ${target_pkg}`)
        return true
    }

    // cell test tests/suite or cell test <path> - specific test file
    var test_path = args[0]

    // Normalize path - add tests/ prefix if not present and doesn't start with /
    if (!starts_with(test_path, 'tests/') && !starts_with(test_path, '/')) {
        // Check if file exists as-is first
        if (!fd.is_file(test_path + '.cm') && !fd.is_file(test_path)) {
            // Try with tests/ prefix
            if (fd.is_file('tests/' + test_path + '.cm') || fd.is_file('tests/' + test_path)) {
                test_path = 'tests/' + test_path
            }
        }
    }

    target_test = test_path
    target_pkg = null

    if (!is_valid_package('.')) {
        log.console('No cell.toml found in current directory')
        return false
    }

    return true
}

if (!parse_args()) {
    $stop()
    return
}

function ensure_dir(path) {
    if (fd.is_dir(path)) return true

    var parts = array(path, '/')
    var current = starts_with(path, '/') ? '/' : ''
    for (var i = 0; i < length(parts); i++) {
        if (parts[i] == '') continue
        current += parts[i] + '/'
        if (!fd.is_dir(current))
            fd.mkdir(current)
    }
    return true
}

// Get the directory for a package
function get_pkg_dir(package_name) {
    if (!package_name) {
        return fd.realpath('.')
    }
    if (starts_with(package_name, '/')) {
        return package_name
    }
    return shop.get_package_dir(package_name)
}

// Collect .ce actor tests from a package
function collect_actor_tests(package_name, specific_test) {
    var prefix = get_pkg_dir(package_name)
    var tests_dir = prefix + '/tests'

    if (!fd.is_dir(tests_dir)) return []

    var files = pkg.list_files(package_name)
    var actor_tests = []
    for (var i = 0; i < length(files); i++) {
        var f = files[i]
        // Check if file is in tests/ folder and is a .ce actor
        if (starts_with(f, "tests/") && ends_with(f, ".ce")) {
            // If specific test requested, filter
            if (specific_test) {
                var test_name = text(f, 0, -3) // remove .ce
                var match_name = specific_test
                if (!starts_with(match_name, 'tests/')) match_name = 'tests/' + match_name
                if (!ends_with(match_name, '.ce')) match_name = match_name
                // Match without extension
                var test_base = test_name
                var match_base = ends_with(match_name, '.ce') ? text(match_name, 0, -3) : match_name
                if (test_base != match_base) continue
            }

            push(actor_tests,{
                package: package_name || "local",
                file: f,
                path: prefix + '/' + f
            })
        }
    }
    return actor_tests
}

// Spawn an actor test and track it
function spawn_actor_test(test_info) {
    var test_name = text(test_info.file, 6, -3) // remove "tests/" and ".ce"
    log.console(`  [ACTOR] ${test_info.file}`)

    var entry = {
        package: test_info.package,
        file: test_info.file,
        test: test_name,
        status: "running",
        start_time: time.number(),
        actor: null
    }

    try {
        // Spawn the actor test - it should send back results
        var actor_path = text(test_info.path, 0, -3) // remove .ce
        entry.actor = $start(actor_path)
        push(pending_actor_tests, entry)
    } catch (e) {
        entry.status = "failed"
        entry.error = { message: `Failed to spawn actor: ${e}` }
        entry.duration_ns = 0
        push(actor_test_results, entry)
        log.console(`    FAIL ${test_name}: `)
        log.error(e)
    }
}

function run_tests(package_name, specific_test) {
    var prefix = get_pkg_dir(package_name)
    var tests_dir = prefix + '/tests'

    var pkg_result = {
        package: package_name || "local",
        files: [],
        total: 0,
        passed: 0,
        failed: 0
    }

    if (!fd.is_dir(tests_dir)) return pkg_result

    var files = pkg.list_files(package_name)
    var test_files = []
    for (var i = 0; i < length(files); i++) {
        var f = files[i]
        // Check if file is in tests/ folder and is a .cm module (not .ce - those are actor tests)
        if (starts_with(f, "tests/") && ends_with(f, ".cm")) {
            // If specific test requested, filter
            if (specific_test) {
                var test_name = text(f, 0, -3) // remove .cm
                var match_name = specific_test
                if (!starts_with(match_name, 'tests/')) match_name = 'tests/' + match_name
                // Match without extension
                var match_base = ends_with(match_name, '.cm') ? text(match_name, 0, -3) : match_name
                if (test_name != match_base) continue
            }
            push(test_files, f)
        }
    }

    if (length(test_files) > 0) {
        if (package_name) log.console(`Running tests for ${package_name}`)
        else log.console(`Running tests for local package`)
    }

    for (var i = 0; i < length(test_files); i++) {
        var f = test_files[i]
        var mod_path = text(f, 0, -3) // remove .cm

        var file_result = {
            name: f,
            tests: [],
            passed: 0,
            failed: 0
        }

        try {
            var test_mod
            // For local packages (null), use the current directory as package context
            var use_pkg = package_name ? package_name : fd.realpath('.')
            test_mod = shop.use(mod_path, use_pkg)

            var tests = []
            if (is_function(test_mod)) {
                push(tests, {name: 'main', fn: test_mod})
            } else if (is_object(test_mod)) {
                arrfor(array(test_mod), function(k) {
                    if (is_function(test_mod[k])) {
                        push(tests, {name: k, fn: test_mod[k]})
                    }
                })
            }

            if (length(tests) > 0) {
                log.console(`  ${f}`)
                for (var j = 0; j < length(tests); j++) {
                    var t = tests[j]
                    var test_entry = {
                        package: pkg_result.package,
                        test: t.name,
                        status: "pending",
                        duration_ns: 0
                    }

                    var start_time = time.number()
                    try {
                        var ret = t.fn()

                        if (is_text(ret)) {
                             throw Error(ret)
                        } else if (ret && (is_text(ret.message) || is_proto(ret, Error))) {
                             throw ret
                        }

                        test_entry.status = "passed"
                        log.console(`    PASS  ${t.name}`)
                        pkg_result.passed++
                        file_result.passed++
                    } catch (e) {
                        test_entry.status = "failed"
                        test_entry.error = {
                            message: e,
                            stack: e.stack || ""
                        }
                        if (e.name) test_entry.error.name = e.name

                        if (is_object(e) && e.message) {
                             test_entry.error.message = e.message
                        }

                        log.console(`    FAIL ${t.name} ${test_entry.error.message}`)
                        if (test_entry.error.stack) {
                             log.console(`      ${text(array(test_entry.error.stack, '\n'), '\n      ')}`)
                        }

                        pkg_result.failed++
                        file_result.failed++
                    }
                    var end_time = time.number()
                    test_entry.duration_ns = round((end_time - start_time) * 1000000000)

                    push(file_result.tests, test_entry)
                    pkg_result.total++
                    if (gc_after_each_test) {
                        dbg.gc()
                    }
                }
            }

        } catch (e) {
            log.console(`  Error loading ${f}: ${e}`)
             var test_entry = {
                package: pkg_result.package,
                test: "load_module",
                status: "failed",
                duration_ns: 0,
                error: { message: `Error loading module: ${e}` }
            }
            push(file_result.tests, test_entry)
            pkg_result.failed++
            file_result.failed++
            pkg_result.total++
            if (gc_after_each_test) {
                dbg.gc()
            }
        }
        push(pkg_result.files, file_result)
    }
    return pkg_result
}

var all_results = []
var all_actor_tests = []

if (all_pkgs) {
    // Run local first if we're in a valid package
    if (is_valid_package('.')) {
        push(all_results, run_tests(null, null))
        all_actor_tests = array(all_actor_tests, collect_actor_tests(null, null))
    }

    // Then all packages in lock
    var packages = shop.list_packages()
    for (var i = 0; i < length(packages); i++) {
        push(all_results, run_tests(packages[i], null))
        all_actor_tests = array(all_actor_tests, collect_actor_tests(packages[i], null))
    }
} else {
    push(all_results, run_tests(target_pkg, target_test))
    all_actor_tests = array(all_actor_tests, collect_actor_tests(target_pkg, target_test))
}

// Spawn actor tests if any
if (length(all_actor_tests) > 0) {
    log.console(`Running ${length(all_actor_tests)} actor test(s)...`)
    for (var i = 0; i < length(all_actor_tests); i++) {
        spawn_actor_test(all_actor_tests[i])
    }
}

// Handle messages from actor tests
function handle_actor_message(msg) {
    var sender = msg.$sender
    var found_idx = -1
    for (var i = 0; i < length(pending_actor_tests); i++) {
        if (pending_actor_tests[i].actor == sender) {
            found_idx = i
            break
        }
    }

    if (found_idx == -1) return

    var base_entry = pending_actor_tests[found_idx]
    pending_actor_tests = array(array(pending_actor_tests, 0, found_idx), array(pending_actor_tests, found_idx + 1))

    var end_time = time.number()
    var duration_ns = round((end_time - base_entry.start_time) * 1000000000)

    var results = []
    if (is_array(msg)) {
        results = msg
    } else if (msg && is_array(msg.results)) {
        results = msg.results
    } else {
        results = [msg]
    }

    for (var i = 0; i < length(results); i++) {
        var res = results[i] || {}
        var entry = {
            package: base_entry.package,
            file: base_entry.file,
            test: res.test || base_entry.test + (length(results) > 1 ? `#${i+1}` : ""),
            status: "failed",
            duration_ns: duration_ns
        }

        if (res.type && res.type != "test_result") {
            entry.error = { message: `Unexpected message type: ${res.type}` }
            log.console(`    FAIL ${entry.test}: unexpected message`)
        } else if (res.passed) {
            entry.status = "passed"
            log.console(`    PASS  ${entry.test}`)
        } else {
            entry.error = { message: res.error || "Test failed" }
            if (res.stack) entry.error.stack = res.stack
            log.console(`    FAIL ${entry.test}: ${entry.error.message}`)
        }

        push(actor_test_results, entry)
    }

    if (gc_after_each_test) {
        dbg.gc()
    }

    check_completion()
}

// Check for timed out actor tests
function check_timeouts() {
    var now = time.number()
    var timed_out = []

    for (var i = length(pending_actor_tests) - 1; i >= 0; i--) {
        var entry = pending_actor_tests[i]
        var elapsed_ms = (now - entry.start_time) * 1000
        if (elapsed_ms > ACTOR_TEST_TIMEOUT) {
            push(timed_out, i)
        }
    }

    for (var i = 0; i < length(timed_out); i++) {
        var idx = timed_out[i]
        var entry = pending_actor_tests[idx]
        pending_actor_tests = array(array(pending_actor_tests, 0, idx), array(pending_actor_tests, idx + 1))

        entry.status = "failed"
        entry.error = { message: "Test timed out" }
        entry.duration_ns = ACTOR_TEST_TIMEOUT * 1000000
        push(actor_test_results, entry)
        log.console(`    TIMEOUT ${entry.test}`)
    }

    if (length(pending_actor_tests) > 0) {
        $delay(check_timeouts, 1000)
    }
    check_completion()
}

// Check if all tests are complete and finalize
var finalized = false
function check_completion() {
    if (finalized) return
    if (length(pending_actor_tests) > 0) return

    finalized = true
    finalize_results()
}

function finalize_results() {
    // Add actor test results to all_results
    for (var i = 0; i < length(actor_test_results); i++) {
        var r = actor_test_results[i]
        var pkg_result = null
        for (var j = 0; j < length(all_results); j++) {
            if (all_results[j].package == r.package) {
                pkg_result = all_results[j]
                break
            }
        }
        if (!pkg_result) {
            pkg_result = { package: r.package, files: [], total: 0, passed: 0, failed: 0 }
            push(all_results, pkg_result)
        }

        var file_result = null
        for (var j = 0; j < length(pkg_result.files); j++) {
            if (pkg_result.files[j].name == r.file) {
                file_result = pkg_result.files[j]
                break
            }
        }
        if (!file_result) {
            file_result = { name: r.file, tests: [], passed: 0, failed: 0 }
            push(pkg_result.files, file_result)
        }

        push(file_result.tests, r)
        pkg_result.total++
        if (r.status == "passed") {
            pkg_result.passed++
            file_result.passed++
        } else {
            pkg_result.failed++
            file_result.failed++
        }
    }

    // Calculate totals
    var totals = { total: 0, passed: 0, failed: 0 }
    for (var i = 0; i < length(all_results); i++) {
        totals.total += all_results[i].total
        totals.passed += all_results[i].passed
        totals.failed += all_results[i].failed
    }

    log.console(`----------------------------------------`)
    log.console(`Tests: ${totals.passed} passed, ${totals.failed} failed, ${totals.total} total`)

    generate_reports(totals)
    $stop()
}

// If no actor tests, finalize immediately
var totals
if (length(all_actor_tests) == 0) {
    totals = { total: 0, passed: 0, failed: 0 }
    for (var i = 0; i < length(all_results); i++) {
        totals.total += all_results[i].total
        totals.passed += all_results[i].passed
        totals.failed += all_results[i].failed
    }

    log.console(`----------------------------------------`)
    log.console(`Tests: ${totals.passed} passed, ${totals.failed} failed, ${totals.total} total`)
} else {
    $delay(check_timeouts, 1000)
}

// Generate Reports function
function generate_reports(totals) {
    var timestamp = text(floor(time.number()))
    var report_dir = shop.get_reports_dir() + '/test_' + timestamp
    ensure_dir(report_dir)

    var txt_report = `TEST REPORT
Date: ${time.text(time.number())}
Total: ${totals.total}, Passed: ${totals.passed}, Failed: ${totals.failed}

=== SUMMARY ===
`
    for (var i = 0; i < length(all_results); i++) {
        var pkg_res = all_results[i]
        if (pkg_res.total == 0) continue
        txt_report += `Package: ${pkg_res.package}\n`
        for (var j = 0; j < length(pkg_res.files); j++) {
            var f = pkg_res.files[j]
            var status = f.failed == 0 ? "PASS" : "FAIL"
            txt_report += `  [${status}] ${f.name} (${f.passed}/${length(f.tests)})\n`
        }
    }

    txt_report += `\n=== FAILURES ===\n`
    var has_failures = false
    for (var i = 0; i < length(all_results); i++) {
        var pkg_res = all_results[i]
        for (var j = 0; j < length(pkg_res.files); j++) {
            var f = pkg_res.files[j]
            for (var k = 0; k < length(f.tests); k++) {
                var t = f.tests[k]
                if (t.status == "failed") {
                    has_failures = true
                    txt_report += `FAIL: ${pkg_res.package} :: ${f.name} :: ${t.test}\n`
                    if (t.error) {
                        txt_report += `  Message: ${t.error.message}\n`
                        if (t.error.stack) {
                            txt_report += `  Stack:\n${text(array(array(t.error.stack, '\n'), l => `    ${l}`), '\n')}\n`
                        }
                    }
                    txt_report += `\n`
                }
            }
        }
    }
    if (!has_failures) txt_report += `None\n`

    txt_report += `\n=== DETAILED RESULTS ===\n`
    for (var i = 0; i < length(all_results); i++) {
        var pkg_res = all_results[i]
        if (pkg_res.total == 0) continue

        for (var j = 0; j < length(pkg_res.files); j++) {
            var f = pkg_res.files[j]
            for (var k = 0; k < length(f.tests); k++) {
                var t = f.tests[k]
                var dur = `${t.duration_ns || 0}ns`
                var status = t.status == "passed" ? "PASS" : "FAIL"
                txt_report += `[${status}] ${pkg_res.package} ${t.test} (${dur})\n`
            }
        }
    }
    ensure_dir(report_dir)
    fd.slurpwrite(`${report_dir}/test.txt`, stone(blob(txt_report)))
    log.console(`Report written to ${report_dir}/test.txt`)

    // Generate JSON per package
    for (var i = 0; i < length(all_results); i++) {
        var pkg_res = all_results[i]
        if (pkg_res.total == 0) continue

        var pkg_tests = []
        for (var j = 0; j < length(pkg_res.files); j++) {
            var f = pkg_res.files[j]
            for (var k = 0; k < length(f.tests); k++) {
                push(pkg_tests, f.tests[k])
            }
        }

        var json_path = `${report_dir}/${replace(pkg_res.package, /\//, '_')}.json`
        fd.slurpwrite(json_path, stone(blob(json.encode(pkg_tests))))
    }
}

// If no actor tests, generate reports and stop immediately
if (length(all_actor_tests) == 0) {
    generate_reports(totals)
    $stop()
} else {
    $portal(function(msg) {
        handle_actor_message(msg)
    })
}