john/cell
1
0
Fork 0
Code Issues 31 Pull Requests Packages Projects Releases 2 Wiki Activity

turn into a cell package

Browse Source
This commit is contained in:
John Alanbrook
2025-12-08 17:39:17 -06:00
parent aae267a6e9
commit 38d6b4d4e8
52 changed files with 44 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

542
test.ce Normal file
View File

@@ -0,0 +1,542 @@
var shop = use('shop')
var fd = use('fd')
var time = use('time')
var json = use('json')
var utf8 = use('utf8')
if (!args) args = []
var target_pkg = null // null = current, otherwise canonical path
var all_pkgs = false
// Actor test support
def ACTOR_TEST_TIMEOUT = 30000 // 30 seconds timeout for actor tests
var pending_actor_tests = []
var actor_test_results = []
if (args.length > 0) {
if (args[0] == 'package') {
if (args.length < 2) {
log.console(`Usage: cell test package <name>`)
$_.stop()
return
}
var name = args[1]
var resolved = shop.resolve_alias(name, null)
if (resolved) {
target_pkg = resolved.pkg
log.console(`Testing package: ${resolved.alias} (${resolved.pkg})`)
} else {
log.console(`Package not found: ${name}`)
$_.stop()
return
}
} else if (args[0] == 'all') {
all_pkgs = true
log.console(`Testing all packages...`)
} else {
log.console(`Usage: cell test [package <name> | all]`)
$_.stop()
return
}
}
function ensure_dir(path) {
if (fd.is_dir(path)) return true
var parts = path.split('/')
var current = ''
for (var i = 0; i < parts.length; i++) {
if (parts[i] == '') continue
current += `${parts[i]}/`
if (!fd.is_dir(current)) {
fd.mkdir(current)
}
}
return true
}
// Collect .ce actor tests from a package
function collect_actor_tests(pkg) {
var prefix = pkg ? shop.get_shop_path() + '/modules/' + pkg : (shop.get_current_package() || '.')
var tests_dir = prefix + '/tests'
if (!fd.is_dir(tests_dir)) return []
var files = shop.list_files(pkg)
var actor_tests = []
for (var i = 0; i < files.length; i++) {
var f = files[i]
// Check if file is in tests/ folder and is a .ce actor
if (f.startsWith("tests/") && f.endsWith(".ce")) {
actor_tests.push({
package: pkg || "local",
file: f,
path: pkg ? `${prefix}/${f}` : f
})
}
}
return actor_tests
}
// Spawn an actor test and track it
function spawn_actor_test(test_info) {
var test_name = test_info.file.substring(6, test_info.file.length - 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
// The actor receives $_.parent which it can use to send results
var actor_path = test_info.path.substring(0, test_info.path.length - 3) // remove .ce
entry.actor = $_.start(actor_path)
pending_actor_tests.push(entry)
} catch (e) {
entry.status = "failed"
entry.error = { message: `Failed to spawn actor: ${e}` }
entry.duration_ns = 0
actor_test_results.push(entry)
log.console(` FAIL ${test_name}: `)
log.error(e)
}
}
function run_tests(pkg) {
var prefix = pkg ? shop.get_shop_path() + '/modules/' + pkg : (shop.get_current_package() || '.')
var tests_dir = prefix + '/tests'
var pkg_result = {
package: pkg || "local",
files: [],
total: 0,
passed: 0,
failed: 0
}
if (!fd.is_dir(tests_dir)) return pkg_result
var files = shop.list_files(pkg)
var test_files = []
for (var i = 0; i < files.length; i++) {
var f = files[i]
// Check if file is in tests/ folder and is a .cm module (not .ce - those are actor tests)
if (f.startsWith("tests/") && f.endsWith(".cm")) {
test_files.push(f)
}
}
if (test_files.length > 0) {
if (pkg) log.console(`Running tests for ${pkg}`)
else log.console(`Running tests for local package`)
}
for (var i = 0; i < test_files.length; i++) {
var f = test_files[i]
var mod_path = f.substring(0, f.length - 3) // remove .cm
var file_result = {
name: f,
tests: [],
passed: 0,
failed: 0
}
try {
var test_mod
if (pkg) {
test_mod = shop.use(mod_path, pkg)
} else {
test_mod = globalThis.use(mod_path)
}
var tests = []
if (typeof test_mod == 'function') {
tests.push({name: 'main', fn: test_mod})
} else if (typeof test_mod == 'object') {
for (var k in test_mod) {
if (typeof test_mod[k] == 'function') {
tests.push({name: k, fn: test_mod[k]})
}
}
}
if (tests.length > 0) {
log.console(` ${f}`)
for (var j = 0; j < tests.length; 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 (typeof ret == 'string') {
throw new Error(ret)
} else if (ret && (typeof ret.message == 'string' || ret instanceof 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.toString(),
stack: e.stack || ""
}
if (e.name) test_entry.error.name = e.name
// If it's an object but not a native Error, try to extract more info
if (typeof e == 'object' && e.message) {
test_entry.error.message = e.message
}
log.console(` FAIL ${t.name} ${test_entry.error.message}`)
if (test_entry.error.stack) {
log.console(` ${test_entry.error.stack.split('\n').join('\n ')}`)
}
pkg_result.failed++
file_result.failed++
}
var end_time = time.number()
test_entry.duration_ns = Math.round((end_time - start_time) * 1000000000)
file_result.tests.push(test_entry)
pkg_result.total++
}
}
} catch (e) {
log.console(` Error loading ${f}: ${e}`)
// Treat load error as a file failure?
// Or maybe add a dummy test entry for "load"
var test_entry = {
package: pkg_result.package,
test: "load_module",
status: "failed",
duration_ns: 0,
error: { message: `Error loading module: ${e}` }
}
file_result.tests.push(test_entry)
pkg_result.failed++
file_result.failed++
pkg_result.total++
}
pkg_result.files.push(file_result)
}
return pkg_result
}
var all_results = []
var all_actor_tests = []
if (all_pkgs) {
// Run local first
all_results.push(run_tests(null))
all_actor_tests = all_actor_tests.concat(collect_actor_tests(null))
// Then all dependencies
var deps = shop.list_packages(null)
for (var i = 0; i < deps.length; i++) {
all_results.push(run_tests(deps[i]))
all_actor_tests = all_actor_tests.concat(collect_actor_tests(deps[i]))
}
} else {
all_results.push(run_tests(target_pkg))
all_actor_tests = all_actor_tests.concat(collect_actor_tests(target_pkg))
}
// Spawn actor tests if any
if (all_actor_tests.length > 0) {
log.console(`Running ${all_actor_tests.length} actor test(s)...`)
for (var i = 0; i < all_actor_tests.length; i++) {
spawn_actor_test(all_actor_tests[i])
}
}
// Handle messages from actor tests
// Actor tests should send either a single result `{ type: "test_result", ... }`
// or an array / object containing multiple results (e.g. {results:[...]})
function handle_actor_message(msg) {
// Find the pending test from this sender
var sender = msg.$sender
var found_idx = -1
for (var i = 0; i < pending_actor_tests.length; i++) {
if (pending_actor_tests[i].actor == sender) {
found_idx = i
break
}
}
if (found_idx == -1) return // Unknown sender
var base_entry = pending_actor_tests[found_idx]
pending_actor_tests.splice(found_idx, 1)
var end_time = time.number()
var duration_ns = Math.round((end_time - base_entry.start_time) * 1000000000)
// Normalize to an array of result objects
var results = []
if (Array.isArray(msg)) {
results = msg
} else if (msg && Array.isArray(msg.results)) {
results = msg.results
} else {
results = [msg]
}
for (var i = 0; i < results.length; i++) {
var res = results[i] || {}
var entry = {
package: base_entry.package,
file: base_entry.file,
test: res.test || base_entry.test + (results.length > 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}`)
}
actor_test_results.push(entry)
}
check_completion()
}
// Check for timed out actor tests
function check_timeouts() {
var now = time.number()
var timed_out = []
for (var i = pending_actor_tests.length - 1; i >= 0; i--) {
var entry = pending_actor_tests[i]
var elapsed_ms = (now - entry.start_time) * 1000
if (elapsed_ms > ACTOR_TEST_TIMEOUT) {
timed_out.push(i)
}
}
for (var i = 0; i < timed_out.length; i++) {
var idx = timed_out[i]
var entry = pending_actor_tests[idx]
pending_actor_tests.splice(idx, 1)
entry.status = "failed"
entry.error = { message: "Test timed out" }
entry.duration_ns = ACTOR_TEST_TIMEOUT * 1000000
actor_test_results.push(entry)
log.console(` TIMEOUT ${entry.test}`)
}
if (pending_actor_tests.length > 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 (pending_actor_tests.length > 0) return
finalized = true
finalize_results()
}
function finalize_results() {
// Add actor test results to all_results
for (var i = 0; i < actor_test_results.length; i++) {
var r = actor_test_results[i]
// Find or create package result
var pkg_result = null
for (var j = 0; j < all_results.length; 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 }
all_results.push(pkg_result)
}
// Find or create file result
var file_result = null
for (var j = 0; j < pkg_result.files.length; 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 }
pkg_result.files.push(file_result)
}
file_result.tests.push(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 < all_results.length; 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
if (all_actor_tests.length == 0) {
// Calculate totals
var totals = { total: 0, passed: 0, failed: 0 }
for (var i = 0; i < all_results.length; 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 {
// Start timeout checker
$_.delay(check_timeouts, 1000)
}
// Generate Reports function
function generate_reports(totals) {
var timestamp = Math.floor(time.number()).toString()
var report_dir = shop.get_reports_dir() + '/test_' + timestamp
ensure_dir(report_dir)
// Generate test.txt
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 < all_results.length; 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 < pkg_res.files.length; j++) {
var f = pkg_res.files[j]
var status = f.failed == 0 ? "PASS" : "FAIL"
txt_report += ` [${status}] ${f.name} (${f.passed}/${f.tests.length})\n`
}
}
txt_report += `\n=== FAILURES ===\n`
var has_failures = false
for (var i = 0; i < all_results.length; i++) {
var pkg_res = all_results[i]
for (var j = 0; j < pkg_res.files.length; j++) {
var f = pkg_res.files[j]
for (var k = 0; k < f.tests.length; 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${t.error.stack.split('\n').map(function(l){return ` ${l}`}).join('\n')}\n`
}
}
txt_report += `\n`
}
}
}
}
if (!has_failures) txt_report += `None\n`
txt_report += `\n=== DETAILED RESULTS ===\n`
for (var i = 0; i < all_results.length; i++) {
var pkg_res = all_results[i]
if (pkg_res.total == 0) continue
for (var j = 0; j < pkg_res.files.length; j++) {
var f = pkg_res.files[j]
for (var k = 0; k < f.tests.length; 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`
}
}
}
fd.slurpwrite(`${report_dir}/test.txt`, utf8.encode(txt_report))
log.console(`Report written to ${report_dir}/test.txt`)
// Generate JSON per package
for (var i = 0; i < all_results.length; i++) {
var pkg_res = all_results[i]
if (pkg_res.total == 0) continue
var pkg_tests = []
for (var j = 0; j < pkg_res.files.length; j++) {
var f = pkg_res.files[j]
for (var k = 0; k < f.tests.length; k++) {
pkg_tests.push(f.tests[k])
}
}
var json_path = `${report_dir}/${pkg_res.package.replace(/\//g, '_')}.json`
fd.slurpwrite(json_path, utf8.encode(json.encode(pkg_tests)))
}
}
// If no actor tests, generate reports and stop immediately
if (all_actor_tests.length == 0) {
generate_reports(totals)
$_.stop()
} else {
// Set up portal to receive messages from actor tests
$_.portal(function(msg) {
handle_actor_message(msg)
})
}