onbuzz 5.0.2 → 5.3.0

package/src/tools/importAnalysis/__tests__/callableChecker.test.js

@@ -0,0 +1,356 @@
+import { describe, test, expect } from '@jest/globals';
+import {
+  parseModule,
+  collectModuleInfo,
+  analyzeCalls,
+  calleeToString,
+} from '../callableChecker.js';
+
+/**
+ * In-memory harness: `files` maps a module name → source. Imports reference
+ * other modules as './<name>'. Returns all findings across the project.
+ */
+function analyze(files) {
+  const infos = new Map();
+  const asts = new Map();
+  for (const [name, code] of Object.entries(files)) {
+    const ast = parseModule(code);
+    asts.set(name, ast);
+    infos.set(name, collectModuleInfo(ast));
+  }
+  const resolve = (_owner, source) => {
+    const base = source.replace(/^\.+\//, '').replace(/\.(js|mjs|ts|jsx|tsx)$/, '');
+    return infos.get(base) || null;
+  };
+  const findings = [];
+  for (const [name, ast] of asts) {
+    findings.push(...analyzeCalls({ ast, info: infos.get(name), file: name, resolve }));
+  }
+  return findings;
+}
+
+const reasons = (f) => f.map((x) => `${x.confidence}:${x.callee}`);
+
+describe('parseModule', () => {
+  test('parses valid JS and exposes a program', () => {
+    const ast = parseModule('const x = 1; foo();');
+    expect(ast?.program?.body?.length).toBe(2);
+  });
+  test('parses TypeScript syntax with the ts option', () => {
+    expect(parseModule('const x: number = 1;', { ts: true })).toBeTruthy();
+  });
+  test('returns null on a non-string / unparseable input', () => {
+    expect(parseModule(123)).toBeNull();
+  });
+});
+
+describe('calleeToString', () => {
+  test('identifiers, members, computed, this, unknown', () => {
+    const call = (src) => parseModule(src).program.body[0].expression.callee;
+    expect(calleeToString(call('foo()'))).toBe('foo');
+    expect(calleeToString(call('a.b()'))).toBe('a.b');
+    expect(calleeToString(call('a[x]()'))).toBe('a.[…]');
+    expect(calleeToString(call('this.run()'))).toBe('this.run');
+    expect(calleeToString(null)).toBe('<unknown>');
+    expect(calleeToString({ type: 'Weird' })).toBe('<expr>');
+  });
+});
+
+describe('high-confidence — import/export graph', () => {
+  test('named import that is not exported, then called', () => {
+    const f = analyze({
+      m: 'export const bar = 1;',
+      a: "import { foo } from './m'; foo();",
+    });
+    expect(reasons(f)).toEqual(['high:foo']);
+    expect(f[0].reason).toMatch(/not exported by '\.\/m'/);
+  });
+
+  test('named import that is a non-function value, then called', () => {
+    const f = analyze({
+      m: 'export const CONFIG = {};',
+      a: "import { CONFIG } from './m'; CONFIG();",
+    });
+    expect(reasons(f)).toEqual(['high:CONFIG']);
+    expect(f[0].reason).toMatch(/object export, not a function/);
+  });
+
+  test('namespace member that is not exported', () => {
+    const f = analyze({
+      m: 'export const x = 1;',
+      a: "import * as M from './m'; M.foo();",
+    });
+    expect(reasons(f)).toEqual(['high:M.foo']);
+  });
+
+  test('namespace object called directly', () => {
+    const f = analyze({
+      m: 'export const x = 1;',
+      a: "import * as M from './m'; M();",
+    });
+    expect(reasons(f)).toEqual(['high:M']);
+    expect(f[0].reason).toMatch(/namespace object/);
+  });
+
+  test('namespace member that is a non-function export', () => {
+    const f = analyze({
+      m: 'export const settings = {};',
+      a: "import * as M from './m'; M.settings();",
+    });
+    expect(reasons(f)).toEqual(['high:M.settings']);
+  });
+
+  test('default export value invoked but it is an object', () => {
+    const f = analyze({
+      m: 'export default {};',
+      a: "import api from './m'; api();",
+    });
+    expect(reasons(f)).toEqual(['high:api']);
+    expect(f[0].reason).toMatch(/object export, not a function/);
+  });
+});
+
+describe('medium-confidence — local shapes & instances', () => {
+  test('default export object: missing member', () => {
+    const f = analyze({
+      m: 'export default { doThing() {} };',
+      a: "import api from './m'; api.nope();",
+    });
+    expect(reasons(f)).toEqual(['medium:api.nope']);
+    expect(f[0].reason).toMatch(/has no member 'nope'/);
+  });
+
+  test('default export object: member exists but is a value', () => {
+    const f = analyze({
+      m: 'export default { conf: {} };',
+      a: "import api from './m'; api.conf();",
+    });
+    expect(reasons(f)).toEqual(['medium:api.conf']);
+  });
+
+  test('default export instance: missing method', () => {
+    const f = analyze({
+      m: 'class Svc { run() {} } export default new Svc();',
+      a: "import svc from './m'; svc.walk();",
+    });
+    expect(reasons(f)).toEqual(['medium:svc.walk']);
+    expect(f[0].reason).toMatch(/instance of '\.\/m' has no method 'walk'/);
+  });
+
+  test('local object literal: missing member', () => {
+    const f = analyze({ a: 'const o = { a() {} }; o.b();' });
+    expect(reasons(f)).toEqual(['medium:o.b']);
+  });
+
+  test('local instance: missing method (local class)', () => {
+    const f = analyze({ a: 'class Foo { run() {} } const x = new Foo(); x.walk();' });
+    expect(reasons(f)).toEqual(['medium:x.walk']);
+  });
+
+  test('local instance: missing method (imported class)', () => {
+    const f = analyze({
+      m: 'export class Foo { run() {} }',
+      a: "import { Foo } from './m'; const x = new Foo(); x.walk();",
+    });
+    expect(reasons(f)).toEqual(['medium:x.walk']);
+  });
+});
+
+describe('high-confidence — local bindings', () => {
+  test('local non-callable value invoked', () => {
+    const f = analyze({ a: 'const x = {}; x();' });
+    expect(reasons(f)).toEqual(['high:x']);
+    expect(f[0].reason).toMatch(/is an object, not a function/);
+  });
+  test('local primitive value invoked', () => {
+    const f = analyze({ a: 'const n = 5; n();' });
+    expect(reasons(f)).toEqual(['high:n']);
+    expect(f[0].reason).toMatch(/is a value, not a function/);
+  });
+});
+
+describe('low-confidence — wildcard re-export modules', () => {
+  test('symbol not directly found but module has export *', () => {
+    const f = analyze({
+      other: 'export const mystery = () => {};',
+      m: "export * from './other'; export const known = () => {};",
+      a: "import { mystery } from './m'; mystery();",
+    });
+    expect(reasons(f)).toEqual(['low:mystery']);
+    expect(f[0].reason).toMatch(/wildcard re-exports/);
+  });
+});
+
+describe('no false positives', () => {
+  const clean = (files) => expect(analyze(files)).toEqual([]);
+
+  test('valid named function call', () => clean({ m: 'export function foo() {}', a: "import { foo } from './m'; foo();" }));
+  test('valid namespace member call', () => clean({ m: 'export function foo() {}', a: "import * as M from './m'; M.foo();" }));
+  test('valid default function call', () => clean({ m: 'export default function () {}', a: "import run from './m'; run();" }));
+  test('valid default object member', () => clean({ m: 'export default { doThing() {} };', a: "import api from './m'; api.doThing();" }));
+  test('valid default instance method', () => clean({ m: 'class S { run() {} } export default new S();', a: "import s from './m'; s.run();" }));
+  test('external/unresolved import is skipped', () => clean({ a: "import { x } from 'lodash'; x();" }));
+  test('reassigned local (to a function) is skipped', () => clean({ a: 'let x = {}; x = () => {}; x();' }));
+  test('unknown local (call result) is skipped', () => clean({ a: 'const x = make(); x();' }));
+  test('parameter call is skipped', () => clean({ a: 'function f(cb) { cb(); }' }));
+  test('computed member call is skipped', () => clean({ a: "const o = {}; o['x']();" }));
+  test('this-member call is skipped', () => clean({ a: 'class A { m() { this.n(); } }' }));
+  test('default export with unknown shape (function) skips member calls', () =>
+    clean({ m: 'export default function () {}', a: "import api from './m'; api.whatever();" }));
+  test('object literal with a spread is treated as incomplete (skipped)', () =>
+    clean({ a: 'const base = {}; const o = { ...base, a() {} }; o.b();' }));
+  test('class with a superclass is treated as incomplete (skipped)', () =>
+    clean({ a: 'class Base {} class Foo extends Base { run() {} } const x = new Foo(); x.inherited();' }));
+  test('getter method is not assumed callable-or-not (skipped when missing checks pass)', () =>
+    clean({ a: 'class Foo { get thing() { return () => {}; } } const x = new Foo(); x.thing();' }));
+  test('local function declaration call', () => clean({ a: 'function foo() {} foo();' }));
+  test('valid local object member that is a method', () => clean({ a: 'const o = { a() {} }; o.a();' }));
+  test('named import member call (foo.bar) is skipped — too deep', () =>
+    clean({ m: 'export const foo = {};', a: "import { foo } from './m'; foo.bar();" }));
+  test('namespace re-export module: present export still validates', () =>
+    clean({ other: 'export const k = () => {};', m: "export * from './other'; export const known = () => {};", a: "import { known } from './m'; known();" }));
+});
+
+describe('binding/member kinds & extra shapes', () => {
+  test('various non-callable literal kinds invoked', () => {
+    expect(reasons(analyze({ a: 'const a = []; a();' }))).toEqual(['high:a']);
+    expect(reasons(analyze({ a: 'const b = true; b();' }))).toEqual(['high:b']);
+    expect(reasons(analyze({ a: 'const c = null; c();' }))).toEqual(['high:c']);
+    expect(reasons(analyze({ a: 'const d = `x`; d();' }))).toEqual(['high:d']);
+    expect(reasons(analyze({ a: "const s = 'x'; s();" }))).toEqual(['high:s']);
+    expect(reasons(analyze({ a: 'const g = 1n; g();' }))).toEqual(['high:g']);
+  });
+
+  test('unknown-kind inits (conditional/logical/await/member) are skipped', () => {
+    expect(analyze({ a: 'const x = cond ? a : b; x();' })).toEqual([]);
+    expect(analyze({ a: 'const y = a || b; y();' })).toEqual([]);
+    expect(analyze({ a: 'const z = obj.prop; z();' })).toEqual([]);
+  });
+
+  test('string/number-keyed object members are handled', () => {
+    expect(reasons(analyze({ a: "const o = { 'a-b': {} }; o['a-b']();" }))).toEqual([]); // computed → skip
+    const f = analyze({ a: "const o = { 'doIt'() {} }; o.nope();" });
+    expect(reasons(f)).toEqual(['medium:o.nope']);
+  });
+
+  test('string-keyed class methods are handled', () => {
+    const f = analyze({ a: "class F { 'run'() {} } const i = new F(); i.walk();" });
+    expect(reasons(f)).toEqual(['medium:i.walk']);
+  });
+
+  test('class expression instance: missing method', () => {
+    const f = analyze({ a: 'const E = class { m() {} }; const i = new E(); i.nope();' });
+    expect(reasons(f)).toEqual(['medium:i.nope']);
+  });
+
+  test('local object member exists but is a non-function value', () => {
+    const f = analyze({ a: 'const o = { x: {} }; o.x();' });
+    expect(reasons(f)).toEqual(['medium:o.x']);
+  });
+
+  test('class property (non-function) called as instance method', () => {
+    const f = analyze({ a: 'class F { x = 1 } const i = new F(); i.x();' });
+    expect(reasons(f)).toEqual(['medium:i.x']);
+  });
+
+  test('export default class used via new in the same module', () => {
+    const f = analyze({ a: 'export default class Foo { run() {} }\nconst x = new Foo(); x.walk();' });
+    expect(reasons(f)).toEqual(['medium:x.walk']);
+  });
+
+  test('export specifier resolves local kind (non-function value)', () => {
+    const f = analyze({
+      m: 'const conf = {}; export { conf };',
+      a: "import { conf } from './m'; conf();",
+    });
+    expect(reasons(f)).toEqual(['high:conf']);
+  });
+
+  test('export specifier of a function is valid', () =>
+    expect(analyze({ m: 'const foo = () => {}; export { foo };', a: "import { foo } from './m'; foo();" })).toEqual([]));
+
+  test('re-export with source (kind unknown) is not flagged', () =>
+    expect(analyze({ m: "export { thing } from './other';", a: "import { thing } from './m'; thing();" })).toEqual([]));
+
+  test('export default identifier with object shape: missing member', () => {
+    const f = analyze({
+      m: 'const obj = { a() {} }; export default obj;',
+      a: "import api from './m'; api.nope();",
+    });
+    expect(reasons(f)).toEqual(['medium:api.nope']);
+  });
+
+  test('export default identifier with no resolvable shape is skipped', () =>
+    expect(analyze({ m: 'const obj = make(); export default obj;', a: "import api from './m'; api.x();" })).toEqual([]));
+
+  test('re-export of an imported symbol has unknown kind (not flagged)', () =>
+    expect(analyze({
+      h: 'export const helper = () => {};',
+      m: "import { helper } from './h'; export { helper };",
+      a: "import { helper } from './m'; helper();",
+    })).toEqual([]));
+
+  test('export specifier of an undeclared local resolves to unknown (not flagged)', () =>
+    expect(analyze({ m: 'export { Ghost };', a: "import { Ghost } from './m'; Ghost();" })).toEqual([]));
+
+  test('default export object with a spread (incomplete shape) is skipped', () =>
+    expect(analyze({
+      m: 'const base = {}; export default { ...base, a() {} };',
+      a: "import api from './m'; api.x();",
+    })).toEqual([]));
+
+  test('default instance method exists but is a non-function property', () => {
+    const f = analyze({
+      m: 'class S { handler = 1 } export default new S();',
+      a: "import s from './m'; s.handler();",
+    });
+    expect(reasons(f)).toEqual(['medium:s.handler']);
+  });
+
+  test('optional call of a not-exported named import', () => {
+    const f = analyze({ m: 'export const y = 1;', a: "import { foo } from './m'; foo?.();" });
+    expect(reasons(f)).toEqual(['high:foo']);
+  });
+
+  test('optional member call resolves like a normal member', () => {
+    const f = analyze({ m: 'export const s = {};', a: "import * as M from './m'; M?.s();" });
+    expect(reasons(f)).toEqual(['high:M.s']);
+  });
+});
+
+describe('CommonJS export shapes feed default resolution', () => {
+  test('module.exports = new Instance → method resolution', () => {
+    const f = analyze({
+      m: 'class Svc { run() {} } module.exports = new Svc();',
+      a: "import api from './m'; api.walk();",
+    });
+    expect(reasons(f)).toEqual(['medium:api.walk']);
+  });
+
+  test('default instance with a superclass is treated as incomplete (skipped)', () =>
+    expect(analyze({
+      m: 'class Base {} class S extends Base { run() {} } export default new S();',
+      a: "import s from './m'; s.anything();",
+    })).toEqual([]));
+
+  test('module.exports = object → missing member flagged', () => {
+    const f = analyze({
+      m: 'module.exports = { doThing() {} };',
+      a: "import api from './m'; api.nope();",
+    });
+    expect(reasons(f)).toEqual(['medium:api.nope']);
+  });
+  test('exports.foo non-function called via namespace', () => {
+    const f = analyze({
+      m: 'exports.conf = {};',
+      a: "import * as M from './m'; M.conf();",
+    });
+    expect(reasons(f)).toEqual(['high:M.conf']);
+  });
+  test('module.exports.fn = function → valid call, no finding', () => {
+    expect(analyze({
+      m: 'module.exports.run = function () {};',
+      a: "import * as M from './m'; M.run();",
+    })).toEqual([]);
+  });
+});