@meza/adr-tools 1.0.12 → 2.0.1

package/src/lib/config.test.ts

@@ -0,0 +1,69 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+vi.mock('fs/promises', () => ({
+  default: {
+    access: vi.fn(),
+    readFile: vi.fn(),
+    mkdir: vi.fn()
+  }
+}));
+
+const setupModule = async (cwd: string) => {
+  vi.resetModules();
+  vi.spyOn(process, 'cwd').mockReturnValue(cwd);
+  const module = await import('./config.js');
+  return module;
+};
+
+describe('config', () => {
+  beforeEach(() => {
+    vi.mocked(fs.access).mockReset();
+    vi.mocked(fs.readFile).mockReset();
+    vi.mocked(fs.mkdir).mockReset();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('uses configured adr directory when .adr-dir exists', async () => {
+    const cwd = path.join(path.parse(process.cwd()).root, 'repo');
+    const { getDir, workingDir } = await setupModule(cwd);
+    vi.mocked(fs.access).mockResolvedValueOnce(undefined);
+    vi.mocked(fs.readFile).mockResolvedValueOnce('doc/adr');
+
+    const dir = await getDir();
+    expect(workingDir()).toEqual(cwd);
+    expect(dir).toEqual(path.join('doc', 'adr'));
+    expect(fs.mkdir).toHaveBeenCalledWith(path.join('doc', 'adr'), { recursive: true });
+  });
+
+  it('falls back to doc/adr when no config exists', async () => {
+    const cwd = path.join(path.parse(process.cwd()).root, 'repo');
+    const { getDir } = await setupModule(cwd);
+    vi.mocked(fs.access).mockRejectedValue(new Error('missing'));
+
+    const dir = await getDir();
+    expect(dir).toEqual(path.resolve(cwd, 'doc/adr'));
+    expect(fs.mkdir).toHaveBeenCalledWith(path.resolve(cwd, 'doc/adr'), { recursive: true });
+  });
+
+  it('resolves .adr-dir from a parent directory', async () => {
+    const repoRoot = path.join(path.parse(process.cwd()).root, 'repo');
+    const cwd = path.join(repoRoot, 'subdir');
+    const { getDir } = await setupModule(cwd);
+    vi.mocked(fs.access).mockImplementation(async (target) => {
+      const targetPath = typeof target === 'string' ? target : target.toString();
+      if (targetPath === path.join(repoRoot, '.adr-dir')) {
+        return;
+      }
+      throw new Error('missing');
+    });
+    vi.mocked(fs.readFile).mockResolvedValueOnce('doc/adr');
+
+    const dir = await getDir();
+    expect(dir).toEqual(path.join('..', 'doc/adr'));
+  });
+});

package/src/lib/config.ts

@@ -1,15 +1,16 @@
 import { constants } from 'fs';
-import path from 'path';
 import fs from 'fs/promises';
+import path from 'path';
 
 export const workingDir = () => process.cwd();
+const rootDir = path.parse(process.cwd()).root;
 
 const findTopLevelDir = async (dir: string): Promise<string> => {
   try {
     await fs.access(path.join(dir, '.adr-dir'), constants.F_OK);
     return dir;
   } catch (_e) {
-    if (dir === '/') {
+    if (dir === rootDir) {
       throw new Error('No ADR directory config found');
     }
     const newDir = path.join(dir, '..');

package/src/lib/links.test.ts

@@ -7,13 +7,17 @@ vi.mock('./config.js');
 vi.mock('fs/promises');
 
 describe('The link lib', () => {
+  const mockReaddir = vi.mocked(fs.readdir) as unknown as {
+    mockResolvedValueOnce: (value: string[]) => void;
+  };
+
   afterEach(() => {
     vi.resetAllMocks();
   });
 
   it('does not care if there are no matches', async () => {
     vi.mocked(getDir).mockResolvedValueOnce('/');
-    vi.mocked(fs.readdir).mockResolvedValueOnce([] as any);
+    mockReaddir.mockResolvedValueOnce([]);
     const linkString = '1:overrides:overriden by';
     const response = await getLinkDetails(linkString);
     expect(response).toEqual({
@@ -27,7 +31,7 @@ describe('The link lib', () => {
 
   it('does handles multiple matches', async () => {
     vi.mocked(getDir).mockResolvedValueOnce('/');
-    vi.mocked(fs.readdir).mockResolvedValueOnce(['1-one', '1-two', '1-three'] as any);
+    mockReaddir.mockResolvedValueOnce(['1-one', '1-two', '1-three']);
     const linkString = '1:overrides:overriden by';
     const response = await getLinkDetails(linkString);
     expect(response).toEqual({
@@ -41,7 +45,7 @@ describe('The link lib', () => {
 
   it('returns only files that match the pattern', async () => {
     vi.mocked(getDir).mockResolvedValueOnce('/');
-    vi.mocked(fs.readdir).mockResolvedValueOnce(['on1e', '1-two', 'three'] as any);
+    mockReaddir.mockResolvedValueOnce(['on1e', '1-two', 'three']);
     const linkString = '1:overrides:overriden by';
     const response = await getLinkDetails(linkString);
     expect(response).toEqual({
@@ -55,7 +59,7 @@ describe('The link lib', () => {
 
   it('handles superseding', async () => {
     vi.mocked(getDir).mockResolvedValueOnce('/');
-    vi.mocked(fs.readdir).mockResolvedValueOnce([] as any);
+    mockReaddir.mockResolvedValueOnce([]);
     const linkString = '1';
     const supersede = true;
     const response = await getLinkDetails(linkString, supersede);

package/src/lib/manipulator-errors.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it, vi } from 'vitest';
+
+vi.mock('marked', () => ({
+  marked: {
+    lexer: () => [
+      {
+        type: 'paragraph',
+        text: {
+          toString: () => 'Superseded by [1. title](0001-title.md)',
+          match: () => null
+        }
+      }
+    ]
+  }
+}));
+
+describe('The ADR manipulator error cases', () => {
+  it('throws when a link cannot be parsed', async () => {
+    const { getLinksFrom } = await import('./manipulator.js');
+    expect(() => getLinksFrom('ignored')).toThrowError('Could not parse link from');
+  });
+});

package/src/lib/manipulator.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { getLinksFrom, getTitleFrom, injectLink } from './manipulator.js';
+import { getLinksFrom, getTitleFrom, injectLink, supersede } from './manipulator.js';
 
 describe('The ADR manipulator', () => {
   const original =
@@ -64,12 +64,36 @@ describe('The ADR manipulator', () => {
     expect(test).toEqual(expected);
   });
 
+  it('throws when status section is missing for supersede', () => {
+    const noStatus = '# NUMBER. TITLE\n';
+    const test = () => supersede(noStatus, 'Superseded by [ADR 1](0001-adr.md)');
+    expect(test).toThrowError('Could not find status section');
+  });
+
+  it('throws when status section has no paragraph', () => {
+    const noStatusParagraph = '# NUMBER. TITLE\n\n## Status\n\n## Context\n';
+    const test = () => supersede(noStatusParagraph, 'Superseded by [ADR 1](0001-adr.md)');
+    expect(test).toThrowError('There is no status paragraph. Please format your adr properly');
+  });
+
+  it('replaces status paragraph when superseding', () => {
+    const markdown = '# NUMBER. TITLE\n\n## Status\n\nAccepted\n\n## Context\n';
+    const link = 'Superseded by [ADR 1](0001-adr.md)';
+    const result = supersede(markdown, link);
+    expect(result).toEqual('# NUMBER. TITLE\n\n## Status\n\nSuperseded by [ADR 1](0001-adr.md)\n\n## Context\n');
+  });
+
   it('can return the title and number', () => {
     const original = '# 2. This is the title\n';
     const test = getTitleFrom(original);
     expect(test).toEqual('2. This is the title');
   });
 
+  it('throws when main heading is missing', () => {
+    const test = () => getTitleFrom('No heading here');
+    expect(test).toThrowError('No main heading found');
+  });
+
   it('can extract links from the status section', () => {
     const original = '## Status\n' + '\n' + 'Superseded by [3. title here](and-a-link-here.md)\n';
     const extractedLink = getLinksFrom(original);

package/src/lib/numbering.test.ts

@@ -34,4 +34,12 @@ describe('The numbering logic', () => {
     const num = await newNumber();
     expect(num).toEqual(3);
   });
+
+  it('ignores non-adr filenames when deriving numbers', async () => {
+    const fakeFiles: string[] = ['notes.txt', '0005-fifth.md'];
+    vi.mocked(fs.readFile).mockRejectedValueOnce('no sequence file');
+    vi.mocked(fs.readdir as unknown as ReaddirMock).mockResolvedValueOnce(fakeFiles);
+    const num = await newNumber();
+    expect(num).toEqual(6);
+  });
 });

package/src/lib/numbering.ts

@@ -1,5 +1,5 @@
-import * as path from 'path';
 import fs from 'fs/promises';
+import * as path from 'path';
 import { getDir } from './config.js';
 
 export const newNumber = async () => {

package/src/lib/opening.test.ts

@@ -0,0 +1,96 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { chooseOpenPlan } from './adr.js';
+
+describe('chooseOpenPlan', () => {
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+  it('returns none when open is false', () => {
+    expect(chooseOpenPlan({ open: false })).toEqual({ type: 'none' });
+  });
+
+  it('treats open-with as enabling open', () => {
+    expect(chooseOpenPlan({ openWith: 'code --wait' })).toEqual({
+      type: 'app',
+      name: 'code',
+      args: ['--wait']
+    });
+  });
+
+  it('parses quoted arguments', () => {
+    expect(chooseOpenPlan({ openWith: 'code "arg with space"' })).toEqual({
+      type: 'app',
+      name: 'code',
+      args: ['arg with space']
+    });
+  });
+
+  it('unescapes quoted arguments', () => {
+    expect(chooseOpenPlan({ openWith: 'code "arg \\"quoted\\""' })).toEqual({
+      type: 'app',
+      name: 'code',
+      args: ['arg "quoted"']
+    });
+  });
+
+  it('parses single-quoted arguments', () => {
+    expect(chooseOpenPlan({ openWith: "code 'arg with space'" })).toEqual({
+      type: 'app',
+      name: 'code',
+      args: ['arg with space']
+    });
+  });
+
+  it('returns none when open-with is not parseable', () => {
+    expect(chooseOpenPlan({ openWith: '"' })).toEqual({ type: 'none' });
+  });
+
+  it('returns none when open-with is whitespace', () => {
+    expect(chooseOpenPlan({ openWith: '   ' })).toEqual({ type: 'none' });
+  });
+
+  it('returns none when open-with is only quoted whitespace', () => {
+    expect(chooseOpenPlan({ openWith: '"   "' })).toEqual({ type: 'none' });
+  });
+
+  it('handles quoted empty command', () => {
+    expect(chooseOpenPlan({ openWith: '""', open: true })).toEqual({ type: 'default' });
+  });
+
+  it('ignores boolean-like editor values', () => {
+    vi.stubEnv('VISUAL', 'true');
+    vi.stubEnv('EDITOR', 'false');
+    expect(chooseOpenPlan({ open: true })).toEqual({ type: 'default' });
+  });
+
+  it('prefers VISUAL over EDITOR when both are set', () => {
+    vi.stubEnv('VISUAL', 'code');
+    vi.stubEnv('EDITOR', 'vim');
+    expect(chooseOpenPlan({ open: true })).toEqual({ type: 'app', name: 'code', args: [] });
+  });
+
+  it('uses EDITOR when it is not npm injected', () => {
+    vi.stubEnv('EDITOR', 'vim');
+    vi.stubEnv('npm_execpath', '');
+    vi.stubEnv('npm_config_editor', '');
+    expect(chooseOpenPlan({ open: true })).toEqual({ type: 'app', name: 'vim', args: [] });
+  });
+
+  it('falls back to default when EDITOR is npm injected', () => {
+    vi.stubEnv('npm_execpath', '/usr/bin/npm');
+    vi.stubEnv('npm_config_editor', 'vi');
+    vi.stubEnv('EDITOR', 'vi');
+    vi.stubEnv('VISUAL', '');
+
+    expect(chooseOpenPlan({ open: true })).toEqual({ type: 'default' });
+  });
+
+  it('uses EDITOR when npm_config_editor is different', () => {
+    vi.stubEnv('npm_execpath', '/usr/bin/npm');
+    vi.stubEnv('npm_config_editor', 'code');
+    vi.stubEnv('EDITOR', 'vim');
+    vi.stubEnv('VISUAL', '');
+
+    expect(chooseOpenPlan({ open: true })).toEqual({ type: 'app', name: 'vim', args: [] });
+  });
+});

package/src/lib/prompt.ts

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
-import inquirer from 'inquirer';
 
 export const askForClarification = async (searchString: string, matches: string[]) => {
+  const { default: inquirer } = await import('inquirer');
   const selection = await inquirer.prompt([
     {
       type: 'list',

package/src/lib/template.test.ts

@@ -0,0 +1,74 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+vi.mock('fs/promises', () => ({
+  default: {
+    readFile: vi.fn()
+  }
+}));
+
+vi.mock('./config.js', () => ({
+  getDir: vi.fn()
+}));
+
+const mockEnv = (key: string, value: string | undefined) => {
+  if (value === undefined) {
+    delete process.env[key];
+    return;
+  }
+  process.env[key] = value;
+};
+
+describe('template', () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.mocked(fs.readFile).mockReset();
+    mockEnv('ADR_TEMPLATE', undefined);
+  });
+
+  afterEach(() => {
+    mockEnv('ADR_TEMPLATE', undefined);
+    vi.restoreAllMocks();
+  });
+
+  it('uses the explicit template file when provided', async () => {
+    const { template } = await import('./template.js');
+    vi.mocked(fs.readFile).mockResolvedValueOnce('custom');
+
+    const result = await template('/tmp/custom.md');
+    expect(result).toEqual('custom');
+    expect(fs.readFile).toHaveBeenCalledWith(path.resolve('/tmp/custom.md'), 'utf8');
+  });
+
+  it('uses ADR_TEMPLATE when set', async () => {
+    const { template } = await import('./template.js');
+    mockEnv('ADR_TEMPLATE', '/tmp/env.md');
+    vi.mocked(fs.readFile).mockResolvedValueOnce('env');
+
+    const result = await template();
+    expect(result).toEqual('env');
+    expect(fs.readFile).toHaveBeenCalledWith(path.resolve('/tmp/env.md'), 'utf8');
+  });
+
+  it('uses template from adr directory when available', async () => {
+    const { template } = await import('./template.js');
+    const { getDir } = await import('./config.js');
+    vi.mocked(getDir).mockResolvedValueOnce('/repo/doc/adr');
+    vi.mocked(fs.readFile).mockResolvedValueOnce('repo-template');
+
+    const result = await template();
+    expect(result).toEqual('repo-template');
+    expect(fs.readFile).toHaveBeenCalledWith(path.join('/repo/doc/adr', 'templates/template.md'), 'utf8');
+  });
+
+  it('falls back to built-in template when repo template is missing', async () => {
+    const { template } = await import('./template.js');
+    const { getDir } = await import('./config.js');
+    vi.mocked(getDir).mockResolvedValueOnce('/repo/doc/adr');
+    vi.mocked(fs.readFile).mockRejectedValueOnce(new Error('missing')).mockResolvedValueOnce('built-in');
+
+    const result = await template();
+    expect(result).toEqual('built-in');
+  });
+});

package/src/version.ts

@@ -1,2 +1 @@
-export const LIB_VERSION = '1.0.12';
-
+export const LIB_VERSION = '2.0.1';

package/tests/edit-on-create.e2e.test.ts

@@ -1,15 +1,32 @@
-import * as childProcess from 'child_process';
-import * as fs from 'fs';
+import * as fs from 'node:fs';
 import * as os from 'os';
 import * as path from 'path';
 /* eslint-disable no-sync */
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { createAdrCli } from './helpers/adr-cli';
+
+const waitForFile = async (filePath: string, timeoutMs: number) => {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    if (fs.existsSync(filePath)) {
+      return;
+    }
+    await new Promise((r) => setTimeout(r, 25));
+  }
+  throw new Error(`Timed out waiting for file: ${filePath}`);
+};
 
 describe('Edit new Adrs on creation', () => {
   const adr = path.resolve(path.dirname(__filename), '../src/index.ts');
-  const command = `npx tsx ${adr}`;
-  const visualHelper = path.resolve(path.dirname(__filename), './fake-visual');
-  const editorHelper = path.resolve(path.dirname(__filename), './fake-editor');
+  const cli = createAdrCli(adr);
+  const visualHelper =
+    process.platform === 'win32'
+      ? path.resolve(path.dirname(__filename), './fake-visual.cmd')
+      : path.resolve(path.dirname(__filename), './fake-visual');
+  const editorHelper =
+    process.platform === 'win32'
+      ? path.resolve(path.dirname(__filename), './fake-editor.cmd')
+      : path.resolve(path.dirname(__filename), './fake-editor');
 
   let adrDirectory: string;
   let workDir: string;
@@ -22,38 +39,52 @@ describe('Edit new Adrs on creation', () => {
   });
 
   afterEach(() => {
-    fs.rmdirSync(workDir, {
+    fs.rmSync(workDir, {
       recursive: true,
+      force: true,
       maxRetries: 3,
       retryDelay: 500
     });
   });
 
-  it('should open a new ADR in the VISUAL', () => {
-    childProcess.execSync(`VISUAL="${visualHelper}" ${command} new Example ADR`, { timeout: 10000, cwd: workDir });
+  it('should open a new ADR in the VISUAL', async () => {
+    cli.run(['new', '--open', 'Example', 'ADR'], {
+      cwd: workDir,
+      env: { VISUAL: visualHelper }
+    });
 
     const expectedNewFile: string = path.join(workDir, 'visual.out');
+    await waitForFile(expectedNewFile, 2000);
     const fileContents = fs.readFileSync(expectedNewFile, 'utf8');
-    expect(fileContents.trim()).toEqual(`VISUAL ${adrDirectory}/0001-example-adr.md`);
+    const reported = fileContents.trim().replace(/^VISUAL\s+/, '');
+    expect(path.normalize(reported)).toEqual(path.normalize(`${adrDirectory}/0001-example-adr.md`));
   });
 
-  it.skip('should open a new ADR in the EDITOR', () => {
-    childProcess.execSync(`EDITOR="${editorHelper}" ${command} new Example ADR`, { timeout: 10000, cwd: workDir });
+  it('should open a new ADR in the EDITOR', async () => {
+    cli.run(['new', '--open', 'Example', 'ADR'], {
+      cwd: workDir,
+      env: { EDITOR: editorHelper }
+    });
 
     const expectedNewFile: string = path.join(workDir, 'editor.out');
+    await waitForFile(expectedNewFile, 2000);
     const fileContents = fs.readFileSync(expectedNewFile, 'utf8');
-    expect(fileContents.trim()).toEqual(`EDITOR ${adrDirectory}/0001-example-adr.md`);
+    const reported = fileContents.trim().replace(/^EDITOR\s+/, '');
+    expect(path.normalize(reported)).toEqual(path.normalize(`${adrDirectory}/0001-example-adr.md`));
   });
 
-  it('should open a new ADR in the VISUAL if both VISUAL and EDITOR is supplied', () => {
-    childProcess.execSync(`EDITOR="${editorHelper}" VISUAL="${visualHelper}" ${command} new Example ADR`, {
-      cwd: workDir
+  it('should open a new ADR in the VISUAL if both VISUAL and EDITOR is supplied', async () => {
+    cli.run(['new', '--open', 'Example', 'ADR'], {
+      cwd: workDir,
+      env: { EDITOR: editorHelper, VISUAL: visualHelper }
     });
 
     expect(fs.existsSync(path.join(workDir, 'editor.out'))).toBeFalsy();
 
     const expectedNewFile: string = path.join(workDir, 'visual.out');
+    await waitForFile(expectedNewFile, 2000);
     const fileContents = fs.readFileSync(expectedNewFile, 'utf8');
-    expect(fileContents.trim()).toEqual(`VISUAL ${adrDirectory}/0001-example-adr.md`);
+    const reported = fileContents.trim().replace(/^VISUAL\s+/, '');
+    expect(path.normalize(reported)).toEqual(path.normalize(`${adrDirectory}/0001-example-adr.md`));
   });
 });

package/tests/fake-editor.cmd

@@ -0,0 +1,2 @@
+@echo off
+echo EDITOR %~1 > editor.out

package/tests/fake-visual.cmd

@@ -0,0 +1,2 @@
+@echo off
+echo VISUAL %~1 > visual.out

package/tests/funny-characters.e2e.test.ts

@@ -1,24 +1,25 @@
-import * as childProcess from 'child_process';
-import * as fs from 'fs';
+import * as fs from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import os from 'os';
 import * as path from 'path';
 
 /* eslint-disable no-sync */
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { createAdrCli } from './helpers/adr-cli';
 
 const __filename = fileURLToPath(import.meta.url);
 
-describe.skip('Funny Characters', () => {
+describe('Funny Characters', () => {
   const adr: string = path.resolve(path.dirname(__filename), '../src/index.ts');
-  const command = `npx tsx ${adr}`;
+  const cli = createAdrCli(adr);
 
   let adrDirectory: string;
   let workDir: string;
 
   afterEach(() => {
-    fs.rmdirSync(workDir, {
+    fs.rmSync(workDir, {
       recursive: true,
+      force: true,
       maxRetries: 3,
       retryDelay: 500
     });
@@ -27,23 +28,23 @@ describe.skip('Funny Characters', () => {
   beforeEach(() => {
     workDir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'adr-')));
     adrDirectory = path.resolve(path.join(workDir, 'doc/adr'));
-    childProcess.execSync(`${command} init ${adrDirectory}`, { timeout: 10000, cwd: workDir });
+    cli.run(['init', adrDirectory], { cwd: workDir });
   });
 
   it('should handle titles with periods in them', async () => {
-    childProcess.execSync(`${command} new Something About Node.JS`, { timeout: 10000, cwd: workDir });
+    cli.run(['new', 'Something', 'About', 'Node.JS'], { cwd: workDir });
     const expectedFile: string = path.join(adrDirectory, '0002-something-about-node-js.md');
     expect(fs.existsSync(expectedFile)).toBeTruthy();
   });
 
-  it.skip('should handle titles with slashes in them', async () => {
-    childProcess.execSync(`${command} new Slash/Slash/Slash/`, { timeout: 10000, cwd: workDir });
+  it('should handle titles with slashes in them', async () => {
+    cli.run(['new', 'Slash/Slash/Slash/'], { cwd: workDir });
     const expectedFile: string = path.join(adrDirectory, '0002-slash-slash-slash.md');
     expect(fs.existsSync(expectedFile)).toBeTruthy();
   });
 
-  it.skip('should handle titles with other weirdness in them', async () => {
-    childProcess.execSync(`${command} new -- "-Bar-"`, { timeout: 10000, cwd: workDir });
+  it('should handle titles with other weirdness in them', async () => {
+    cli.run(['new', '--', '-Bar-'], { cwd: workDir });
     const expectedFile: string = path.join(adrDirectory, '0002-bar.md');
     expect(fs.existsSync(expectedFile)).toBeTruthy();
   });

package/tests/generate-graph.e2e.test.ts

@@ -1,25 +1,25 @@
-import * as childProcess from 'child_process';
-import { realpathSync, rmdirSync } from 'node:fs';
+import { realpathSync, rmSync } from 'node:fs';
+import * as fs from 'fs/promises';
 import * as os from 'os';
 import * as path from 'path';
-import * as fs from 'fs/promises';
 /* eslint-disable no-sync */
 import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest';
+import { createAdrCli } from './helpers/adr-cli';
 
 describe('Generating Graphs', () => {
   const adr = path.resolve(path.dirname(__filename), '../src/index.ts');
-  const command = `npx tsx ${adr}`;
+  const cli = createAdrCli(adr);
   let workDir: string;
 
   beforeAll(async () => {
     // @ts-ignore
     process.env.ADR_DATE = '1992-01-12';
     workDir = path.resolve(realpathSync(await fs.mkdtemp(path.join(os.tmpdir(), 'adr-'))));
-    childProcess.execSync(`${command} init`, { timeout: 10000, cwd: workDir });
-    childProcess.execSync(`${command} new An idea that seems good at the time`, { timeout: 10000, cwd: workDir });
-    childProcess.execSync(`${command} new -s 2 A better idea`, { timeout: 10000, cwd: workDir });
-    childProcess.execSync(`${command} new This will work`, { timeout: 10000, cwd: workDir });
-    childProcess.execSync(`${command} new -s 3 The end`, { timeout: 10000, cwd: workDir });
+    cli.run(['init'], { cwd: workDir });
+    cli.run(['new', 'An', 'idea', 'that', 'seems', 'good', 'at', 'the', 'time'], { cwd: workDir });
+    cli.run(['new', '-s', '2', 'A', 'better', 'idea'], { cwd: workDir });
+    cli.run(['new', 'This', 'will', 'work'], { cwd: workDir });
+    cli.run(['new', '-s', '3', 'The', 'end'], { cwd: workDir });
   });
 
   afterEach(() => {
@@ -27,26 +27,22 @@ describe('Generating Graphs', () => {
   });
 
   afterAll(() => {
-    rmdirSync(workDir, {
+    rmSync(workDir, {
       recursive: true,
+      force: true,
       maxRetries: 3,
       retryDelay: 500
     });
   });
 
   it('should generate a graph', async () => {
-    const child = childProcess.execSync(`${command} generate graph`, { timeout: 10000, cwd: workDir });
-    const childContent = child.toString().trim();
+    const childContent = cli.run(['generate', 'graph'], { cwd: workDir });
 
     expect(childContent).toMatchSnapshot();
   });
 
   it('should generate a graph with specified route and extension ', async () => {
-    const child = childProcess.execSync(`${command} generate graph -p http://example.com/ -e .xxx`, {
-      timeout: 10000,
-      cwd: workDir
-    });
-    const childContent = child.toString().trim();
+    const childContent = cli.run(['generate', 'graph', '-p', 'http://example.com/', '-e', '.xxx'], { cwd: workDir });
 
     expect(childContent).toMatchSnapshot();
   });