2026-11-13 23:28:59 -08:00
// Tests for plan2code-deps's scripts/deps.mjs: the command dispatch, the run
// folder, version math, the manifest reader and one-string edits, the label
// rules and the batch planner. See skill-script-helpers.mjs for how these run.
// The pure pieces are imported from the built script and fed fixture manifests
// and records under scripts/fixtures/deps/. The commands that run tools (detect,
// scan, apply, restore, notes) run against stub npm, pnpm, yarn, cargo, pip, uv, go, dotnet (and their plugins) and git in a temp
// folder used as the whole PATH, replaying recorded tool output, so the suite
// passes on a machine with none of the tools installed.
2026-11-15 14:58:05 -08:00
import { test , before , after } from "node:test" ;
2026-11-13 23:28:59 -08:00
import assert from "node:assert/strict" ;
import { spawn } from "node:child_process" ;
import fs from "node:fs" ;
import os from "node:os" ;
import path from "node:path" ;
import { pathToFileURL } from "node:url" ;
import { ROOT , SKILLS , NOW , runScript , tmp , write , fixtureCleanup } from "./skill-script-helpers.mjs" ;
after ( fixtureCleanup );
// The script runs from the built skill, beside the shared scripts it imports
// (skill-script-helpers.mjs rebuilds skills/ when this file loads it).
const SCRIPT = path . join ( SKILLS , "plan2code-deps" , "scripts" , "deps.mjs" );
const deps = await import ( pathToFileURL ( SCRIPT ). href );
const FIXTURES = path . join ( ROOT , "scripts" , "fixtures" , "deps" );
const MANIFESTS = path . join ( FIXTURES , "manifests" );
const readJson = (... p ) => JSON . parse ( fs . readFileSync ( path . join ( FIXTURES , ... p ), "utf8" ));
const runDeps = ( args , opts ) => runScript ( "plan2code-deps" , "deps.mjs" , args , opts );
const made = [];
after (() => {
for ( const dir of made ) fs . rmSync ( dir , { recursive : true , force : true });
});
/** A run folder as detect will make one (named plan2code-deps-...), with files in it. */
function runFolder ( files = {}) {
const dir = fs . mkdtempSync ( path . join ( fs . realpathSync . native ( os . tmpdir ()), "plan2code-deps-test-" ));
made . push ( dir );
for ( const [ name , value ] of Object . entries ( files )) fs . writeFileSync ( path . join ( dir , name ), JSON . stringify ( value ));
return dir ;
}
/** A manifest fixture copied into a temp folder (edits never touch the fixture). */
function copyManifest ( rel , { crlf = false } = {}) {
const dir = tmp ( "deps-manifest" );
const dest = path . join ( dir , path . basename ( rel ));
let text = fs . readFileSync ( path . join ( MANIFESTS , rel ), "utf8" );
if ( crlf ) text = text . replace ( /\r?\n/g , "\r\n" );
fs . writeFileSync ( dest , text );
return dest ;
}
/* -------------------------------------------------------------- dispatch */
test ( "deps --help names every command and every exit code" , () => {
const r = runDeps ([ "--help" ]);
assert . equal ( r . code , 0 , r . stderr );
2026-11-14 18:33:02 -08:00
for ( const command of [ "detect" , "scan" , "notes" , "fit" , "pins" , "label" , "checks" , "baseline" , "compare" , "batches" , "backup" , "apply" , "restore" , "handoff" , "cleanup" ]) {
2026-11-13 23:28:59 -08:00
assert . match ( r . stdout , new RegExp ( `deps\\.mjs ${ command } \\b` ), command );
}
for ( const exit of [ "0 ok" , "1 crash" , "2 bad arguments" , "3 not found" , "4 invalid" , "5 refused" ]) assert . ok ( r . stdout . includes ( exit ), exit );
});
test ( "deps: an unknown command and a missing one exit 2 naming the commands" , () => {
const unknown = runDeps ([ "sweep" ]);
assert . equal ( unknown . code , 2 );
assert . equal ( unknown . json . error , "unknown-command" );
for ( const command of [ "detect" , "label" , "batches" , "cleanup" ]) assert . match ( unknown . json . next , new RegExp ( command ));
const missing = runDeps ([]);
assert . equal ( missing . code , 2 );
assert . equal ( missing . json . error , "missing-command" );
assert . match ( missing . json . next , /handoff/ );
});
test ( "deps: an unknown flag exits 2" , () => {
const r = runDeps ([ "cleanup" , "--nope" , "x" ]);
assert . equal ( r . code , 2 );
assert . equal ( r . json . error , "unknown-flag" );
});
test ( "deps: notes and handoff need a run folder and their row ids" , () => {
for ( const command of [ "notes" , "handoff" ]) {
const r = runDeps ([ command ]);
assert . equal ( r . code , 2 , command );
assert . equal ( r . json . error , "missing-run" , command );
}
const dir = runFolder ({ "scan.json" : { lockfiles : [] } });
assert . equal ( runDeps ([ "notes" , "--run" , dir ]). json . error , "missing-id" );
assert . equal ( runDeps ([ "handoff" , "--run" , dir ]). json . error , "missing-ids" );
});
/* ------------------------------------------------------------ run folder */
test ( "newRun makes a plan2code-deps-<date>-<random> folder under temp; readRun and writeRun round-trip" , () => {
const dir = deps . newRun ();
made . push ( dir );
assert . ok ( fs . statSync ( dir ). isDirectory ());
assert . equal ( path . dirname ( dir ), os . tmpdir ());
assert . match ( path . basename ( dir ), /^plan2code-deps-\d{8}-[0-9a-f]{8}$/ );
assert . equal ( deps . readRun ( dir , "scan.json" ), null );
deps . writeRun ( dir , "scan.json" , { rows : [ 1 , 2 ] });
assert . deepEqual ( deps . readRun ( dir , "scan.json" ), { rows : [ 1 , 2 ] });
const second = deps . newRun ();
made . push ( second );
assert . notEqual ( second , dir , "each run gets its own folder" );
});
test ( "cleanup removes a run folder" , () => {
const dir = runFolder ({ "scan.json" : {} });
const r = runDeps ([ "cleanup" , "--run" , dir ]);
assert . equal ( r . code , 0 , r . stderr );
assert . equal ( r . json . ok , true );
assert . equal ( r . json . removed , dir . split ( path . sep ). join ( "/" ));
assert . equal ( fs . existsSync ( dir ), false );
});
test ( "cleanup refuses a folder that is not a deps run, and a run that is not there" , () => {
const foreign = tmp ( "deps-foreign" );
fs . writeFileSync ( path . join ( foreign , "keep.txt" ), "x" );
const r = runDeps ([ "cleanup" , "--run" , foreign ]);
assert . equal ( r . code , 3 );
assert . equal ( r . json . error , "not-a-run" );
assert . ok ( fs . existsSync ( path . join ( foreign , "keep.txt" )), "the foreign folder is untouched" );
const gone = path . join ( os . tmpdir (), "plan2code-deps-19990101-deadbeef" );
const missing = runDeps ([ "cleanup" , "--run" , gone ]);
assert . equal ( missing . code , 3 );
assert . equal ( missing . json . error , "run-missing" );
const lookalike = path . join ( tmp ( "deps-project" ), "src" , "plan2code-deps-scripts" );
fs . mkdirSync ( lookalike , { recursive : true });
fs . writeFileSync ( path . join ( lookalike , "deps.mjs" ), "// source" );
const outside = runDeps ([ "cleanup" , "--run" , lookalike ]);
assert . equal ( outside . code , 3 , "a plan2code-deps- folder outside the temp folder is not a run" );
assert . equal ( outside . json . error , "not-a-run" );
assert . ok ( fs . existsSync ( path . join ( lookalike , "deps.mjs" )), "and it is left in place" );
const none = runDeps ([ "cleanup" ]);
assert . equal ( none . code , 2 );
assert . equal ( none . json . error , "missing-run" );
});
/* ---------------------------------------------------------- version math */
test ( "compareVersions: semver precedence with prereleases and build metadata" , () => {
const c = ( a , b ) => deps . compareVersions ( "npm" , a , b );
assert . equal ( c ( "1.2.3" , "1.2.3" ), 0 );
assert . equal ( c ( "1.2.3" , "1.2.10" ), - 1 );
assert . equal ( c ( "2.0.0" , "1.99.99" ), 1 );
assert . equal ( c ( "1.0.0-alpha" , "1.0.0" ), - 1 );
assert . equal ( c ( "1.0.0-alpha" , "1.0.0-alpha.1" ), - 1 );
assert . equal ( c ( "1.0.0-alpha.1" , "1.0.0-alpha.beta" ), - 1 );
assert . equal ( c ( "1.0.0-beta.2" , "1.0.0-beta.11" ), - 1 );
assert . equal ( c ( "1.0.0-rc.1" , "1.0.0-beta.11" ), 1 );
assert . equal ( c ( "1.0.0+build.1" , "1.0.0+build.2" ), 0 , "build metadata is ignored" );
assert . equal ( deps . compareVersions ( "cargo" , "0.8.2" , "0.8.23" ), - 1 );
});
test ( "compareVersions: Go drops a leading v and +incompatible, NuGet takes four parts" , () => {
assert . equal ( deps . compareVersions ( "go" , "v1.2.3" , "1.2.3" ), 0 );
assert . equal ( deps . compareVersions ( "go" , "v2.0.0+incompatible" , "v2.0.1" ), - 1 );
assert . equal ( deps . compareVersions ( "go" , "v0.0.0-20240101000000-abcdef123456" , "v0.0.1" ), - 1 );
assert . equal ( deps . compareVersions ( "nuget" , "1.2.3.4" , "1.2.3" ), 1 );
assert . equal ( deps . compareVersions ( "nuget" , "1.2" , "1.2.0" ), 0 );
assert . equal ( deps . compareVersions ( "nuget" , "13.0.1" , "13.0.3" ), - 1 );
assert . equal ( deps . compareVersions ( "npm" , "1.2.3.4" , "1.2.3" ), null , "four parts are NuGet only" );
});
test ( "compareVersions: the PEP 440 subset orders epoch, dev, pre, release and post" , () => {
const c = ( a , b ) => deps . compareVersions ( "python" , a , b );
assert . equal ( c ( "1.0.dev1" , "1.0a1" ), - 1 , "a dev-only release sorts before its pre-releases" );
assert . equal ( c ( "1.0a1" , "1.0b1" ), - 1 );
assert . equal ( c ( "1.0b2" , "1.0rc1" ), - 1 );
assert . equal ( c ( "1.0rc1" , "1.0" ), - 1 );
assert . equal ( c ( "1.0" , "1.0.post1" ), - 1 );
assert . equal ( c ( "1.0.post1.dev1" , "1.0.post1" ), - 1 );
assert . equal ( c ( "1.0" , "1.0.0" ), 0 , "trailing zeros do not count" );
assert . equal ( c ( "1!0.1" , "2.0" ), 1 , "the epoch wins" );
assert . equal ( c ( "1.0-alpha1" , "1.0a1" ), 0 , "alternate spellings normalize" );
assert . equal ( c ( "2.31.0+local.1" , "2.31.0" ), 0 , "a local label is ignored" );
});
test ( "parseVersion and compareVersions return null on unreadable input and never throw" , () => {
for ( const eco of [ "npm" , "cargo" , "go" , "nuget" , "python" ]) {
for ( const bad of [ "" , "latest" , "1.2.x" , "^1.2.3" , null , undefined , 42 ]) {
assert . equal ( deps . parseVersion ( eco , bad ), null , ` ${ eco } ${ bad } ` );
}
}
assert . equal ( deps . parseVersion ( "maven" , "1.2.3" ), null );
assert . equal ( deps . compareVersions ( "npm" , "1.2.3" , "nope" ), null );
});
test ( "jumpOf: patch, minor, major, and 0.x for moves under 1.0" , () => {
assert . equal ( deps . jumpOf ( "npm" , "1.2.3" , "1.2.9" ), "patch" );
assert . equal ( deps . jumpOf ( "npm" , "1.2.3" , "1.3.0" ), "minor" );
assert . equal ( deps . jumpOf ( "npm" , "9.6.1" , "10.2.1" ), "major" );
assert . equal ( deps . jumpOf ( "npm" , "0.8.2" , "0.9.0" ), "0.x" );
assert . equal ( deps . jumpOf ( "npm" , "0.0.3" , "0.0.4" ), "0.x" );
assert . equal ( deps . jumpOf ( "cargo" , "0.8.2" , "0.8.23" ), "patch" );
assert . equal ( deps . jumpOf ( "cargo" , "0.9.1" , "1.0.0" ), "major" );
assert . equal ( deps . jumpOf ( "npm" , "1.0.0-beta.1" , "1.0.0" ), "patch" );
assert . equal ( deps . jumpOf ( "go" , "v1.8.0" , "v1.9.0" ), "minor" );
assert . equal ( deps . jumpOf ( "nuget" , "13.0.1.0" , "13.0.1.5" ), "patch" );
assert . equal ( deps . jumpOf ( "python" , "2.31.0" , "2.32.3" ), "minor" );
assert . equal ( deps . jumpOf ( "python" , "0.13.7" , "0.14.0" ), "0.x" );
assert . equal ( deps . jumpOf ( "npm" , "1.2.3" , "bogus" ), null );
});
test ( "inRange: npm caret, tilde, exact, comparator pairs, x wildcards, * and ||" , () => {
const r = ( range , v ) => deps . inRange ( "npm" , range , v );
assert . equal ( r ( "^1.2.3" , "1.9.0" ), true );
assert . equal ( r ( "^1.2.3" , "2.0.0" ), false );
assert . equal ( r ( "^1.2.3" , "1.2.2" ), false );
assert . equal ( r ( "^0.2.3" , "0.2.9" ), true );
assert . equal ( r ( "^0.2.3" , "0.3.0" ), false , "a 0.x caret holds the minor" );
assert . equal ( r ( "^0.0.3" , "0.0.4" ), false );
assert . equal ( r ( "^1.2" , "1.9.9" ), true );
assert . equal ( r ( "~1.2.3" , "1.2.9" ), true );
assert . equal ( r ( "~1.2.3" , "1.3.0" ), false );
assert . equal ( r ( "~1" , "1.9.0" ), true );
assert . equal ( r ( "1.2.3" , "1.2.3" ), true );
assert . equal ( r ( "1.2.3" , "1.2.4" ), false );
assert . equal ( r ( "=1.2.3" , "1.2.3" ), true );
assert . equal ( r ( ">=2 <4" , "3.5.0" ), true );
assert . equal ( r ( ">=2 <4" , "4.0.0" ), false );
assert . equal ( r ( ">= 2.1.0 < 3" , "2.5.0" ), true );
assert . equal ( r ( "1.x" , "1.4.0" ), true );
assert . equal ( r ( "1.2.x" , "1.3.0" ), false );
assert . equal ( r ( "*" , "9.9.9" ), true );
assert . equal ( r ( "" , "9.9.9" ), true );
assert . equal ( r ( "^1.0.0 || ^2.0.0" , "2.5.0" ), true );
assert . equal ( r ( "1.0.0 - 2.0.0" , "2.0.0" ), true );
assert . equal ( r ( "^1.2.3" , "1.3.0-beta.1" ), false , "a prerelease needs a prerelease comparator on its version" );
assert . equal ( r ( "^1.3.0-beta.1" , "1.3.0-beta.2" ), true );
assert . equal ( r ( "latest" , "1.0.0" ), null );
assert . equal ( r ( "^1.2.3" , "nope" ), null );
});
test ( "inRange: Cargo's default caret and =, PEP 440, NuGet bare and brackets, Go" , () => {
assert . equal ( deps . inRange ( "cargo" , "1.2" , "1.9.9" ), true );
assert . equal ( deps . inRange ( "cargo" , "1.2.3" , "2.0.0" ), false );
assert . equal ( deps . inRange ( "cargo" , "0.8.2" , "0.8.23" ), true );
assert . equal ( deps . inRange ( "cargo" , "0.8.2" , "0.9.0" ), false );
assert . equal ( deps . inRange ( "cargo" , "=1.2.3" , "1.2.4" ), false );
assert . equal ( deps . inRange ( "cargo" , ">=1.2, <1.5" , "1.4.0" ), true );
assert . equal ( deps . inRange ( "cargo" , "1.2.*" , "1.2.9" ), true , "a Cargo wildcard is an x-range" );
assert . equal ( deps . inRange ( "cargo" , "1.2.*" , "1.5.0" ), false );
assert . equal ( deps . inRange ( "cargo" , "1.*" , "1.9.0" ), true );
assert . equal ( deps . inRange ( "cargo" , "1.*" , "2.0.0" ), false );
assert . equal ( deps . inRange ( "cargo" , "*" , "9.0.0" ), true );
assert . equal ( deps . inRange ( "python" , "==1.2.3" , "1.2.3" ), true );
assert . equal ( deps . inRange ( "python" , "==1.2.*" , "1.2.9" ), true );
assert . equal ( deps . inRange ( "python" , "~=1.4.2" , "1.4.9" ), true );
assert . equal ( deps . inRange ( "python" , "~=1.4.2" , "1.5.0" ), false );
assert . equal ( deps . inRange ( "python" , "~=1.4" , "1.9" ), true );
assert . equal ( deps . inRange ( "python" , ">=1.0,<2.0" , "1.5" ), true );
assert . equal ( deps . inRange ( "python" , ">=1.0,<2.0" , "2.0" ), false );
assert . equal ( deps . inRange ( "python" , ">=1.0,!=1.5" , "1.5" ), false );
assert . equal ( deps . inRange ( "python" , "requests" , "1.0" ), null );
assert . equal ( deps . inRange ( "nuget" , "13.0.1" , "13.0.3" ), true , "a bare NuGet version is a minimum" );
assert . equal ( deps . inRange ( "nuget" , "13.0.1" , "12.0.0" ), false );
assert . equal ( deps . inRange ( "nuget" , "[1.0,2.0)" , "1.9" ), true );
assert . equal ( deps . inRange ( "nuget" , "[1.0,2.0)" , "2.0" ), false );
assert . equal ( deps . inRange ( "nuget" , "[1.0,2.0]" , "2.0" ), true );
assert . equal ( deps . inRange ( "nuget" , "(1.0,)" , "1.0" ), false );
assert . equal ( deps . inRange ( "nuget" , "(,1.0]" , "0.5" ), true );
assert . equal ( deps . inRange ( "nuget" , "[1.2.3]" , "1.2.3" ), true );
assert . equal ( deps . inRange ( "nuget" , "[1.2.3]" , "1.2.4" ), false );
assert . equal ( deps . inRange ( "go" , "v1.8.0" , "v1.8.0" ), true );
assert . equal ( deps . inRange ( "go" , "v1.8.0" , "v1.9.0" ), false );
});
test ( "raiseRange keeps the operator style and the range's precision" , () => {
const raise = ( eco , range , target ) => deps . raiseRange ( eco , range , target );
assert . deepEqual ( raise ( "npm" , "^9.6.1" , "10.2.1" ), { rewritten : true , from : "^9.6.1" , to : "^10.2.1" });
assert . deepEqual ( raise ( "npm" , "~1.2.3" , "1.4.0" ), { rewritten : true , from : "~1.2.3" , to : "~1.4.0" });
assert . deepEqual ( raise ( "npm" , "1.64.1" , "1.66.0" ), { rewritten : true , from : "1.64.1" , to : "1.66.0" }, "an exact pin stays exact" );
assert . deepEqual ( raise ( "npm" , "=1.2.3" , "2.0.0" ), { rewritten : true , from : "=1.2.3" , to : "=2.0.0" });
assert . deepEqual ( raise ( "npm" , "^1.2" , "2.3.4" ), { rewritten : true , from : "^1.2" , to : "^2.3" });
assert . deepEqual ( raise ( "cargo" , "1.2" , "2.0.5" ), { rewritten : true , from : "1.2" , to : "2.0" });
assert . deepEqual ( raise ( "cargo" , "=0.8.2" , "0.9.1" ), { rewritten : true , from : "=0.8.2" , to : "=0.9.1" });
assert . deepEqual ( raise ( "python" , ">=1.2" , "2.0.1" ), { rewritten : true , from : ">=1.2" , to : ">=2.0" });
assert . deepEqual ( raise ( "python" , "==13.7.1" , "14.0.0" ), { rewritten : true , from : "==13.7.1" , to : "==14.0.0" });
assert . deepEqual ( raise ( "python" , "~=1.4" , "2.1.0" ), { rewritten : true , from : "~=1.4" , to : "~=2.1" });
assert . deepEqual ( raise ( "python" , "==1.2" , "2.0.1" ), { rewritten : true , from : "==1.2" , to : "==2.0.1" }, "== names one version, so it takes the whole target" );
assert . deepEqual ( raise ( "nuget" , "13.0" , "13.0.3" ), { rewritten : true , from : "13.0" , to : "13.0.3" }, "a NuGet minimum takes the whole target" );
for ( const [ eco , range , target ] of [[ "python" , "==1.2" , "2.0.1" ], [ "nuget" , "13.0" , "13.0.3" ], [ "cargo" , "1.2" , "2.0.5" ], [ "npm" , "^1.2" , "2.3.4" ], [ "python" , ">=1.2" , "2.0.1" ]]) {
assert . equal ( deps . inRange ( eco , raise ( eco , range , target ). to , target ), true , ` ${ eco } ${ range } raised still holds ${ target } ` );
}
assert . deepEqual ( raise ( "python" , ">=1.2" , "2.0rc1" ), { rewritten : true , from : ">=1.2" , to : ">=2.0rc1" }, "a prerelease target is kept whole" );
assert . deepEqual ( raise ( "nuget" , "13.0.1" , "13.0.3" ), { rewritten : true , from : "13.0.1" , to : "13.0.3" });
assert . deepEqual ( raise ( "go" , "v1.8.0" , "v1.9.0" ), { rewritten : true , from : "v1.8.0" , to : "v1.9.0" });
assert . deepEqual ( raise ( "npm" , "^1.0.0-beta.1" , "2.0.0-rc.1" ), { rewritten : true , from : "^1.0.0-beta.1" , to : "^2.0.0-rc.1" });
});
test ( "raiseRange leaves hand-written ranges alone: fits, or range not rewritten" , () => {
const notRewritten = { rewritten : false , reason : "range not rewritten" };
const fits = { rewritten : false , fits : true };
assert . deepEqual ( deps . raiseRange ( "npm" , ">=2 <4" , "3.1.0" ), fits );
assert . deepEqual ( deps . raiseRange ( "npm" , ">=2 <4" , "4.0.0" ), notRewritten );
assert . deepEqual ( deps . raiseRange ( "npm" , "1.x" , "1.5.0" ), fits );
assert . deepEqual ( deps . raiseRange ( "npm" , "1.x" , "2.0.0" ), notRewritten );
assert . deepEqual ( deps . raiseRange ( "npm" , "*" , "9.0.0" ), fits );
assert . deepEqual ( deps . raiseRange ( "npm" , "^1.0.0 || ^2.0.0" , "3.0.0" ), notRewritten );
assert . deepEqual ( deps . raiseRange ( "cargo" , ">=1.2, <1.5" , "1.6.0" ), notRewritten );
assert . deepEqual ( deps . raiseRange ( "cargo" , "1.2.*" , "1.5.0" ), notRewritten );
assert . deepEqual ( deps . raiseRange ( "cargo" , "1.2.*" , "1.2.7" ), fits );
assert . deepEqual ( deps . raiseRange ( "python" , ">=1.0,<2.0" , "1.5" ), fits );
assert . deepEqual ( deps . raiseRange ( "nuget" , "[1.0,2.0)" , "2.1" ), notRewritten );
assert . deepEqual ( deps . raiseRange ( "npm" , "latest" , "2.0.0" ), notRewritten , "an unreadable range is not rewritten" );
assert . deepEqual ( deps . raiseRange ( "npm" , "^1.0.0" , "nope" ), notRewritten );
});
/* ------------------------------------------------------------- manifests */
test ( "readKeys reads each runtime and hold key from its one line" , () => {
const at = ( rel ) => deps . readKeys ( path . join ( MANIFESTS , rel ));
assert . deepEqual ( at ( "package.json" ), { ecosystem : "npm" , enginesNode : ">=18" });
assert . deepEqual ( at ( "pyproject.toml" ), { ecosystem : "python" , requiresPython : ">=3.9" }, "only [project] counts" );
assert . deepEqual ( at ( "Cargo.toml" ), { ecosystem : "cargo" , rustVersion : "1.75" , patch : [ "crates-io" , "https://github.com/example/repo" ] });
assert . deepEqual ( at ( "workspace/Cargo.toml" ), { ecosystem : "cargo" , rustVersion : "1.80" , patch : [] });
assert . deepEqual ( at ( "go.mod" ), { ecosystem : "go" , go : "1.22" });
assert . deepEqual ( at ( "App.csproj" ), { ecosystem : "nuget" , targetFramework : "net8.0" , targetFrameworks : null });
assert . deepEqual ( at ( "multi/Lib.csproj" ), { ecosystem : "nuget" , targetFramework : null , targetFrameworks : [ "net8.0" , "net6.0" ] });
});
test ( "readKeys reads a key spread over several lines, or not a plain string, as null" , () => {
const at = ( rel ) => deps . readKeys ( path . join ( MANIFESTS , rel ));
assert . deepEqual ( at ( "multiline/pyproject.toml" ), { ecosystem : "python" , requiresPython : null });
assert . deepEqual ( at ( "multiline/Cargo.toml" ), { ecosystem : "cargo" , rustVersion : null , patch : [] });
assert . deepEqual ( at ( "multiline/App.csproj" ), { ecosystem : "nuget" , targetFramework : null , targetFrameworks : null });
assert . equal ( deps . readKeys ( path . join ( MANIFESTS , "nope.json" )), null );
const other = copyManifest ( "go.mod" );
const txt = path . join ( path . dirname ( other ), "notes.txt" );
fs . writeFileSync ( txt , "go 1.22\n" );
assert . equal ( deps . readKeys ( txt ), null , "a file it does not know" );
});
test ( "readKeys reads CRLF manifests the same" , () => {
assert . deepEqual ( deps . readKeys ( copyManifest ( "Cargo.toml" , { crlf : true })), { ecosystem : "cargo" , rustVersion : "1.75" , patch : [ "crates-io" , "https://github.com/example/repo" ] });
assert . deepEqual ( deps . readKeys ( copyManifest ( "go.mod" , { crlf : true })), { ecosystem : "go" , go : "1.22" });
});
/** Assert file now equals before with exactly one `from` -> `to` at the place that follows `anchor`. */
function assertOneChange ( file , before , anchor , from , to ) {
const at = before . indexOf ( from , before . indexOf ( anchor ) + anchor . length );
const expected = before . slice ( 0 , at ) + to + before . slice ( at + from . length );
assert . equal ( fs . readFileSync ( file , "utf8" ), expected );
}
test ( "editVersion changes only the one literal, in every manifest kind" , () => {
const cases = [
[ "package.json" , { name : "chalk" , from : "^5.6.2" , to : "^6.0.1" }, '"chalk"' ],
[ "pyproject.toml" , { name : "requests" , from : "2.31.0" , to : "2.32.3" }, '"requests' ],
[ "Cargo.toml" , { name : "toml" , from : "0.8.2" , to : "0.8.23" }, "toml =" ],
[ "Cargo.toml" , { name : "serde" , from : "1.0.200" , to : "1.0.215" }, "serde =" ],
[ "go.mod" , { name : "github.com/spf13/cobra" , from : "v1.8.0" , to : "v1.9.1" }, "cobra" ],
[ "App.csproj" , { name : "Serilog" , from : "3.1.1" , to : "4.0.0" }, '"Serilog"' ],
];
for ( const [ rel , edit , anchor ] of cases ) {
const file = copyManifest ( rel );
const before = fs . readFileSync ( file , "utf8" );
const r = deps . editVersion ( file , edit );
assert . equal ( r . ok , true , ` ${ rel } ${ edit . name } : ${ r . reason } ` );
assert . equal ( r . from , edit . from );
assert . equal ( r . to , edit . to );
assertOneChange ( file , before , anchor , edit . from , edit . to );
}
});
test ( "editVersion matches the package name whole: chalk never edits chalk-template" , () => {
const file = copyManifest ( "package.json" );
const r = deps . editVersion ( file , { name : "chalk" , from : "^5.6.2" , to : "^6.0.1" });
assert . equal ( r . ok , true , r . reason );
assert . equal ( r . line , 6 );
const text = fs . readFileSync ( file , "utf8" );
assert . match ( text , /"chalk": "\^6\.0\.1"/ );
assert . match ( text , /"chalk-template": "\^5\.6\.2"/ );
});
test ( "editVersion keeps CRLF line endings byte for byte" , () => {
const file = copyManifest ( "package.json" , { crlf : true });
const before = fs . readFileSync ( file );
const r = deps . editVersion ( file , { name : "execa" , from : "^9.6.1" , to : "^10.2.1" });
assert . equal ( r . ok , true , r . reason );
const after = fs . readFileSync ( file );
const expected = Buffer . from ( before . toString ( "utf8" ). replace ( '"execa": "^9.6.1"' , '"execa": "^10.2.1"' ), "utf8" );
assert . ok ( after . equals ( expected ));
assert . equal ( after . toString ( "utf8" ). split ( "\r\n" ). length , before . toString ( "utf8" ). split ( "\r\n" ). length );
assert . ok ( ! /[^\r]\n/ . test ( after . toString ( "utf8" )), "no bare LF appears" );
});
test ( "editVersion refuses and leaves the file as it was: no match, several matches, nothing to change" , () => {
const file = copyManifest ( "package.json" );
const before = fs . readFileSync ( file );
assert . equal ( deps . editVersion ( file , { name : "left-pad" , from : "^1.0.0" , to : "^2.0.0" }). ok , false );
assert . match ( deps . editVersion ( file , { name : "chalk" , from : "^4.0.0" , to : "^6.0.0" }). reason , /no line names chalk/ );
assert . match ( deps . editVersion ( file , { name : "chalk" , from : "^5.6.2" , to : "^5.6.2" }). reason , /same/ );
assert . match ( deps . editVersion ( path . join ( path . dirname ( file ), "missing.json" ), { name : "a" , from : "1" , to : "2" }). reason , /not found/ );
assert . ok ( fs . readFileSync ( file ). equals ( before ));
const twice = path . join ( path . dirname ( file ), "twice.json" );
const text = '{\n "dependencies": { "zod": "^3.0.0" },\n "devDependencies": { "zod": "^3.0.0" }\n}\n' ;
fs . writeFileSync ( twice , text );
const r = deps . editVersion ( twice , { name : "zod" , from : "^3.0.0" , to : "^4.0.0" });
assert . equal ( r . ok , false );
assert . match ( r . reason , /2 lines name zod/ );
assert . equal ( fs . readFileSync ( twice , "utf8" ), text );
});
test ( "editVersion matches the from literal whole: 1.2 never edits inside 1.2.3" , () => {
const file = copyManifest ( "go.mod" );
const r = deps . editVersion ( file , { name : "github.com/spf13/cobra" , from : "v1.8" , to : "v1.9" });
assert . equal ( r . ok , false );
assert . match ( r . reason , /no line names/ );
});
test ( "editVersion: a refused write leaves the file untouched" , { skip : typeof process . getuid === "function" && process . getuid () === 0 ? "root ignores read-only files" : false }, () => {
const file = copyManifest ( "Cargo.toml" );
const before = fs . readFileSync ( file );
fs . chmodSync ( file , 0o444 );
try {
const r = deps . editVersion ( file , { name : "toml" , from : "0.8.2" , to : "0.8.23" });
assert . equal ( r . ok , false );
assert . match ( r . reason , /could not write/ );
} finally {
fs . chmodSync ( file , 0o644 );
}
assert . ok ( fs . readFileSync ( file ). equals ( before ));
});
/* ---------------------------------------------------------------- labels */
const SCAN = readJson ( "label" , "scan.json" );
const RECORDS = readJson ( "label" , "records.json" );
const labeled = ( scan = SCAN , records = RECORDS ) => Object . fromEntries ( deps . label ( scan , records ). map (( l ) => [ l . id , l ]));
test ( "label: Safe is an in-range patch or minor, notes read with no breaking lines, checks covering it" , () => {
const l = labeled ();
assert . equal ( l . r1 . label , "safe" );
assert . deepEqual ( l . r1 . reasons , [ "used in 2 files" ]);
});
test ( "label: every major and 0.x move is Check first at best, with its range change" , () => {
const l = labeled ();
assert . equal ( l . r3 . label , "check-first" );
assert . ok ( l . r3 . reasons . includes ( "0.x" ), "0.x is worked out from the versions when jump is missing" );
assert . ok ( l . r3 . reasons . includes ( "range ^0.8.2 → ^0.9.0" ));
assert . equal ( l . r4 . label , "check-first" );
assert . ok ( l . r4 . reasons . includes ( "major" ));
assert . ok ( l . r4 . reasons . includes ( "range ^9.6.1 → ^10.2.1" ));
});
test ( "label: breaking notes, notes not read, notes that could not be read and a missing record keep a minor at Check first" , () => {
const l = labeled ();
assert . equal ( l . r2 . label , "check-first" );
assert . ok ( l . r2 . reasons . includes ( "breaking notes" ));
assert . equal ( l . r8 . label , "check-first" );
assert . ok ( l . r8 . reasons . includes ( "notes not read" ), "a row with no record counts as notes not read" );
assert . equal ( l . r9 . label , "check-first" );
assert . ok ( l . r9 . reasons . includes ( "notes could not be read" ));
const notRead = labeled ( SCAN , RECORDS . map (( r ) => ( r . id === "r1" ? { ... r , notes : "not read" } : r )));
assert . equal ( notRead . r1 . label , "check-first" );
assert . ok ( notRead . r1 . reasons . includes ( "notes not read" ));
});
test ( "label: a major whose changed API the code calls is a Warning" , () => {
const l = labeled ();
assert . equal ( l . r5 . label , "warning" );
assert . ok ( l . r5 . reasons . includes ( "calls a changed API" ));
assert . ok ( l . r5 . reasons . includes ( "used in 14 files" ));
});
test ( "label: a major with unreadable notes is a Warning at 5 or more importing files, Check first below" , () => {
const l = labeled ();
assert . equal ( deps . WIDE_USE_FILES , 5 );
assert . equal ( l . r6 . label , "warning" );
assert . ok ( l . r6 . reasons . includes ( "notes could not be read" ));
assert . ok ( l . r6 . reasons . includes ( "used in 7 files" ));
assert . equal ( l . r7 . label , "check-first" );
const atFive = labeled ( SCAN , RECORDS . map (( r ) => ( r . id === "r7" ? { ... r , files : 5 } : r )));
assert . equal ( atFive . r7 . label , "warning" );
const unticked = labeled ( SCAN , RECORDS . map (( r ) => ( r . id === "r6" ? { ... r , notes : "not read" } : r )));
assert . equal ( unticked . r6 . label , "warning" , "notes not read (fetching unticked) count as unreadable notes" );
assert . ok ( unticked . r6 . reasons . includes ( "notes not read" ));
assert . equal ( labeled (). r14 . label , "check-first" , "a major with no record has no file count and stays Check first" );
});
test ( "label: a hand-written range the target does not fit is Check first with range not rewritten" , () => {
const l = labeled ();
assert . equal ( l . r10 . label , "check-first" );
assert . ok ( l . r10 . reasons . includes ( "range not rewritten" ));
const minor = labeled ({ ... SCAN , lockfiles : [{ ... SCAN . lockfiles [ 0 ], rows : [{ id : "x" , current : "1.2.0" , target : "1.3.0" , jump : "minor" , inRange : false , range : { from : "1.2.x" , to : null } }] }] }, [{ id : "x" , notes : "read" , breaking : [], files : 1 , calls : [] }]);
assert . equal ( minor . x . label , "check-first" );
assert . ok ( minor . x . reasons . includes ( "range not rewritten" ));
});
test ( "label: a minor needing a range raise is Check first, not Safe" , () => {
const l = labeled ();
assert . equal ( l . r16 . label , "check-first" );
assert . ok ( l . r16 . reasons . includes ( "range ~1.2.0 → ~1.3.0" ));
});
test ( "label: exact pins are normal rows with a pinned note; a pinned major is Check first" , () => {
const l = labeled ();
assert . equal ( l . r11 . label , "safe" );
assert . ok ( l . r11 . reasons . includes ( "pinned 1.64.1 → 1.66.0" ));
assert . ok ( ! l . r11 . reasons . some (( r ) => r . startsWith ( "range " )), "a pin shows as pinned, not as a range change" );
assert . equal ( l . r12 . label , "check-first" );
assert . ok ( l . r12 . reasons . includes ( "pinned 6.0.0 → 7.0.0" ));
assert . ok ( l . r12 . reasons . includes ( "major" ));
});
test ( "label: security rows keep their label and carry a security reason first" , () => {
const l = labeled ();
assert . equal ( l . r13 . label , "safe" );
assert . equal ( l . r13 . reasons [ 0 ], "security (high)" );
assert . equal ( l . r14 . label , "check-first" );
assert . equal ( l . r14 . reasons [ 0 ], "security" );
assert . ok ( l . r14 . reasons . includes ( "notes not read" ));
});
test ( "label: unreadable tool output is Check first with a could not read note naming the tool" , () => {
const l = labeled ();
assert . equal ( l . r15 . label , "check-first" );
assert . ok ( l . r15 . reasons . includes ( "could not read npm audit output" ));
});
test ( "label: a move whose size cannot be worked out is never Safe" , () => {
const rows = [
{ id : "u1" , current : "1.2.3" , target : "2.0.0" , inRange : true },
{ id : "u2" , current : "abc" , target : "def" , inRange : true },
];
const scan = { noChecks : false , lockfiles : [{ lockfile : "pnpm-lock.yaml" , ecosystem : "pnpm" , checks : { rows : [ "Root" ], discovered : [] }, rows }] };
const records = rows . map (({ id }) => ({ id , notes : "read" , breaking : [], files : 1 , calls : [] }));
const l = labeled ( scan , records );
for ( const id of [ "u1" , "u2" ]) {
assert . equal ( l [ id ]. label , "check-first" , id );
assert . ok ( l [ id ]. reasons . includes ( "could not read the versions" ), id );
}
const npm = labeled ({ ... scan , lockfiles : [{ ... scan . lockfiles [ 0 ], ecosystem : "npm" }] }, records );
assert . equal ( npm . u2 . label , "check-first" , "unparseable versions under a known ecosystem too" );
});
test ( "label: a row whose runtime fit was not checked is never Safe and says which runtime" , () => {
const scan = structuredClone ( SCAN );
const row = scan . lockfiles . flatMap (( l ) => l . rows ). find (( r ) => r . id === "r1" );
row . runtimeNotChecked = ">=3.10" ;
const l = labeled ( scan );
assert . equal ( l . r1 . label , "check-first" );
assert . ok ( l . r1 . reasons . includes ( "runtime fit not checked (>=3.10)" ));
});
test ( "label: a lockfile no check covers tops out at Check first" , () => {
const l = labeled ();
assert . equal ( l . r20 . label , "check-first" );
assert . ok ( l . r20 . reasons . includes ( "no checks cover this lockfile" ));
});
test ( "label: no checks at all caps every row at Check first with no checks to run; Warnings stay" , () => {
const l = labeled ({ ... SCAN , noChecks : true });
for ( const id of [ "r1" , "r11" , "r13" ]) {
assert . equal ( l [ id ]. label , "check-first" , id );
assert . ok ( l [ id ]. reasons . includes ( "no checks to run" ), id );
}
assert . equal ( l . r5 . label , "warning" );
assert . ok ( Object . values ( l ). every (( x ) => x . label !== "safe" ));
});
test ( "label is pure: same input, same output, inputs untouched, scan order kept" , () => {
const scan = structuredClone ( SCAN );
const records = structuredClone ( RECORDS );
const a = deps . label ( scan , records );
const b = deps . label ( scan , records );
assert . deepEqual ( a , b );
assert . deepEqual ( scan , SCAN );
assert . deepEqual ( records , RECORDS );
assert . deepEqual ( a . map (( x ) => x . id ), SCAN . lockfiles . flatMap (( lf ) => lf . rows . map (( r ) => r . id )));
assert . deepEqual ( deps . label ({}, []), []);
});
test ( "label --run --records writes labels.json and prints the labels" , () => {
const dir = runFolder ({ "scan.json" : SCAN });
const r = runDeps ([ "label" , "--run" , dir , "--records" , path . join ( FIXTURES , "label" , "records.json" )]);
assert . equal ( r . code , 0 , r . stderr );
assert . equal ( r . json . ok , true );
assert . deepEqual ( r . json . labels , deps . label ( SCAN , RECORDS ));
assert . deepEqual ( JSON . parse ( fs . readFileSync ( path . join ( dir , "labels.json" ), "utf8" )), r . json . labels );
const wrapped = path . join ( dir , "wrapped.json" );
fs . writeFileSync ( wrapped , JSON . stringify ({ records : RECORDS }));
assert . equal ( runDeps ([ "label" , "--run" , dir , "--records" , wrapped ]). code , 0 );
});
test ( "label: a missing scan.json exits 3, an unreadable records file exits 4" , () => {
const empty = runFolder ();
const noScan = runDeps ([ "label" , "--run" , empty , "--records" , path . join ( FIXTURES , "label" , "records.json" )]);
assert . equal ( noScan . code , 3 );
assert . equal ( noScan . json . error , "scan-missing" );
const dir = runFolder ({ "scan.json" : SCAN });
const bad = path . join ( dir , "bad.json" );
fs . writeFileSync ( bad , "{ not json" );
const r = runDeps ([ "label" , "--run" , dir , "--records" , bad ]);
assert . equal ( r . code , 4 );
assert . equal ( r . json . error , "records-invalid" );
const shape = path . join ( dir , "shape.json" );
fs . writeFileSync ( shape , JSON . stringify ({ rows : [] }));
assert . equal ( runDeps ([ "label" , "--run" , dir , "--records" , shape ]). code , 4 );
assert . equal ( runDeps ([ "label" , "--run" , dir ]). code , 2 );
});
/* --------------------------------------------------------------- batches */
/** A scan with lockfiles of rows; each row spec is [id, pair?]. */
function batchScan ( lockfiles ) {
return {
noChecks : false ,
lockfiles : Object . entries ( lockfiles ). map (([ lockfile , rows ]) => ({
lockfile ,
ecosystem : "npm" ,
checks : { rows : [ "Root" ], discovered : [] },
rows : rows . map (([ id , pair = null ]) => ({ id , package : id , current : "1.0.0" , target : "1.0.1" , pair })),
})),
};
}
const labelsOf = ( map ) => Object . entries ( map ). map (([ id , l ]) => ({ id , label : l }));
test ( "planBatches: one Safe batch per lockfile, each Check first and Warning pick alone, Safe batches first" , () => {
const scan = batchScan ({
"a/package-lock.json" : [[ "a1" ], [ "a2" ], [ "a3" ], [ "a4" ]],
"b/package-lock.json" : [[ "b1" ], [ "b2" ], [ "b3" ]],
});
const labels = labelsOf ({ a1 : "safe" , a2 : "check-first" , a3 : "safe" , a4 : "warning" , b1 : "safe" , b2 : "safe" , b3 : "check-first" });
const { batches , unknown } = deps . planBatches ( scan , labels , [ "b3" , "a4" , "b2" , "a1" , "a2" , "b1" , "a3" ]);
assert . deepEqual ( unknown , []);
assert . deepEqual ( batches , [
{ id : "b1" , lockfile : "a/package-lock.json" , picks : [ "a1" , "a3" ] },
{ id : "b2" , lockfile : "b/package-lock.json" , picks : [ "b1" , "b2" ] },
{ id : "b3" , lockfile : "a/package-lock.json" , picks : [ "a2" ] },
{ id : "b4" , lockfile : "a/package-lock.json" , picks : [ "a4" ] },
{ id : "b5" , lockfile : "b/package-lock.json" , picks : [ "b3" ] },
]);
});
test ( "planBatches keeps pairs in one batch, in the riskier pick's place; unpicked partners and unknown ids" , () => {
const scan = batchScan ({ "package-lock.json" : [[ "s1" , "p1" ], [ "c1" , "p1" ], [ "s2" , "s3" ], [ "s3" ], [ "s4" , "x9" ], [ "w1" ]] });
const labels = labelsOf ({ s1 : "safe" , c1 : "check-first" , s2 : "safe" , s3 : "safe" , s4 : "safe" , w1 : "warning" });
const { batches , unknown } = deps . planBatches ( scan , labels , [ "s1" , "c1" , "s2" , "s3" , "s4" , "w1" , "zz" ]);
assert . deepEqual ( unknown , [ "zz" ]);
assert . deepEqual ( batches , [
{ id : "b1" , lockfile : "package-lock.json" , picks : [ "s2" , "s3" , "s4" ] },
{ id : "b2" , lockfile : "package-lock.json" , picks : [ "s1" , "c1" ] },
{ id : "b3" , lockfile : "package-lock.json" , picks : [ "w1" ] },
]);
const half = deps . planBatches ( scan , labels , [ "c1" ]);
assert . deepEqual ( half . batches , [{ id : "b1" , lockfile : "package-lock.json" , picks : [ "c1" ] }], "a partner not picked is left out" );
});
const many = ( n , prefix = "s" ) => Array . from ({ length : n }, ( _ , i ) => [ ` ${ prefix }${ i + 1 } ` ]);
test ( "splitBatch: a batch of 7 or more is halved" , () => {
const scan = batchScan ({ "package-lock.json" : many ( 8 ) });
const eight = { id : "b1" , lockfile : "package-lock.json" , picks : many ( 8 ). map (([ id ]) => id ) };
assert . deepEqual ( deps . splitBatch ( scan , eight ), [
{ id : "b1.1" , lockfile : "package-lock.json" , picks : [ "s1" , "s2" , "s3" , "s4" ] },
{ id : "b1.2" , lockfile : "package-lock.json" , picks : [ "s5" , "s6" , "s7" , "s8" ] },
]);
const seven = { ... eight , picks : eight . picks . slice ( 0 , 7 ) };
assert . deepEqual ( deps . splitBatch ( scan , seven ). map (( b ) => b . picks ), [[ "s1" , "s2" , "s3" , "s4" ], [ "s5" , "s6" , "s7" ]]);
});
test ( "splitBatch never splits a pair when halving" , () => {
const rows = [[ "s1" ], [ "s2" ], [ "s3" ], [ "s4" , "p" ], [ "s5" , "p" ], [ "s6" ], [ "s7" ]];
const scan = batchScan ({ "package-lock.json" : rows });
const batch = { id : "b2" , lockfile : "package-lock.json" , picks : rows . map (([ id ]) => id ) };
const parts = deps . splitBatch ( scan , batch );
assert . equal ( parts . length , 2 );
assert . ok ( parts . some (( b ) => b . picks . includes ( "s4" ) && b . picks . includes ( "s5" )), JSON . stringify ( parts ));
assert . deepEqual ( parts . flatMap (( b ) => b . picks ). sort (), batch . picks . slice (). sort ());
});
test ( "splitBatch: 2 to 6 picks become one batch per pick, a pair as one" , () => {
const scan = batchScan ({ "package-lock.json" : [[ "s1" ], [ "s2" , "s3" ], [ "s3" ], [ "s4" ]] });
const batch = { id : "b1" , lockfile : "package-lock.json" , picks : [ "s1" , "s2" , "s3" , "s4" ] };
assert . deepEqual ( deps . splitBatch ( scan , batch ), [
{ id : "b1.1" , lockfile : "package-lock.json" , picks : [ "s1" ] },
{ id : "b1.2" , lockfile : "package-lock.json" , picks : [ "s2" , "s3" ] },
{ id : "b1.3" , lockfile : "package-lock.json" , picks : [ "s4" ] },
]);
const six = batchScan ({ "package-lock.json" : many ( 6 ) });
assert . equal ( deps . splitBatch ( six , { id : "b3" , lockfile : "package-lock.json" , picks : many ( 6 ). map (([ id ]) => id ) }). length , 6 );
const two = deps . splitBatch ( six , { id : "b1.2" , lockfile : "package-lock.json" , picks : [ "s1" , "s2" ] });
assert . deepEqual ( two . map (( b ) => b . id ), [ "b1.2.1" , "b1.2.2" ]);
});
test ( "splitBatch: a single pair that failed is retried as the pair; a single pick cannot be split" , () => {
const scan = batchScan ({ "package-lock.json" : [[ "s1" , "s2" ], [ "s2" ], [ "s3" ]] });
assert . deepEqual ( deps . splitBatch ( scan , { id : "b4" , lockfile : "package-lock.json" , picks : [ "s1" , "s2" ] }), [{ id : "b4.1" , lockfile : "package-lock.json" , picks : [ "s1" , "s2" ] }]);
assert . equal ( deps . splitBatch ( scan , { id : "b5" , lockfile : "package-lock.json" , picks : [ "s3" ] }), null );
});
test ( "batches --picks and --split write batches.json; --split replaces the batch in place" , () => {
const scan = batchScan ({ "package-lock.json" : [... many ( 8 ), [ "c1" ]] });
const labels = labelsOf ({ ... Object . fromEntries ( many ( 8 ). map (([ id ]) => [ id , "safe" ])), c1 : "check-first" });
const dir = runFolder ({ "scan.json" : scan , "labels.json" : labels });
const planned = runDeps ([ "batches" , "--run" , dir , "--picks" , "c1,s1,s2,s3,s4,s5,s6,s7,s8" ]);
assert . equal ( planned . code , 0 , planned . stderr );
assert . deepEqual ( planned . json . batches . map (( b ) => [ b . id , b . picks . length ]), [[ "b1" , 8 ], [ "b2" , 1 ]]);
assert . deepEqual ( JSON . parse ( fs . readFileSync ( path . join ( dir , "batches.json" ), "utf8" )). batches , planned . json . batches );
const split = runDeps ([ "batches" , "--run" , dir , "--split" , "b1" ]);
assert . equal ( split . code , 0 , split . stderr );
assert . equal ( split . json . split , "b1" );
assert . deepEqual ( split . json . batches . map (( b ) => b . id ), [ "b1.1" , "b1.2" ]);
const saved = JSON . parse ( fs . readFileSync ( path . join ( dir , "batches.json" ), "utf8" )). batches ;
assert . deepEqual ( saved . map (( b ) => b . id ), [ "b1.1" , "b1.2" , "b2" ]);
const again = runDeps ([ "batches" , "--run" , dir , "--split" , "b1.1" ]);
assert . deepEqual ( again . json . batches . map (( b ) => b . picks ), [[ "s1" ], [ "s2" ], [ "s3" ], [ "s4" ]]);
const single = runDeps ([ "batches" , "--run" , dir , "--split" , "b2" ]);
assert . equal ( single . code , 4 );
assert . equal ( single . json . error , "cannot-split" );
});
test ( "batches: usage and lookup failures" , () => {
const scan = batchScan ({ "package-lock.json" : [[ "s1" ]] });
const dir = runFolder ({ "scan.json" : scan , "labels.json" : labelsOf ({ s1 : "safe" }) });
assert . equal ( runDeps ([ "batches" , "--run" , dir ]). code , 2 );
assert . equal ( runDeps ([ "batches" , "--run" , dir , "--picks" , "s1" , "--split" , "b1" ]). code , 2 );
const unknown = runDeps ([ "batches" , "--run" , dir , "--picks" , "s1,nope" ]);
assert . equal ( unknown . code , 3 );
assert . deepEqual ( unknown . json . unknown , [ "nope" ]);
assert . equal ( runDeps ([ "batches" , "--run" , dir , "--split" , "b1" ]). json . error , "batches-missing" );
runDeps ([ "batches" , "--run" , dir , "--picks" , "s1" ]);
assert . equal ( runDeps ([ "batches" , "--run" , dir , "--split" , "b9" ]). json . error , "unknown-batch" );
const noLabels = runFolder ({ "scan.json" : scan });
assert . equal ( runDeps ([ "batches" , "--run" , noLabels , "--picks" , "s1" ]). json . error , "labels-missing" );
});
/* ------------------------------------------------- npm family: stubs on PATH */
// Recorded with npm 11.20.0 from a small workspace (npm-11.20.0/project): a
// direct vulnerability (semver), a transitive one (minimist via mkdirp), a pin
// (left-pad), an override (ms) and a member (packages/app). pnpm and Yarn 1 do
// not run on the recording machine, so pnpm-docs/ and yarn1-docs/ follow their
// documented output shapes.
const NPM = path . join ( FIXTURES , "npm-11.20.0" );
const fx = (... p ) => path . join ( FIXTURES , ... p );
/** Env additions that set PATH to exactly `dir`, every case variant of the key overridden. */
function withPath ( dir , extra = {}) {
const env = { ... extra };
for ( const key of Object . keys ( process . env )) if ( /^path$/i . test ( key )) env [ key ] = dir ;
env . PATH = dir ;
return env ;
}
// Every stub folder made, so the last test can read every call any stub got.
const stubDirs = [];
/**
* The stub every tool shares: it logs its arguments to calls.log, then plays
* the first rule in plan.json for its name whose `has` strings each match an
* argument (equal, or its start): prints `out` (a fixture path), `outs` (one
* per call, in order), `err` (on stderr) or `text`,
* exits with `code`, and for `writes` copies a fixture over a file in its
* working folder or moves npm lockfile entries (`bump`).
*/
const STUB = [
'import fs from "node:fs";' ,
'import path from "node:path";' ,
'import { fileURLToPath } from "node:url";' ,
"const self = fileURLToPath(import.meta.url);" ,
"const here = path.dirname(self);" ,
'const name = path.basename(self).replace(/-stub\\.mjs$/, "");' ,
"const args = process.argv.slice(2);" ,
'fs.appendFileSync(path.join(here, "calls.log"), JSON.stringify({ tool: name, args, cwd: process.cwd() }) + "\\n");' ,
'const plan = JSON.parse(fs.readFileSync(path.join(here, "plan.json"), "utf8"))[name] || [];' ,
"const rule = plan.find((r) => (r.has || []).every((h) => args.some((a) => a === h || a.startsWith(h))));" ,
'if (!rule) { process.stderr.write("stub: no rule for " + args.join(" ")); process.exit(9); }' ,
"for (const w of rule.writes || []) {" ,
" const file = path.join(process.cwd(), w.file);" ,
" if (w.copy) fs.copyFileSync(w.copy, file);" ,
" if (w.bump) {" ,
' const lock = JSON.parse(fs.readFileSync(file, "utf8"));' ,
" for (const [key, v] of Object.entries(w.bump)) lock.packages[key].version = v;" ,
' fs.writeFileSync(file, JSON.stringify(lock, null, 2) + "\\n");' ,
" }" ,
"}" ,
'if (rule.out) process.stdout.write(fs.readFileSync(rule.out, "utf8"));' ,
// outs: one fixture per call of the rule, in order, the last repeating (a tool whose answer changes, as pip freeze after an install).
"if (rule.outs) {" ,
" const counter = path.join(here, `count-${name}-${plan.indexOf(rule)}.txt`);" ,
' const n = fs.existsSync(counter) ? Number(fs.readFileSync(counter, "utf8")) : 0;' ,
" fs.writeFileSync(counter, String(n + 1));" ,
' process.stdout.write(fs.readFileSync(rule.outs[Math.min(n, rule.outs.length - 1)], "utf8"));' ,
"}" ,
// err: a fixture printed on stderr, where the tool prints it (cargo update --dry-run).
'if (rule.err) process.stderr.write(fs.readFileSync(rule.err, "utf8"));' ,
"if (rule.text) process.stdout.write(rule.text);" ,
"process.exitCode = rule.code || 0;" ,
"" ,
]. join ( "\n" );
/** A folder of stub tools (each a node script, .cmd wrapped on Windows) playing `plan`. */
function stubPath ( plan ) {
const dir = tmp ( "deps-stubs" );
stubDirs . push ( dir );
fs . writeFileSync ( path . join ( dir , "plan.json" ), JSON . stringify ( plan ));
for ( const name of Object . keys ( plan )) {
const js = path . join ( dir , ` ${ name } -stub.mjs` );
fs . writeFileSync ( js , STUB );
if ( process . platform === "win32" ) {
fs . writeFileSync ( path . join ( dir , ` ${ name } .cmd` ), `@" ${ process . execPath } " " ${ js } " %*\r\n@exit /b %errorlevel%\r\n` );
} else {
const sh = path . join ( dir , name );
fs . writeFileSync ( sh , `#!/bin/sh\nexec " ${ process . execPath } " " ${ js } " "$@"\n` );
fs . chmodSync ( sh , 0o755 );
}
}
return dir ;
}
const callsOf = ( dir ) => {
const file = path . join ( dir , "calls.log" );
return fs . existsSync ( file ) ? fs . readFileSync ( file , "utf8" ). trim (). split ( "\n" ). filter ( Boolean ). map (( l ) => JSON . parse ( l )) : [];
};
// Run folders detect makes in the system temp folder, removed after the suite.
const runFolders = [];
after (() => {
for ( const dir of runFolders ) fs . rmSync ( dir , { recursive : true , force : true });
});
/** deps.mjs with `pathDir` as the whole PATH. */
function runStubbed ( args , pathDir ) {
const r = runDeps ( args , { env : withPath ( pathDir ) });
if ( r . json && r . json . run ) runFolders . push ( r . json . run );
return r ;
}
/** The recorded project copied into a temp folder (extra files on top), so a run never touches the fixture. */
function project ( extra = {}) {
const dir = tmp ( "deps-project" );
fs . cpSync ( path . join ( NPM , "project" ), dir , { recursive : true });
for ( const [ rel , content ] of Object . entries ( extra )) write ( dir , rel , typeof content === "string" ? content : JSON . stringify ( content , null , 2 ) + "\n" );
return dir ;
}
/** npm rules replaying the recordings: outdated, audit and one view per package; `over` rules come first. */
const npmRules = ( over = []) => [
... over ,
{ has : [ "outdated" ], out : path . join ( NPM , "outdated.json" ), code : 1 },
{ has : [ "audit" ], out : path . join ( NPM , "audit.json" ), code : 1 },
{ has : [ "view" , "minimist@^1.2.5" ], out : path . join ( NPM , "view-minimist.json" ) },
...[ "chalk" , "left-pad" , "mkdirp" , "semver" , "is-number" , "ms" ]. map (( p ) => ({ has : [ "view" , ` ${ p } @>` ], out : path . join ( NPM , `view- ${ p } .json` ) })),
];
/** git that says root is a repository with these porcelain lines, tracking only `tracked`. */
const gitRules = ( root , { status = [], tracked = [] } = {}) => [
{ has : [ "rev-parse" , "--show-toplevel" ], text : root },
{ has : [ "status" ], text : status . map (( l ) => ` ${ l } \0` ). join ( "" ) },
... tracked . map (( t ) => ({ has : [ "ls-files" , t ], text : ` ${ t } \n` })),
{ has : [ "ls-files" ], code : 1 },
];
/** detect, then scan, on a project with stub tools playing `plan`. */
function detectAndScan ( root , plan , scanArgs = []) {
const bin = stubPath ( plan );
const d = runStubbed ([ "detect" , "--root" , root ], bin );
assert . equal ( d . code , 0 , d . stderr || d . stdout );
const s = runStubbed ([ "scan" , "--run" , d . json . run , ... scanArgs ], bin );
const scan = s . code === 0 ? JSON . parse ( fs . readFileSync ( path . join ( d . json . run , "scan.json" ), "utf8" )) : null ;
return { bin , detect : d , scanRun : s , run : d . json . run , scan };
}
test ( "detect finds lockfiles, workspace members, noLockfile, dirty, tracked and missing tools" , () => {
const root = project ({
"loose/package.json" : { name : "loose" , dependencies : { chalk : "^4.0.0" } },
"empty/package.json" : { name : "empty" , type : "module" },
"web/package.json" : { name : "web" , dependencies : { chalk : "^4.0.0" } },
"web/pnpm-lock.yaml" : "lockfileVersion: '9.0'\n" ,
"node_modules/x/package.json" : { name : "x" , dependencies : { y : "1" } },
"specs/s/package.json" : { name : "s" , dependencies : { y : "1" } },
});
const bin = stubPath ({
npm : npmRules (),
git : gitRules ( root , { status : [ " M package-lock.json" , " M src/index.js" , "?? notes.txt" ], tracked : [ "web/pnpm-lock.yaml" ] }),
});
const r = runStubbed ([ "detect" , "--root" , root ], bin );
assert . equal ( r . code , 0 , r . stderr );
assert . equal ( r . json . git , true );
const [ rootLock , web ] = r . json . lockfiles ;
assert . equal ( rootLock . lockfile , "package-lock.json" );
assert . equal ( rootLock . manager , "npm" );
assert . deepEqual ( rootLock . members , [ "." , "packages/app" ]);
assert . equal ( rootLock . tracked , false );
assert . deepEqual ( rootLock . dirty , [ "package-lock.json" ]);
assert . equal ( rootLock . updates , 6 );
assert . equal ( rootLock . install , "npm ci" );
assert . equal ( web . lockfile , "web/pnpm-lock.yaml" );
assert . equal ( web . manager , "pnpm" );
assert . equal ( web . tracked , true );
assert . equal ( web . updates , null , "no pnpm on PATH, no count" );
assert . deepEqual ( r . json . missingTools , [{ tool : "pnpm" , lockfiles : [ "web/pnpm-lock.yaml" ] }]);
assert . deepEqual ( r . json . noLockfile . map (( n ) => n . manifest ), [ "loose/package.json" ], "empty, node_modules and specs manifests are never listed" );
assert . match ( r . json . noLockfile [ 0 ]. reason , /no lockfile/ );
assert . equal ( r . json . unrelatedChanges , 2 );
assert . deepEqual ( r . json . notCovered , []);
const saved = JSON . parse ( fs . readFileSync ( path . join ( r . json . run , "detect.json" ), "utf8" ));
assert . equal ( saved . root , root );
assert . ok ( path . basename ( r . json . run ). startsWith ( "plan2code-deps-" ));
});
test ( "detect outside a git repository leaves tracked, dirty and unrelatedChanges unknown" , () => {
const r = runStubbed ([ "detect" , "--root" , project ()], stubPath ({ npm : npmRules () }));
assert . equal ( r . code , 0 , r . stderr );
assert . equal ( r . json . git , false );
assert . equal ( r . json . lockfiles [ 0 ]. tracked , null );
assert . equal ( r . json . lockfiles [ 0 ]. dirty , null );
assert . equal ( r . json . unrelatedChanges , null );
});
test ( "detect reads pnpm-workspace.yaml members and marks a Yarn 2+ lockfile" , () => {
const root = tmp ( "deps-ws" );
write ( root , "package.json" , JSON . stringify ({ name : "r" }));
write ( root , "pnpm-lock.yaml" , "lockfileVersion: '9.0'\n" );
write ( root , "pnpm-workspace.yaml" , "packages:\n - 'apps/*'\n - \"libs/**\"\n - '!apps/skip'\n" );
for ( const m of [ "apps/a" , "apps/skip" , "libs/x/y" ]) write ( root , ` ${ m } /package.json` , JSON . stringify ({ name : m }));
write ( root , "berry/package.json" , JSON . stringify ({ name : "b" }));
write ( root , "berry/yarn.lock" , "__metadata:\n version: 8\n" );
const r = runStubbed ([ "detect" , "--root" , root ], stubPath ({ npm : npmRules () }));
assert . equal ( r . code , 0 , r . stderr );
const byLock = Object . fromEntries ( r . json . lockfiles . map (( l ) => [ l . lockfile , l ]));
assert . deepEqual ( byLock [ "pnpm-lock.yaml" ]. members , [ "." , "apps/a" , "libs/x/y" ]);
assert . equal ( byLock [ "berry/yarn.lock" ]. berry , true );
assert . equal ( byLock [ "berry/yarn.lock" ]. manager , "yarn" );
});
test ( "scan builds rows: target, jump, in range, range raise, pin, via row, security and the runtime cut" , () => {
const { scanRun , scan } = detectAndScan ( project (), { npm : npmRules () }, [ "--notes" ]);
assert . equal ( scanRun . code , 0 , scanRun . stderr );
assert . deepEqual ( scanRun . json . lockfiles , [{ lockfile : "package-lock.json" , rows : 6 , held : 1 , notScanned : 0 , stillOpen : 0 , audited : true , checks : 0 }]);
assert . equal ( scan . noChecks , true , "no AGENTS.md, no test map rows" );
const lock = scan . lockfiles [ 0 ];
const rows = Object . fromEntries ( lock . rows . map (( r ) => [ r . package , r ]));
assert . ok ( lock . rows [ 0 ]. security && lock . rows [ 1 ]. security , "vulnerability fixes lead" );
// engines.node >=12: chalk 5 and 6 need a newer Node, so the newest that fits is 4.1.2.
assert . equal ( rows . chalk . id , "package-lock.json#chalk" );
assert . equal ( rows . chalk . target , "4.1.2" );
assert . equal ( rows . chalk . jump , "patch" );
assert . equal ( rows . chalk . inRange , true );
assert . deepEqual ( rows . chalk . range , { from : "^4.1.0" , to : "^4.1.0" });
assert . equal ( rows . chalk . newerNotFitting [ 0 ], "6.0.1" );
assert . ok ( rows . chalk . newerNotFitting . includes ( "5.0.0" ));
assert . equal ( rows . chalk . repo , "https://github.com/chalk/chalk" );
assert . deepEqual ( rows [ "is-number" ]. range , { from : "^6.0.0" , to : "^7.0.0" });
assert . equal ( rows [ "is-number" ]. jump , "major" );
assert . equal ( rows [ "is-number" ]. inRange , false );
assert . deepEqual ( rows [ "is-number" ]. declaredIn , [{ file : "packages/app/package.json" , range : "^6.0.0" }]);
assert . equal ( rows [ "left-pad" ]. pinned , true );
assert . deepEqual ( rows [ "left-pad" ]. range , { from : "1.1.0" , to : "1.3.0" });
assert . equal ( rows . mkdirp . jump , "major" );
assert . deepEqual ( rows . semver . security , { severity : "high" , ids : [ "GHSA-c2qf-rxjj-qqgw" ] });
assert . equal ( rows . semver . target , "7.8.6" );
assert . equal ( rows . minimist . via , "mkdirp" );
assert . equal ( rows . minimist . lockfileOnly , true );
assert . equal ( rows . minimist . current , "1.2.5" );
assert . equal ( rows . minimist . target , "1.2.8" );
assert . equal ( rows . minimist . inRange , true );
assert . deepEqual ( rows . minimist . security , { severity : "critical" , ids : [ "GHSA-xvch-5gv4-984h" ] });
assert . deepEqual ( lock . held , [{ id : "package-lock.json#ms" , package : "ms" , current : "2.1.2" , latest : "2.1.3" , reason : "held by overrides in package.json" , file : "package.json" , security : null }]);
assert . deepEqual ( lock . runtime , { declared : ">=12" , source : "engines" , machine : process . version . replace ( /^v/ , "" ) });
assert . equal ( deps . label ( scan , []). length , 6 , "every row takes a label" );
});
test ( "scan without --notes leaves repo null, and --no-audit skips the audit" , () => {
const { scan , bin } = detectAndScan ( project (), { npm : npmRules () }, [ "--no-audit" ]);
const lock = scan . lockfiles [ 0 ];
assert . equal ( lock . audited , false );
assert . ok ( lock . rows . every (( r ) => r . repo === null && r . security === null && ! r . via ));
assert . ok ( ! callsOf ( bin ). some (( c ) => c . args . includes ( "audit" )), "no audit run" );
});
test ( "scan: a package with no version that runs on the project's declared Node is held with the reason" , () => {
// engines >=8: no chalk after 4.1.0 runs on Node 8 (4.1.2 needs >=10).
const root = project ();
const pkg = JSON . parse ( fs . readFileSync ( path . join ( root , "package.json" ), "utf8" ));
pkg . engines . node = ">=8" ;
fs . writeFileSync ( path . join ( root , "package.json" ), JSON . stringify ( pkg , null , 2 ) + "\n" );
const { scan } = detectAndScan ( root , { npm : npmRules () }, [ "--no-audit" ]);
const held = scan . lockfiles [ 0 ]. held . find (( h ) => h . package === "chalk" );
assert . ok ( held , "chalk held" );
assert . match ( held . reason , /needs Node .*the project declares >=8/ );
assert . ok ( ! scan . lockfiles [ 0 ]. rows . some (( r ) => r . package === "chalk" ));
});
test ( "scan: an engines.node with no lower bound fits against this machine's Node, not 0.0.0" , () => {
for ( const range of [ "*" , "<99" ]) {
const root = project ();
const pkg = JSON . parse ( fs . readFileSync ( path . join ( root , "package.json" ), "utf8" ));
pkg . engines . node = range ;
fs . writeFileSync ( path . join ( root , "package.json" ), JSON . stringify ( pkg , null , 2 ) + "\n" );
const { scan } = detectAndScan ( root , { npm : npmRules () }, [ "--no-audit" ]);
const lock = scan . lockfiles [ 0 ];
assert . ok ( ! lock . held . some (( h ) => h . package === "chalk" ), ` ${ range } : chalk is not held` );
assert . ok ( lock . rows . some (( r ) => r . package === "chalk" ), ` ${ range } : chalk is a row` );
assert . equal ( lock . runtime . declared , range );
}
});
/** The recorded audit with `change` applied, saved to a temp file for a stub to print. */
function auditWith ( change ) {
const audit = JSON . parse ( fs . readFileSync ( path . join ( NPM , "audit.json" ), "utf8" ));
change ( audit . vulnerabilities );
const file = path . join ( tmp ( "deps-audit" ), "audit.json" );
fs . writeFileSync ( file , JSON . stringify ( audit ));
return file ;
}
test ( "scan: an override holding a vulnerable package badges the hold and lists it as still open" , () => {
const file = auditWith (( v ) => {
v . ms = { ... v . semver , name : "ms" , isDirect : false , nodes : [ "node_modules/ms" ], via : [{ ... v . semver . via [ 0 ], name : "ms" , url : "https://github.com/advisories/GHSA-test-ms00-0000" }] };
});
const lock = detectAndScan ( project (), { npm : npmRules ([{ has : [ "audit" ], out : file , code : 1 }]) }). scan . lockfiles [ 0 ];
assert . deepEqual ( lock . held . find (( h ) => h . package === "ms" ). security , { severity : "high" , ids : [ "GHSA-test-ms00-0000" ] });
assert . deepEqual ( lock . stillOpen , [{ package : "ms" , severity : "high" , ids : [ "GHSA-test-ms00-0000" ], reason : "held by overrides in package.json" }]);
});
test ( "scan: a finding only a parent major fixes badges the parent's row; one nothing fixes is still open" , () => {
const file = auditWith (( v ) => {
v . minimist . fixAvailable = { name : "mkdirp" , version : "1.0.0" , isSemVerMajor : true };
v [ "has-flag" ] = { name : "has-flag" , severity : "low" , isDirect : false , via : [{ source : 1 , name : "has-flag" , url : "https://github.com/advisories/GHSA-test-none-0000" , severity : "low" , range : "<9" }], effects : [], nodes : [ "node_modules/has-flag" ], fixAvailable : false };
});
const lock = detectAndScan ( project (), { npm : npmRules ([{ has : [ "audit" ], out : file , code : 1 }]) }). scan . lockfiles [ 0 ];
const mkdirp = lock . rows . find (( r ) => r . package === "mkdirp" );
assert . deepEqual ( mkdirp . fixes , [ "minimist" ]);
assert . equal ( mkdirp . security . severity , "critical" );
assert . ok ( ! lock . rows . some (( r ) => r . package === "minimist" ), "no via row when only a major fixes it" );
assert . deepEqual ( lock . stillOpen , [{ package : "has-flag" , severity : "low" , ids : [ "GHSA-test-none-0000" ], reason : "no fixed version published yet" }]);
});
test ( "scan: a lookup the registry refuses puts that package in notScanned with the reason" , () => {
const plan = { npm : npmRules ([{ has : [ "view" , "is-number@>" ], out : path . join ( NPM , "view-e404.json" ), code : 1 }]) };
const lock = detectAndScan ( project (), plan , [ "--no-audit" ]). scan . lockfiles [ 0 ];
assert . deepEqual ( lock . notScanned . map (( n ) => n . package ), [ "is-number" ]);
assert . match ( lock . notScanned [ 0 ]. reason , /^Not Found - GET https:\/\/registry\.npmjs\.org\// );
assert . ok ( ! lock . rows . some (( r ) => r . package === "is-number" ));
assert . ok ( lock . rows . length > 0 , "everything else scanned" );
});
test ( "scan exits 3 with no registry answered when every lookup fails" , () => {
const bin = stubPath ({ npm : [{ has : [ "outdated" ], out : path . join ( NPM , "view-e404.json" ), code : 1 }] });
const d = runStubbed ([ "detect" , "--root" , project ()], bin );
const r = runStubbed ([ "scan" , "--run" , d . json . run ], bin );
assert . equal ( r . code , 3 );
assert . equal ( r . json . ok , false );
assert . equal ( r . json . reason , "no registry answered" );
assert . ok ( ! fs . existsSync ( path . join ( d . json . run , "scan.json" )));
});
test ( "scan: an unknown --folders entry exits 3; a known one scans only that lockfile" , () => {
const bin = stubPath ({ npm : npmRules () });
const d = runStubbed ([ "detect" , "--root" , project ()], bin );
assert . equal ( runStubbed ([ "scan" , "--run" , d . json . run , "--folders" , "nope" ], bin ). code , 3 );
const r = runStubbed ([ "scan" , "--run" , d . json . run , "--folders" , "." , "--no-audit" ], bin );
assert . equal ( r . code , 0 , r . stderr );
assert . equal ( r . json . lockfiles . length , 1 );
});
test ( "scan attaches the test map rows covering a lockfile's members; a Shared row means the full suite" , () => {
const root = project ({
"AGENTS.md" : "# A\n\n## Test map\n\n| Area | Paths | Run | Shared |\n| --- | --- | --- | --- |\n| App | `packages/app/**` | `npm test -w app` | no |\n| Web | `web/**` | `x` | no |\n| Build | `scripts/**` | `npm test` | yes |\n" ,
"web/package.json" : { name : "web" , dependencies : { chalk : "^4.0.0" } },
"web/package-lock.json" : JSON . stringify ({ lockfileVersion : 3 , packages : {} }),
});
const { scan } = detectAndScan ( root , { npm : npmRules () }, [ "--no-audit" ]);
const byLock = Object . fromEntries ( scan . lockfiles . map (( l ) => [ l . lockfile , l . checks ]));
// The root lockfile resolves the root folder, so every row falls in it.
2026-11-14 18:33:02 -08:00
// Each command gets a stable id across the scan: the same command in two lockfiles keeps one id.
assert . deepEqual ( byLock [ "package-lock.json" ], {
rows : [ "App" , "Web" , "Build" ],
commands : [ "npm test -w app" , "x" , "npm test" ],
discovered : [],
full : true ,
list : [
{ id : "c1" , area : "App" , run : "npm test -w app" , paths : [ "packages/app/**" ], shared : false },
{ id : "c2" , area : "Web" , run : "x" , paths : [ "web/**" ], shared : false },
{ id : "c3" , area : "Build" , run : "npm test" , paths : [ "scripts/**" ], shared : true },
],
build : [],
});
assert . deepEqual ( byLock [ "web/package-lock.json" ], { rows : [ "Web" ], commands : [ "x" ], discovered : [], full : false , list : [{ id : "c2" , area : "Web" , run : "x" , paths : [ "web/**" ], shared : false }], build : [] });
2026-11-13 23:28:59 -08:00
assert . equal ( scan . noChecks , false );
});
test ( "scan reads pnpm's outdated JSON and Yarn 1's JSON lines; their transitive findings stay open" , () => {
const root = tmp ( "deps-pm" );
for ( const dir of [ "p" , "y" ]) write ( root , ` ${ dir } /package.json` , JSON . stringify ({ name : dir , engines : { node : ">=12" }, dependencies : { chalk : "^4.1.0" , "is-number" : "^6.0.0" } }));
write ( root , "p/pnpm-lock.yaml" , "lockfileVersion: '9.0'\n" );
write ( root , "y/yarn.lock" , "# yarn lockfile v1\n" );
const plan = {
npm : npmRules (). filter (( r ) => r . has [ 0 ] === "view" ),
pnpm : [
{ has : [ "outdated" ], out : fx ( "pnpm-docs" , "outdated.json" ), code : 1 },
{ has : [ "audit" ], out : fx ( "pnpm-docs" , "audit.json" ), code : 1 },
],
yarn : [
{ has : [ "outdated" ], out : fx ( "yarn1-docs" , "outdated.jsonl" ), code : 1 },
{ has : [ "audit" ], out : fx ( "yarn1-docs" , "audit.jsonl" ), code : 16 },
],
};
const { scan , scanRun } = detectAndScan ( root , plan );
assert . equal ( scanRun . code , 0 , scanRun . stderr );
assert . deepEqual ( scan . lockfiles . map (( l ) => l . manager ), [ "pnpm" , "yarn" ]);
for ( const lock of scan . lockfiles ) {
const rows = Object . fromEntries ( lock . rows . map (( r ) => [ r . package , r ]));
assert . equal ( rows . chalk . target , "4.1.2" , lock . lockfile );
assert . equal ( rows . chalk . inRange , true , lock . lockfile );
assert . equal ( rows [ "is-number" ]. target , "7.0.0" , lock . lockfile );
assert . equal ( lock . audited , true , lock . lockfile );
assert . equal ( lock . stillOpen . length , 1 , lock . lockfile );
assert . equal ( lock . stillOpen [ 0 ]. package , "minimist" );
assert . match ( lock . stillOpen [ 0 ]. reason , /does not say whether the parent's range allows the fix/ );
}
});
test ( "scan: Yarn 2+ has no outdated list, so its lockfile is listed as not scanned" , () => {
const root = tmp ( "deps-berry" );
write ( root , "package.json" , JSON . stringify ({ name : "b" , dependencies : { chalk : "^4.1.0" } }));
write ( root , "yarn.lock" , "__metadata:\n version: 8\n" );
const { scan , scanRun } = detectAndScan ( root , { npm : [], yarn : [{ has : [ "npm" , "audit" ], text : "" }] });
assert . equal ( scanRun . code , 0 , scanRun . stderr );
assert . match ( scan . lockfiles [ 0 ]. notScanned [ 0 ]. reason , /Yarn 2\+ has no outdated list/ );
assert . equal ( scan . lockfiles [ 0 ]. berry , true , "scan.json keeps the Yarn 2+ mark, so install and apply pick Berry's flags" );
});
/** detect, scan, label and plan batches for picks; returns the run folder, its stub PATH and the batches. */
function planned ( root , picks , plan ) {
const { run , bin } = detectAndScan ( root , plan , [ "--no-audit" ]);
const records = path . join ( run , "records.json" );
fs . writeFileSync ( records , "[]" );
assert . equal ( runStubbed ([ "label" , "--run" , run , "--records" , records ], bin ). code , 0 );
const b = runStubbed ([ "batches" , "--run" , run , "--picks" , picks . map (( p ) => `package-lock.json# ${ p } ` ). join ( "," )], bin );
assert . equal ( b . code , 0 , b . stderr );
return { run , bin , batches : b . json . batches };
}
const bytesOf = ( root , files ) => Object . fromEntries ( files . map (( f ) => [ f , fs . readFileSync ( path . join ( root , f ))]));
const batchFor = ( batches , pkg ) => batches . find (( b ) => b . picks . includes ( `package-lock.json# ${ pkg } ` ));
test ( "apply moves the picks with the package manager's own command and reports changed and unpicked moves" , () => {
const root = project ();
const { run , bin , batches } = planned ( root , [ "chalk" ], {
npm : npmRules ([{ has : [ "update" , "chalk" ], writes : [{ file : "package-lock.json" , bump : { "node_modules/chalk" : "4.1.2" , "node_modules/is-number" : "7.0.0" } }] }]),
});
const b = batchFor ( batches , "chalk" );
assert . equal ( runStubbed ([ "backup" , "--run" , run , "--batch" , b . id ], bin ). code , 0 );
const manifest = fs . readFileSync ( path . join ( root , "package.json" ));
const r = runStubbed ([ "apply" , "--run" , run , "--batch" , b . id ], bin );
assert . equal ( r . code , 0 , r . stderr );
assert . equal ( r . json . command , "npm update chalk --package-lock-only --ignore-scripts --no-audit --no-fund" );
assert . equal ( r . json . failed , false );
assert . deepEqual ( r . json . changed . map (( c ) => [ c . package , c . from , c . to ]), [[ "chalk" , "4.1.0" , "4.1.2" ], [ "is-number" , "6.0.0" , "7.0.0" ]]);
assert . deepEqual ( r . json . rangeRaised , [], "in range: the manifest stays as it is" );
assert . ok ( fs . readFileSync ( path . join ( root , "package.json" )). equals ( manifest ));
assert . deepEqual ( r . json . unpicked . map (( u ) => u . package ), [ "is-number" ], "a package that moved without being picked" );
assert . deepEqual ( r . json . offTarget , []);
});
test ( "apply raises an out-of-range pick's range and a pin in the manifest that declares it, one literal each" , () => {
const root = project ();
const { run , bin , batches } = planned ( root , [ "is-number" , "left-pad" ], {
npm : npmRules ([{ has : [ "update" ], writes : [{ file : "package-lock.json" , bump : { "node_modules/is-number" : "7.0.0" , "node_modules/left-pad" : "1.3.0" } }] }]),
});
const app = fs . readFileSync ( path . join ( root , "packages/app/package.json" ), "utf8" );
const top = fs . readFileSync ( path . join ( root , "package.json" ), "utf8" );
for ( const b of batches ) {
runStubbed ([ "backup" , "--run" , run , "--batch" , b . id ], bin );
const r = runStubbed ([ "apply" , "--run" , run , "--batch" , b . id ], bin );
assert . equal ( r . code , 0 , r . stderr );
assert . equal ( r . json . rangeRaised . length , 1 );
}
assert . equal ( fs . readFileSync ( path . join ( root , "packages/app/package.json" ), "utf8" ), app . replace ( '"is-number": "^6.0.0"' , '"is-number": "^7.0.0"' ));
assert . equal ( fs . readFileSync ( path . join ( root , "package.json" ), "utf8" ), top . replace ( '"left-pad": "1.1.0"' , '"left-pad": "1.3.0"' ), "the override is never touched" );
});
test ( "apply refuses a batch with no backup (exit 5) and reports a pick that never landed" , () => {
const { run , bin , batches } = planned ( project (), [ "chalk" ], { npm : npmRules ([{ has : [ "update" ], text : "up to date\n" }]) });
const refused = runStubbed ([ "apply" , "--run" , run , "--batch" , batches [ 0 ]. id ], bin );
assert . equal ( refused . code , 5 );
assert . equal ( refused . json . error , "no-backup" );
runStubbed ([ "backup" , "--run" , run , "--batch" , batches [ 0 ]. id ], bin );
const r = runStubbed ([ "apply" , "--run" , run , "--batch" , batches [ 0 ]. id ], bin );
assert . deepEqual ( r . json . changed , []);
assert . deepEqual ( r . json . offTarget , [{ id : "package-lock.json#chalk" , package : "chalk" , target : "4.1.2" , now : [] }]);
});
test ( "backup then restore --verify puts an untracked CRLF lockfile and a tracked one back byte for byte" , () => {
const root = project ({
"web/package.json" : fs . readFileSync ( path . join ( NPM , "project" , "package.json" ), "utf8" ),
"web/package-lock.json" : fs . readFileSync ( path . join ( NPM , "project" , "package-lock.json" ), "utf8" ),
});
// The root lockfile is untracked and written with CRLF, as some Windows tools leave one: put back exactly as found.
const lockPath = path . join ( root , "package-lock.json" );
fs . writeFileSync ( lockPath , fs . readFileSync ( lockPath , "utf8" ). replace ( /\n/g , "\r\n" ));
const bin = stubPath ({
npm : npmRules ([{ has : [ "update" ], writes : [{ file : "package-lock.json" , copy : path . join ( NPM , "lock-after-update-chalk.json" ) }] }]),
git : gitRules ( root , { tracked : [ "web/package-lock.json" ] }),
});
const d = runStubbed ([ "detect" , "--root" , root ], bin );
assert . deepEqual ( d . json . lockfiles . map (( l ) => [ l . lockfile , l . tracked ]), [[ "package-lock.json" , false ], [ "web/package-lock.json" , true ]]);
const run = d . json . run ;
runStubbed ([ "scan" , "--run" , run , "--no-audit" ], bin );
const records = path . join ( run , "records.json" );
fs . writeFileSync ( records , "[]" );
runStubbed ([ "label" , "--run" , run , "--records" , records ], bin );
const plannedBoth = runStubbed ([ "batches" , "--run" , run , "--picks" , "package-lock.json#chalk,web/package-lock.json#chalk" ], bin );
assert . equal ( plannedBoth . json . batches . length , 2 );
for ( const b of plannedBoth . json . batches ) {
const dir = path . posix . dirname ( b . lockfile );
const entry = d . json . lockfiles . find (( l ) => l . lockfile === b . lockfile );
const files = [ b . lockfile , ... entry . members . map (( m ) => ( m === "." ? "package.json" : ` ${ m } /package.json` ))];
const before = bytesOf ( root , files );
const backed = runStubbed ([ "backup" , "--run" , run , "--batch" , b . id ], bin );
assert . deepEqual ( backed . json . files , files );
const applied = runStubbed ([ "apply" , "--run" , run , "--batch" , b . id ], bin );
assert . ok ( applied . json . changed . some (( c ) => c . package === "chalk" ), b . lockfile );
assert . ok ( ! fs . readFileSync ( path . join ( root , b . lockfile )). equals ( before [ b . lockfile ]), "the batch changed the lockfile" );
const r = runStubbed ([ "restore" , "--run" , run , "--batch" , b . id , "--verify" ], bin );
assert . equal ( r . code , 0 , r . stderr );
assert . deepEqual ( r . json . restored , files );
assert . equal ( r . json . verified , true );
assert . deepEqual ( r . json . mismatched , []);
assert . deepEqual ( r . json . reinstall , { cmd : "npm" , args : [ "ci" ], cwd : dir , command : "npm ci" });
for ( const f of files ) assert . ok ( fs . readFileSync ( path . join ( root , f )). equals ( before [ f ]), ` ${ f } byte for byte` );
}
});
test ( "restore without --verify leaves verified null; a batch never backed up exits 3" , () => {
const { run , bin , batches } = planned ( project (), [ "chalk" ], { npm : npmRules () });
assert . equal ( runStubbed ([ "restore" , "--run" , run , "--batch" , batches [ 0 ]. id ], bin ). json . error , "backup-missing" );
runStubbed ([ "backup" , "--run" , run , "--batch" , batches [ 0 ]. id ], bin );
assert . equal ( runStubbed ([ "restore" , "--run" , run , "--batch" , batches [ 0 ]. id ], bin ). json . verified , null );
assert . equal ( runStubbed ([ "apply" , "--run" , run , "--batch" , "b9" ], bin ). json . error , "unknown-batch" );
});
test ( "restore removes a file the batch made that was not there before" , () => {
const root = project ();
const { run , bin , batches } = planned ( root , [ "chalk" ], { npm : npmRules () });
fs . rmSync ( path . join ( root , "packages/app/package.json" ));
const backed = runStubbed ([ "backup" , "--run" , run , "--batch" , batches [ 0 ]. id ], bin );
assert . deepEqual ( backed . json . missing , [ "packages/app/package.json" ]);
write ( root , "packages/app/package.json" , "{}" );
const r = runStubbed ([ "restore" , "--run" , run , "--batch" , batches [ 0 ]. id , "--verify" ], bin );
assert . deepEqual ( r . json . deleted , [ "packages/app/package.json" ]);
assert . equal ( r . json . verified , true );
assert . ok ( ! fs . existsSync ( path . join ( root , "packages/app/package.json" )));
});
/* ------------------------------------------------- final review fixes */
test ( "scan without node_modules reads current from the lockfile; a package the lockfile lacks is not scanned" , () => {
const file = outdatedWith (( o ) => {
delete o . chalk . current ;
o . ghost = { wanted : "1.0.0" , latest : "1.0.0" , dependent : "fixture" , type : "dependencies" };
});
const { scan } = detectAndScan ( project (), { npm : npmRules ([{ has : [ "outdated" ], out : file , code : 1 }]) }, [ "--no-audit" ]);
const lock = scan . lockfiles [ 0 ];
const chalk = lock . rows . find (( r ) => r . package === "chalk" );
assert . equal ( chalk . current , "4.1.0" , "the lockfile's version" );
assert . equal ( chalk . target , "4.1.2" , "the runtime cut still applies" );
const ghost = lock . notScanned . find (( n ) => n . package === "ghost" );
assert . ok ( ghost , "a package with no current version anywhere is listed, not offered" );
assert . match ( ghost . reason , /run the install, then scan again/ );
assert . ok ( ! lock . rows . some (( r ) => r . package === "ghost" ));
});
test ( "scan: a failed npm audit marks every row not audited, so none is Safe" , () => {
const { scan } = detectAndScan ( project (), { npm : npmRules ([{ has : [ "audit" ], text : "" , code : 1 }]) });
const lock = scan . lockfiles [ 0 ];
assert . equal ( lock . audited , false );
assert . match ( lock . auditNote , /^not checked for vulnerabilities/ );
assert . ok ( lock . rows . length && lock . rows . every (( r ) => r . notAudited === true ));
for ( const l of deps . label ( scan , [])) {
assert . notEqual ( l . label , "safe" , l . id );
assert . ok ( l . reasons . includes ( "not checked for vulnerabilities" ), l . id );
}
});
test ( "apply fails a batch whose pick, held below latest for the runtime, went past its target" , () => {
const root = project ();
const { run , bin , batches } = planned ( root , [ "chalk" ], {
npm : npmRules ([{ has : [ "update" , "chalk" ], writes : [{ file : "package-lock.json" , bump : { "node_modules/chalk" : "5.0.0" } }] }]),
});
const b = batchFor ( batches , "chalk" );
runStubbed ([ "backup" , "--run" , run , "--batch" , b . id ], bin );
const r = runStubbed ([ "apply" , "--run" , run , "--batch" , b . id ], bin );
assert . equal ( r . code , 0 , r . stderr );
assert . equal ( r . json . failed , true );
assert . deepEqual ( r . json . overshot . map (( o ) => [ o . package , o . target , o . now ]), [[ "chalk" , "4.1.2" , [ "5.0.0" ]]]);
assert . match ( r . json . overshot [ 0 ]. reason , /runtime/ );
});
test ( "apply: a pick with no runtime cut that lands off target is reported, not failed" , () => {
const root = project ();
const { run , bin , batches } = planned ( root , [ "left-pad" ], {
npm : npmRules ([{ has : [ "update" , "left-pad" ], writes : [{ file : "package-lock.json" , bump : { "node_modules/left-pad" : "1.2.0" } }] }]),
});
const b = batchFor ( batches , "left-pad" );
runStubbed ([ "backup" , "--run" , run , "--batch" , b . id ], bin );
const r = runStubbed ([ "apply" , "--run" , run , "--batch" , b . id ], bin );
assert . equal ( r . json . failed , false );
assert . deepEqual ( r . json . overshot , []);
assert . deepEqual ( r . json . offTarget . map (( o ) => o . package ), [ "left-pad" ]);
});
test ( "restore names a file it cannot put back with its reason and verified false, never a crash" , () => {
const root = project ();
const { run , bin , batches } = planned ( root , [ "chalk" ], { npm : npmRules () });
runStubbed ([ "backup" , "--run" , run , "--batch" , batches [ 0 ]. id ], bin );
// A folder where the lockfile was: no copy can land there, on any platform or user.
const lockPath = path . join ( root , "package-lock.json" );
fs . rmSync ( lockPath );
fs . mkdirSync ( lockPath );
fs . writeFileSync ( path . join ( lockPath , "keep" ), "x" );
const r = runStubbed ([ "restore" , "--run" , run , "--batch" , batches [ 0 ]. id , "--verify" ], bin );
assert . equal ( r . code , 0 , r . stderr );
assert . equal ( r . json . ok , true );
assert . equal ( r . json . verified , false );
assert . equal ( r . json . mismatched . length , 1 );
assert . equal ( r . json . mismatched [ 0 ]. path , "package-lock.json" );
assert . ok ( r . json . mismatched [ 0 ]. reason , "the OS's reason" );
assert . ok ( ! r . json . restored . includes ( "package-lock.json" ));
assert . ok ( fs . existsSync ( path . join ( run , "backups" , batches [ 0 ]. id , "files" , "package-lock.json" )), "the as-found copy is kept" );
// Even without --verify, a file that could not be put back is never a silent success.
const again = runStubbed ([ "restore" , "--run" , run , "--batch" , batches [ 0 ]. id ], bin );
assert . equal ( again . json . verified , false );
});
/* ------------------------------------------------- review fixes */
/** The recorded outdated JSON with `change` applied, saved for a stub to print. */
function outdatedWith ( change ) {
const json = JSON . parse ( fs . readFileSync ( path . join ( NPM , "outdated.json" ), "utf8" ));
change ( json );
const file = path . join ( tmp ( "deps-outdated" ), "outdated.json" );
fs . writeFileSync ( file , JSON . stringify ( json ));
return file ;
}
test ( "scan: a prerelease ahead of the latest release is never offered as a downgrade" , () => {
const file = outdatedWith (( o ) => {
o . chalk = { ... o . chalk , current : "7.0.0-beta.1" , wanted : "7.0.0-beta.1" , latest : "6.0.1" };
});
const plan = { npm : npmRules ([{ has : [ "outdated" ], out : file , code : 1 }, { has : [ "view" , "chalk@>" ], text : "" }]) };
const lock = detectAndScan ( project (), plan , [ "--no-audit" ]). scan . lockfiles [ 0 ];
assert . ok ( ! lock . rows . some (( r ) => r . package === "chalk" ), "no chalk row" );
assert . ok ( lock . rows . some (( r ) => r . package === "semver" ), "the rest still scanned" );
});
test ( "overrideNames reads scoped, nested and Yarn path keys, holding a nested key's parent only with a dot entry" , () => {
const names = ( obj ) => [... deps . overrideNames ( obj )]. sort ();
assert . deepEqual ( names ({ foo : "1" , "bar@2" : "3" , "@scope/baz@^2" : "4" }), [ "@scope/baz" , "bar" , "foo" ]);
assert . deepEqual ( names ({ "**/@types/react" : "18" , "react-scripts/@babel/core" : "7" , "**/left-pad" : "1" }), [ "@babel/core" , "@types/react" , "left-pad" ]);
assert . deepEqual ( names ({ "parent>@scope/foo" : "1" , "a>b" : "2" }), [ "@scope/foo" , "b" ]);
assert . deepEqual ( names ({ baz : { bar : "1" } }), [ "bar" ], "only bar is overridden under baz" );
assert . deepEqual ( names ({ baz : { "." : "2" , bar : "1" } }), [ "bar" , "baz" ], "a dot entry overrides baz itself" );
});
test ( "scan: an advisory the target clears badges the row, one it does not stays open beside it" , () => {
const file = auditWith (( v ) => {
v . semver . via . push ({ source : 2 , name : "semver" , url : "https://github.com/advisories/GHSA-test-semv-0000" , severity : "moderate" , range : "<8.0.0" });
});
const lock = detectAndScan ( project (), { npm : npmRules ([{ has : [ "audit" ], out : file , code : 1 }]) }). scan . lockfiles [ 0 ];
const semver = lock . rows . find (( r ) => r . package === "semver" );
assert . deepEqual ( semver . security , { severity : "high" , ids : [ "GHSA-c2qf-rxjj-qqgw" ] });
assert . deepEqual ( lock . stillOpen , [{ package : "semver" , severity : "moderate" , ids : [ "GHSA-test-semv-0000" ], reason : "7.8.6 is still affected" }]);
});
test ( "apply in a pnpm workspace updates every member: --recursive, never --force" , () => {
const root = tmp ( "deps-pnpm-ws" );
write ( root , "package.json" , JSON . stringify ({ name : "w" , engines : { node : ">=12" }, dependencies : { chalk : "^4.1.0" } }));
write ( root , "pnpm-lock.yaml" , "lockfileVersion: '9.0'\n\npackages:\n\n chalk@4.1.0:\n resolution: {integrity: x}\n" );
write ( root , "pnpm-workspace.yaml" , "packages:\n - 'packages/*'\n" );
write ( root , "packages/app/package.json" , JSON . stringify ({ name : "app" , dependencies : { "is-number" : "^6.0.0" } }));
const plan = {
npm : npmRules (). filter (( r ) => r . has [ 0 ] === "view" ),
pnpm : [
{ has : [ "outdated" ], out : fx ( "pnpm-docs" , "outdated.json" ), code : 1 },
{ has : [ "update" ], text : "" },
],
};
const { run , bin } = detectAndScan ( root , plan , [ "--no-audit" ]);
const records = path . join ( run , "records.json" );
fs . writeFileSync ( records , "[]" );
runStubbed ([ "label" , "--run" , run , "--records" , records ], bin );
const b = runStubbed ([ "batches" , "--run" , run , "--picks" , "pnpm-lock.yaml#chalk" ], bin ). json . batches [ 0 ];
runStubbed ([ "backup" , "--run" , run , "--batch" , b . id ], bin );
const r = runStubbed ([ "apply" , "--run" , run , "--batch" , b . id ], bin );
assert . equal ( r . code , 0 , r . stderr );
assert . equal ( r . json . command , "pnpm update chalk@4.1.2 --lockfile-only --no-save --recursive" );
const update = callsOf ( bin ). find (( c ) => c . tool === "pnpm" && c . args [ 0 ] === "update" );
assert . deepEqual ( update . args , [ "update" , "chalk@4.1.2" , "--lockfile-only" , "--no-save" , "--recursive" ]);
});
test ( "a package two members declare is pinned when either pins it, and apply raises each declaration that needs it" , () => {
const root = project ();
// The member pins chalk where the root takes a caret range.
const appFile = path . join ( root , "packages/app/package.json" );
const app = JSON . parse ( fs . readFileSync ( appFile , "utf8" ));
app . dependencies . chalk = "4.1.0" ;
fs . writeFileSync ( appFile , JSON . stringify ( app , null , 2 ) + "\n" );
const file = outdatedWith (( o ) => {
o . chalk = [ o . chalk , { ... o . chalk , wanted : "4.1.0" , dependent : "app" , dependedByLocation : "packages/app" }];
});
const plan = { npm : npmRules ([{ has : [ "outdated" ], out : file , code : 1 }, { has : [ "update" ], writes : [{ file : "package-lock.json" , bump : { "node_modules/chalk" : "4.1.2" } }] }]) };
const { run , bin , scan } = detectAndScan ( root , plan , [ "--no-audit" ]);
const chalk = scan . lockfiles [ 0 ]. rows . find (( r ) => r . package === "chalk" );
assert . deepEqual ( chalk . declaredIn , [{ file : "package.json" , range : "^4.1.0" }, { file : "packages/app/package.json" , range : "4.1.0" }]);
assert . equal ( chalk . pinned , true );
assert . equal ( chalk . inRange , false );
const records = path . join ( run , "records.json" );
fs . writeFileSync ( records , "[]" );
runStubbed ([ "label" , "--run" , run , "--records" , records ], bin );
const b = runStubbed ([ "batches" , "--run" , run , "--picks" , "package-lock.json#chalk" ], bin ). json . batches [ 0 ];
const top = fs . readFileSync ( path . join ( root , "package.json" ));
runStubbed ([ "backup" , "--run" , run , "--batch" , b . id ], bin );
const r = runStubbed ([ "apply" , "--run" , run , "--batch" , b . id ], bin );
assert . equal ( r . code , 0 , r . stderr );
assert . deepEqual ( r . json . rangeRaised , [{ id : "package-lock.json#chalk" , package : "chalk" , file : "packages/app/package.json" , from : "4.1.0" , to : "4.1.2" }]);
assert . ok ( fs . readFileSync ( path . join ( root , "package.json" )). equals ( top ), "the root's ^4.1.0 already takes 4.1.2 and stays" );
assert . match ( fs . readFileSync ( appFile , "utf8" ), /"chalk": "4\.1\.2"/ );
});
test ( "detect through a linked root still finds the already-changed lockfile" , () => {
const root = project ();
const link = path . join ( tmp ( "deps-link" ), "linked" );
fs . symlinkSync ( root , link , process . platform === "win32" ? "junction" : "dir" );
const bin = stubPath ({ npm : npmRules (), git : gitRules ( root , { status : [ " M package-lock.json" , " M src/x.js" ] }) });
const r = runStubbed ([ "detect" , "--root" , link ], bin );
assert . equal ( r . code , 0 , r . stderr );
assert . deepEqual ( r . json . lockfiles [ 0 ]. dirty , [ "package-lock.json" ]);
assert . equal ( r . json . unrelatedChanges , 1 );
});
test ( "apply skips a pick one declaration cannot take before raising any other declaration" , () => {
const root = project ();
// The member takes chalk as "latest", which no range can be raised from; the root pins it.
const appFile = path . join ( root , "packages/app/package.json" );
const app = JSON . parse ( fs . readFileSync ( appFile , "utf8" ));
app . dependencies . chalk = "latest" ;
fs . writeFileSync ( appFile , JSON . stringify ( app , null , 2 ) + "\n" );
const topFile = path . join ( root , "package.json" );
const top = JSON . parse ( fs . readFileSync ( topFile , "utf8" ));
top . dependencies . chalk = "4.1.0" ;
fs . writeFileSync ( topFile , JSON . stringify ( top , null , 2 ) + "\n" );
const file = outdatedWith (( o ) => {
o . chalk = [ o . chalk , { ... o . chalk , dependent : "app" , dependedByLocation : "packages/app" }];
});
const plan = { npm : npmRules ([{ has : [ "outdated" ], out : file , code : 1 }, { has : [ "update" ], writes : [{ file : "package-lock.json" , bump : { "node_modules/chalk" : "4.1.2" } }] }]) };
const { run , bin , scan } = detectAndScan ( root , plan , [ "--no-audit" ]);
const chalk = scan . lockfiles [ 0 ]. rows . find (( r ) => r . package === "chalk" );
assert . deepEqual ( chalk . declaredIn . map (( d ) => d . range ), [ "4.1.0" , "latest" ]);
const records = path . join ( run , "records.json" );
fs . writeFileSync ( records , "[]" );
runStubbed ([ "label" , "--run" , run , "--records" , records ], bin );
const b = runStubbed ([ "batches" , "--run" , run , "--picks" , "package-lock.json#chalk" ], bin ). json . batches [ 0 ];
const before = bytesOf ( root , [ "package.json" , "packages/app/package.json" , "package-lock.json" ]);
runStubbed ([ "backup" , "--run" , run , "--batch" , b . id ], bin );
const updatesBefore = callsOf ( bin ). filter (( c ) => c . tool === "npm" && c . args [ 0 ] === "update" ). length ;
const r = runStubbed ([ "apply" , "--run" , run , "--batch" , b . id ], bin );
assert . equal ( r . code , 0 , r . stderr );
assert . deepEqual ( r . json . skipped . map (( s ) => [ s . id , s . file ]), [[ "package-lock.json#chalk" , "packages/app/package.json" ]]);
assert . deepEqual ( r . json . rangeRaised , [], "the root's pin is not raised when the member cannot follow" );
assert . deepEqual ( r . json . changed , []);
assert . equal ( r . json . command , null , "no command is reported when nothing ran" );
assert . equal ( r . json . exit , null );
assert . equal ( r . json . cwd , null );
assert . equal ( r . json . failed , false );
assert . deepEqual ( r . json . undoFailed , []);
assert . deepEqual ( r . json . offTarget . map (( o ) => [ o . id , o . now ]), [[ "package-lock.json#chalk" , []]], "a skipped pick did not land" );
assert . equal ( callsOf ( bin ). filter (( c ) => c . tool === "npm" && c . args [ 0 ] === "update" ). length , updatesBefore , "no update ran" );
for ( const [ rel , bytes ] of Object . entries ( before )) assert . ok ( fs . readFileSync ( path . join ( root , rel )). equals ( bytes ), rel );
});
test ( "backup refuses a batch that already has one (exit 5), keeping the as-found copy" , () => {
const root = project ();
const { run , bin , batches } = planned ( root , [ "chalk" ], { npm : npmRules () });
const b = batches [ 0 ];
assert . equal ( runStubbed ([ "backup" , "--run" , run , "--batch" , b . id ], bin ). code , 0 );
const lock = fs . readFileSync ( path . join ( root , "package-lock.json" ));
write ( root , "package-lock.json" , "{}\n" );
const again = runStubbed ([ "backup" , "--run" , run , "--batch" , b . id ], bin );
assert . equal ( again . code , 5 );
assert . equal ( again . json . error , "backup-exists" );
const r = runStubbed ([ "restore" , "--run" , run , "--batch" , b . id , "--verify" ], bin );
assert . equal ( r . json . verified , true );
assert . ok ( fs . readFileSync ( path . join ( root , "package-lock.json" )). equals ( lock ), "the first backup put back" );
});
test ( "installCommand is a frozen install for every npm-family manager" , () => {
const npmFamily = deps . ADAPTERS . find (( a ) => a . id === "npm" );
const line = ( entry ) => {
const c = npmFamily . installCommand ({ lockfile : "x/lock" , members : [ "x" ], ... entry }, "/r" );
return [ c . cmd , ... c . args ]. join ( " " );
};
assert . equal ( line ({ manager : "npm" }), "npm ci" );
assert . equal ( line ({ manager : "pnpm" }), "pnpm install --frozen-lockfile" );
assert . equal ( line ({ manager : "yarn" }), "yarn install --frozen-lockfile" );
assert . equal ( line ({ manager : "yarn" , berry : true }), "yarn install --immutable" );
});
/* ------------------------------------------------- Cargo, pip and uv: stubs on PATH */
// Recorded with cargo 1.99.1, pip 26.3 (Python 3.13.17) and uv 0.13.7 from
// scratch projects: Cargo with itoa and hex behind in range and bitflags and
// cfg-if behind out of range (plus a two-member workspace for metadata); pip
// with five == pins; uv with requests and urllib3 under capped ranges.
// cargo-outdated, cargo-audit and pip-audit are never installed (NFR-1), so
// their *-docs.json files follow the shapes their source prints, with the
// recorded packages and versions.
const CARGO = fx ( "cargo-1.99.1" );
const PIP = fx ( "pip-26.3" );
const UV = fx ( "uv-0.13.7" );
/** A recorded project folder copied into a temp folder, extra files on top. */
function copyFrom ( src , extra = {}) {
const dir = tmp ( "deps-eco" );
fs . cpSync ( src , dir , { recursive : true });
for ( const [ rel , content ] of Object . entries ( extra )) write ( dir , rel , content );
return dir ;
}
const cargoRules = ( over = []) => [
... over ,
{ has : [ "metadata" ], out : path . join ( CARGO , "metadata.json" ) },
{ has : [ "outdated" ], out : path . join ( CARGO , "outdated-docs.json" ) },
{ has : [ "audit" ], out : path . join ( CARGO , "audit-docs.json" ), code : 1 },
{ has : [ "update" , "--dry-run" ], err : path . join ( CARGO , "dry-run.txt" ) },
{ has : [ "update" , "-p" ], text : "" },
];
const rustcRules = [{ has : [ "--version" ], out : path . join ( CARGO , "rustc-version.txt" ) }];
const pythonRules = [{ has : [ "--version" ], out : path . join ( PIP , "python-version.txt" ) }];
const pipRules = ( over = []) => [... over , { has : [ "list" , "--outdated" ], out : path . join ( PIP , "outdated.json" ) }, { has : [ "freeze" ], out : path . join ( PIP , "freeze.txt" ) }, { has : [ "install" ], text : "" }, { has : [ "uninstall" ], text : "" }];
const uvRules = ( over = []) => [... over , { has : [ "tree" , "--outdated" ], out : path . join ( UV , "tree-outdated.txt" ) }, { has : [ "audit" ], out : path . join ( UV , "audit.json" ), code : 1 }];
/** Text saved to a temp file, for a stub rule to print. */
function textFile ( text ) {
const file = path . join ( tmp ( "deps-out" ), "out.txt" );
fs . writeFileSync ( file , text );
return file ;
}
const rowsOf = ( lock ) => Object . fromEntries ( lock . rows . map (( r ) => [ r . package , r ]));
test ( "Cargo detect: the lockfile with its Cargo.toml, workspace members from cargo metadata, and cargo fetch --locked" , () => {
const single = runStubbed ([ "detect" , "--root" , copyFrom ( path . join ( CARGO , "project" ))], stubPath ({ cargo : cargoRules (), rustc : rustcRules }));
assert . equal ( single . code , 0 , single . stderr );
assert . deepEqual ( single . json . lockfiles . map (( l ) => [ l . lockfile , l . manifest , l . manager , l . members , l . install ]), [[ "Cargo.lock" , "Cargo.toml" , "cargo" , [ "." ], "cargo fetch --locked" ]]);
assert . equal ( single . json . lockfiles [ 0 ]. updates , null , "no cargo-outdated, no quick count" );
const ws = runStubbed ([ "detect" , "--root" , copyFrom ( path . join ( CARGO , "workspace" ))], stubPath ({ cargo : cargoRules ([{ has : [ "metadata" ], out : path . join ( CARGO , "metadata-workspace.json" ) }]) }));
assert . equal ( ws . code , 0 , ws . stderr );
assert . deepEqual ( ws . json . lockfiles [ 0 ]. members , [ "." , "crates/a" , "crates/b" ]);
const none = runStubbed ([ "detect" , "--root" , copyFrom ( path . join ( CARGO , "project" ))], stubPath ({ git : [{ has : [ "rev-parse" ], code : 128 }] }));
assert . deepEqual ( none . json . missingTools , [{ tool : "cargo" , lockfiles : [ "Cargo.lock" ] }]);
assert . deepEqual ( none . json . lockfiles [ 0 ]. members , [ "." ], "without cargo the lockfile's own folder is its one member" );
});
test ( "Cargo scan without cargo-outdated or cargo-audit: the dry run gives rows, each plugin is named once with its install line, every row is not audited" , () => {
const { scanRun , scan , bin } = detectAndScan ( copyFrom ( path . join ( CARGO , "project" )), { cargo : cargoRules (), rustc : rustcRules });
assert . equal ( scanRun . code , 0 , scanRun . stderr );
assert . deepEqual ( scan . missingTools , [
{ tool : "cargo-outdated" , step : "outdated" , install : "cargo install cargo-outdated" },
{ tool : "cargo-audit" , step : "audit" , install : "cargo install cargo-audit" },
]);
const lock = scan . lockfiles [ 0 ];
assert . deepEqual ( lock . runtime , { declared : null , source : "machine" , machine : "1.99.1" });
assert . equal ( lock . audited , false );
assert . match ( lock . auditNote , /cargo-audit is not installed/ );
const rows = rowsOf ( lock );
assert . deepEqual ( Object . keys ( rows ), [ "bitflags" , "cfg-if" , "hex" , "itoa" ]);
assert . deepEqual ([ rows . itoa . current , rows . itoa . target , rows . itoa . jump , rows . itoa . inRange ], [ "1.0.9" , "1.0.19" , "patch" , true ]);
assert . deepEqual ( rows . itoa . range , { from : "1.0" , to : "1.0" });
assert . deepEqual ( rows . itoa . declaredIn , [{ file : "Cargo.toml" , range : "1.0" }]);
assert . deepEqual ([ rows . bitflags . target , rows . bitflags . jump , rows . bitflags . inRange ], [ "2.13.2" , "major" , false ]);
assert . deepEqual ( rows . bitflags . range , { from : "1" , to : "2" });
assert . deepEqual ([ rows [ "cfg-if" ]. target , rows [ "cfg-if" ]. jump ], [ "1.0.5" , "major" ]);
assert . deepEqual ([ rows . hex . target , rows . hex . inRange ], [ "0.4.3" , true ]);
assert . ok ( lock . rows . every (( r ) => r . notAudited === true && ! r . couldNotRead ));
const calls = callsOf ( bin ). filter (( c ) => c . tool === "cargo" ). map (( c ) => c . args . join ( " " ));
assert . ok ( calls . includes ( "update --dry-run --verbose" ));
assert . ok ( ! calls . some (( c ) => /^ ( outdated | audit ) / . test ( c )), "a plugin that is not installed is never called" );
});
test ( "Cargo dry run: a line it cannot read flags the row it names, or every row when it names none" , () => {
const dry = fs . readFileSync ( path . join ( CARGO , "dry-run.txt" ), "utf8" );
const named = detectAndScan ( copyFrom ( path . join ( CARGO , "project" )), { cargo : cargoRules ([{ has : [ "update" , "--dry-run" ], err : textFile ( ` ${ dry } Repinning itoa v1.0.9 => v1.0.20\n` ) }]), rustc : rustcRules }, [ "--no-audit" ]);
const rows = rowsOf ( named . scan . lockfiles [ 0 ]);
assert . equal ( rows . itoa . couldNotRead , "cargo update --dry-run" );
assert . equal ( rows . hex . couldNotRead , undefined );
const nameless = detectAndScan ( copyFrom ( path . join ( CARGO , "project" )), { cargo : cargoRules ([{ has : [ "update" , "--dry-run" ], err : textFile ( ` ${ dry } Something new happened here\n` ) }]), rustc : rustcRules }, [ "--no-audit" ]);
assert . ok ( nameless . scan . lockfiles [ 0 ]. rows . every (( r ) => r . couldNotRead === "cargo update --dry-run" ));
assert . ok ( deps . label ( nameless . scan , []). every (( l ) => l . label !== "safe" ));
});
test ( "Cargo scan with cargo-outdated and cargo-audit: rows from its JSON, a fixed advisory badges the row, nothing missing" , () => {
const { scanRun , scan , bin } = detectAndScan ( copyFrom ( path . join ( CARGO , "project" )), { cargo : cargoRules (), rustc : rustcRules , "cargo-outdated" : [], "cargo-audit" : [] });
assert . equal ( scanRun . code , 0 , scanRun . stderr );
assert . deepEqual ( scan . missingTools , []);
const lock = scan . lockfiles [ 0 ];
assert . equal ( lock . audited , true );
const rows = rowsOf ( lock );
assert . deepEqual ( Object . keys ( rows ). sort (), [ "bitflags" , "cfg-if" , "hex" , "itoa" ]);
assert . equal ( rows . itoa . inRange , true , "compat equal to latest is the tool's own in-range answer" );
assert . equal ( rows . bitflags . inRange , false );
assert . deepEqual ( rows . itoa . security . ids , [ "RUSTSEC-2099-0001" ], "1.0.19 is in the patched range >=1.0.11" );
assert . equal ( lock . rows [ 0 ]. package , "itoa" , "vulnerability fixes lead" );
assert . ok ( lock . rows . every (( r ) => ! r . notAudited ));
assert . deepEqual ( lock . stillOpen , []);
const calls = callsOf ( bin ). filter (( c ) => c . tool === "cargo" ). map (( c ) => c . args . join ( " " ));
assert . ok ( calls . includes ( "outdated --format json --root-deps-only" ));
assert . ok ( calls . includes ( "audit --json" ));
assert . ok ( ! calls . some (( c ) => c . includes ( "--dry-run" )), "no dry run when cargo outdated answers" );
});
test ( "Cargo: a crate a [patch] section replaces is held, naming Cargo.toml" , () => {
const root = copyFrom ( path . join ( CARGO , "project" ));
fs . appendFileSync ( path . join ( root , "Cargo.toml" ), '\n[patch.crates-io]\nitoa = { path = "../itoa" }\n' );
const { scan } = detectAndScan ( root , { cargo : cargoRules (), rustc : rustcRules }, [ "--no-audit" ]);
const lock = scan . lockfiles [ 0 ];
assert . ok ( ! lock . rows . some (( r ) => r . package === "itoa" ));
assert . deepEqual ( lock . held . map (( h ) => [ h . package , h . reason , h . file ]), [[ "itoa" , "held by [patch] in Cargo.toml" , "Cargo.toml" ]]);
assert . deepEqual ( deps . cargoPatched ( '[patch.crates-io]\nserde = "1"\n[patch.crates-io.tokio]\ngit = "x"\n[dependencies]\nrand = "1"\n' ), [ "serde" , "tokio" ]);
});
/** detect, scan, label and plan batches for row ids, on any ecosystem's project. */
function plannedIds ( root , ids , plan ) {
const { run , bin } = detectAndScan ( root , plan , [ "--no-audit" ]);
const records = path . join ( run , "records.json" );
fs . writeFileSync ( records , "[]" );
assert . equal ( runStubbed ([ "label" , "--run" , run , "--records" , records ], bin ). code , 0 );
const b = runStubbed ([ "batches" , "--run" , run , "--picks" , ids . join ( "," )], bin );
assert . equal ( b . code , 0 , b . stderr );
return { run , bin , batches : b . json . batches };
}
test ( "Cargo apply: an out-of-range pick raises Cargo.toml, then cargo update -p --precise, one command per pick" , () => {
const root = copyFrom ( path . join ( CARGO , "project" ));
const { run , bin , batches } = plannedIds ( root , [ "Cargo.lock#bitflags" , "Cargo.lock#itoa" ], {
cargo : cargoRules ([{ has : [ "update" , "-p" , "itoa" ], writes : [{ file : "Cargo.lock" , copy : path . join ( CARGO , "lock-after-update-itoa.lock" ) }] }]),
rustc : rustcRules ,
});
const before = fs . readFileSync ( path . join ( root , "Cargo.toml" ), "utf8" );
const results = {};
for ( const b of batches ) {
assert . equal ( runStubbed ([ "backup" , "--run" , run , "--batch" , b . id ], bin ). code , 0 );
results [ b . picks [ 0 ]] = runStubbed ([ "apply" , "--run" , run , "--batch" , b . id ], bin ). json ;
}
const bitflags = results [ "Cargo.lock#bitflags" ];
assert . equal ( bitflags . command , "cargo update -p bitflags@1.3.2 --precise 2.13.2" , "the locked version names it, in case the lockfile holds two" );
assert . deepEqual ( bitflags . rangeRaised . map (( r ) => [ r . file , r . from , r . to ]), [[ "Cargo.toml" , "1" , "2" ]]);
assert . equal ( fs . readFileSync ( path . join ( root , "Cargo.toml" ), "utf8" ), before . replace ( 'bitflags = "1"' , 'bitflags = "2"' ));
const itoa = results [ "Cargo.lock#itoa" ];
assert . equal ( itoa . command , "cargo update -p itoa@1.0.9 --precise 1.0.19" );
assert . deepEqual ( itoa . rangeRaised , [], "in range: Cargo.toml stays as it is" );
assert . deepEqual ( itoa . changed . map (( c ) => [ c . package , c . from , c . to ]), [[ "itoa" , "1.0.9" , "1.0.15" ]]);
const adapter = deps . ADAPTERS . find (( a ) => a . id === "cargo" );
const entry = { lockfile : "Cargo.lock" , members : [ "." ] };
const calls = adapter . applyCommand ({ rows : [{ package : "itoa" , current : "1.0.9" , target : "1.0.19" }, { package : "hex" , current : "0.4.2" , target : "0.4.3" }] }, entry , root );
assert . deepEqual ( calls . map (( c ) => [ c . cmd , ... c . args ]. join ( " " )), [ "cargo update -p itoa@1.0.9 --precise 1.0.19" , "cargo update -p hex@0.4.2 --precise 0.4.3" ]);
assert . deepEqual ( adapter . files ({ lockfile : "Cargo.lock" , members : [ "." , "crates/a" ] }), [ "Cargo.lock" , "Cargo.toml" , "crates/a/Cargo.toml" ]);
});
test ( "pip detect: a requirements file pinning every line is the lockfile, constraints beside it or named by -c are held, loose requirements list as noLockfile" , () => {
const root = copyFrom ( path . join ( PIP ), {
"constraints.txt" : "idna<4\n" ,
"requirements-dev.txt" : "pytest>=8\n" ,
"tools/requirements.txt" : "-c ../shared/limits.txt\nblack==24.1.0\n" ,
"shared/limits.txt" : "black<25\n" ,
});
const r = runStubbed ([ "detect" , "--root" , root ], stubPath ({ pip : pipRules (), python : pythonRules }));
assert . equal ( r . code , 0 , r . stderr );
const byLock = Object . fromEntries ( r . json . lockfiles . map (( l ) => [ l . lockfile , l ]));
assert . deepEqual ( Object . keys ( byLock ). sort (), [ "requirements.txt" , "tools/requirements.txt" ]);
assert . deepEqual ( byLock [ "requirements.txt" ]. constraints , [ "constraints.txt" ]);
assert . deepEqual ( byLock [ "tools/requirements.txt" ]. constraints , [ "shared/limits.txt" ]);
assert . equal ( byLock [ "requirements.txt" ]. install , "pip install -r requirements.txt" );
assert . equal ( byLock [ "requirements.txt" ]. updates , 5 );
assert . deepEqual ( r . json . noLockfile . map (( n ) => [ n . manifest , n . ecosystem ]), [[ "requirements-dev.txt" , "python" ]]);
assert . match ( r . json . noLockfile [ 0 ]. reason , /no lockfile/ );
});
test ( "pip scan: rows for the file's pins only, constraints hold theirs, pip-audit missing marks every row not audited" , () => {
const root = copyFrom ( PIP , { "constraints.txt" : "idna<4\n" });
const { scan } = detectAndScan ( root , { pip : pipRules (), python : pythonRules });
const lock = scan . lockfiles [ 0 ];
assert . deepEqual ( scan . missingTools , [{ tool : "pip-audit" , step : "audit" , install : "pip install pip-audit" }]);
assert . deepEqual ( lock . runtime , { declared : null , source : "machine" , machine : "3.13.17" });
const rows = rowsOf ( lock );
assert . deepEqual ( Object . keys ( rows ), [ "certifi" , "charset-normalizer" , "requests" , "urllib3" ]);
assert . deepEqual ( lock . held . map (( h ) => [ h . package , h . reason ]), [[ "idna" , "held by constraints in constraints.txt" ]]);
assert . deepEqual ([ rows . requests . current , rows . requests . target , rows . requests . jump , rows . requests . pinned ], [ "2.31.0" , "2.34.2" , "minor" , true ]);
assert . deepEqual ( rows . requests . range , { from : "==2.31.0" , to : "==2.34.2" });
assert . equal ( rows . urllib3 . jump , "major" );
assert . ok ( lock . rows . every (( r ) => r . notAudited === true ));
assert . ok ( lock . rows . every (( r ) => ! r . runtimeNotChecked ), "no requires-python declared: nothing to check against" );
});
test ( "pip scan with pip-audit: a fix on the target's own release line badges the row" , () => {
const { scan } = detectAndScan ( copyFrom ( PIP ), { pip : pipRules (), python : pythonRules , "pip-audit" : [{ has : [ "--format" , "json" ], out : path . join ( PIP , "pip-audit-docs.json" ), code : 1 }] });
const lock = scan . lockfiles [ 0 ];
assert . deepEqual ( scan . missingTools , []);
assert . equal ( lock . audited , true );
const rows = rowsOf ( lock );
assert . deepEqual ( rows . requests . security . ids , [ "GHSA-9wx4-h78v-vm56" ]);
assert . deepEqual ( rows . urllib3 . security . ids , [ "GHSA-34jh-p97f-mpxf" ], "2.8.0 is past 2.2.2, the fix on its own major line" );
assert . deepEqual ( lock . stillOpen , []);
});
test ( "pip put-back: backup snapshots pip freeze, restore reinstalls it and uninstalls what the batch added" , () => {
const root = copyFrom ( PIP );
const after = textFile ( ` ${ fs . readFileSync ( path . join ( PIP , "freeze.txt" ), "utf8" ) } six==1.16.0\n` );
const { run , bin , batches } = plannedIds ( root , [ "requirements.txt#requests" ], {
pip : pipRules ([{ has : [ "freeze" ], outs : [ path . join ( PIP , "freeze.txt" ), after ] }]),
python : pythonRules ,
});
const id = batches [ 0 ]. id ;
const backup = runStubbed ([ "backup" , "--run" , run , "--batch" , id ], bin );
assert . equal ( backup . code , 0 , backup . stderr );
assert . deepEqual ( backup . json . snapshot , { ok : true , file : "pip-freeze.txt" , packages : 5 });
const snap = path . join ( run , "backups" , id , "pip-freeze.txt" );
assert . equal ( fs . readFileSync ( snap , "utf8" ), fs . readFileSync ( path . join ( PIP , "freeze.txt" ), "utf8" ));
const req = fs . readFileSync ( path . join ( root , "requirements.txt" ), "utf8" );
const applied = runStubbed ([ "apply" , "--run" , run , "--batch" , id ], bin );
assert . equal ( applied . json . command , "pip install -r requirements.txt" );
assert . equal ( fs . readFileSync ( path . join ( root , "requirements.txt" ), "utf8" ), req . replace ( "requests==2.31.0" , "requests==2.34.2" ));
assert . deepEqual ( applied . json . changed . map (( c ) => [ c . package , c . from , c . to ]), [[ "requests" , "2.31.0" , "2.34.2" ]]);
const restored = runStubbed ([ "restore" , "--run" , run , "--batch" , id , "--verify" ], bin );
assert . equal ( restored . code , 0 , restored . stderr );
assert . equal ( restored . json . verified , true );
assert . equal ( fs . readFileSync ( path . join ( root , "requirements.txt" ), "utf8" ), req );
assert . deepEqual ( restored . json . extra , { ok : true , uninstalled : [ "six" ] });
const pip = callsOf ( bin ). filter (( c ) => c . tool === "pip" ). map (( c ) => c . args );
const reinstall = pip . findIndex (( a ) => a [ 0 ] === "install" && a [ 2 ] && a [ 2 ]. endsWith ( "pip-freeze.txt" ));
assert . ok ( reinstall !== - 1 , "pip install -r pip-freeze.txt" );
assert . deepEqual ( pip [ pip . length - 1 ], [ "uninstall" , "-y" , "six" ], "then the package the batch added goes" );
assert . equal ( restored . json . reinstall . command , "pip install -r requirements.txt" );
});
test ( "uv scan: rows from uv tree --outdated with each range, audit fixes badge rows, transitive findings stay open" , () => {
const { scanRun , scan } = detectAndScan ( copyFrom ( path . join ( UV , "project" )), { uv : uvRules (), python : pythonRules });
assert . equal ( scanRun . code , 0 , scanRun . stderr );
const lock = scan . lockfiles [ 0 ];
assert . deepEqual ([ lock . lockfile , lock . manager , lock . install ], [ "uv.lock" , "uv" , "uv sync --frozen" ]);
assert . equal ( lock . audited , true );
const rows = rowsOf ( lock );
assert . deepEqual ( Object . keys ( rows ). sort (), [ "requests" , "urllib3" ]);
assert . deepEqual ([ rows . requests . current , rows . requests . target , rows . requests . inRange ], [ "2.31.0" , "2.34.2" , true ]);
assert . deepEqual ( rows . requests . range , { from : ">=2.31,<3" , to : ">=2.31,<3" });
assert . deepEqual ([ rows . urllib3 . target , rows . urllib3 . inRange ], [ "2.8.0" , false ]);
assert . deepEqual ( rows . urllib3 . range , { from : ">=1.26,<2" , to : null }, "a compound range is never rewritten" );
assert . ok ( rows . requests . security . ids . length > 0 );
assert . deepEqual ([... new Set ( lock . stillOpen . map (( s ) => s . package ))]. sort (), [ "certifi" , "idna" ]);
assert . ok ( lock . stillOpen . every (( s ) => s . reason === "no upgrade on the list pulls it in" ));
const adapter = deps . ADAPTERS . find (( a ) => a . id === "uv" );
const call = adapter . applyCommand ({ rows : [{ package : "requests" , target : "2.34.2" }] }, { lockfile : "uv.lock" , members : [ "." ] }, "/p" );
assert . deepEqual ([ call . cmd , ... call . args ], [ "uv" , "lock" , "--upgrade-package" , "requests==2.34.2" ]);
});
test ( "uv: an audit in a shape it does not know sets couldNotRead on the audit only; an unreadable tree line flags its row" , () => {
const shape = detectAndScan ( copyFrom ( path . join ( UV , "project" )), { uv : uvRules ([{ has : [ "audit" ], text : '{"schema":{"version":"2"},"findings":[]}' , code : 0 }]), python : pythonRules });
const lock = shape . scan . lockfiles [ 0 ];
assert . equal ( lock . audited , false );
assert . equal ( lock . auditCouldNotRead , "uv audit" );
assert . match ( lock . auditNote , /could not read uv audit output/ );
assert . ok ( lock . rows . length === 2 && lock . rows . every (( r ) => r . notAudited === true && ! r . couldNotRead ), "the rows' versions were read; only the audit was not" );
const tree = ` ${ fs . readFileSync ( path . join ( UV , "tree-outdated.txt" ), "utf8" ) } └── requests ~ 2.31.0 -> latest 2.34.2\n` ;
const lines = detectAndScan ( copyFrom ( path . join ( UV , "project" )), { uv : uvRules ([{ has : [ "tree" ], out : textFile ( tree ) }]), python : pythonRules }, [ "--no-audit" ]);
const rows = rowsOf ( lines . scan . lockfiles [ 0 ]);
assert . equal ( rows . requests . couldNotRead , "uv tree" );
assert . equal ( rows . urllib3 . couldNotRead , undefined );
});
test ( "label: couldNotRead and notAudited rows are Check first with their reasons, never Safe" , () => {
const base = { id : "x" , current : "1.0.0" , target : "1.0.1" , jump : "patch" , inRange : true , range : { from : "^1.0.0" , to : "^1.0.0" }, pinned : false , security : null };
const scan = {
noChecks : false ,
lockfiles : [
{
lockfile : "Cargo.lock" ,
ecosystem : "cargo" ,
checks : { rows : [ "App" ], discovered : [] },
rows : [
{ ... base , id : "Cargo.lock#safe" },
{ ... base , id : "Cargo.lock#unread" , couldNotRead : "cargo update --dry-run" },
{ ... base , id : "Cargo.lock#unaudited" , notAudited : true },
],
},
],
};
const records = [ "safe" , "unread" , "unaudited" ]. map (( n ) => ({ id : `Cargo.lock# ${ n } ` , notes : "read" , breaking : [], files : 1 , calls : [] }));
const byId = Object . fromEntries ( deps . label ( scan , records ). map (( l ) => [ l . id , l ]));
assert . equal ( byId [ "Cargo.lock#safe" ]. label , "safe" , "the control row, same in every other way, is Safe" );
assert . equal ( byId [ "Cargo.lock#unread" ]. label , "check-first" );
assert . ok ( byId [ "Cargo.lock#unread" ]. reasons . some (( r ) => / could not read / . test ( r )));
assert . equal ( byId [ "Cargo.lock#unaudited" ]. label , "check-first" );
assert . ok ( byId [ "Cargo.lock#unaudited" ]. reasons . includes ( "not checked for vulnerabilities" ));
});
test ( "Cargo: cargo outdated --workspace lists a crate two members use once, declared in each" , () => {
const root = copyFrom ( path . join ( CARGO , "workspace" ));
fs . appendFileSync ( path . join ( root , "crates/b/Cargo.toml" ), 'itoa = "1.0"\n' );
const outdated = [
{ crate_name : "a" , dependencies : [{ name : "itoa" , project : "1.0.9" , compat : "1.0.19" , latest : "1.0.19" , kind : "Normal" , platform : null }] },
{ crate_name : "b" , dependencies : [{ name : "itoa" , project : "1.0.9" , compat : "1.0.19" , latest : "1.0.19" , kind : "Normal" , platform : null }] },
];
const { scan , bin } = detectAndScan ( root , {
cargo : cargoRules ([{ has : [ "metadata" ], out : path . join ( CARGO , "metadata-workspace.json" ) }, { has : [ "outdated" ], out : textFile ( outdated . map (( o ) => JSON . stringify ( o )). join ( "\n" ) + "\n" ) }]),
rustc : rustcRules ,
"cargo-outdated" : [],
}, [ "--no-audit" ]);
const itoa = scan . lockfiles [ 0 ]. rows . filter (( r ) => r . id === "Cargo.lock#itoa" );
assert . equal ( itoa . length , 1 , "one row per id" );
assert . deepEqual ( itoa [ 0 ]. declaredIn . map (( d ) => d . file ). sort (), [ "crates/a/Cargo.toml" , "crates/b/Cargo.toml" ]);
assert . ok ( callsOf ( bin ). some (( c ) => c . tool === "cargo" && c . args . includes ( "--workspace" )), "a workspace asks for every member" );
});
test ( "pyprojectDeps finds the array's end outside quoted strings, so extras keep every later entry" , () => {
const text = '[project]\ndependencies = [\n "uvicorn[standard]>=0.30",\n "PyYAML==6.0.1",\n]\n[dependency-groups]\ndev = ["pytest[cov]>=8", "ruff==0.6.0"]\n' ;
assert . deepEqual ( deps . pyprojectDeps ( text ). map (( d ) => [ d . name , d . spec , d . group ]), [
[ "uvicorn" , ">=0.30" , "project" ],
[ "PyYAML" , "==6.0.1" , "project" ],
[ "pytest" , ">=8" , "dev" ],
[ "ruff" , "==0.6.0" , "dev" ],
]);
});
test ( "uv: tree and audit run --frozen, so a scan never rewrites uv.lock" , () => {
const { bin } = detectAndScan ( copyFrom ( path . join ( UV , "project" )), { uv : uvRules (), python : pythonRules });
const uv = callsOf ( bin ). filter (( c ) => c . tool === "uv" );
assert . ok ( uv . length >= 3 , "detect's count, the scan's tree and the audit" );
for ( const c of uv ) assert . ok ( c . args . includes ( "--frozen" ), c . args . join ( " " ));
});
test ( "uv apply: a pin declared as PyYAML is raised in the file's own spelling while the row keeps uv's name" , () => {
const root = copyFrom ( path . join ( UV , "project" ));
const py = fs . readFileSync ( path . join ( root , "pyproject.toml" ), "utf8" ). replace ( /dependencies = \[/ , 'dependencies = [\n "PyYAML==6.0.1",' );
fs . writeFileSync ( path . join ( root , "pyproject.toml" ), py );
const tree = ` ${ fs . readFileSync ( path . join ( UV , "tree-outdated.txt" ), "utf8" ) } └── pyyaml v6.0.1 (latest: v6.0.2)\n` ;
const { run , bin , batches } = plannedIds ( root , [ "uv.lock#pyyaml" ], { uv : uvRules ([{ has : [ "tree" ], out : textFile ( tree ) }, { has : [ "lock" ], text : "" }]), python : pythonRules });
assert . equal ( runStubbed ([ "backup" , "--run" , run , "--batch" , batches [ 0 ]. id ], bin ). code , 0 );
const r = runStubbed ([ "apply" , "--run" , run , "--batch" , batches [ 0 ]. id ], bin );
assert . equal ( r . code , 0 , r . stderr );
assert . deepEqual ( r . json . skipped , []);
assert . deepEqual ( r . json . rangeRaised . map (( x ) => [ x . package , x . file , x . from , x . to ]), [[ "pyyaml" , "pyproject.toml" , "==6.0.1" , "==6.0.2" ]]);
assert . equal ( r . json . command , "uv lock --upgrade-package pyyaml==6.0.2" );
assert . equal ( fs . readFileSync ( path . join ( root , "pyproject.toml" ), "utf8" ), py . replace ( '"PyYAML==6.0.1"' , '"PyYAML==6.0.2"' ));
});
test ( "pip: a requirements file pinned with hashes is list only with its own reason, continuations joined" , () => {
const hashed = "requests==2.32.3 \\\n --hash=sha256:aaaa \\\n --hash=sha256:bbbb\nidna==3.7 \\\n --hash=sha256:cccc\n" ;
const lines = deps . requirementLines ( hashed ). reqs ;
assert . deepEqual ( lines . map (( q ) => [ q . name , q . spec , q . hashed , q . line ]), [[ "requests" , "==2.32.3" , true , 1 ], [ "idna" , "==3.7" , true , 4 ]]);
const root = tmp ( "deps-hashed" );
write ( root , "requirements.txt" , hashed );
const r = runStubbed ([ "detect" , "--root" , root ], stubPath ({ pip : pipRules () }));
assert . deepEqual ( r . json . lockfiles , []);
assert . deepEqual ( r . json . noLockfile , [{ manifest : "requirements.txt" , ecosystem : "python" , reason : "pinned with hashes: regenerate the file to update it" }]);
});
test ( "pip apply refuses a batch whose backup has no environment snapshot (exit 5), and moves nothing" , () => {
const root = copyFrom ( PIP );
const { run , bin , batches } = plannedIds ( root , [ "requirements.txt#requests" ], { pip : pipRules ([{ has : [ "freeze" ], code : 1 , text : "" }]), python : pythonRules });
const backup = runStubbed ([ "backup" , "--run" , run , "--batch" , batches [ 0 ]. id ], bin );
assert . equal ( backup . json . snapshot . ok , false );
const req = fs . readFileSync ( path . join ( root , "requirements.txt" ), "utf8" );
const r = runStubbed ([ "apply" , "--run" , run , "--batch" , batches [ 0 ]. id ], bin );
assert . equal ( r . code , 5 );
assert . equal ( r . json . error , "no-snapshot" );
assert . equal ( fs . readFileSync ( path . join ( root , "requirements.txt" ), "utf8" ), req );
assert . ok ( ! callsOf ( bin ). some (( c ) => c . tool === "pip" && c . args [ 0 ] === "install" ));
});
test ( "pip put-back: a failed reinstall of the snapshot is reported with the command to run by hand" , () => {
const root = copyFrom ( PIP );
const { run , bin , batches } = plannedIds ( root , [ "requirements.txt#requests" ], { pip : pipRules ([{ has : [ "install" , "-r" , "requirements.txt" ], text : "" }, { has : [ "install" ], code : 1 , text : "" }]), python : pythonRules });
const id = batches [ 0 ]. id ;
runStubbed ([ "backup" , "--run" , run , "--batch" , id ], bin );
const r = runStubbed ([ "restore" , "--run" , run , "--batch" , id , "--verify" ], bin );
assert . equal ( r . code , 0 , r . stderr );
assert . equal ( r . json . verified , true , "the files are back" );
assert . equal ( r . json . extra . ok , false , "but the environment is not" );
assert . match ( r . json . extra . command , /^pip install -r .*pip-freeze\.txt$/ );
});
test ( "uv without an audit command: rows are not audited, the rest of the scan stands" , () => {
const { scan } = detectAndScan ( copyFrom ( path . join ( UV , "project" )), { uv : uvRules ([{ has : [ "audit" ], code : 2 , err : textFile ( "error: unrecognized subcommand 'audit'\n" ) }]), python : pythonRules });
const lock = scan . lockfiles [ 0 ];
assert . equal ( lock . audited , false );
assert . match ( lock . auditNote , /no audit command/ );
assert . equal ( lock . rows . length , 2 );
assert . ok ( lock . rows . every (( r ) => r . notAudited === true ));
assert . deepEqual ( scan . missingTools , [], "not a plugin to install" );
});
test ( "raiseRange keeps the space in a spaced PEP 440 pin, so apply can raise it" , () => {
assert . deepEqual ( deps . raiseRange ( "python" , "== 2.31.0" , "2.34.2" ), { rewritten : true , from : "== 2.31.0" , to : "== 2.34.2" });
assert . deepEqual ( deps . raiseRange ( "python" , "==2.31.0" , "2.34.2" ), { rewritten : true , from : "==2.31.0" , to : "==2.34.2" });
});
/* ------------------------------------------------- Go and .NET: stubs on PATH */
// Go recorded with go 1.27.3 from a scratch module (go-1.27.3/project):
// golang.org/x/mod and x/net required directly, x/text indirect, five more
// modules in the graph. go-1.27.3/go.mod-after-get-mod is the real go get of
// x/mod v0.43.0, which rewrote the go directive 1.22 => 1.26.0. govulncheck is
// never installed (NFR-1) and no .NET SDK runs on the recording machine, so
// govulncheck-docs.json and dotnet-docs/ follow their documented shapes.
const GO = fx ( "go-1.27.3" );
const DOTNET = fx ( "dotnet-docs" );
const goRules = ( over = []) => [
... over ,
{ has : [ "list" , "-m" ], out : path . join ( GO , "list-m-u-json-all.json" ) },
{ has : [ "version" ], out : path . join ( GO , "go-version.txt" ) },
{ has : [ "mod" , "tidy" ], text : "" },
{ has : [ "get" ], text : "" },
];
const govulncheckRules = [{ has : [ "-json" ], out : path . join ( GO , "govulncheck-docs.json" ) }];
const dotnetRules = ( over = []) => [
... over ,
{ has : [ "list" , "App.csproj" , "package" , "--outdated" ], out : path . join ( DOTNET , "outdated.json" ) },
{ has : [ "list" , "App.csproj" , "package" , "--vulnerable" ], out : path . join ( DOTNET , "vulnerable.json" ) },
{ has : [ "add" ], text : "" },
];
test ( "Go scan: rows for direct requirements only, the go directive as runtime, govulncheck missing leaves every row not audited" , () => {
const { scanRun , scan , detect , bin } = detectAndScan ( copyFrom ( path . join ( GO , "project" )), { go : goRules () });
assert . equal ( scanRun . code , 0 , scanRun . stderr );
assert . deepEqual ( detect . json . lockfiles . map (( l ) => [ l . lockfile , l . manifest , l . manager , l . members , l . install , l . updates ]), [[ "go.sum" , "go.mod" , "go" , [ "." ], "go mod download" , 2 ]]);
const lock = scan . lockfiles [ 0 ];
assert . deepEqual ( lock . runtime , { declared : "1.22" , source : "go" , machine : null });
const rows = rowsOf ( lock );
assert . deepEqual ( Object . keys ( rows ), [ "golang.org/x/mod" , "golang.org/x/net" ], "indirect modules (x/text, x/crypto, ...) are never rows" );
const mod = rows [ "golang.org/x/mod" ];
assert . deepEqual ([ mod . id , mod . current , mod . target , mod . jump , mod . inRange , mod . lockfileOnly ], [ "go.sum#golang.org/x/mod" , "v0.17.0" , "v0.43.0" , "0.x" , true , true ]);
assert . deepEqual ( mod . range , { from : "v0.17.0" , to : "v0.43.0" }, "go get rewrites the require line" );
assert . deepEqual ( scan . missingTools , [{ tool : "govulncheck" , step : "audit" , install : "go install golang.org/x/vuln/cmd/govulncheck@latest" }]);
assert . equal ( lock . audited , false );
assert . match ( lock . auditNote , /govulncheck is not installed/ );
assert . ok ( lock . rows . every (( r ) => r . notAudited === true ));
assert . ok ( ! callsOf ( bin ). some (( c ) => c . tool === "govulncheck" ));
assert . ok ( deps . label ( scan , []). every (( l ) => l . label !== "safe" && l . reasons . includes ( "not checked for vulnerabilities" )));
});
test ( "Go scan with govulncheck: a finding the target fixes badges its row, one with no fix on an indirect module stays open" , () => {
const { scan , bin } = detectAndScan ( copyFrom ( path . join ( GO , "project" )), { go : goRules (), govulncheck : govulncheckRules });
const lock = scan . lockfiles [ 0 ];
assert . equal ( lock . audited , true );
assert . deepEqual ( scan . missingTools , []);
const rows = rowsOf ( lock );
assert . deepEqual ( rows [ "golang.org/x/net" ]. security , { severity : null , ids : [ "GO-2099-0001" ] }, "v0.62.0 is past the fix v0.23.0; the repeated finding counts once" );
assert . equal ( rows [ "golang.org/x/mod" ]. security , null );
assert . equal ( lock . rows [ 0 ]. package , "golang.org/x/net" , "vulnerability fixes lead" );
assert . deepEqual ( lock . stillOpen . map (( s ) => [ s . package , s . ids , s . reason ]), [[ "golang.org/x/text" , [ "GO-2099-0002" ], "no fixed version published yet" ]]);
assert . deepEqual ( callsOf ( bin ). find (( c ) => c . tool === "govulncheck" ). args , [ "-json" , "./..." ]);
});
test ( "Go apply: a go get that raises the go directive marks needsNewerRuntime and fails; restore --verify puts the line back" , () => {
const root = copyFrom ( path . join ( GO , "project" ));
const { run , bin , batches } = plannedIds ( root , [ "go.sum#golang.org/x/mod" ], {
go : goRules ([{ has : [ "get" , "golang.org/x/mod@v0.43.0" ], writes : [{ file : "go.mod" , copy : path . join ( GO , "go.mod-after-get-mod" ) }, { file : "go.sum" , copy : path . join ( GO , "go.sum-after-get-mod" ) }] }]),
});
const id = batches [ 0 ]. id ;
const backup = runStubbed ([ "backup" , "--run" , run , "--batch" , id ], bin );
assert . deepEqual ( backup . json . files , [ "go.sum" , "go.mod" ]);
const r = runStubbed ([ "apply" , "--run" , run , "--batch" , id ], bin );
assert . equal ( r . code , 0 , r . stderr );
assert . equal ( r . json . command , "go get golang.org/x/mod@v0.43.0 && go mod tidy" );
assert . deepEqual ( r . json . rangeRaised , [], "go get writes go.mod itself" );
assert . deepEqual ( r . json . changed . map (( c ) => [ c . package , c . from , c . to ]), [[ "golang.org/x/mod" , "v0.17.0" , "v0.43.0" ]]);
assert . deepEqual ( r . json . needsNewerRuntime , [{ id : "go.sum#golang.org/x/mod" , package : "golang.org/x/mod" , file : "go.mod" , from : "1.22" , to : "1.26.0" }]);
assert . equal ( r . json . failed , true , "a raised go directive is never kept" );
assert . match ( fs . readFileSync ( path . join ( root , "go.mod" ), "utf8" ), /^go 1\.26\.0$/m );
const back = runStubbed ([ "restore" , "--run" , run , "--batch" , id , "--verify" ], bin );
assert . equal ( back . json . verified , true );
assert . equal ( back . json . reinstall . command , "go mod download" );
assert . equal ( fs . readFileSync ( path . join ( root , "go.mod" ), "utf8" ), fs . readFileSync ( path . join ( GO , "project" , "go.mod" ), "utf8" ));
assert . match ( fs . readFileSync ( path . join ( root , "go.mod" ), "utf8" ), /^go 1\.22$/m );
});
test ( "Go apply: a go directive written into a go.mod that had none counts as raised from Go's implicit 1.16" , () => {
const plain = fs . readFileSync ( path . join ( GO , "project" , "go.mod" ), "utf8" ). replace ( /^go 1\.22\r?\n\r?\n/m , "" );
assert . ok ( ! /^go /m . test ( plain ), "the fixture copy has no go directive" );
const root = copyFrom ( path . join ( GO , "project" ), { "go.mod" : plain });
const { run , bin , batches } = plannedIds ( root , [ "go.sum#golang.org/x/mod" ], {
go : goRules ([{ has : [ "get" , "golang.org/x/mod@" ], writes : [{ file : "go.mod" , copy : path . join ( GO , "go.mod-after-get-mod" ) }, { file : "go.sum" , copy : path . join ( GO , "go.sum-after-get-mod" ) }] }]),
});
runStubbed ([ "backup" , "--run" , run , "--batch" , batches [ 0 ]. id ], bin );
const r = runStubbed ([ "apply" , "--run" , run , "--batch" , batches [ 0 ]. id ], bin );
assert . equal ( r . code , 0 , r . stderr );
assert . deepEqual ( r . json . needsNewerRuntime , [{ id : "go.sum#golang.org/x/mod" , package : "golang.org/x/mod" , file : "go.mod" , from : null , to : "1.26.0" }]);
assert . equal ( r . json . failed , true );
assert . equal ( runStubbed ([ "restore" , "--run" , run , "--batch" , batches [ 0 ]. id , "--verify" ], bin ). json . verified , true );
assert . equal ( fs . readFileSync ( path . join ( root , "go.mod" ), "utf8" ), plain );
});
test ( "Go apply: an update that leaves the go directive alone has no needsNewerRuntime" , () => {
const root = copyFrom ( path . join ( GO , "project" ));
const { run , bin , batches } = plannedIds ( root , [ "go.sum#golang.org/x/net" ], {
go : goRules ([{ has : [ "get" , "golang.org/x/net@" ], writes : [{ file : "go.mod" , copy : path . join ( GO , "go.mod-after-get-net" ) }, { file : "go.sum" , copy : path . join ( GO , "go.sum-after-get-net" ) }] }]),
});
runStubbed ([ "backup" , "--run" , run , "--batch" , batches [ 0 ]. id ], bin );
const r = runStubbed ([ "apply" , "--run" , run , "--batch" , batches [ 0 ]. id ], bin );
assert . equal ( r . code , 0 , r . stderr );
assert . deepEqual ( r . json . needsNewerRuntime , []);
assert . equal ( r . json . failed , false );
assert . deepEqual ( r . json . changed . map (( c ) => [ c . package , c . to ]), [[ "golang.org/x/net" , "v0.21.0" ]]);
assert . deepEqual ( r . json . unpicked , []);
});
test ( ".NET detect: packages.lock.json beside each project, a project without one listed as noLockfile and still scanned" , () => {
const root = copyFrom ( path . join ( DOTNET , "project" ), { "lib/Lib.fsproj" : '<Project Sdk="Microsoft.NET.Sdk">\n <PropertyGroup>\n <TargetFrameworks>net8.0;net10.0</TargetFrameworks>\n </PropertyGroup>\n <ItemGroup>\n <PackageReference Include="FSharp.Core" Version="8.0.400" />\n </ItemGroup>\n</Project>\n' });
const r = runStubbed ([ "detect" , "--root" , root ], stubPath ({ dotnet : dotnetRules () }));
assert . equal ( r . code , 0 , r . stderr );
const byManifest = Object . fromEntries ( r . json . lockfiles . map (( l ) => [ l . manifest , l ]));
assert . deepEqual ( Object . keys ( byManifest ), [ "App.csproj" , "lib/Lib.fsproj" ]);
assert . deepEqual ([ byManifest [ "App.csproj" ]. lockfile , byManifest [ "App.csproj" ]. install , byManifest [ "App.csproj" ]. updates ], [ "packages.lock.json" , "dotnet restore App.csproj --locked-mode" , 2 ]);
const lib = byManifest [ "lib/Lib.fsproj" ];
assert . deepEqual ([ lib . lockfile , lib . noLockfile , lib . install ], [ "lib/Lib.fsproj" , true , "dotnet restore Lib.fsproj" ]);
assert . deepEqual ( r . json . noLockfile . map (( n ) => [ n . manifest , n . ecosystem ]), [[ "lib/Lib.fsproj" , "nuget" ]]);
assert . match ( r . json . noLockfile [ 0 ]. reason , /no packages\.lock\.json/ );
const adapter = deps . ADAPTERS . find (( a ) => a . id === "dotnet" );
assert . deepEqual ( adapter . runtime ({ manifest : "lib/Lib.fsproj" }, root ), { declared : "net8.0;net10.0" , source : "TargetFramework" , machine : null , floor : "8.0" });
});
test ( ".NET scan: rows from --outdated, implicit packages skipped; a vulnerability with no fix version badges its row and stays open" , () => {
const { scanRun , scan , bin } = detectAndScan ( copyFrom ( path . join ( DOTNET , "project" )), { dotnet : dotnetRules () });
assert . equal ( scanRun . code , 0 , scanRun . stderr );
const lock = scan . lockfiles [ 0 ];
assert . deepEqual ( lock . runtime , { declared : "net8.0" , source : "TargetFramework" , machine : null });
const rows = rowsOf ( lock );
assert . deepEqual ( Object . keys ( rows ), [ "Newtonsoft.Json" , "Serilog" ], "autoReferenced Microsoft.NET.ILLink.Tasks is not a row" );
assert . ok ( lock . rows . every (( r ) => r . runtimeNotChecked === "net8.0" ), "no target is cut by TargetFramework yet: never Safe" );
const nj = rows [ "Newtonsoft.Json" ];
assert . deepEqual ([ nj . id , nj . current , nj . target , nj . jump , nj . inRange , nj . lockfileOnly ], [ "packages.lock.json#Newtonsoft.Json" , "13.0.1" , "13.0.4" , "patch" , true , true ]);
assert . deepEqual ( nj . range , { from : "13.0.1" , to : "13.0.4" });
assert . deepEqual ([ rows . Serilog . jump , rows . Serilog . range ], [ "major" , { from : "3.1.1" , to : "4.3.0" }]);
assert . equal ( lock . audited , true );
assert . deepEqual ( nj . security , { severity : "high" , ids : [ "https://github.com/advisories/GHSA-0000-fixture-0001" ] });
assert . deepEqual ( lock . stillOpen . map (( s ) => [ s . package , s . severity ]), [[ "Newtonsoft.Json" , "high" ], [ "System.Text.RegularExpressions" , "moderate" ]]);
assert . match ( lock . stillOpen [ 0 ]. reason , /does not say which version fixes it/ );
const calls = callsOf ( bin ). filter (( c ) => c . tool === "dotnet" ). map (( c ) => c . args . join ( " " ));
assert . ok ( calls . includes ( "list App.csproj package --outdated --format json" ));
assert . ok ( calls . includes ( "list App.csproj package --vulnerable --include-transitive --format json" ), "never combined with --outdated" );
});
test ( ".NET apply: dotnet add package per pick writes the project and the lock; restore --verify puts both back" , () => {
const root = copyFrom ( path . join ( DOTNET , "project" ));
const { run , bin , batches } = plannedIds ( root , [ "packages.lock.json#Newtonsoft.Json" ], {
dotnet : dotnetRules ([{ has : [ "add" , "App.csproj" , "package" , "Newtonsoft.Json" ], writes : [{ file : "App.csproj" , copy : path . join ( DOTNET , "App.csproj-after-add-newtonsoft" ) }, { file : "packages.lock.json" , copy : path . join ( DOTNET , "packages.lock-after-add-newtonsoft.json" ) }] }]),
});
const id = batches [ 0 ]. id ;
assert . deepEqual ( runStubbed ([ "backup" , "--run" , run , "--batch" , id ], bin ). json . files , [ "packages.lock.json" , "App.csproj" ]);
const r = runStubbed ([ "apply" , "--run" , run , "--batch" , id ], bin );
assert . equal ( r . code , 0 , r . stderr );
assert . equal ( r . json . command , "dotnet add App.csproj package Newtonsoft.Json --version 13.0.4" );
assert . deepEqual ( r . json . rangeRaised , [], "dotnet add writes the PackageReference itself" );
assert . deepEqual ( r . json . changed . map (( c ) => [ c . package , c . from , c . to ]), [[ "Newtonsoft.Json" , "13.0.1" , "13.0.4" ]]);
assert . deepEqual ([ r . json . unpicked , r . json . offTarget , r . json . failed ], [[], [], false ]);
const back = runStubbed ([ "restore" , "--run" , run , "--batch" , id , "--verify" ], bin );
assert . equal ( back . json . verified , true );
assert . equal ( fs . readFileSync ( path . join ( root , "App.csproj" ), "utf8" ), fs . readFileSync ( path . join ( DOTNET , "project" , "App.csproj" ), "utf8" ));
const adapter = deps . ADAPTERS . find (( a ) => a . id === "dotnet" );
const calls = adapter . applyCommand ({ rows : [{ package : "A" , target : "1.1.0" }, { package : "B" , target : "2.0.0" }] }, { manifest : "src/App.csproj" }, root );
assert . deepEqual ( calls . map (( c ) => [ c . cmd , ... c . args ]. join ( " " )), [ "dotnet add App.csproj package A --version 1.1.0" , "dotnet add App.csproj package B --version 2.0.0" ]);
});
test ( ".NET apply without a packages.lock.json: the project file is the record, read for the move and put back byte for byte" , () => {
const csproj = ( v ) => `<Project Sdk="Microsoft.NET.Sdk">\n <PropertyGroup>\n <TargetFramework>net8.0</TargetFramework>\n </PropertyGroup>\n <ItemGroup>\n <PackageReference Include="FSharp.Core" Version=" ${ v } " />\n </ItemGroup>\n</Project>\n` ;
const root = tmp ( "deps-dotnet-nolock" );
write ( root , "lib/Lib.fsproj" , csproj ( "8.0.400" ));
const outdated = { version : 1 , parameters : "--outdated" , projects : [{ path : "Lib.fsproj" , frameworks : [{ framework : "net8.0" , topLevelPackages : [{ id : "FSharp.Core" , requestedVersion : "8.0.400" , resolvedVersion : "8.0.400" , latestVersion : "8.0.403" }] }] }] };
const { run , bin , batches } = plannedIds ( root , [ "lib/Lib.fsproj#FSharp.Core" ], {
dotnet : [
{ has : [ "list" , "Lib.fsproj" , "package" , "--outdated" ], out : textFile ( JSON . stringify ( outdated )) },
{ has : [ "add" , "Lib.fsproj" , "package" , "FSharp.Core" ], writes : [{ file : "Lib.fsproj" , copy : textFile ( csproj ( "8.0.403" )) }] },
],
});
const id = batches [ 0 ]. id ;
assert . deepEqual ( runStubbed ([ "backup" , "--run" , run , "--batch" , id ], bin ). json . files , [ "lib/Lib.fsproj" ]);
const r = runStubbed ([ "apply" , "--run" , run , "--batch" , id ], bin );
assert . equal ( r . code , 0 , r . stderr );
assert . equal ( r . json . command , "dotnet add Lib.fsproj package FSharp.Core --version 8.0.403" );
assert . deepEqual ( r . json . changed . map (( c ) => [ c . package , c . from , c . to ]), [[ "FSharp.Core" , "8.0.400" , "8.0.403" ]]);
assert . deepEqual ([ r . json . offTarget , r . json . unpicked , r . json . failed ], [[], [], false ]);
const back = runStubbed ([ "restore" , "--run" , run , "--batch" , id , "--verify" ], bin );
assert . equal ( back . json . verified , true );
assert . equal ( back . json . reinstall . command , "dotnet restore Lib.fsproj" , "no --locked-mode without a lockfile" );
assert . equal ( fs . readFileSync ( path . join ( root , "lib/Lib.fsproj" ), "utf8" ), csproj ( "8.0.400" ));
});
test ( "detect lists a pom.xml and a Gemfile in notCovered with folder and ecosystem, and scan makes no rows for them" , () => {
const root = tmp ( "deps-uncovered" );
write ( root , "pom.xml" , "<project></project>\n" );
write ( root , "ruby/Gemfile" , 'source "https://rubygems.org"\ngem "rails", "~> 7.1"\n' );
write ( root , "node_modules/x/composer.json" , "{}\n" );
write ( root , "vendor/acme/lib/composer.json" , "{}\n" );
write ( root , "ruby/vendor/bundle/gems/rake/Gemfile" , "\n" );
const bin = stubPath ({ git : [{ has : [ "rev-parse" ], code : 128 }] });
const d = runStubbed ([ "detect" , "--root" , root ], bin );
assert . equal ( d . code , 0 , d . stderr );
assert . deepEqual ( d . json . notCovered , [
{ folder : "." , manifest : "pom.xml" , ecosystem : "Maven" },
{ folder : "ruby" , manifest : "ruby/Gemfile" , ecosystem : "Ruby (Bundler)" },
], "skipped folders (node_modules) and dependency copies under vendor/ are never listed" );
assert . deepEqual ( d . json . lockfiles , []);
const s = runStubbed ([ "scan" , "--run" , d . json . run ], bin );
assert . equal ( s . code , 0 , s . stderr );
const scan = JSON . parse ( fs . readFileSync ( path . join ( d . json . run , "scan.json" ), "utf8" ));
assert . deepEqual ( scan . lockfiles , []);
assert . deepEqual ( scan . notCovered , d . json . notCovered );
});
/** Runs `fn` with PATH (every case of the key) set to `dir` in this process, for spawnTool. */
function withProcessPath ( dir , fn ) {
const saved = Object . fromEntries ( Object . keys ( process . env ). filter (( k ) => /^ path$ / i . test ( k )). map (( k ) => [ k , process . env [ k ]]));
for ( const k of Object . keys ( saved )) process . env [ k ] = dir ;
process . env . PATH = dir ;
try {
return fn ();
} finally {
for ( const [ k , v ] of Object . entries ( saved )) process . env [ k ] = v ;
}
}
test ( "spawnTool refuses an argument cmd.exe cannot quote safely, before the tool starts" , { skip : process . platform !== "win32" && "cmd.exe only" }, () => {
const bin = stubPath ({ npm : [{ has : [], text : "ran" }] });
for ( const bad of [ '1" & echo x & "' , "%PATH%" , "a!b" , "a\nb" ]) {
const r = withProcessPath ( bin , () => deps . spawnTool ( "npm" , [ "view" , bad ]));
assert . equal ( r . code , null );
assert . match ( r . stderr , /cannot be quoted safely/ );
}
assert . deepEqual ( callsOf ( bin ), [], "the stub never ran" );
const ok = withProcessPath ( bin , () => deps . spawnTool ( "npm" , [ "view" , "a b" , ">=1.0.0 <2" ]));
assert . equal ( ok . code , 0 , ok . stderr );
assert . deepEqual ( callsOf ( bin )[ 0 ]. args , [ "view" , "a b" , ">=1.0.0 <2" ]);
});
test ( "a timed-out .cmd tool is stopped with its whole tree, so it writes nothing afterward" , { skip : process . platform !== "win32" && "cmd.exe only" }, async () => {
const dir = tmp ( "deps-slow" );
const marker = path . join ( dir , "late.txt" );
const js = path . join ( dir , "slow.mjs" );
fs . writeFileSync ( js , `import fs from "node:fs";\nsetTimeout(() => fs.writeFileSync( ${ JSON . stringify ( marker ) } , "late"), 3000);\n` );
fs . writeFileSync ( path . join ( dir , "npm.cmd" ), `@" ${ process . execPath } " " ${ js } " %*\r\n` );
const r = withProcessPath ( dir , () => deps . spawnTool ( "npm" , [ "update" ], { timeoutMs : 1000 }));
assert . equal ( r . timedOut , true );
assert . equal ( r . code , null );
await new Promise (( done ) => setTimeout ( done , 4000 ));
assert . ok ( ! fs . existsSync ( marker ), "the tool kept running after the timeout" );
});
test ( "spawnTool refuses --force before anything runs" , () => {
assert . throws (() => deps . spawnTool ( "npm" , [ "audit" , "fix" , "--force" ]), /--force/ );
assert . throws (() => deps . spawnTool ( "npm" , [ "install" , "--force=true" ]), /--force/ );
});
/* --------------------------------------------------------------- notes */
// Saved HTTP responses under fixtures/deps/http/, served by a local server in
// a child process (runDeps blocks this process while the script runs, so a
// server here could never answer). PLAN2CODE_DEPS_HTTP_BASE sends the script's
// requests to it as <base>/<host><path>; any other path answers 404.
const HTTP_FX = path . join ( FIXTURES , "http" );
const HTTP_SERVER = [
'import http from "node:http";' ,
'import fs from "node:fs";' ,
'const routes = JSON.parse(fs.readFileSync(process.argv[2], "utf8"));' ,
"const server = http.createServer((req, res) => {" ,
' const route = routes[new URL(req.url, "http://x").pathname];' ,
' if (!route) { res.writeHead(404); res.end("not found"); return; }' ,
" if (route.hang) return;" ,
" const body = route.big" ,
' ? JSON.stringify([{ tag_name: "v2.0.0", name: "v2.0.0", body: "x".repeat(route.big) }])' ,
" : route.bare" ,
' ? JSON.stringify(["v1.3.0", "v1.2.0"].map((t) => ({ tag_name: t, name: t, draft: false, body: null })))' ,
" : fs.readFileSync(route.file);" ,
" res.writeHead(200); res.end(body);" ,
"});" ,
'server.listen(0, "127.0.0.1", () => process.stdout.write(server.address().port + "\\n"));' ,
"" ,
]. join ( "\n" );
const HTTP_ROUTES = {
"/api.github.com/repos/chalk/chalk/releases" : { file : path . join ( HTTP_FX , "releases-chalk.json" ) },
"/raw.githubusercontent.com/left-pad/left-pad/HEAD/CHANGELOG.md" : { file : path . join ( HTTP_FX , "changelog-left-pad.md" ) },
"/crates.io/api/v1/crates/serde" : { file : path . join ( HTTP_FX , "crates-serde.json" ) },
"/pypi.org/pypi/requests/json" : { file : path . join ( HTTP_FX , "pypi-requests.json" ) },
"/api.github.com/repos/big/notes/releases" : { big : 40000 },
"/api.github.com/repos/bare/pad/releases" : { bare : true },
"/raw.githubusercontent.com/bare/pad/HEAD/CHANGELOG.md" : { file : path . join ( HTTP_FX , "changelog-left-pad.md" ) },
"/hang" : { hang : true },
};
2026-11-15 14:58:05 -08:00
let httpChild = null ;
2026-11-13 23:28:59 -08:00
async function httpServer ( routes ) {
const dir = tmp ( "deps-http" );
fs . writeFileSync ( path . join ( dir , "server.mjs" ), HTTP_SERVER );
fs . writeFileSync ( path . join ( dir , "routes.json" ), JSON . stringify ( routes ));
const child = spawn ( process . execPath , [ path . join ( dir , "server.mjs" ), path . join ( dir , "routes.json" )], { stdio : [ "ignore" , "pipe" , "inherit" ] });
2026-11-15 14:58:05 -08:00
httpChild = child ;
2026-11-13 23:28:59 -08:00
const port = await new Promise (( resolve , reject ) => {
child . stdout . once ( "data" , ( d ) => resolve ( Number ( String ( d ). trim ())));
child . once ( "exit" , ( code ) => reject ( new Error ( `the test HTTP server exited ( ${ code } )` )));
});
return `http://127.0.0.1: ${ port } ` ;
}
2026-11-15 14:58:05 -08:00
// Started in a root before hook, never with a top-level await here: tests are
// already registered above, so node:test starts running them during such an
// await, sees the root suite finish, and runs its after hooks (this server's
// kill and fixtureCleanup) before the notes tests below ever run.
let HTTP = null ;
before ( async () => {
HTTP = await httpServer ( HTTP_ROUTES );
});
after (() => httpChild ? . kill ());
2026-11-13 23:28:59 -08:00
const noteRow = ( lockfile , pkg , current , target , extra = {}) => ({ id : ` ${ lockfile } # ${ pkg } ` , package : pkg , current , target , jump : deps . jumpOf ( "npm" , current , target ), inRange : true , range : null , pinned : false , security : null , repo : null , pair : null , ... extra });
/** A scan.json for notes: npm rows with and without a repo, a Cargo row and a pip row, each found through a registry. */
function notesScan ( root ) {
const checks = { rows : [ "Root" ], commands : [ "npm test" ], discovered : [], full : false };
return {
ok : true ,
root ,
noChecks : false ,
lockfiles : [
{
lockfile : "package-lock.json" ,
adapter : "npm" ,
ecosystem : "npm" ,
manager : "npm" ,
members : [ "." ],
checks ,
rows : [
noteRow ( "package-lock.json" , "chalk" , "4.1.0" , "5.3.0" , { repo : "https://github.com/chalk/chalk" }),
noteRow ( "package-lock.json" , "left-pad" , "1.1.0" , "1.3.0" , { repo : "git+https://github.com/left-pad/left-pad.git" }),
noteRow ( "package-lock.json" , "ms" , "2.1.2" , "2.1.3" ),
noteRow ( "package-lock.json" , "big-notes" , "1.0.0" , "2.0.0" , { repo : "https://github.com/big/notes" }),
noteRow ( "package-lock.json" , "bare-pad" , "1.1.0" , "1.3.0" , { repo : "https://github.com/bare/pad" }),
noteRow ( "package-lock.json" , "gone" , "1.0.0" , "1.1.0" , { repo : "https://github.com/gone/gone" }),
],
},
{ lockfile : "Cargo.lock" , adapter : "cargo" , ecosystem : "cargo" , manager : "cargo" , members : [ "." ], checks , rows : [ noteRow ( "Cargo.lock" , "serde" , "1.0.200" , "1.0.210" )] },
{ lockfile : "requirements.txt" , adapter : "pip" , ecosystem : "python" , manager : "pip" , members : [ "." ], checks , rows : [ noteRow ( "requirements.txt" , "requests" , "2.31.0" , "2.32.3" )] },
],
};
}
/** notes for one row, with `plan` as the stub tools on PATH (none by default, so no gh) and the test server as every host. */
function notesFor ( id , plan = {}) {
const dir = runFolder ({ "scan.json" : notesScan ( tmp ( "deps-notes" )) });
const r = runDeps ([ "notes" , "--run" , dir , "--id" , id ], { env : withPath ( stubPath ( plan ), { PLAN2CODE_DEPS_HTTP_BASE : HTTP }) });
assert . equal ( r . code , 0 , r . stderr || r . stdout );
return { ... r . json , dir };
}
test ( "githubRepo reads URLs, git remotes and shorthands as owner/name; other hosts are null" , () => {
assert . equal ( deps . githubRepo ( "https://github.com/chalk/chalk" ), "chalk/chalk" );
assert . equal ( deps . githubRepo ( "git+https://github.com/left-pad/left-pad.git" ), "left-pad/left-pad" );
assert . equal ( deps . githubRepo ( "git@github.com:serde-rs/serde.git" ), "serde-rs/serde" );
assert . equal ( deps . githubRepo ( "https://github.com/babel/babel/tree/main/packages/babel-core" ), "babel/babel" );
assert . equal ( deps . githubRepo ( "github:vercel/ms" ), "vercel/ms" );
assert . equal ( deps . githubRepo ( "vercel/ms" ), "vercel/ms" );
assert . equal ( deps . githubRepo ( "github.com/pkg/errors/v2" ), "pkg/errors" );
assert . equal ( deps . githubRepo ( "https://gitlab.com/a/b" ), null );
assert . equal ( deps . githubRepo ( "https://notgithub.com/a/b" ), null );
assert . equal ( deps . githubRepo ( "golang.org/x/text" ), null );
assert . equal ( deps . githubRepo ( null ), null );
});
test ( "tagVersion reads v, bare, prefixed and monorepo tags; another package's tag is null" , () => {
assert . equal ( deps . tagVersion ( "npm" , "v5.0.0" , "chalk" ), "5.0.0" );
assert . equal ( deps . tagVersion ( "npm" , "release-1.2.3" , "x" ), "1.2.3" );
assert . equal ( deps . tagVersion ( "npm" , "chalk@5.0.0" , "chalk" ), "5.0.0" );
assert . equal ( deps . tagVersion ( "npm" , "@babel/core@7.24.0" , "@babel/core" ), "7.24.0" );
assert . equal ( deps . tagVersion ( "npm" , "chalk-template@1.0.0" , "chalk" ), null );
assert . equal ( deps . tagVersion ( "npm" , "nightly" , "chalk" ), null );
assert . equal ( deps . tagVersion ( "npm" , "pubsub-v1.2.0" , "pubsub" ), "1.2.0" , "the package's own dash tag" );
assert . equal ( deps . tagVersion ( "npm" , "storage-v7.0.0" , "pubsub" ), null , "a sibling package's dash tag" );
assert . equal ( deps . tagVersion ( "npm" , "Version 2.0.0" , "x" ), "2.0.0" );
assert . equal ( deps . tagVersion ( "npm" , "core-v1.0.0" , "@babel/core" ), "1.0.0" , "a scoped package's last segment" );
});
test ( "notes: releases in range with no body fall through to the changelog" , () => {
const r = notesFor ( "package-lock.json#bare-pad" );
assert . equal ( r . source , "changelog" );
assert . equal ( r . url , "https://github.com/bare/pad/blob/HEAD/CHANGELOG.md" );
assert . match ( r . text , /^## \[1\.3\.0\]/ );
assert . equal ( deps . sliceReleases ([{ tag_name : "v1.3.0" , body : " " }], { ecosystem : "npm" , package : "x" , current : "1.0.0" , target : "1.3.0" }), "" );
});
test ( "notes: GitHub releases sliced to after current and up to target, newest first, drafts and other tags left out" , () => {
const r = notesFor ( "package-lock.json#chalk" );
assert . equal ( r . source , "fetch" );
assert . equal ( r . repo , "chalk/chalk" );
assert . equal ( r . url , "https://github.com/chalk/chalk/releases" );
assert . equal ( r . truncated , false );
const titles = [... r . text . matchAll ( /^## (\S+)/gm )]. map (( m ) => m [ 1 ]);
assert . deepEqual ( titles , [ "v5.3.0" , "v5.2.0" , "v5.0.0" , "v4.1.2" ]);
assert . match ( r . text , /Chalk is now ESM only/ );
assert . doesNotMatch ( r . text , /level option|Not published yet|Another package|hex colors|Not a version/ );
});
test ( "notes: gh api reads the releases when gh is installed; a failing gh falls back to a fetch" , () => {
const releases = path . join ( HTTP_FX , "releases-chalk.json" );
const viaGh = notesFor ( "package-lock.json#chalk" , { gh : [{ has : [ "api" , "repos/chalk/chalk/releases" ], out : releases }] });
assert . equal ( viaGh . source , "gh" );
assert . match ( viaGh . text , /^## v5\.3\.0/ );
const broken = notesFor ( "package-lock.json#chalk" , { gh : [{ has : [ "api" ], code : 1 , text : "" }] });
assert . equal ( broken . source , "fetch" );
assert . equal ( broken . text , viaGh . text );
});
test ( "notes: with no release in range, CHANGELOG.md from the default branch is sliced between the two versions" , () => {
const r = notesFor ( "package-lock.json#left-pad" );
assert . equal ( r . source , "changelog" );
assert . equal ( r . repo , "left-pad/left-pad" );
assert . equal ( r . url , "https://github.com/left-pad/left-pad/blob/HEAD/CHANGELOG.md" );
const versions = [... r . text . matchAll ( /^## \[([\d.]+)\]/gm )]. map (( m ) => m [ 1 ]);
assert . deepEqual ( versions , [ "1.3.0" , "1.2.0" , "1.1.3" ]);
assert . match ( r . text , /### Added\n\n- TypeScript types\./ , "subheadings stay inside their version" );
assert . match ( r . text , /A heading inside a code block/ , "a fenced heading is not a version heading" );
assert . doesNotMatch ( r . text , /Unreleased|First release/ );
});
test ( "notes: the repo comes from npm view, crates.io or PyPI when the row has none" , () => {
const npm = notesFor ( "package-lock.json#ms" , { npm : [{ has : [ "view" , "ms" , "repository.url" ], text : '"git+https://github.com/vercel/ms.git"' }] });
assert . equal ( npm . repo , "vercel/ms" );
assert . equal ( notesFor ( "Cargo.lock#serde" ). repo , "serde-rs/serde" );
assert . equal ( notesFor ( "requirements.txt#requests" ). repo , "psf/requests" );
});
test ( "notes: a 404 everywhere is source none, and that row labels Check first, not Safe" , () => {
const r = notesFor ( "package-lock.json#gone" );
assert . equal ( r . source , "none" );
assert . equal ( r . url , null );
assert . equal ( r . text , "" );
const records = path . join ( r . dir , "helper-records.json" );
fs . writeFileSync ( records , JSON . stringify ([{ id : r . id , notes : r . source === "none" ? "could not read" : "read" , breaking : [], files : 1 , calls : [] }]));
const l = runDeps ([ "label" , "--run" , r . dir , "--records" , records ]);
assert . equal ( l . code , 0 , l . stderr );
const gone = l . json . labels . find (( x ) => x . id === r . id );
assert . equal ( gone . label , "check-first" );
assert . ok ( gone . reasons . includes ( "notes could not be read" ));
const read = deps . label ( notesScan ( "." ), [{ id : r . id , notes : "read" , breaking : [], files : 1 , calls : [] }]). find (( x ) => x . id === r . id );
assert . equal ( read . label , "safe" , "the same row with its notes read is Safe" );
});
test ( "notes: no repo found is source none; an unknown row exits 3" , () => {
const r = notesFor ( "package-lock.json#ms" );
assert . equal ( r . repo , null , "npm is not on PATH, so no registry answer" );
assert . equal ( r . source , "none" );
const dir = runFolder ({ "scan.json" : notesScan ( "." ) });
const unknown = runDeps ([ "notes" , "--run" , dir , "--id" , "package-lock.json#nope" ]);
assert . equal ( unknown . code , 3 );
assert . equal ( unknown . json . error , "unknown-row" );
});
test ( "notes: text over 32 KB is cut and marked truncated" , () => {
const r = notesFor ( "package-lock.json#big-notes" );
assert . equal ( r . source , "fetch" );
assert . equal ( r . truncated , true );
assert . ok ( Buffer . byteLength ( r . text , "utf8" ) <= deps . NOTES_CAP_BYTES );
assert . ok ( Buffer . byteLength ( r . text , "utf8" ) > deps . NOTES_CAP_BYTES - 16 );
});
test ( "fetchText and fetchJson stop at the timeout and return null on a 404 or a refused connection, never throwing" , async () => {
assert . equal ( deps . NOTES_TIMEOUT_MS , 15000 );
const started = Date . now ();
assert . equal ( await deps . fetchText ( ` ${ HTTP } /hang` , { timeoutMs : 300 }), null );
assert . ok ( Date . now () - started < 5000 , "the timeout ends the request" );
assert . equal ( await deps . fetchJson ( ` ${ HTTP } /missing` ), null );
assert . deepEqual ( await deps . fetchJson ( ` ${ HTTP } /crates.io/api/v1/crates/serde` ). then (( j ) => j . crate . name ), "serde" );
assert . equal ( await deps . fetchText ( "http://127.0.0.1:1/closed" , { timeoutMs : 2000 }), null );
assert . equal ( await deps . fetchJson ( ` ${ HTTP } /raw.githubusercontent.com/left-pad/left-pad/HEAD/CHANGELOG.md` ), null , "a body that is not JSON" );
});
/* ------------------------------------------------------------- hand-off */
/** A run folder with scan.json for handoff: chalk (out of range), react and react-dom (a pair), @types/node; labels come from label. */
function handoffRun () {
const root = tmp ( "deps-handoff" );
const lock = "package-lock.json" ;
const decl = ( range ) => [{ file : "package.json" , range }];
const scan = {
ok : true ,
root ,
noChecks : false ,
lockfiles : [
{
lockfile : lock ,
adapter : "npm" ,
ecosystem : "npm" ,
manager : "npm" ,
members : [ "." ],
checks : { rows : [ "Root" ], commands : [ "npm test" ], discovered : [], full : false },
rows : [
noteRow ( lock , "chalk" , "4.1.0" , "5.3.0" , { inRange : false , range : { from : "^4.1.0" , to : "^5.3.0" }, declaredIn : decl ( "^4.1.0" ) }),
noteRow ( lock , "react" , "18.3.1" , "19.0.0" , { inRange : false , range : { from : "^18.3.1" , to : "^19.0.0" }, declaredIn : decl ( "^18.3.1" ), pair : ` ${ lock } #react-dom` }),
noteRow ( lock , "react-dom" , "18.3.1" , "19.0.0" , { inRange : false , range : { from : "^18.3.1" , to : "^19.0.0" }, declaredIn : decl ( "^18.3.1" ) }),
noteRow ( lock , "@types/node" , "20.0.0" , "22.0.0" , { inRange : false , range : { from : "^20.0.0" , to : "^22.0.0" }, declaredIn : decl ( "^20.0.0" ) }),
],
},
],
};
const dir = runFolder ({ "scan.json" : scan });
const records = [
{ id : ` ${ lock } #chalk` , notes : "read" , source : "fetch" , url : "https://github.com/chalk/chalk/releases" , breaking : [ "Chalk is now ESM only. Use chalk 4 from CommonJS." ], files : 2 , calls : [{ file : "src/color.js" , line : 3 , api : "chalk.red" }] },
{ id : ` ${ lock } #react` , notes : "could not read" , source : "none" , breaking : [], files : 9 , calls : [] },
];
const helper = path . join ( tmp ( "deps-records" ), "records.json" );
fs . writeFileSync ( helper , JSON . stringify ( records ));
const l = runDeps ([ "label" , "--run" , dir , "--records" , helper ]);
assert . equal ( l . code , 0 , l . stderr );
return { root , dir , lock };
}
const BRIEF_DATE = NOW . slice ( 0 , 10 ). replace ( /-/g , "" );
test ( "label saves the helper records in the run folder for handoff" , () => {
const { dir , lock } = handoffRun ();
const saved = JSON . parse ( fs . readFileSync ( path . join ( dir , "records.json" ), "utf8" ));
assert . deepEqual ( saved . map (( r ) => r . id ), [ ` ${ lock } #chalk` , ` ${ lock } #react` ]);
});
test ( "handoff writes one brief per package in the 4.5 format, every section present" , () => {
const { root , dir , lock } = handoffRun ();
const r = runDeps ([ "handoff" , "--run" , dir , "--ids" , ` ${ lock } #chalk` ]);
assert . equal ( r . code , 0 , r . stderr );
const file = `specs/chalk-upgrade/UPGRADE- ${ BRIEF_DATE } .md` ;
assert . deepEqual ( r . json . written , [{ file , folder : "specs/chalk-upgrade" , ids : [ ` ${ lock } #chalk` ], packages : [ "chalk" ] }]);
assert . equal (
fs . readFileSync ( path . join ( root , file ), "utf8" ),
[
"# Upgrade chalk 4.1.0 to 5.3.0" ,
"" ,
"**Status:** Ready" ,
"**Ecosystem:** npm" ,
"**Folder:** ." ,
"" ,
"## Why it was held back" ,
"" ,
2026-11-14 18:33:02 -08:00
"- **chalk**: Warning (a big change, the allowed range widens from ^4.1.0 to ^5.3.0, the notes say something was removed or changed, your code uses something that changed, 2 files use it)" ,
2026-11-13 23:28:59 -08:00
"" ,
"## What the notes say changed" ,
"" ,
"> Chalk is now ESM only. Use chalk 4 from CommonJS." ,
"" ,
"Source: fetch, https://github.com/chalk/chalk/releases" ,
"" ,
"## Where the code calls it" ,
"" ,
"- `src/color.js:3` (chalk.red)" ,
"" ,
"## Checks that cover it" ,
"" ,
"- `npm test`" ,
"" ,
"## How to apply" ,
"" ,
"- Raise the chalk range in package.json: `^4.1.0` to `^5.3.0`." ,
"- In `.`, run:" ,
"" ,
"```" ,
"npm update chalk --package-lock-only --ignore-scripts --no-audit --no-fund" ,
"```" ,
"" ,
]. join ( "\n" ),
);
});
test ( "handoff: a pair shares one brief listing both packages; a scoped name gets scope-name; a second run replaces the brief" , () => {
const { root , dir , lock } = handoffRun ();
const ids = [ ` ${ lock } #react` , ` ${ lock } #react-dom` , ` ${ lock } #@types/node` ];
const r = runDeps ([ "handoff" , "--run" , dir , "--ids" , ids . join ( "," )]);
assert . equal ( r . code , 0 , r . stderr );
assert . deepEqual ( r . json . written . map (( w ) => [ w . folder , w . packages ]), [[ "specs/react-upgrade" , [ "react" , "react-dom" ]], [ "specs/types-node-upgrade" , [ "@types/node" ]]]);
assert . deepEqual ( fs . readdirSync ( path . join ( root , "specs" )). sort (), [ "react-upgrade" , "types-node-upgrade" ], "exactly two folders" );
const pair = fs . readFileSync ( path . join ( root , "specs" , "react-upgrade" , `UPGRADE- ${ BRIEF_DATE } .md` ), "utf8" );
assert . match ( pair , /^# Upgrade react 18\.3\.1 to 19\.0\.0 and react-dom 18\.3\.1 to 19\.0\.0\n/ );
for ( const section of [ "Why it was held back" , "What the notes say changed" , "Where the code calls it" , "Checks that cover it" , "How to apply" ]) assert . match ( pair , new RegExp ( `^## ${ section } $` , "m" ), section );
assert . match ( pair , /^\*\*Status:\*\* Ready$/m );
2026-11-14 18:33:02 -08:00
assert . match ( pair , /- \*\*react\*\*: Warning \(a big change, .*9 files use it/ , "a big change with unreadable notes in 9 files" );
assert . match ( pair , /- \*\*react-dom\*\*: Check first \(a big change/ );
2026-11-13 23:28:59 -08:00
assert . match ( pair , /### react\n\nThe notes could not be read\./ );
assert . match ( pair , /### react-dom\n\nThe notes were not read\./ );
assert . match ( pair , /npm update react react-dom --package-lock-only/ , "one command moves both" );
const stale = path . join ( root , "specs" , "types-node-upgrade" , `UPGRADE- ${ BRIEF_DATE } .md` );
fs . writeFileSync ( stale , "old brief\n" );
assert . equal ( runDeps ([ "handoff" , "--run" , dir , "--ids" , ` ${ lock } #@types/node` ]). code , 0 );
assert . match ( fs . readFileSync ( stale , "utf8" ), /^# Upgrade @types\/node 20\.0\.0 to 22\.0\.0\n/ );
assert . deepEqual ( fs . readdirSync ( path . dirname ( stale )), [ `UPGRADE- ${ BRIEF_DATE } .md` ]);
});
test ( "handoff: one package ticked in two lockfiles gets a brief each, the later one naming its folder" , () => {
const root = tmp ( "deps-handoff-two" );
const checks = { rows : [ "Root" ], commands : [ "npm test" ], discovered : [], full : false };
const lockOf = ( lockfile , member ) => ({ lockfile , adapter : "npm" , ecosystem : "npm" , manager : "npm" , members : [ member ], checks , rows : [ noteRow ( lockfile , "chalk" , "4.1.0" , "5.3.0" )] });
const dir = runFolder ({ "scan.json" : { ok : true , root , noChecks : false , lockfiles : [ lockOf ( "package-lock.json" , "." ), lockOf ( "web/package-lock.json" , "web" )] } });
const helper = path . join ( tmp ( "deps-records" ), "records.json" );
fs . writeFileSync ( helper , "[]" );
assert . equal ( runDeps ([ "label" , "--run" , dir , "--records" , helper ]). code , 0 );
const r = runDeps ([ "handoff" , "--run" , dir , "--ids" , "package-lock.json#chalk,web/package-lock.json#chalk" ]);
assert . equal ( r . code , 0 , r . stderr );
assert . deepEqual ( r . json . written . map (( w ) => w . folder ), [ "specs/chalk-upgrade" , "specs/chalk-web-upgrade" ]);
assert . match ( fs . readFileSync ( path . join ( root , "specs" , "chalk-upgrade" , `UPGRADE- ${ BRIEF_DATE } .md` ), "utf8" ), /^\*\*Folder:\*\* \.$/m );
assert . match ( fs . readFileSync ( path . join ( root , "specs" , "chalk-web-upgrade" , `UPGRADE- ${ BRIEF_DATE } .md` ), "utf8" ), /^\*\*Folder:\*\* web$/m );
});
test ( "upgradeBrief quotes every line of a breaking note that spans lines" , () => {
const lock = { lockfile : "package-lock.json" , ecosystem : "npm" , manager : "npm" , checks : {} };
const row = noteRow ( "package-lock.json" , "chalk" , "4.1.0" , "5.3.0" );
const brief = deps . upgradeBrief ([{ row , lock , label : { label : "warning" , reasons : [ "major" ] }, record : { notes : "read" , breaking : [ "Chalk is now ESM only.\nUse chalk 4 from CommonJS.\r\n\r\n- Drops Node 12." ] } }]);
assert . match ( brief , /\n> Chalk is now ESM only\.\n> Use chalk 4 from CommonJS\.\n>\n> - Drops Node 12\.\n/ );
});
test ( "handoff refuses an id not in labels.json (exit 3) and writes nothing; upgradeFolder never leaves specs/" , () => {
const { root , dir , lock } = handoffRun ();
const r = runDeps ([ "handoff" , "--run" , dir , "--ids" , ` ${ lock } #chalk, ${ lock } #nope` ]);
assert . equal ( r . code , 3 );
assert . equal ( r . json . error , "unknown-id" );
assert . deepEqual ( r . json . unknown , [ ` ${ lock } #nope` ]);
assert . equal ( fs . existsSync ( path . join ( root , "specs" )), false , "not even the known id's brief" );
fs . rmSync ( path . join ( dir , "labels.json" ));
assert . equal ( runDeps ([ "handoff" , "--run" , dir , "--ids" , ` ${ lock } #chalk` ]). json . error , "labels-missing" );
assert . equal ( deps . upgradeFolder ( "@types/node" ), "types-node-upgrade" );
assert . equal ( deps . upgradeFolder ( "github.com/pkg/errors" ), "github.com-pkg-errors-upgrade" );
assert . equal ( deps . upgradeFolder ( "../../etc" ), "etc-upgrade" );
assert . equal ( deps . upgradeFolder ( ".." ), "package-upgrade" );
});
2026-11-14 18:33:02 -08:00
/* ------------------------------------------------------------ pins */
const PINS = fx ( "pins" , "project" );
/** The pins fixture project copied into a temp folder, with extra files on top. */
function pinsProject ( extra = {}) {
const dir = tmp ( "deps-pins" );
fs . cpSync ( PINS , dir , { recursive : true });
for ( const [ rel , content ] of Object . entries ( extra )) write ( dir , rel , content );
return dir ;
}
const PW = { id : "package-lock.json#playwright-core" , package : "playwright-core" , current : "1.64.1" , target : "1.66.0" };
test ( "findPins finds a whole-token exact version beside the package name, never a stray number" , () => {
const root = pinsProject ();
const pins = deps . findPins ( root , [ PW ], { skip : [ "package.json" , "package-lock.json" ] });
assert . deepEqual ( pins , [{ id : PW . id , file : "scripts/test-browser-helper.mjs" , line : 4 , text : 'export const BROWSER = "playwright-core@1.64.1";' }], "the 11.64.10 and 1.64.12 line is no pin" );
});
test ( "findPins skips lockfiles, files a lockfile entry owns, binary files and files over 1 MB" , () => {
const big = `playwright-core 1.64.1\n ${ "x" . repeat ( deps . PIN_FILE_CAP ) } ` ;
const root = pinsProject ({ "web/package-lock.json" : '{"playwright-core": "1.64.1"}\n' , "notes/big.txt" : big , "docs/readme.md" : "Uses playwright-core 1.64.1 today.\n" });
fs . writeFileSync ( path . join ( root , "assets.bin" ), Buffer . concat ([ Buffer . from ( "playwright-core 1.64.1\n" ), Buffer . from ([ 0 , 1 , 2 ])]));
const files = deps . findPins ( root , [ PW ], { skip : [ "package.json" , "package-lock.json" ] }). map (( p ) => p . file );
assert . deepEqual ( files . sort (), [ "docs/readme.md" , "scripts/test-browser-helper.mjs" ]);
const owned = deps . findPins ( root , [ PW ], { skip : [ "package-lock.json" ] }). map (( p ) => p . file );
assert . ok ( owned . includes ( "package.json" ), "a manifest not on the skip list is searched" );
assert . deepEqual ( deps . findPins ( root , [ PW ], { files : [ "docs/readme.md" ] }). map (( p ) => p . file ), [ "docs/readme.md" ], "files limits the search" );
assert . deepEqual ( deps . findPins ( root , []), [], "no rows, no search" );
});
test ( "label: a pin outside the row's own files moves a Safe row to Check first, naming the file" , () => {
const before = labeled ();
assert . equal ( before . r1 . label , "safe" );
const pins = { pins : [{ id : "r1" , file : "scripts/test-browser-helper.mjs" , line : 4 , text : "x" }, { id : "r1" , file : "package-lock.json" , line : 9 , text : "x" }] };
const after = Object . fromEntries ( deps . label ( SCAN , RECORDS , pins ). map (( l ) => [ l . id , l ]));
assert . equal ( after . r1 . label , "check-first" );
assert . ok ( after . r1 . reasons . includes ( "exact version used in scripts/test-browser-helper.mjs" ), after . r1 . reasons . join ( "; " ));
assert . match ( after . r1 . reasonsPlain . join ( " " ), /scripts\/test-browser-helper\.mjs names this exact version \(1\.2\.3\)/ );
const own = Object . fromEntries ( deps . label ( SCAN , RECORDS , [{ id : "r1" , file : "package-lock.json" }]). map (( l ) => [ l . id , l ]));
assert . equal ( own . r1 . label , "safe" , "a pin in its own lockfile moves with the update" );
assert . deepEqual ( deps . label ( SCAN , RECORDS , null ), deps . label ( SCAN , RECORDS ), "no pins.json changes nothing" );
const warning = Object . fromEntries ( deps . label ( SCAN , RECORDS , [{ id : "r5" , file : "a.js" }]). map (( l ) => [ l . id , l ]));
assert . equal ( warning . r5 . label , "warning" , "the Warning rules stay as they are" );
});
test ( "pins --run writes pins.json, label reads it, and the row with a pin in a test file leaves Safe" , () => {
const root = pinsProject ();
const lock = { lockfile : "package-lock.json" , manifest : "package.json" , adapter : "npm" , ecosystem : "npm" , manager : "npm" , members : [ "." ], checks : { rows : [ "Root" ], discovered : [] }, rows : [{ ... PW , jump : "minor" , inRange : false , range : { from : "1.64.1" , to : "1.66.0" }, pinned : true , security : null , declaredIn : [{ file : "package.json" , range : "1.64.1" }] }] };
const dir = runFolder ({ "scan.json" : { root , noChecks : false , lockfiles : [ lock ] } });
const r = runDeps ([ "pins" , "--run" , dir ]);
assert . equal ( r . code , 0 , r . stderr );
assert . equal ( r . json . count , 1 );
assert . deepEqual ( r . json . pins . map (( p ) => [ p . file , p . line ]), [[ "scripts/test-browser-helper.mjs" , 4 ]]);
assert . deepEqual ( JSON . parse ( fs . readFileSync ( path . join ( dir , "pins.json" ), "utf8" )), { pins : r . json . pins });
const records = path . join ( dir , "records-in.json" );
fs . writeFileSync ( records , JSON . stringify ([{ id : PW . id , notes : "read" , breaking : [], usedIn : [ "scripts/test-browser-helper.mjs" ] }]));
const unpinned = deps . label ({ noChecks : false , lockfiles : [ lock ] }, JSON . parse ( fs . readFileSync ( records , "utf8" )));
assert . equal ( unpinned [ 0 ]. label , "safe" , "without the pin the row is Safe" );
const l = runDeps ([ "label" , "--run" , dir , "--records" , records ]);
assert . equal ( l . code , 0 , l . stderr );
assert . equal ( l . json . labels [ 0 ]. label , "check-first" );
assert . ok ( l . json . labels [ 0 ]. reasons . includes ( "exact version used in scripts/test-browser-helper.mjs" ));
});
test ( "pins: a run folder that is not there and a run with no scan.json exit 3" , () => {
const gone = runDeps ([ "pins" , "--run" , path . join ( os . tmpdir (), "plan2code-deps-19990101-deadbeef" )]);
assert . equal ( gone . code , 3 );
assert . equal ( gone . json . error , "run-missing" );
const empty = runDeps ([ "pins" , "--run" , runFolder ()]);
assert . equal ( empty . code , 3 );
assert . equal ( empty . json . next , "Run scan first." );
});
/* ------------------------------------------------------------ checks: failing tests */
const LOGS = fx ( "logs" );
const logText = ( name ) => fs . readFileSync ( path . join ( LOGS , name ), "utf8" );
test ( "failedTests reads each runner's failing tests; TODO and SKIP lines are no failures" , () => {
const cases = {
"tap.txt" : [ "parses dates" ],
"node-spec.txt" : [ "parses dates" ],
"jest.txt" : [ "divides by zero" ],
"vitest.txt" : [ "src/b.test.ts > math > divides by zero" ],
"pytest.txt" : [ "tests/test_b.py::test_divides" ],
"cargo.txt" : [ "math::divides" ],
"go.txt" : [ "TestDivides" ],
"dotnet.txt" : [ "MyApp.Tests.Divides" ],
};
for ( const [ file , names ] of Object . entries ( cases )) assert . deepEqual ( deps . failedTests ( logText ( file )), { names , known : true }, file );
assert . deepEqual ( deps . failedTests ( logText ( "unknown.txt" )), { names : [], known : false }, "an unknown format falls back to the command" );
assert . deepEqual ( deps . failedTests ( "ok 1 - adds\nok 2 - parses\n" ), { names : [], known : true }, "a known format with nothing failing" );
assert . deepEqual ( deps . failedTests ( "\x1b[31m--- FAIL: TestColor (0.00s)\x1b[0m\n" ), { names : [ "TestColor" ], known : true }, "color codes are dropped" );
});
2026-11-14 21:18:33 -08:00
test ( "baseline without --outcome reads a bare FAIL line as a failure, and a TODO line as none" , () => {
const dir = fs . mkdtempSync ( path . join ( os . tmpdir (), "deps-bare-" ));
const jestDefault = path . join ( dir , "jest-default.txt" );
fs . writeFileSync ( jestDefault , "PASS src/a.test.js\nFAIL src/b.test.js\n" );
const todo = path . join ( dir , "todo.txt" );
fs . writeFileSync ( todo , "ok 1 - adds\nnot ok 2 - later # TODO\n" );
assert . deepEqual ( deps . readCheckLog ( jestDefault ), { names : [], known : false , outcome : "failed" });
assert . equal ( deps . readCheckLog ( todo ). outcome , "passed" );
});
2026-11-14 18:33:02 -08:00
test ( "judgeCheck and compareCheck: red before, flaky and new failures by name; a whole command when the log is unknown" , () => {
const log = ( names , outcome = names . length ? "failed" : "passed" , known = true ) => ({ names , known , outcome });
const base = ( first , retry ) => {
const j = deps . judgeCheck ( first , retry );
return { failing : j . names , flaky : j . flaky , known : j . known , commandFailed : j . commandFailed , ...( j . timeout ? { timeout : true } : {}) };
};
const red = base ( log ([ "a" ]), log ([ "a" ]));
assert . deepEqual ( red . failing , [ "a" ]);
const wobbly = base ( log ([ "b" ]), log ([]));
assert . deepEqual ([ wobbly . failing , wobbly . flaky ], [[], [ "b" ]]);
assert . deepEqual ( deps . compareCheck ( red , deps . judgeCheck ( log ([ "a" ]), log ([ "a" ]))), { newFailures : [], stillFailing : [ "a" ], flaky : [], blame : false , known : true });
assert . equal ( deps . compareCheck ( wobbly , deps . judgeCheck ( log ([ "b" ]), log ([ "b" ]))). blame , false , "flaky before never blames" );
const broke = deps . compareCheck ( red , deps . judgeCheck ( log ([ "a" , "c" ]), log ([ "a" , "c" ])));
assert . deepEqual ([ broke . newFailures , broke . blame ], [[ "c" ], true ]);
assert . equal ( deps . compareCheck ( red , deps . judgeCheck ( log ([ "c" ]), log ([]))). blame , false , "a test that fails once and passes on the retry is flaky now" );
const unknownPass = base ( log ([], "passed" , false ));
assert . equal ( deps . compareCheck ( unknownPass , deps . judgeCheck ( log ([], "failed" , false ))). blame , true , "a command that passed before and fails now" );
const unknownFail = base ( log ([], "failed" , false ));
assert . equal ( deps . compareCheck ( unknownFail , deps . judgeCheck ( log ([], "failed" , false ))). blame , false , "a command already failing as a whole" );
assert . equal ( deps . compareCheck ( red , deps . judgeCheck ( log ([], "failed" , false ))). blame , true , "a run that names no test now, after named failures before, is blamed" );
});
/* ------------------------------------------------------------ checks: commands */
const CHECKS_LOCK = "package-lock.json" ;
const TOOLS_LOCK = "tools/package-lock.json" ;
/** A run folder: the root version list with test map rows (one Shared) and a build check, and tools/ with only a confirmed command. */
function checksRun ({ records = null , pins = null , list = null } = {}) {
const lock = {
lockfile : CHECKS_LOCK ,
manifest : "package.json" ,
adapter : "npm" ,
ecosystem : "npm" ,
manager : "npm" ,
members : [ "." ],
install : "npm ci" ,
checks : {
rows : [ "App" , "Web" , "Everything" ],
commands : [ "npm test -w app" , "npm test -w web" , "npm test" ],
discovered : [],
full : true ,
list : list || [
{ id : "c1" , area : "App" , run : "npm test -w app" , paths : [ "packages/app/**" ], shared : false },
{ id : "c2" , area : "Web" , run : "npm test -w web" , paths : [ "web/**" ], shared : false },
{ id : "c3" , area : "Everything" , run : "npm test" , paths : [ "scripts/**" ], shared : true },
],
build : [{ command : "npm run build" , cwd : "." }],
},
rows : [ "a" , "b" , "c" , "d" ]. map (( p ) => ({ id : ` ${ CHECKS_LOCK } # ${ p } ` , package : p , current : "1.0.0" , target : "1.0.1" })),
held : [],
};
const tools = {
lockfile : TOOLS_LOCK ,
manifest : "tools/package.json" ,
adapter : "npm" ,
ecosystem : "npm" ,
manager : "npm" ,
members : [ "tools" ],
install : "npm ci" ,
checks : { rows : [], commands : [], discovered : [{ command : "npm run lint" , cwd : "tools" }], full : false , list : [], build : [] },
rows : [{ id : ` ${ TOOLS_LOCK } #e` , package : "e" , current : "1.0.0" , target : "1.0.1" }],
held : [],
};
const batches = [...[ "a" , "b" , "c" , "d" ]. map (( p , i ) => ({ id : `b ${ i + 1 } ` , lockfile : CHECKS_LOCK , picks : [ ` ${ CHECKS_LOCK } # ${ p } ` ] })), { id : "b5" , lockfile : TOOLS_LOCK , picks : [ ` ${ TOOLS_LOCK } #e` ] }];
const files = {
"scan.json" : { root : tmp ( "deps-checks" ), noChecks : false , lockfiles : [ lock , tools ] },
"batches.json" : { batches },
};
if ( records ) files [ "records.json" ] = records ;
if ( pins ) files [ "pins.json" ] = pins ;
return runFolder ( files );
}
test ( "checks lists every check with an id for the baseline, the Shared rows too; full is the full suite" , () => {
const r = runDeps ([ "checks" , "--run" , checksRun ()]);
assert . equal ( r . code , 0 , r . stderr );
assert . deepEqual (
r . json . checks . map (( c ) => [ c . id , c . command , c . cwd , c . kind , c . lockfile , Boolean ( c . shared )]),
[
[ "install" , "npm ci" , "." , "install" , CHECKS_LOCK , false ],
[ "c1" , "npm test -w app" , "." , "map" , CHECKS_LOCK , false ],
[ "c2" , "npm test -w web" , "." , "map" , CHECKS_LOCK , false ],
[ "c3" , "npm test" , "." , "map" , CHECKS_LOCK , true ],
[ "d1" , "npm run build" , "." , "build" , CHECKS_LOCK , false ],
[ "install-2" , "npm ci" , "tools" , "install" , TOOLS_LOCK , false ],
[ "d2" , "npm run lint" , "tools" , "discovered" , TOOLS_LOCK , false ],
],
);
assert . deepEqual ( r . json . full , [{ id : "c3" , command : "npm test" , cwd : "." , area : "Everything" }]);
});
test ( "checks --batch narrows by usedIn and pins and adds the build; a Shared row runs only when it alone covers a file" , () => {
const dir = checksRun ({
records : [
{ id : ` ${ CHECKS_LOCK } #a` , usedIn : [ "packages/app/src/x.js" ] },
{ id : ` ${ CHECKS_LOCK } #c` , usedIn : [ "tools2/y.js" ] },
{ id : ` ${ CHECKS_LOCK } #d` , usedIn : [ "scripts\\helper.mjs" , "packages/app/z.js" ] },
],
pins : { pins : [{ id : ` ${ CHECKS_LOCK } #b` , file : "web/test/pin.test.js" , line : 3 , text : "b 1.0.0" }] },
});
const a = runDeps ([ "checks" , "--run" , dir , "--batch" , "b1" ]);
assert . equal ( a . code , 0 , a . stderr );
assert . equal ( a . json . narrowed , true );
assert . deepEqual ( a . json . commands . map (( c ) => c . id ), [ "c1" , "d1" ], "the App row and the build" );
assert . deepEqual ( a . json . install , { id : "install" , command : "npm ci" , cwd : "." });
assert . deepEqual ( a . json . full . map (( c ) => c . id ), [ "c3" ], "the Shared row is left for the end" );
assert . equal ( a . json . message , null );
const b = runDeps ([ "checks" , "--run" , dir , "--batch" , "b2" ]);
assert . deepEqual ( b . json . commands . map (( c ) => c . id ), [ "c2" , "d1" ], "narrowed by the pin's file" );
const d = runDeps ([ "checks" , "--run" , dir , "--batch" , "b4" ]);
assert . deepEqual ( d . json . commands . map (( c ) => c . id ), [ "c1" , "c3" , "d1" ], "scripts/helper.mjs is covered only by the Shared row" );
assert . deepEqual ( d . json . full , [], "it ran in the group, so nothing is left for the end" );
const c = runDeps ([ "checks" , "--run" , dir , "--batch" , "b3" ]);
assert . equal ( c . json . narrowed , false );
assert . deepEqual ( c . json . commands . map (( x ) => x . id ), [ "c1" , "c2" , "d1" ]);
assert . match ( c . json . message , /No test map row covers/ );
const none = runDeps ([ "checks" , "--run" , checksRun (), "--batch" , "b1" ]);
assert . equal ( none . json . narrowed , false );
assert . match ( none . json . message , /Nothing says which files/ );
assert . ok ( ! none . json . commands . some (( x ) => x . id === "c3" ), "with other tests, not narrowed still leaves the Shared row out" );
const tools = runDeps ([ "checks" , "--run" , dir , "--batch" , "b5" ]);
assert . deepEqual ([ tools . json . commands . map (( x ) => x . id ), tools . json . install . id ], [[ "d2" ], "install-2" ], "a folder with only a confirmed command runs it" );
assert . equal ( runDeps ([ "checks" , "--run" , dir , "--batch" , "b9" ]). code , 3 , "an unknown batch" );
});
test ( "checks --batch: a pin file no narrower row covers runs the full suite in the group, narrowed or not" , () => {
const dir = checksRun ({
records : [{ id : ` ${ CHECKS_LOCK } #a` , usedIn : [ "packages/app/src/x.js" ] }],
pins : {
pins : [
{ id : ` ${ CHECKS_LOCK } #a` , file : "tests/browser.test.mjs" , line : 4 , text : "a 1.0.0" },
{ id : ` ${ CHECKS_LOCK } #c` , file : "tests/other.test.mjs" , line : 2 , text : "c 1.0.0" },
{ id : ` ${ CHECKS_LOCK } #b` , file : "web/pin.test.js" , line : 3 , text : "b 1.0.0" },
],
},
});
const narrowed = runDeps ([ "checks" , "--run" , dir , "--batch" , "b1" ]);
assert . equal ( narrowed . code , 0 , narrowed . stderr );
assert . equal ( narrowed . json . narrowed , true );
assert . deepEqual ( narrowed . json . commands . map (( c ) => c . id ), [ "c1" , "c3" , "d1" ], "the App row, then the full suite for the uncovered pin" );
assert . deepEqual ( narrowed . json . full , []);
assert . match ( narrowed . json . message , /covers tests\/browser\.test\.mjs, which names the exact version, so the full suite runs/ );
const wide = runDeps ([ "checks" , "--run" , dir , "--batch" , "b3" ]);
assert . equal ( wide . json . narrowed , false );
assert . deepEqual ( wide . json . commands . map (( c ) => c . id ), [ "c1" , "c2" , "c3" , "d1" ], "every row, plus the full suite for the pin" );
assert . match ( wide . json . message , /tests\/other\.test\.mjs/ );
const covered = runDeps ([ "checks" , "--run" , dir , "--batch" , "b2" ]);
assert . deepEqual ( covered . json . commands . map (( c ) => c . id ), [ "c2" , "d1" ], "a pin a narrower row covers changes nothing" );
assert . equal ( covered . json . message , null );
});
test ( "checks --batch: a folder whose only test is a Shared row runs it, so a group never runs without a test" , () => {
const dir = checksRun ({ list : [{ id : "c1" , area : "Everything" , run : "npm test" , paths : [ "scripts/**" ], shared : true }] });
const r = runDeps ([ "checks" , "--run" , dir , "--batch" , "b1" ]);
assert . equal ( r . code , 0 , r . stderr );
assert . equal ( r . json . narrowed , false );
assert . deepEqual ( r . json . commands . map (( c ) => c . id ), [ "c1" , "d1" ]);
assert . match ( r . json . message , /full suite is the only test/ );
assert . deepEqual ( r . json . full , []);
});
test ( "scan saves the build checks test-commands.mjs finds in each version list's folder" , () => {
const root = project ({ "package.json" : { name : "fixture-root" , private : true , engines : { node : ">=12" }, workspaces : [ "packages/*" ], scripts : { build : "tsup" , test : "node --test" }, dependencies : { chalk : "^4.1.0" , "left-pad" : "1.1.0" , semver : "^7.5.0" , mkdirp : "^0.5.5" }, overrides : { ms : "2.1.2" } } });
const { scan } = detectAndScan ( root , { npm : npmRules () }, [ "--no-audit" ]);
assert . deepEqual ( scan . lockfiles [ 0 ]. checks . build , [{ command : "npm run build" , cwd : "." }]);
assert . deepEqual ( deps . checkList ( scan )[ 0 ]. discovered , [{ id : "d1" , command : "npm run build" , cwd : "." , kind : "build" }]);
assert . equal ( deps . label ( scan , []). length > 0 , true );
});
/* ------------------------------------------------------------ checks: baseline and compare */
function logFile ( text ) {
const dir = tmp ( "deps-log" );
return write ( dir , "check.log" , text );
}
const TAP = ( fails ) => [ "TAP version 13" , "ok 1 - adds numbers" , ... fails . map (( n , i ) => `not ok ${ i + 2 } - ${ n } ` ), "" ]. join ( "\n" );
test ( "baseline records red-before and flaky tests; compare blames only tests that passed before" , () => {
const dir = checksRun ();
const b = runDeps ([ "baseline" , "--run" , dir , "--check" , "c1" , "--log" , logFile ( TAP ([ "parses dates" , "reads the clock" ])), "--outcome" , "failed" , "--retry-log" , logFile ( TAP ([ "parses dates" ])), "--retry-outcome" , "failed" ]);
assert . equal ( b . code , 0 , b . stderr );
assert . deepEqual ([ b . json . failing , b . json . flaky , b . json . known , b . json . commandFailed ], [[ "parses dates" ], [ "reads the clock" ], true , false ]);
const saved = JSON . parse ( fs . readFileSync ( path . join ( dir , "baseline.json" ), "utf8" ));
assert . deepEqual ( saved . checks . c1 . failing , [ "parses dates" ]);
const same = runDeps ([ "compare" , "--run" , dir , "--batch" , "b1" , "--check" , "c1" , "--log" , logFile ( TAP ([ "parses dates" , "reads the clock" ])), "--retry-log" , logFile ( TAP ([ "parses dates" , "reads the clock" ]))]);
assert . equal ( same . code , 0 , same . stderr );
assert . deepEqual ([ same . json . newFailures , same . json . stillFailing , same . json . flaky , same . json . blame ], [[], [ "parses dates" ], [ "reads the clock" ], false ], "red before and flaky never blame" );
const broke = runDeps ([ "compare" , "--run" , dir , "--batch" , "b1" , "--check" , "c1" , "--log" , logFile ( TAP ([ "adds more" , "parses dates" ])), "--outcome" , "failed" ]);
assert . deepEqual ([ broke . json . newFailures , broke . json . blame ], [[ "adds more" ], true ], "a test that passed before" );
const record = JSON . parse ( fs . readFileSync ( path . join ( dir , "compare.json" ), "utf8" ));
assert . equal ( record . batches . b1 . c1 . blame , true );
});
test ( "baseline and compare judge a log in an unknown format, and a timeout, by the whole command" , () => {
const dir = checksRun ();
const unknown = logFile ( logText ( "unknown.txt" ));
const pass = runDeps ([ "baseline" , "--run" , dir , "--check" , "install" , "--log" , unknown , "--outcome" , "passed" ]);
assert . equal ( pass . code , 0 , pass . stderr );
assert . deepEqual ([ pass . json . known , pass . json . commandFailed ], [ false , false ]);
const now = runDeps ([ "compare" , "--run" , dir , "--batch" , "b1" , "--check" , "install" , "--log" , unknown , "--outcome" , "failed" ]);
assert . deepEqual ([ now . json . known , now . json . blame ], [ false , true ], "passed before, fails now" );
const red = runDeps ([ "baseline" , "--run" , dir , "--check" , "d1" , "--log" , unknown , "--outcome" , "failed" ]);
assert . deepEqual ([ red . json . known , red . json . commandFailed ], [ false , true ]);
assert . equal ( runDeps ([ "compare" , "--run" , dir , "--batch" , "b1" , "--check" , "d1" , "--log" , unknown , "--outcome" , "failed" ]). json . blame , false , "already failing as a whole" );
const slow = runDeps ([ "baseline" , "--run" , dir , "--check" , "c2" , "--log" , logFile ( TAP ([])), "--outcome" , "timeout" ]);
assert . deepEqual ([ slow . json . commandFailed , slow . json . timeout , slow . json . known ], [ true , true , false ]);
});
test ( "baseline and compare: usage, a missing log, an unknown check and a check with no baseline" , () => {
const dir = checksRun ();
const log = logFile ( TAP ([]));
assert . equal ( runDeps ([ "baseline" , "--run" , dir , "--log" , log ]). json . error , "missing-check" );
assert . equal ( runDeps ([ "baseline" , "--run" , dir , "--check" , "c1" ]). json . error , "missing-log" );
const unknownCheck = runDeps ([ "baseline" , "--run" , dir , "--check" , "c9" , "--log" , log ]);
assert . equal ( unknownCheck . code , 3 );
assert . equal ( unknownCheck . json . error , "unknown-check" );
const missing = runDeps ([ "baseline" , "--run" , dir , "--check" , "c1" , "--log" , path . join ( tmp ( "deps-log" ), "nope.log" )]);
assert . equal ( missing . code , 3 );
assert . equal ( missing . json . error , "log-missing" );
const unread = runDeps ([ "baseline" , "--run" , dir , "--check" , "c1" , "--log" , logFile ( logText ( "unknown.txt" ))]);
assert . equal ( unread . code , 2 , "an unknown format needs run-check's outcome" );
assert . equal ( unread . json . error , "missing-outcome" );
assert . equal ( runDeps ([ "baseline" , "--run" , dir , "--check" , "c1" , "--log" , log , "--outcome" , "maybe" ]). json . error , "bad-outcome" );
const noBase = runDeps ([ "compare" , "--run" , dir , "--batch" , "b1" , "--check" , "c2" , "--log" , log ]);
assert . equal ( noBase . code , 3 );
assert . equal ( noBase . json . next , "Run baseline for this check first." );
});
/* ------------------------------------------------------------ runtime fit */
test ( "bestFit: the newest version that fits, none, and never one older than the current" , () => {
const versions = [
{ version : "4.1.2" , engines : ">=10" },
{ version : "5.0.0" , engines : ">=16" },
{ version : "6.0.1" , engines : ">=22" },
];
const fits = ( floor ) => ( v ) => ! v . engines || Number ( v . engines . replace ( ">=" , "" )) <= floor ;
assert . deepEqual ( deps . bestFit ({ current : "4.1.0" , versions , fits : fits ( 18 ) }), { best : "5.0.0" , needs : ">=22" });
assert . deepEqual ( deps . bestFit ({ current : "4.1.0" , versions , fits : fits ( 8 ) }), { best : null , needs : ">=22" });
assert . deepEqual ( deps . bestFit ({ current : "4.1.0" , latest : "5.0.0" , versions , fits : fits ( 18 ) }), { best : "5.0.0" , needs : null }, "latest caps the list" );
assert . deepEqual ( deps . bestFit ({ current : "5.0.0" , versions : [{ version : "4.1.2" , engines : ">=10" }, { version : "6.0.1" , engines : ">=22" }], fits : fits ( 18 ) }), { best : null , needs : ">=22" }, "an older version that fits is never offered" );
});
/** A run folder whose scan holds chalk held for the runtime, ms held by an override, and a Cargo crate held for Rust. */
function fitRun ( root ) {
const npmLock = {
lockfile : "package-lock.json" ,
manifest : "package.json" ,
adapter : "npm" ,
ecosystem : "npm" ,
manager : "npm" ,
members : [ "." , "packages/app" ],
runtime : { declared : JSON . parse ( fs . readFileSync ( path . join ( root , "package.json" ), "utf8" )). engines . node , source : "engines" , machine : "24.0.0" },
checks : { rows : [ "Root" ], discovered : [] },
rows : [],
held : [
{ id : "package-lock.json#chalk" , package : "chalk" , current : "4.1.0" , latest : "6.0.1" , reason : "every newer version needs Node >=22 (the project declares >=12)" , file : null , security : null },
{ id : "package-lock.json#ms" , package : "ms" , current : "2.1.2" , latest : "2.1.3" , reason : "held by overrides in package.json" , file : "package.json" , security : null },
],
};
const cargoLock = {
lockfile : "app/Cargo.lock" ,
manifest : "app/Cargo.toml" ,
adapter : "cargo" ,
ecosystem : "cargo" ,
manager : "cargo" ,
members : [ "app" ],
runtime : { declared : "1.70" , source : "rust-version" , machine : "1.99.1" },
checks : { rows : [], discovered : [] },
rows : [],
held : [{ id : "app/Cargo.lock#serde" , package : "serde" , current : "1.0.100" , latest : "1.0.200" , reason : "every newer version needs Rust 1.80 (the project declares 1.70)" , file : null , security : null }],
};
return runFolder ({ "scan.json" : { root , noChecks : false , lockfiles : [ npmLock , cargoLock ] } });
}
test ( "fit turns a runtime hold with a fitting version into an ordinary row that can be Safe; an override stays held; no adapter means unknown" , () => {
const root = project ();
const dir = fitRun ( root );
const r = runStubbed ([ "fit" , "--run" , dir ], stubPath ({ npm : npmRules () }));
assert . equal ( r . code , 0 , r . stderr );
const chalk = r . json . rows . find (( x ) => x . package === "chalk" );
assert . deepEqual ( chalk , { id : "package-lock.json#chalk" , package : "chalk" , current : "4.1.0" , best : "4.1.2" , needs : ">=22" , source : "registry" });
assert . deepEqual ( r . json . unknown , [ "app/Cargo.lock#serde" ]);
assert . ok ( ! r . json . rows . some (( x ) => x . package === "ms" ), "an override hold is not a runtime hold" );
const scan = JSON . parse ( fs . readFileSync ( path . join ( dir , "scan.json" ), "utf8" ));
const [ npmLock , cargoLock ] = scan . lockfiles ;
assert . deepEqual ( npmLock . held . map (( h ) => h . package ), [ "ms" ]);
const row = npmLock . rows . find (( x ) => x . package === "chalk" );
assert . equal ( row . target , "4.1.2" );
assert . equal ( row . inRange , true );
assert . deepEqual ( row . fit , { runtime : "Node" , declared : ">=12" , needs : ">=22" , latest : "6.0.1" });
const [ l ] = deps . label ( scan , [{ id : row . id , notes : "read" , breaking : [] }]);
assert . equal ( l . label , "safe" , "labeled by the same rules" );
assert . match ( l . reasonsPlain . join ( " " ), /newest version that runs on Node >=12; the latest needs Node >=22/ );
assert . equal ( cargoLock . held [ 0 ]. reason , "needs Rust 1.80 (you declare 1.70)" );
assert . equal ( cargoLock . held [ 0 ]. raise , "change `rust-version` in `app/Cargo.toml`" );
assert . deepEqual ( JSON . parse ( fs . readFileSync ( path . join ( dir , "fit.json" ), "utf8" )). unknown , [ "app/Cargo.lock#serde" ]);
});
test ( "fit: with no version that runs on the declared Node the row stays held, saying what it needs and how to raise it" , () => {
const root = project ();
const pkg = JSON . parse ( fs . readFileSync ( path . join ( root , "package.json" ), "utf8" ));
pkg . engines . node = ">=8" ;
fs . writeFileSync ( path . join ( root , "package.json" ), JSON . stringify ( pkg , null , 2 ) + "\n" );
const dir = fitRun ( root );
const r = runStubbed ([ "fit" , "--run" , dir ], stubPath ({ npm : npmRules () }));
assert . equal ( r . code , 0 , r . stderr );
assert . deepEqual ( r . json . rows . find (( x ) => x . package === "chalk" ), { id : "package-lock.json#chalk" , package : "chalk" , current : "4.1.0" , best : null , needs : ">=22" , source : "registry" });
assert . ok ( ! r . json . unknown . includes ( "package-lock.json#chalk" ), "the registry answered: none fits" );
const held = JSON . parse ( fs . readFileSync ( path . join ( dir , "scan.json" ), "utf8" )). lockfiles [ 0 ]. held . find (( h ) => h . package === "chalk" );
assert . equal ( held . reason , "needs Node >=22 (you declare >=8)" );
assert . equal ( held . raise , "change `engines.node` in `package.json`" );
});
test ( "fit: a row the scan already cut keeps its target and learns what the latest needs; a run with no scan exits 3" , () => {
const { scan , run , bin } = detectAndScan ( project (), { npm : npmRules () }, [ "--no-audit" ]);
assert . ok ( scan . lockfiles [ 0 ]. rows . find (( x ) => x . package === "chalk" ). newerNotFitting );
const r = runStubbed ([ "fit" , "--run" , run ], bin );
assert . equal ( r . code , 0 , r . stderr );
assert . deepEqual ( r . json . rows . find (( x ) => x . package === "chalk" ), { id : "package-lock.json#chalk" , package : "chalk" , current : "4.1.0" , best : "4.1.2" , needs : ">=22" , source : "registry" });
const row = JSON . parse ( fs . readFileSync ( path . join ( run , "scan.json" ), "utf8" )). lockfiles [ 0 ]. rows . find (( x ) => x . package === "chalk" );
assert . equal ( row . target , "4.1.2" );
assert . equal ( row . fit . needs , ">=22" );
const empty = runDeps ([ "fit" , "--run" , runFolder ()]);
assert . equal ( empty . code , 3 );
assert . equal ( empty . json . next , "Run scan first." );
});
test ( "fit --id --best makes the version worked out with the person a pick; a hold that is not the runtime's and a version not newer are refused" , () => {
const root = project ();
const dir = fitRun ( root );
const first = runStubbed ([ "fit" , "--run" , dir ], stubPath ({ npm : npmRules () }));
assert . deepEqual ( first . json . unknown , [ "app/Cargo.lock#serde" ]);
const r = runDeps ([ "fit" , "--run" , dir , "--id" , "app/Cargo.lock#serde" , "--best" , "1.0.150" ]);
assert . equal ( r . code , 0 , r . stderr );
assert . deepEqual ( r . json . rows , [{ id : "app/Cargo.lock#serde" , package : "serde" , current : "1.0.100" , best : "1.0.150" , needs : "1.80" , source : "agent" }]);
const scan = JSON . parse ( fs . readFileSync ( path . join ( dir , "scan.json" ), "utf8" ));
const cargo = scan . lockfiles [ 1 ];
assert . deepEqual ( cargo . held , []);
assert . equal ( cargo . rows [ 0 ]. target , "1.0.150" );
assert . deepEqual ( cargo . rows [ 0 ]. fit , { runtime : "Rust" , declared : "1.70" , needs : "1.80" , latest : "1.0.200" });
const fit = JSON . parse ( fs . readFileSync ( path . join ( dir , "fit.json" ), "utf8" ));
assert . deepEqual ( fit . unknown , []);
assert . equal ( fit . rows . find (( x ) => x . id === "app/Cargo.lock#serde" ). source , "agent" );
const override = runDeps ([ "fit" , "--run" , dir , "--id" , "package-lock.json#ms" , "--best" , "2.1.3" ]);
assert . equal ( override . code , 5 );
assert . equal ( override . json . error , "not-a-runtime-hold" );
const again = fitRun ( project ());
const older = runDeps ([ "fit" , "--run" , again , "--id" , "app/Cargo.lock#serde" , "--best" , "1.0.90" ]);
assert . equal ( older . code , 4 );
assert . equal ( older . json . error , "not-newer" );
assert . equal ( runDeps ([ "fit" , "--run" , again , "--id" , "nope#x" , "--best" , "1.0.0" ]). code , 3 );
assert . equal ( runDeps ([ "fit" , "--run" , again , "--id" , "app/Cargo.lock#serde" ]). code , 2 , "--id needs --best" );
});
test ( "fit: when the adapter cannot answer, the held reason keeps a runtime range with spaces whole" , () => {
const root = project ();
const dir = fitRun ( root );
const scan = JSON . parse ( fs . readFileSync ( path . join ( dir , "scan.json" ), "utf8" ));
scan . lockfiles [ 0 ]. held [ 0 ]. reason = "every newer version needs Node ^12.17.0 || >=16.0.0 (the project declares >=12)" ;
fs . writeFileSync ( path . join ( dir , "scan.json" ), JSON . stringify ( scan ));
const r = runStubbed ([ "fit" , "--run" , dir ], stubPath ({ git : [{ has : [ "--version" ], text : "git" }] }));
assert . equal ( r . code , 0 , r . stderr );
assert . deepEqual ( r . json . unknown , [ "package-lock.json#chalk" , "app/Cargo.lock#serde" ], "no npm on PATH: no adapter answers" );
const held = JSON . parse ( fs . readFileSync ( path . join ( dir , "scan.json" ), "utf8" )). lockfiles [ 0 ]. held . find (( h ) => h . package === "chalk" );
assert . equal ( held . reason , "needs Node ^12.17.0 || >=16.0.0 (you declare >=12)" );
});
2026-11-13 23:28:59 -08:00
test ( "no stub ever received --force or an audit fix" , () => {
const calls = stubDirs . flatMap ( callsOf );
assert . ok ( calls . length > 20 , "the stubbed tests ran first" );
for ( const c of calls ) {
assert . ok ( ! c . args . some (( a ) => /^-- force / . test ( a )), ` ${ c . tool } ${ c . args . join ( " " ) } ` );
assert . ok ( ! ( c . args . includes ( "audit" ) && c . args . includes ( "fix" )), "never audit fix" );
}
});
2026-11-14 18:33:02 -08:00
/* ------------------------------------------------------------ plain words */
// Words a person never reads (specs/deps-skill-rework/wording-audit.md). They stay in field names, commands and file names.
const AVOID = /\b(lockfiles?|manifests?|tracked|hand-?offs?|jump)\b/i ;
test ( "label: every row carries reasonsPlain, one plain sentence per reason in the same order, with no avoid-list word" , () => {
const pinned = JSON . parse ( JSON . stringify ( SCAN ));
pinned . lockfiles [ 0 ]. rows [ 0 ] = { ... pinned . lockfiles [ 0 ]. rows [ 0 ], pinned : true , security : { severity : "high" , ids : [ "X" ] }, runtimeNotChecked : ">=3.10" , couldNotRead : "npm" };
const scans = [ SCAN , pinned , { ... SCAN , noChecks : true }];
const lists = [ deps . label ( SCAN , RECORDS ), deps . label ( SCAN , []), deps . label ( pinned , RECORDS ), deps . label ( scans [ 2 ], RECORDS )];
let seen = 0 ;
for ( const labels of lists ) {
for ( const l of labels ) {
assert . ok ( Array . isArray ( l . reasonsPlain ), ` ${ l . id } has reasonsPlain` );
assert . equal ( l . reasonsPlain . length , l . reasons . length , ` ${ l . id } : reasonsPlain lines up with reasons` );
for ( const s of l . reasonsPlain ) {
seen ++ ;
assert . ok ( typeof s === "string" && s . length > 0 , ` ${ l . id } : a plain sentence` );
assert . ok ( ! AVOID . test ( s ), ` ${ l . id } : " ${ s } " uses an avoid-list word` );
assert . ok ( ! l . reasons . includes ( s ), ` ${ l . id } : " ${ s } " is not just the raw reason` );
}
}
}
assert . ok ( seen > 20 , "the fixtures exercise many reasons" );
assert . ok ( deps . label ( SCAN , []). some (( l ) => l . reasonsPlain . includes ( "I did not read the update notes" )));
assert . deepEqual ( labeled (). r1 . reasonsPlain , [ "2 files use it" ]);
});
test ( "label: reasonsPlain is printed by the label command and saved in labels.json" , () => {
const dir = runFolder ({ "scan.json" : SCAN });
const r = runDeps ([ "label" , "--run" , dir , "--records" , path . join ( FIXTURES , "label" , "records.json" )]);
assert . equal ( r . code , 0 , r . stderr );
assert . ok ( r . json . labels . length > 0 );
assert . ok ( JSON . parse ( fs . readFileSync ( path . join ( dir , "labels.json" ), "utf8" )). every (( l ) => Array . isArray ( l . reasonsPlain )));
assert . ok ( r . json . labels . every (( l ) => Array . isArray ( l . reasonsPlain ) && l . reasonsPlain . length === l . reasons . length ));
});
// The text a person reads: every double-quoted sentence in the prompt, and every multi-word string value in the notes' example cards.
function personFacing ( markdown ) {
const out = [];
for ( const m of markdown . matchAll ( /"([^"\n]*\s[^"\n]*)"/g )) out . push ( m [ 1 ]);
return out ;
}
function exampleStrings ( markdown ) {
const out = [];
const walk = ( v ) => {
if ( typeof v === "string" ) {
if ( /\s/ . test ( v )) out . push ( v );
} else if ( Array . isArray ( v )) v . forEach ( walk );
else if ( v && typeof v === "object" ) Object . values ( v ). forEach ( walk );
};
for ( const m of markdown . matchAll ( /```jsonc\n([\s\S]*?)\n```/g )) walk ( JSON . parse ( m [ 1 ]));
return out ;
}
const WHITELIST = /package-lock\.json|package\.json|requirements\.txt|pom\.xml|Cargo\.lock/g ;
test ( "the prompt and the console notes keep avoid-list words out of text a person reads" , () => {
const prompt = fs . readFileSync ( path . join ( ROOT , "src" , "plan2code-deps.md" ), "utf8" );
const notes = fs . readFileSync ( path . join ( ROOT , "src" , "web-console" , "notes" , "deps.md" ), "utf8" );
const strings = [... personFacing ( prompt ), ... exampleStrings ( notes )];
assert . ok ( strings . length > 10 , "there is person-facing text to check" );
for ( const s of strings ) {
const text = s . replace ( WHITELIST , "" ). replace ( /`[^`]*`/g , "" );
assert . ok ( ! AVOID . test ( text ), `" ${ s } " uses an avoid-list word` );
}
});
test ( "the notes no longer carry a card with the id notes, and the start card is a confirm with a Start button" , () => {
const notes = fs . readFileSync ( path . join ( ROOT , "src" , "web-console" , "notes" , "deps.md" ), "utf8" );
const items = [];
for ( const m of notes . matchAll ( /```jsonc\n([\s\S]*?)\n```/g )) items . push (...( JSON . parse ( m [ 1 ]). items || []));
assert . ok ( ! items . some (( i ) => i . id === "notes" ), "the release-notes question is gone" );
const start = items . find (( i ) => i . id === "start" );
assert . equal ( start . kind , "confirm" );
assert . equal ( start . yesLabel , "Start" );
assert . match ( start . body , /I will read what each update changes before judging it/ );
assert . ok ( ! /Release notes|skip the notes/i . test ( notes ), "no release-notes question or skip option remains" );
});
/* ------------------------------------------------------ fixes and tools */
// A fix is one approved replacement in one project file after apply; it is
// backed up into the batch's backup, so restore puts it back with the rest.
/** Every file under root (relative, forward slashes) with its bytes. */
function treeOf ( root ) {
const files = {};
const walkTree = ( dir ) => {
for ( const e of fs . readdirSync ( dir , { withFileTypes : true })) {
const abs = path . join ( dir , e . name );
if ( e . isDirectory ()) walkTree ( abs );
else files [ path . relative ( root , abs ). split ( path . sep ). join ( "/" )] = fs . readFileSync ( abs );
}
};
walkTree ( root );
return files ;
}
function assertSameTree ( root , before ) {
const now = treeOf ( root );
assert . deepEqual ( Object . keys ( now ). sort (), Object . keys ( before ). sort (), "the same files" );
for ( const [ rel , bytes ] of Object . entries ( before )) assert . ok ( now [ rel ]. equals ( bytes ), ` ${ rel } byte for byte` );
}
const PIN_TEST = 'import { test } from "node:test";\nconst BUILD = "1.64.1";\ntest("browser build", () => {\n check(BUILD);\n});\n' ;
/** A project with a test file, chalk planned, backed up and applied: ready for a fix. */
function applied ( extra = {}) {
const root = project ({ "scripts/test-browser.mjs" : PIN_TEST , ... extra });
const start = treeOf ( root );
const { run , bin , batches } = planned ( root , [ "chalk" ], {
npm : npmRules ([{ has : [ "update" , "chalk" ], writes : [{ file : "package-lock.json" , bump : { "node_modules/chalk" : "4.1.2" } }] }]),
});
const b = batches [ 0 ];
assert . equal ( runStubbed ([ "backup" , "--run" , run , "--batch" , b . id ], bin ). code , 0 );
const a = runStubbed ([ "apply" , "--run" , run , "--batch" , b . id ], bin );
assert . equal ( a . code , 0 , a . stderr );
return { root , run , bin , b , start };
}
const fixArgs = ( run , b , file , from , to ) => [ "fix" , "--run" , run , "--batch" , b . id , "--file" , file , "--from" , from , "--to" , to ];
test ( "deps --help names fix and install-tool, and the new rule for editing files" , () => {
const r = runDeps ([ "--help" ]);
for ( const command of [ "fix" , "install-tool" ]) assert . match ( r . stdout , new RegExp ( `deps\\.mjs ${ command } \\b` ), command );
assert . ok ( ! /never edits source code/ . test ( r . stdout ), "the old rule is gone" );
assert . match ( r . stdout , /only through fix, after the person approved that\s+exact change/ );
});
test ( "fix replaces the one place, backs the file up into the batch and records fixes.json" , () => {
const { root , run , bin , b } = applied ();
const r = runStubbed ( fixArgs ( run , b , "scripts/test-browser.mjs" , '"1.64.1"' , '"1.65.1"' ), bin );
assert . equal ( r . code , 0 , r . stderr );
assert . deepEqual ( r . json , { ok : true , batch : b . id , file : "scripts/test-browser.mjs" , replaced : 1 , backedUp : true });
assert . equal ( fs . readFileSync ( path . join ( root , "scripts/test-browser.mjs" ), "utf8" ), PIN_TEST . replace ( "1.64.1" , "1.65.1" ));
const backup = JSON . parse ( fs . readFileSync ( path . join ( run , "backups" , b . id , "backup.json" ), "utf8" ));
assert . deepEqual ( backup . files . at ( - 1 ), { path : "scripts/test-browser.mjs" , existed : true });
assert . deepEqual ( backup . fixed , [ "scripts/test-browser.mjs" ]);
assert . equal ( fs . readFileSync ( path . join ( run , "backups" , b . id , "files" , "scripts/test-browser.mjs" ), "utf8" ), PIN_TEST , "the as-found copy" );
const fixes = JSON . parse ( fs . readFileSync ( path . join ( run , "fixes.json" ), "utf8" )). fixes ;
assert . equal ( fixes . length , 1 );
const { at , ... rest } = fixes [ 0 ];
assert . deepEqual ( rest , { batch : b . id , file : "scripts/test-browser.mjs" , from : '"1.64.1"' , to : '"1.65.1"' });
assert . ok ( ! Number . isNaN ( Date . parse ( at )));
});
test ( "fix needs a backup and an applied batch (exit 5)" , () => {
const root = project ({ "scripts/test-browser.mjs" : PIN_TEST });
const { run , bin , batches } = planned ( root , [ "chalk" ], { npm : npmRules ([{ has : [ "update" ], text : "" }]) });
const b = batches [ 0 ];
const noBackup = runStubbed ( fixArgs ( run , b , "scripts/test-browser.mjs" , "1.64.1" , "1.65.1" ), bin );
assert . equal ( noBackup . code , 5 );
assert . equal ( noBackup . json . error , "no-backup" );
runStubbed ([ "backup" , "--run" , run , "--batch" , b . id ], bin );
const notApplied = runStubbed ( fixArgs ( run , b , "scripts/test-browser.mjs" , "1.64.1" , "1.65.1" ), bin );
assert . equal ( notApplied . code , 5 );
assert . equal ( notApplied . json . error , "not-applied" );
assert . equal ( fs . readFileSync ( path . join ( root , "scripts/test-browser.mjs" ), "utf8" ), PIN_TEST , "nothing changed" );
});
test ( "restore --verify after a fix puts LF and CRLF files back byte for byte and names the fixes" , () => {
const crlf = 'line one\r\nconst BUILD = "1.64.1";\r\nline three\r\n' ;
const { root , run , bin , b , start } = applied ({ "config/browser.txt" : crlf });
const lf = runStubbed ( fixArgs ( run , b , "scripts/test-browser.mjs" , "1.64.1" , "1.65.1" ), bin );
assert . equal ( lf . code , 0 , lf . stderr );
// A bare-LF --from spanning a line break matches the CRLF file and is written back with CRLF.
const cr = runStubbed ( fixArgs ( run , b , "config/browser.txt" , 'line one\nconst BUILD = "1.64.1";' , 'line one\nconst BUILD = "1.65.1";' ), bin );
assert . equal ( cr . code , 0 , cr . stderr );
assert . equal ( fs . readFileSync ( path . join ( root , "config/browser.txt" ), "utf8" ), crlf . replace ( "1.64.1" , "1.65.1" ), "CRLF kept" );
const r = runStubbed ([ "restore" , "--run" , run , "--batch" , b . id , "--verify" ], bin );
assert . equal ( r . code , 0 , r . stderr );
assert . equal ( r . json . verified , true );
assert . deepEqual ( r . json . fixed , [ "scripts/test-browser.mjs" , "config/browser.txt" ]);
assert . ok ( r . json . restored . includes ( "config/browser.txt" ));
assertSameTree ( root , start );
});
test ( "a second fix to the same file keeps the first as-found copy" , () => {
const { root , run , bin , b , start } = applied ();
assert . equal ( runStubbed ( fixArgs ( run , b , "scripts/test-browser.mjs" , "1.64.1" , "1.65.1" ), bin ). code , 0 );
const second = runStubbed ( fixArgs ( run , b , "scripts/test-browser.mjs" , "check(BUILD)" , "check(BUILD, true)" ), bin );
assert . equal ( second . code , 0 , second . stderr );
assert . equal ( second . json . backedUp , false );
assert . equal ( fs . readFileSync ( path . join ( run , "backups" , b . id , "files" , "scripts/test-browser.mjs" ), "utf8" ), PIN_TEST );
const backup = JSON . parse ( fs . readFileSync ( path . join ( run , "backups" , b . id , "backup.json" ), "utf8" ));
assert . equal ( backup . files . filter (( f ) => f . path === "scripts/test-browser.mjs" ). length , 1 , "listed once" );
assert . equal ( JSON . parse ( fs . readFileSync ( path . join ( run , "fixes.json" ), "utf8" )). fixes . length , 2 );
assert . equal ( runStubbed ([ "restore" , "--run" , run , "--batch" , b . id , "--verify" ], bin ). json . verified , true );
assertSameTree ( root , start );
});
test ( "after restore the group is no longer applied, so fix refuses it until apply runs again" , () => {
const { run , bin , b } = applied ();
assert . equal ( runStubbed ([ "restore" , "--run" , run , "--batch" , b . id , "--verify" ], bin ). json . verified , true );
const r = runStubbed ( fixArgs ( run , b , "scripts/test-browser.mjs" , "1.64.1" , "1.65.1" ), bin );
assert . equal ( r . code , 5 );
assert . equal ( r . json . error , "not-applied" );
});
test ( "a fixed executable keeps its mode through the put-back (macOS and Linux)" , { skip : process . platform === "win32" }, () => {
const { root , run , bin , b } = applied ();
const file = path . join ( root , "scripts/test-browser.mjs" );
fs . chmodSync ( file , 0o755 );
assert . equal ( runStubbed ( fixArgs ( run , b , "scripts/test-browser.mjs" , "1.64.1" , "1.65.1" ), bin ). code , 0 );
assert . equal ( runStubbed ([ "restore" , "--run" , run , "--batch" , b . id , "--verify" ], bin ). json . verified , true );
assert . equal ( fs . statSync ( file ). mode & 0o777 , 0o755 );
});
test ( "fix refuses a batch file, a path outside the project, a protected folder, a binary and text found twice or not at all" , () => {
const twice = "a = 1;\na = 1;\n" ;
const { root , run , bin , b } = applied ({ "src/twice.js" : twice , "node_modules/x/index.js" : "const v = 1;\n" , "specs/x/plan.md" : "v 1\n" });
fs . writeFileSync ( path . join ( root , "assets.bin" ), Buffer . from ([ 0x61 , 0x00 , 0x62 , 0x0a ]));
const before = treeOf ( root );
const cases = [
[ "package.json" , '"chalk"' , '"chalk2"' , "fix-batch-file" ],
[ "package-lock.json" , '"4.1.2"' , '"4.1.3"' , "fix-batch-file" ],
[ "packages/app/package.json" , '"is-number"' , '"is-num"' , "fix-batch-file" ],
[ "../outside.txt" , "a" , "b" , "fix-outside" ],
[ path . join ( root , "src" , "twice.js" ), "a = 1" , "a = 2" , "fix-absolute" ],
[ "node_modules/x/index.js" , "1" , "2" , "fix-protected-folder" ],
[ "specs/x/plan.md" , "1" , "2" , "fix-protected-folder" ],
[ "assets.bin" , "a" , "c" , "fix-binary" ],
[ "src/twice.js" , "a = 1;" , "a = 2;" , "fix-many" ],
[ "src/twice.js" , "b = 1;" , "b = 2;" , "fix-not-found-text" ],
[ "src/missing.js" , "a" , "b" , "fix-not-found" ],
];
for ( const [ file , from , to , error ] of cases ) {
const r = runStubbed ( fixArgs ( run , b , file , from , to ), bin );
assert . equal ( r . code , 5 , ` ${ file } : ${ r . stdout } ` );
assert . equal ( r . json . error , error , file );
assert . ok ( r . json . message && r . json . next , ` ${ file } : plain message and next` );
}
assert . match ( runStubbed ( fixArgs ( run , b , "src/twice.js" , "a = 1;" , "a = 2;" ), bin ). json . message , /appears 2 times in src\/twice\.js/ );
assertSameTree ( root , before );
const backup = JSON . parse ( fs . readFileSync ( path . join ( run , "backups" , b . id , "backup.json" ), "utf8" ));
assert . deepEqual ( backup . fixed || [], [], "nothing was backed up for a refused fix" );
assert . ok ( ! fs . existsSync ( path . join ( run , "fixes.json" )));
});
test ( "applyFix refuses a file over 1 MB" , () => {
const root = tmp ( "deps-fix-big" );
const store = tmp ( "deps-fix-store" );
fs . writeFileSync ( path . join ( store , "backup.json" ), JSON . stringify ({ files : [] }));
fs . writeFileSync ( path . join ( root , "big.txt" ), "x" . repeat ( deps . PIN_FILE_CAP + 1 ) + "\nneedle\n" );
assert . deepEqual ( deps . applyFix ( root , store , "big.txt" , "needle" , "pin" ), { ok : false , code : "too-big" , reason : "big.txt is over 1 MB" });
});
test ( "put-back stories: a batch failing after a fix, a skipped fix and a refused fix each end with the tree as found" , () => {
// Failing after a fix: the fix lands, the checks still fail, restore takes both back.
const failing = applied ();
assert . equal ( runStubbed ( fixArgs ( failing . run , failing . b , "scripts/test-browser.mjs" , "1.64.1" , "1.65.1" ), failing . bin ). code , 0 );
const r1 = runStubbed ([ "restore" , "--run" , failing . run , "--batch" , failing . b . id , "--verify" ], failing . bin );
assert . equal ( r1 . json . verified , true );
assert . deepEqual ( r1 . json . fixed , [ "scripts/test-browser.mjs" ]);
assertSameTree ( failing . root , failing . start );
// A skipped fix: no fix call, restore only.
const skipped = applied ();
const r2 = runStubbed ([ "restore" , "--run" , skipped . run , "--batch" , skipped . b . id , "--verify" ], skipped . bin );
assert . equal ( r2 . json . verified , true );
assert . deepEqual ( r2 . json . fixed , []);
assertSameTree ( skipped . root , skipped . start );
// A refused fix: nothing written, restore puts the update back.
const refused = applied ();
assert . equal ( runStubbed ( fixArgs ( refused . run , refused . b , "package.json" , '"chalk"' , '"chalk2"' ), refused . bin ). code , 5 );
const r3 = runStubbed ([ "restore" , "--run" , refused . run , "--batch" , refused . b . id , "--verify" ], refused . bin );
assert . equal ( r3 . json . verified , true );
assert . deepEqual ( r3 . json . fixed , []);
assertSameTree ( refused . root , refused . start );
});
test ( "install-tool prints a listed scanner's exact command and runs nothing; an unlisted one or an empty list exits 5" , () => {
const missingTools = [ "cargo" , { tool : "cargo-audit" , step : "audit" , install : "cargo install cargo-audit" }, { tool : "pip-audit" , step : "audit" , install : "pip install pip-audit" }];
const dir = runFolder ({ "scan.json" : { root : os . tmpdir (), lockfiles : [], missingTools } });
const before = fs . readdirSync ( dir ). sort ();
const r = runDeps ([ "install-tool" , "--run" , dir , "--tool" , "cargo-audit" ]);
assert . equal ( r . code , 0 , r . stderr );
assert . deepEqual ( r . json , { ok : true , tool : "cargo-audit" , command : "cargo install cargo-audit" , step : "audit" });
assert . deepEqual ( fs . readdirSync ( dir ). sort (), before , "nothing written" );
for ( const tool of [ "govulncheck" , "cargo" , "rm" ]) {
const no = runDeps ([ "install-tool" , "--run" , dir , "--tool" , tool ]);
assert . equal ( no . code , 5 , tool );
assert . equal ( no . json . error , "tool-not-listed" );
assert . match ( no . json . message , /was not in the scan's missing list/ );
assert . deepEqual ( no . json . offered , [ "cargo-audit" , "pip-audit" ]);
}
const empty = runFolder ({ "scan.json" : { root : os . tmpdir (), lockfiles : [], missingTools : [] } });
const none = runDeps ([ "install-tool" , "--run" , empty , "--tool" , "pip-audit" ]);
assert . equal ( none . code , 5 );
assert . match ( none . json . next , /found no missing tool/ );
assert . equal ( runDeps ([ "install-tool" , "--run" , empty ]). json . error , "missing-tool" );
});
test ( "fix refuses a batch file or protected folder named in other letter case, or reached through a link, and keeps the as-found copy" , () => {
const { root , run , bin , b , start } = applied ({ "node_modules/x/index.js" : "const v = 1;\n" });
const caseless = process . platform === "win32" || process . platform === "darwin" ;
if ( caseless ) {
for ( const [ file , from , to , error ] of [
[ "PACKAGE.JSON" , '"chalk"' , '"chalk2"' , "fix-batch-file" ],
[ "Package-Lock.json" , '"4.1.2"' , '"4.1.3"' , "fix-batch-file" ],
[ "NODE_MODULES/x/index.js" , "1" , "2" , "fix-protected-folder" ],
]) {
const r = runStubbed ( fixArgs ( run , b , file , from , to ), bin );
assert . equal ( r . code , 5 , ` ${ file } : ${ r . stdout } ` );
assert . equal ( r . json . error , error , file );
}
}
let linked = false ;
try {
fs . symlinkSync ( path . join ( root , "package.json" ), path . join ( root , "link.json" ), "file" );
linked = true ;
} catch {}
if ( linked ) {
const r = runStubbed ( fixArgs ( run , b , "link.json" , '"chalk"' , '"chalk2"' ), bin );
assert . equal ( r . code , 5 , r . stdout );
assert . equal ( r . json . error , "fix-batch-file" , "a link to a batch file is that file" );
fs . rmSync ( path . join ( root , "link.json" ));
}
const restored = runStubbed ([ "restore" , "--run" , run , "--batch" , b . id , "--verify" ], bin );
assert . equal ( restored . json . verified , true );
assertSameTree ( root , start );
});