wehub-resource-sync
374 lines
18 KiB
JavaScript
374 lines
18 KiB
JavaScript
#!/usr/bin/env node
|
|
|
|
/**
|
|
* followup-seed-tests.mjs — regression tests for followup-seed.mjs (#1430).
|
|
*
|
|
* Marking a tracker row Applied used to leave data/follow-ups.md untouched
|
|
* until the user ran the `followup` mode by hand — the seed step never ran on
|
|
* its own. These tests drive followup-seed.mjs's CLI (via execFileSync, like
|
|
* tracker-columns-tests.mjs) end-to-end against sandboxed fixtures, plus a few
|
|
* direct unit-level imports of the exported functions.
|
|
*
|
|
* Run: node followup-seed-tests.mjs
|
|
*/
|
|
|
|
import { execFileSync } from 'child_process';
|
|
import { readFileSync, writeFileSync, mkdtempSync, mkdirSync, rmSync } from 'fs';
|
|
import { join, dirname } from 'path';
|
|
import { tmpdir } from 'os';
|
|
import { fileURLToPath, pathToFileURL } from 'url';
|
|
import { parseNextOverrides, resolveNextOverride, normalizeStatus, addDays, parseDate } from './followup-cadence.mjs';
|
|
|
|
const ROOT = dirname(fileURLToPath(import.meta.url));
|
|
const NODE = process.execPath;
|
|
const SCRIPT = join(ROOT, 'followup-seed.mjs');
|
|
|
|
let passed = 0;
|
|
let failed = 0;
|
|
function pass(m) { console.log(`PASS ${m}`); passed++; }
|
|
function fail(m) { console.error(`FAIL ${m}`); failed++; }
|
|
|
|
function todayStr() {
|
|
return new Date().toISOString().slice(0, 10);
|
|
}
|
|
|
|
// --- sandbox helpers --------------------------------------------------------
|
|
|
|
function makeSandbox() {
|
|
const dir = mkdtempSync(join(tmpdir(), 'co-seed-'));
|
|
const tracker = join(dir, 'applications.md');
|
|
const followups = join(dir, 'follow-ups.md');
|
|
const lock = join(dir, `career-ops-followups-test-${Math.random().toString(36).slice(2)}.lock`);
|
|
return { dir, tracker, followups, lock };
|
|
}
|
|
|
|
function writeTracker(sandbox, rows) {
|
|
const header = [
|
|
'# Applications Tracker',
|
|
'',
|
|
'| # | Date | Company | Role | Score | Status | PDF | Report | Notes |',
|
|
'|---|------|---------|------|-------|--------|-----|--------|-------|',
|
|
...rows,
|
|
'',
|
|
].join('\n');
|
|
writeFileSync(sandbox.tracker, header);
|
|
}
|
|
|
|
function trackerRow(num, date, company, role, score, status, notes) {
|
|
return `| ${num} | ${date} | ${company} | ${role} | ${score} | ${status} | ❌ | — | ${notes} |`;
|
|
}
|
|
|
|
// Run followup-seed.mjs against a sandbox. Returns { code, stdout, stderr }.
|
|
function run(args, sandbox, extraEnv = {}) {
|
|
const env = {
|
|
...process.env,
|
|
CAREER_OPS_TRACKER: sandbox.tracker,
|
|
CAREER_OPS_FOLLOWUPS: sandbox.followups,
|
|
CAREER_OPS_FOLLOWUPS_LOCK: sandbox.lock,
|
|
...extraEnv,
|
|
};
|
|
try {
|
|
const stdout = execFileSync(NODE, [SCRIPT, ...args], {
|
|
cwd: ROOT, env, encoding: 'utf-8', timeout: 30000,
|
|
});
|
|
return { code: 0, stdout, stderr: '' };
|
|
} catch (e) {
|
|
return { code: e.status ?? 1, stdout: e.stdout || '', stderr: e.stderr || '' };
|
|
}
|
|
}
|
|
|
|
function cleanup(sandbox) {
|
|
rmSync(sandbox.dir, { recursive: true, force: true });
|
|
rmSync(sandbox.lock, { recursive: true, force: true });
|
|
}
|
|
|
|
// ── Test 1: round-trip — pin date derives from notes, not the tracker date column ──
|
|
{
|
|
const sb = makeSandbox();
|
|
// Tracker date column (2026-05-01) is deliberately earlier than the notes'
|
|
// "Applied 2026-06-20" — the seed must use the notes date, never the column.
|
|
writeTracker(sb, [trackerRow(1, '2026-05-01', 'Acme', 'Engineer', '4.0/5', 'Applied', 'Applied 2026-06-20. Great team.')]);
|
|
|
|
const res = run(['1', '--json'], sb);
|
|
if (res.code !== 0) {
|
|
fail(`1. round-trip seed exits 0 (got ${res.code})\n${res.stdout}${res.stderr}`);
|
|
} else {
|
|
pass('1. round-trip seed exits 0');
|
|
const content = readFileSync(sb.followups, 'utf-8');
|
|
const overrides = parseNextOverrides(content);
|
|
const override = overrides.get(1);
|
|
if (override) {
|
|
pass('1. pin parses via parseNextOverrides');
|
|
const resolved = resolveNextOverride(override, null);
|
|
const expectedNext = addDays(parseDate('2026-06-20'), 7); // default applied_first
|
|
if (resolved === expectedNext) pass(`1. resolved next date is applied-date + applied_first (${expectedNext})`);
|
|
else fail(`1. resolved next date — expected ${expectedNext}, got ${resolved}`);
|
|
if (override.setDate === todayStr()) pass('1. setDate is today');
|
|
else fail(`1. setDate — expected ${todayStr()}, got ${override.setDate}`);
|
|
} else {
|
|
fail('1. pin parses via parseNextOverrides — no override found for #1');
|
|
}
|
|
}
|
|
cleanup(sb);
|
|
}
|
|
|
|
// ── Test 2: seeded line matches OVERRIDE_RE, never starts with '|' ──────────
|
|
{
|
|
const sb = makeSandbox();
|
|
writeTracker(sb, [trackerRow(1, '2026-05-01', 'Acme', 'Engineer', '4.0/5', 'Applied', 'Applied 2026-06-20.')]);
|
|
run(['1'], sb);
|
|
const content = readFileSync(sb.followups, 'utf-8');
|
|
const lines = content.split('\n').filter(l => l.trim().startsWith('- next'));
|
|
if (lines.length === 1 && /^-\s+next\s+#\d+\s+\d{4}-\d{2}-\d{2}(\s+\(set\s+\d{4}-\d{2}-\d{2}\))?\s*$/i.test(lines[0])) {
|
|
pass('2. seeded line matches OVERRIDE_RE');
|
|
} else {
|
|
fail(`2. seeded line matches OVERRIDE_RE — got: ${JSON.stringify(lines)}`);
|
|
}
|
|
if (!lines[0]?.startsWith('|')) pass('2. seeded line does not start with |');
|
|
else fail('2. seeded line does not start with |');
|
|
cleanup(sb);
|
|
}
|
|
|
|
// ── Test 3: idempotency + --force appends a second pin (last wins) ─────────
|
|
{
|
|
const sb = makeSandbox();
|
|
writeTracker(sb, [trackerRow(1, '2026-05-01', 'Acme', 'Engineer', '4.0/5', 'Applied', 'Applied 2026-06-20.')]);
|
|
const first = run(['1', '--json'], sb);
|
|
const second = run(['1', '--json'], sb);
|
|
if (second.code === 0 && JSON.parse(second.stdout).seeded === false) {
|
|
pass('3. second seed is a no-op (seeded:false)');
|
|
} else {
|
|
fail(`3. second seed is a no-op — code ${second.code}, stdout ${second.stdout}`);
|
|
}
|
|
|
|
// Pre-existing table row for the appNum should also block seeding.
|
|
const sb2 = makeSandbox();
|
|
writeTracker(sb2, [trackerRow(2, '2026-05-01', 'Globex', 'Manager', '4.0/5', 'Applied', 'Applied 2026-06-01.')]);
|
|
const tableHeader = [
|
|
'# Follow-ups',
|
|
'',
|
|
'| num | appNum | date | company | role | channel | contact | notes |',
|
|
'|---|---|---|---|---|---|---|---|',
|
|
'| 1 | 2 | 2026-06-10 | Globex | Manager | email | recruiter@globex.com | sent |',
|
|
'',
|
|
].join('\n');
|
|
writeFileSync(sb2.followups, tableHeader);
|
|
const blocked = run(['2', '--json'], sb2);
|
|
if (blocked.code === 0 && JSON.parse(blocked.stdout).seeded === false) {
|
|
pass('3. pre-existing table row blocks seeding');
|
|
} else {
|
|
fail(`3. pre-existing table row blocks seeding — code ${blocked.code}, stdout ${blocked.stdout}`);
|
|
}
|
|
cleanup(sb2);
|
|
|
|
const forced = run(['1', '--force', '--json'], sb);
|
|
if (forced.code === 0 && JSON.parse(forced.stdout).seeded === true) {
|
|
pass('3. --force appends a fresh pin');
|
|
} else {
|
|
fail(`3. --force appends a fresh pin — code ${forced.code}, stdout ${forced.stdout}`);
|
|
}
|
|
const content = readFileSync(sb.followups, 'utf-8');
|
|
const overrides = parseNextOverrides(content);
|
|
const pinLines = content.split('\n').filter(l => l.trim().startsWith('- next #1 '));
|
|
if (pinLines.length === 2) pass('3. two pin lines now present for #1');
|
|
else fail(`3. two pin lines now present for #1 — got ${pinLines.length}`);
|
|
// parseNextOverrides keeps the LAST pin per app.
|
|
const lastPin = pinLines[pinLines.length - 1];
|
|
const lastDateMatch = lastPin.match(/#1\s+(\d{4}-\d{2}-\d{2})/);
|
|
if (overrides.get(1)?.date === lastDateMatch?.[1]) pass('3. parseNextOverrides returns the LAST pin');
|
|
else fail(`3. parseNextOverrides returns the LAST pin — got ${JSON.stringify(overrides.get(1))} vs last line ${lastPin}`);
|
|
cleanup(sb);
|
|
}
|
|
|
|
// ── Test 4: date resolution order — --date beats notes; notes beat today; column never used ──
|
|
{
|
|
const sb = makeSandbox();
|
|
// Column date is 2026-01-01 (would be very wrong if ever used).
|
|
writeTracker(sb, [trackerRow(1, '2026-01-01', 'Acme', 'Engineer', '4.0/5', 'Applied', 'Applied 2026-06-20.')]);
|
|
const withDate = run(['1', '--date', '2026-06-25', '--json'], sb);
|
|
const parsed = JSON.parse(withDate.stdout);
|
|
if (parsed.appliedDate === '2026-06-25') pass('4. --date beats notes date');
|
|
else fail(`4. --date beats notes date — got ${parsed.appliedDate}`);
|
|
if (parsed.appliedDate !== '2026-01-01') pass('4. tracker date column never used');
|
|
else fail('4. tracker date column never used — got column date');
|
|
cleanup(sb);
|
|
|
|
// Unit-level: resolveAppliedDate directly.
|
|
const mod = await import(pathToFileURL(SCRIPT).href);
|
|
const rowWithNotes = { notes: 'Applied 2026-06-20. Some other text.' };
|
|
if (mod.resolveAppliedDate(rowWithNotes, null) === '2026-06-20') pass('4. resolveAppliedDate: notes beat today (no explicit date)');
|
|
else fail('4. resolveAppliedDate: notes beat today');
|
|
if (mod.resolveAppliedDate(rowWithNotes, '2026-07-01') === '2026-07-01') pass('4. resolveAppliedDate: explicit date wins over notes');
|
|
else fail('4. resolveAppliedDate: explicit date wins over notes');
|
|
const rowNoNotes = { notes: 'no date here' };
|
|
if (mod.resolveAppliedDate(rowNoNotes, null) === todayStr()) pass('4. resolveAppliedDate: falls back to today');
|
|
else fail('4. resolveAppliedDate: falls back to today');
|
|
}
|
|
|
|
// ── Test 5: missing file gets exact canonical header; append preserves bytes ──
|
|
{
|
|
const sb = makeSandbox();
|
|
writeTracker(sb, [trackerRow(1, '2026-05-01', 'Acme', 'Engineer', '4.0/5', 'Applied', 'Applied 2026-06-20.')]);
|
|
run(['1'], sb);
|
|
const content = readFileSync(sb.followups, 'utf-8');
|
|
const expectedHeader = [
|
|
'# Follow-ups',
|
|
'',
|
|
'| num | appNum | date | company | role | channel | contact | notes |',
|
|
'|---|---|---|---|---|---|---|---|',
|
|
].join('\n');
|
|
if (content.startsWith(expectedHeader)) pass('5. missing file created with exact canonical header');
|
|
else fail(`5. missing file created with exact canonical header — got:\n${content.slice(0, 200)}`);
|
|
|
|
// Now append a second app; prior bytes (header + first pin) must be preserved exactly.
|
|
const before = readFileSync(sb.followups, 'utf-8');
|
|
writeTracker(sb, [
|
|
trackerRow(1, '2026-05-01', 'Acme', 'Engineer', '4.0/5', 'Applied', 'Applied 2026-06-20.'),
|
|
trackerRow(2, '2026-05-01', 'Globex', 'Manager', '4.0/5', 'Applied', 'Applied 2026-06-15.'),
|
|
]);
|
|
run(['2'], sb);
|
|
const after = readFileSync(sb.followups, 'utf-8');
|
|
if (after.startsWith(before)) pass('5. appending to existing file preserves prior bytes exactly');
|
|
else fail('5. appending to existing file preserves prior bytes exactly');
|
|
cleanup(sb);
|
|
}
|
|
|
|
// ── Test 6: impossible calendar date rejected ───────────────────────────────
|
|
{
|
|
const sb = makeSandbox();
|
|
writeTracker(sb, [trackerRow(1, '2026-05-01', 'Acme', 'Engineer', '4.0/5', 'Applied', 'Applied 2026-06-20.')]);
|
|
const res = run(['1', '--date', '2026-02-31'], sb);
|
|
if (res.code === 1) pass('6. --date 2026-02-31 exits 1');
|
|
else fail(`6. --date 2026-02-31 exits 1 — got ${res.code}`);
|
|
cleanup(sb);
|
|
}
|
|
|
|
// ── Test 7: non-Applied row rejected without --force, accepted with --force ──
|
|
{
|
|
const sb = makeSandbox();
|
|
writeTracker(sb, [trackerRow(1, '2026-05-01', 'Acme', 'Engineer', '4.0/5', 'Evaluated', 'no applied date yet')]);
|
|
const res = run(['1'], sb);
|
|
if (res.code === 1) pass('7. non-Applied row rejected without --force (exit 1)');
|
|
else fail(`7. non-Applied row rejected without --force — got ${res.code}`);
|
|
const forced = run(['1', '--force', '--json'], sb);
|
|
if (forced.code === 0 && JSON.parse(forced.stdout).seeded === true) pass('7. non-Applied row succeeds with --force');
|
|
else fail(`7. non-Applied row succeeds with --force — code ${forced.code}, stdout ${forced.stdout}`);
|
|
cleanup(sb);
|
|
}
|
|
|
|
// ── Test 8: --backfill seeds only unpinned Applied rows; re-run seeds 0 ────
|
|
{
|
|
const sb = makeSandbox();
|
|
writeTracker(sb, [
|
|
trackerRow(1, '2026-05-01', 'Acme', 'Engineer', '4.0/5', 'Applied', 'Applied 2026-06-01.'), // Applied, unpinned
|
|
trackerRow(2, '2026-05-01', 'Globex', 'Manager', '4.0/5', 'Applied', 'Applied 2026-06-05.'), // Applied, will be pre-pinned
|
|
trackerRow(3, '2026-05-01', 'Initech', 'Analyst', '3.0/5', 'Evaluated', 'not applied'), // Evaluated
|
|
trackerRow(4, '2026-05-01', 'Umbrella', 'Scientist', '2.0/5', 'Rejected', 'Applied 2026-04-01. rejected'), // Rejected
|
|
]);
|
|
// Pre-seed #2 with a pin so backfill must skip it.
|
|
run(['2'], sb);
|
|
|
|
const res = run(['--backfill', '--json'], sb);
|
|
if (res.code !== 0) fail(`8. --backfill exits 0 (got ${res.code})\n${res.stdout}${res.stderr}`);
|
|
else {
|
|
const parsed = JSON.parse(res.stdout);
|
|
if (parsed.seeded.length === 1 && parsed.seeded[0].appNum === 1) pass('8. --backfill seeds exactly the 1 unpinned Applied row');
|
|
else fail(`8. --backfill seeds exactly the 1 unpinned Applied row — got ${JSON.stringify(parsed.seeded)}`);
|
|
if (parsed.skipped.some(s => s.appNum === 2)) pass('8. --backfill skips the already-pinned Applied row');
|
|
else fail(`8. --backfill skips the already-pinned Applied row — got ${JSON.stringify(parsed.skipped)}`);
|
|
}
|
|
|
|
const rerun = run(['--backfill', '--json'], sb);
|
|
const rerunParsed = JSON.parse(rerun.stdout);
|
|
if (rerun.code === 0 && rerunParsed.seeded.length === 0) pass('8. re-run backfill seeds 0');
|
|
else fail(`8. re-run backfill seeds 0 — got ${JSON.stringify(rerunParsed)}`);
|
|
cleanup(sb);
|
|
}
|
|
|
|
// ── Test 9: lock held by a live pid → exit 4 ────────────────────────────────
|
|
{
|
|
const sb = makeSandbox();
|
|
writeTracker(sb, [trackerRow(1, '2026-05-01', 'Acme', 'Engineer', '4.0/5', 'Applied', 'Applied 2026-06-20.')]);
|
|
mkdirSync(sb.lock, { recursive: true });
|
|
writeFileSync(join(sb.lock, 'owner.json'), JSON.stringify({ pid: process.pid, token: 'x', startedAt: new Date().toISOString() }));
|
|
const res = run(['1'], sb, { CAREER_OPS_FOLLOWUPS_LOCK_TIMEOUT_MS: '200' });
|
|
if (res.code === 4) pass('9. lock held by live pid → exit 4');
|
|
else fail(`9. lock held by live pid → exit 4 — got ${res.code}\n${res.stdout}${res.stderr}`);
|
|
cleanup(sb);
|
|
}
|
|
|
|
// ── Test 10: stale-pin harmlessness — pin still parses after status flips to Rejected ──
|
|
{
|
|
const sb = makeSandbox();
|
|
writeTracker(sb, [trackerRow(1, '2026-05-01', 'Acme', 'Engineer', '4.0/5', 'Applied', 'Applied 2026-06-20.')]);
|
|
run(['1'], sb);
|
|
// Flip status to Rejected — the pin is inert (cadence analysis only consumes
|
|
// actionable statuses), but the pin line itself must still parse fine.
|
|
writeTracker(sb, [trackerRow(1, '2026-05-01', 'Acme', 'Engineer', '4.0/5', 'Rejected', 'Applied 2026-06-20. rejected after onsite')]);
|
|
const content = readFileSync(sb.followups, 'utf-8');
|
|
const overrides = parseNextOverrides(content);
|
|
if (overrides.has(1)) pass('10. stale pin still parses via parseNextOverrides');
|
|
else fail('10. stale pin still parses via parseNextOverrides');
|
|
if (normalizeStatus('Rejected') === 'rejected') pass('10. normalizeStatus(Rejected) === rejected (not actionable)');
|
|
else fail(`10. normalizeStatus(Rejected) — got ${normalizeStatus('Rejected')}`);
|
|
cleanup(sb);
|
|
}
|
|
|
|
// ── Test 11: impossible "Applied" date in notes → INVALID_DATE, no garbage pin ──
|
|
{
|
|
const sb = makeSandbox();
|
|
writeTracker(sb, [trackerRow(1, '2026-05-01', 'Acme', 'Engineer', '4.0/5', 'Applied', 'Applied 2026-02-31. Bad date.')]);
|
|
const res = run(['1', '--json'], sb);
|
|
if (res.code === 1) pass('11. impossible notes date → exit 1');
|
|
else fail(`11. impossible notes date → exit 1 — got ${res.code}\n${res.stdout}${res.stderr}`);
|
|
if ((res.stdout + res.stderr).includes('impossible')) pass('11. error names the invalid date problem');
|
|
else fail(`11. error names the invalid date problem — got\n${res.stdout}${res.stderr}`);
|
|
// An explicit valid --date must rescue the row (notes date is skipped entirely).
|
|
const rescued = run(['1', '--date', '2026-06-20', '--json'], sb);
|
|
let rescuedOk = false;
|
|
try { rescuedOk = rescued.code === 0 && JSON.parse(rescued.stdout).seeded === true; } catch { /* fall through */ }
|
|
if (rescuedOk) pass('11. explicit --date rescues a row with bad notes date');
|
|
else fail(`11. explicit --date rescues — got code ${rescued.code}\n${rescued.stdout}${rescued.stderr}`);
|
|
cleanup(sb);
|
|
}
|
|
|
|
// ── Test 12: backfill skips (not aborts on) a row with an impossible notes date ──
|
|
{
|
|
const sb = makeSandbox();
|
|
writeTracker(sb, [
|
|
trackerRow(1, '2026-05-01', 'Acme', 'Engineer', '4.0/5', 'Applied', 'Applied 2026-02-31. Bad date.'),
|
|
trackerRow(2, '2026-05-02', 'Globex', 'Engineer', '4.2/5', 'Applied', 'Applied 2026-06-20.'),
|
|
]);
|
|
const res = run(['--backfill', '--json'], sb);
|
|
if (res.code === 0) pass('12. backfill with one bad-notes row exits 0');
|
|
else fail(`12. backfill with one bad-notes row exits 0 — got ${res.code}\n${res.stdout}${res.stderr}`);
|
|
try {
|
|
const out = JSON.parse(res.stdout);
|
|
if (out.seeded.length === 1 && out.seeded[0].appNum === 2) pass('12. good row still seeded');
|
|
else fail(`12. good row still seeded — got ${JSON.stringify(out.seeded)}`);
|
|
if (out.skipped.length === 1 && out.skipped[0].appNum === 1 && out.skipped[0].reason === 'invalid-notes-date') {
|
|
pass('12. bad row skipped with reason invalid-notes-date');
|
|
} else {
|
|
fail(`12. bad row skipped with reason invalid-notes-date — got ${JSON.stringify(out.skipped)}`);
|
|
}
|
|
} catch (e) {
|
|
fail(`12. backfill JSON parses — ${e.message}\n${res.stdout}`);
|
|
}
|
|
cleanup(sb);
|
|
}
|
|
|
|
// ── Test 13: --date combined with --backfill is a usage error ──
|
|
{
|
|
const sb = makeSandbox();
|
|
writeTracker(sb, [trackerRow(1, '2026-05-01', 'Acme', 'Engineer', '4.0/5', 'Applied', 'Applied 2026-06-20.')]);
|
|
const res = run(['--backfill', '--date', '2026-06-20'], sb);
|
|
if (res.code === 1) pass('13. --backfill --date → exit 1');
|
|
else fail(`13. --backfill --date → exit 1 — got ${res.code}\n${res.stdout}${res.stderr}`);
|
|
if (res.stderr.includes('--date cannot be combined with --backfill')) pass('13. usage error explains the rejection');
|
|
else fail(`13. usage error explains the rejection — got\n${res.stderr}`);
|
|
cleanup(sb);
|
|
}
|
|
|
|
console.log(`\n${passed} passed, ${failed} failed`);
|
|
process.exit(failed > 0 ? 1 : 0);
|