Files
reverse-engineering-anything/src/domain/javascript/javascriptStaticAnalysis.sqliteStorage.test.ts
T
morlutoandShuaixinHuang b46f4fcebd fix(javascript): preserve loader authority for exact suffixes (#9477)
* fix(javascript): require exact loader suffix case

* fix(javascript): share exact loader mode across import resolution

* test(process): align symlink fixture with filesystem checkpoints

* test(javascript): normalize the module resolution oracle path separators

* test(frida): assert the CLI spawn Evidence contract

* test(mcp): use an unsupported analysis-view parent

* test(browser): separate source-location line bounds from parity

* fix(javascript): preserve uncertain loader provenance

* test(javascript): cover uncertain require resolution

* fix(javascript): retain conditional Electron evidence

* fix(javascript): preserve timed semantic provenance

* fix(javascript): retain conditional builtin effects

* test(javascript): distinguish bundled host authority

* fix(javascript): preserve nested loader invocation identity

* test(javascript): qualify Electron fixture authority

* fix(javascript): preserve loader invocation authority

* fix(javascript): respect source order for resolver escapes

* fix(javascript): check nested loader callable mutations

* fix(javascript): retain conditional constructor requests

* fix(reference): retain constructor loader relationships

* fix(reference): follow nested loader callable paths

* refactor(javascript): share callable mutation interpretation

* fix(javascript): require exact package loader suffixes

* refactor(javascript): unify conditional relation evidence

* refactor(javascript): unify conditional node evidence

* fix(javascript): retain unknown authority for mixed case sources

* fix(javascript): preserve loader uncertainty for dotfiles

* fix(reference): classify javascript suffix dotfiles

* test(reference): cover suffix dotfiles through cli

* fix(javascript): retain equivalent conditional built-in origins

* fix(javascript): preserve wrapped resolver operation

* fix(javascript): retain nested conditional built-in receivers

* test(javascript): declare CommonJS in native addon fixtures

* fix(javascript): retain wrapped resolver candidates

* style: format merged native command schema

* fix(javascript): preserve uncertain loader authority

* test(javascript): require candidate preload evidence

* test(javascript): cover reference loader member writes

---------

Co-authored-by: ShuaixinHuang <1836656514@qq.com>
2026-11-09 13:21:24 +08:00

63 lines
3.3 KiB
TypeScript

import { expect, it } from "vitest";
import { analyzeCommonJsStaticFixture } from "../../../tests/fixtures/javascriptCommonJsAnalysis.js";
import { analyzeJavaScriptStaticSource } from "./javascriptStaticAnalysis.js";
it.each([
'class Database { constructor(name) { this.name = name; } } new Database("hello");',
'const Database = class {}; new Database("hello");',
'function Database(name) { return {name}; } new Database("hello");',
'class Local {} const Database = Local; new Database("hello");',
])("omits a proven local constructor: %s", (source) => {
expect(analyzeJavaScriptStaticSource(source).storage).toEqual([]);
});
it.each([
'new Database("shared");',
'import type Database = require("better-sqlite3"); new Database("shared");',
'let Database = require("better-sqlite3"); eval("Database = Other"); new Database("shared");',
'import * as sqlite from "sqlite3"; const alias = sqlite; alias.Database = Other; new sqlite.Database("shared");',
'import Database from "better-sqlite3"; expose(Database); new Database("shared");',
'import type TypeDatabase from "better-sqlite3"; const Database = TypeDatabase; new Database("shared");',
'import * as Database from "better-sqlite3"; new Database("shared");',
'const Database = require("better-sqlite3").default; new Database("shared");',
'const sqlite = require("sqlite3").default; new sqlite.Database("shared");',
'import type Database from "better-sqlite3"; new Database("shared");',
'import * as sqlite from "sqlite3"; new sqlite.default.default.Database("shared");',
'function run(Database) { return new Database("shared"); }',
'import Database from "unknown-library"; new Database("shared");',
'import Database from "better-sqlite3"; Database = Other; new Database("shared");',
'import * as sqlite from "sqlite3"; sqlite.Database = Other; new sqlite.Database("shared");',
])("retains uncertain SQLite names as candidates: %s", (source) => {
expect(analyzeJavaScriptStaticSource(source).storage).toMatchObject([
{ kind: "sqlite", name: "shared", interpretation: "candidate" },
]);
});
it.each([
'import Database from "better-sqlite3"; new Database("known.db");',
'import Database = require("better-sqlite3"); new Database("known.db");',
'import sqlite = require("sqlite3"); new sqlite.Database("known.db");',
'import {Database} from "sqlite3"; new Database("known.db");',
'import * as sqlite from "sqlite3"; new sqlite.Database("known.db");',
])("retains proven SQLite API origins: %s", (source) => {
const analysis = analyzeJavaScriptStaticSource(source);
expect(analysis.storage).toHaveLength(1);
expect(analysis.storage[0]).toMatchObject({
kind: "sqlite",
name: "known.db",
});
expect(analysis.storage[0]).not.toHaveProperty("interpretation");
});
it("distinguishes conditional and proven CommonJS SQLite origins", () => {
const source =
'const Database = require("better-sqlite3"); new Database("known.db");';
expect(analyzeJavaScriptStaticSource(source).storage).toMatchObject([
{ kind: "sqlite", name: "known.db", interpretation: "candidate" },
]);
const proven = analyzeCommonJsStaticFixture(source).storage;
expect(proven).toHaveLength(1);
expect(proven[0]).toMatchObject({ kind: "sqlite", name: "known.db" });
expect(proven[0]).not.toHaveProperty("interpretation");
});