@greenpandastudios/aug-cli 0.19.0

package/src/testing.js

@@ -0,0 +1,186 @@
+import { relative } from 'node:path';
+import { typeName } from "./ast.js";
+import { checkProject } from "./checker.js";
+export function discoverTests(project) {
+    const tests = [];
+    const diagnostics = [];
+    const report = (node, message) => diagnostics.push({
+        file: node.span.file, line: node.span.line, column: node.span.column, code: 'TEST', message
+    });
+    for (const file of project.files.values()) {
+        if (file.builtin || file.package)
+            continue;
+        const suites = new Set();
+        for (const suite of file.items) {
+            if (suite.kind !== 'test')
+                continue;
+            const subject = project.scopes.get(file.path)?.get(suite.type.name);
+            if (subject?.node.kind !== (suite.functionSuite || suite.endpointSuite ? 'function' : 'class') || subject.file !== file.path)
+                report(suite, 'A test must name its class, function, or endpoint declared in the same file');
+            if (suite.endpointSuite && (subject?.node.kind !== 'function' || !subject.node.endpoint))
+                report(suite, 'test endpoint requires an endpoint declared in the same file');
+            if (subject?.node.kind === 'class' && suite.type.args.length !== subject.node.typeParams.length)
+                report(suite, `${suite.type.name} tests need ${subject.node.typeParams.length} type arguments`);
+            if (suite.name === 'next')
+                report(suite, 'next is reserved for interceptor continuations');
+            const suiteType = typeName(suite.type);
+            if (suites.has(suiteType))
+                report(suite, `Duplicate test suite for ${suiteType}`);
+            suites.add(suiteType);
+            if (!suite.groups.length)
+                report(suite, 'A test suite needs at least one when group');
+            const groups = new Set();
+            for (const group of suite.groups) {
+                if (!group.name.trim())
+                    report(group, 'A test group needs a nonempty name');
+                if (groups.has(group.name))
+                    report(group, `Duplicate test group ${group.name}`);
+                groups.add(group.name);
+                const checkSetup = (value) => {
+                    if (!value || typeof value !== 'object')
+                        return;
+                    if (Array.isArray(value)) {
+                        value.forEach(checkSetup);
+                        return;
+                    }
+                    const node = value;
+                    if (node.kind === 'return')
+                        report(node, 'Test setup cannot return before its case runs');
+                    for (const [key, child] of Object.entries(value))
+                        if (key !== 'span')
+                            checkSetup(child);
+                };
+                checkSetup(group.setup);
+                if (!group.cases.length)
+                    report(group, `Group ${group.name} needs at least one it case`);
+                const cases = new Set();
+                for (const test of group.cases) {
+                    if (!test.name.trim())
+                        report(test, 'A test case needs a nonempty name');
+                    if (cases.has(test.name))
+                        report(test, `Duplicate test case ${test.name}`);
+                    cases.add(test.name);
+                    const id = `${relative(project.root, file.path)}:${encodeURIComponent(suiteType)}:${encodeURIComponent(group.name)}:${encodeURIComponent(test.name)}`;
+                    if (test.rows) {
+                        if (!test.rows.length)
+                            report(test, 'Parameterized cases need at least one row');
+                        test.rows.forEach((row, rowIndex) => {
+                            if (row.kind !== 'collection' || row.collection !== 'Tuple' || row.items.length !== test.parameters?.length)
+                                report(test, 'Each parameter row must be a tuple matching the declared names');
+                            tests.push({ id: `${id}:${rowIndex + 1}`, file: file.path, suite, group, test, row, rowIndex });
+                        });
+                    }
+                    else
+                        tests.push({ id, file: file.path, suite, group, test });
+                }
+            }
+        }
+    }
+    return { tests, diagnostics };
+}
+/** Each case is a small program with its own composition root and fresh process. */
+export function projectForTest(project, unit) {
+    const diagnostics = [...project.diagnostics];
+    let declared = false;
+    const typed = (stmt) => {
+        if (!unit.suite.endpointSuite && stmt.kind === 'assign' && stmt.target.kind === 'name' && stmt.target.name === unit.suite.name && !declared) {
+            declared = true;
+            if (stmt.declaredType && typeName(stmt.declaredType) !== typeName(unit.suite.type))
+                diagnostics.push({
+                    file: unit.file, line: stmt.span.line, column: stmt.span.column, code: 'TEST',
+                    message: `Test subject ${unit.suite.name} must use its header type ${typeName(unit.suite.type)}`
+                });
+            return { ...stmt, declaredType: unit.suite.type };
+        }
+        if (stmt.kind === 'if')
+            return { ...stmt, then: stmt.then.map(typed), otherwise: stmt.otherwise.map(typed) };
+        if (stmt.kind === 'try')
+            return { ...stmt, body: stmt.body.map(typed),
+                catches: stmt.catches.map(clause => ({ ...clause, body: clause.body.map(typed) })), always: stmt.always?.map(typed) };
+        if (stmt.kind === 'while' || stmt.kind === 'for' || stmt.kind === 'scope' || stmt.kind === 'unsafe' || stmt.kind === 'borrow' || stmt.kind === 'lock')
+            return { ...stmt, body: stmt.body.map(typed) };
+        if (stmt.kind === 'match')
+            return { ...stmt, cases: stmt.cases.map(clause => ({ ...clause, body: clause.body.map(typed) })) };
+        return stmt;
+    };
+    const row = unit.row && unit.test.parameters ? [{ kind: 'destructure', names: unit.test.parameters, value: unit.row, span: unit.test.span }] : [];
+    const client = unit.suite.endpointSuite ? [{ kind: 'assign', target: { kind: 'name', name: unit.suite.name, span: unit.suite.span },
+            value: { kind: 'call', callee: { kind: 'name', name: 'HttpTestClient', span: unit.suite.span }, args: [], argLabels: [], typeArgs: [], span: unit.suite.span },
+            ownership: 'managed', span: unit.suite.span }] : [];
+    const firstStatement = unit.group.setup.findIndex(item => item.kind !== 'bind' && item.kind !== 'include');
+    const bindingCount = firstStatement < 0 ? unit.group.setup.length : firstStatement;
+    const items = [...unit.group.setup.slice(0, bindingCount), ...client,
+        ...unit.group.setup.slice(bindingCount).map(item => item.kind === 'bind' || item.kind === 'include' ? item : typed(item)), ...row, ...unit.test.body.map(typed)];
+    if (!declared && !unit.suite.functionSuite && !unit.suite.endpointSuite)
+        diagnostics.push({ file: unit.file, line: unit.test.span.line, column: unit.test.span.column,
+            code: 'TEST', message: `Initialize ${unit.suite.name} in group setup or this it case` });
+    const definitions = new Map();
+    const include = (def) => {
+        if (definitions.has(def.id))
+            return;
+        definitions.set(def.id, def);
+        visit(def.node, def.file);
+    };
+    // Traverse declarations and expressions, including type references and tags.
+    // Scopes retain explicit imports, so this cannot make an undeclared dependency visible.
+    const visit = (value, file) => {
+        if (!value || typeof value !== 'object')
+            return;
+        if (Array.isArray(value)) {
+            value.forEach(item => visit(item, file));
+            return;
+        }
+        const record = value;
+        if (typeof record.name === 'string') {
+            const def = project.scopes.get(file)?.get(record.name);
+            if (def)
+                include(def);
+        }
+        if (record.kind === 'bind' && typeof record.key === 'string') {
+            const def = project.scopes.get(file)?.get(record.key);
+            if (def)
+                include(def);
+        }
+        for (const [key, item] of Object.entries(record))
+            if (key !== 'span' && key !== 'nameSpan' && key !== 'sourceSpan')
+                visit(item, file);
+    };
+    visit(unit.suite.type, unit.file);
+    visit(items, unit.file);
+    const main = { path: unit.file, source: project.files.get(unit.file).source, items };
+    return { ...project, main, definitions, diagnostics, testMode: true, testBodyStart: unit.group.setup.length + client.length,
+        testEndpoint: unit.suite.endpointSuite ? { file: unit.file, name: unit.suite.type.name } : undefined };
+}
+export function checkUnitTests(project, tests) {
+    return tests.map(unit => ({ unit, checked: checkProject(projectForTest(project, unit)) }));
+}
+export function uniqueDiagnostics(diagnostics) {
+    return [...new Map(diagnostics.map(issue => [
+            `${issue.file}:${issue.line}:${issue.column}:${issue.code}:${issue.message}`, issue
+        ])).values()];
+}
+export function mergeTestAnalysis(checked, tests) {
+    for (const entry of tests) {
+        for (const [key, scope] of entry.checked.scopes)
+            checked.scopes.set(key, scope);
+        const visit = (value) => {
+            if (!value || typeof value !== 'object')
+                return;
+            if (Array.isArray(value)) {
+                value.forEach(visit);
+                return;
+            }
+            const expr = value;
+            const type = entry.checked.expressionTypes.get(expr);
+            if (type)
+                checked.expressionTypes.set(expr, type);
+            const plan = entry.checked.callPlans.get(expr);
+            if (plan)
+                checked.callPlans.set(expr, plan);
+            for (const [key, child] of Object.entries(value))
+                if (key !== 'span')
+                    visit(child);
+        };
+        visit(entry.checked.project.main?.items);
+    }
+}

package/src/types.js

@@ -0,0 +1,10 @@
+export function tyName(type) {
+    return (type.optional || type.nullable ? 'optional ' : '') + type.name + (type.args.length ? `<${type.args.map(tyName).join(', ')}>` : '');
+}
+export function sameType(left, right) {
+    return left.id === right.id && (left.nullable || !!left.optional) === (right.nullable || !!right.optional) &&
+        left.args.length === right.args.length && left.args.every((arg, i) => sameType(arg, right.args[i]));
+}
+export function containsUnknown(type) {
+    return type.kind === 'error' || type.kind === 'param' || type.args.some(containsUnknown);
+}