test(coverage): add integration tests for all user stories (#190)

Step 0 — infra fixes:
- read-templates: add afterEach to restore journal.scopes after suite
- phase1-regression: use fixed past date to avoid midnight-brittle offset
- week-input: drop moment().week() calls; assert valid range and relative
  offset to survive year-rollover week 52→1
- notes-sync: capture last editor text and include in timeout message

Steps 1–7 — new and extended suites (happy + error path per story):
- codeaction-tasks.test.ts: OpenTaskActions and CompletedTaskActions
  provideCodeActions → WorkspaceEdit round-trip; non-matching lines
  return empty
- commands-inject.test.ts: Inject.injectInput for memo and task; empty
  text returns early with no error logged
- commands-note.test.ts: ShowNoteCommand creates note file; cancelled
  input triggers showError
- commands-weekly.test.ts: Reader.loadEntryForWeek creates and preserves
  weekly file; week 0 handled gracefully
- commands-entry.test.ts: real-FS suite for today/yesterday/tomorrow
  commands; reader-throws path triggers showError
- commands-prev-next.test.ts: scoped navigation helper-layer tests via
  findAdjacentEntry with explicit Anchor; verifies scope isolation and
  null result at history start; this.slow() thresholds throughout
- commands-print.test.ts: error paths for non-numeric sum and
  single-cursor duration

Performance: this.slow(ms) set on each new suite so CI output flags
slow tests without hard-failing on timing.

#190

Author: pajoma

src/test/suite/codeaction-tasks.test.ts

@@ -0,0 +1,102 @@
+import * as assert from 'assert';
+import * as vscode from 'vscode';
+import { OpenTaskActions } from '../../provider/codeactions/for-open-tasks';
+import { CompletedTaskActions } from '../../provider/codeactions/for-completed-tasks';
+import * as J from '../..';
+import { createMockCtrl, openEditor } from './command-test-helpers';
+
+function makeRange(line: number, startChar: number, endChar: number): vscode.Range {
+    return new vscode.Range(line, startChar, line, endChar);
+}
+
+function makeContext(): vscode.CodeActionContext {
+    return {
+        diagnostics: [],
+        only: undefined,
+        triggerKind: vscode.CodeActionTriggerKind.Invoke
+    };
+}
+
+suite('Code actions — task state transitions', function () {
+    this.slow(3000);
+
+    suite('OpenTaskActions (open → completed)', () => {
+        test('happy: open-task line returns Complete action; applying edit marks [x] + timestamp', async () => {
+            const editor = await openEditor('- [ ] write tests\n');
+            const doc = editor.document;
+            const line = doc.lineAt(0);
+            const range = makeRange(0, 0, line.text.length);
+            const token = new vscode.CancellationTokenSource().token;
+            const ctrl = createMockCtrl({
+                config: {
+                    getTaskInlineTemplate: async () => ({ template: '- [ ] ${input}', value: '- [ ] ${input}' } as J.Model.InlineTemplate),
+                    getTimeStringTemplate: async () => ({ value: '12:34' } as J.Model.ScopedTemplate),
+                    getBasePath: () => '/tmp/journal-tests',
+                    getBasePathForLocalOpen: () => '/tmp/journal-tests'
+                }
+            });
+
+            const provider = new OpenTaskActions(ctrl);
+            const actions = await provider.provideCodeActions(doc, range, makeContext(), token) as vscode.CodeAction[];
+
+            assert.ok(Array.isArray(actions) && actions.length > 0, 'expected at least one action');
+            const completeAction = actions[0];
+            assert.ok(completeAction.edit, 'action must have a WorkspaceEdit');
+
+            await vscode.workspace.applyEdit(completeAction.edit!);
+
+            const updated = doc.getText();
+            assert.ok(updated.includes('[x]'), `expected [x] in: ${updated}`);
+            assert.ok(updated.includes('done:'), `expected done: timestamp in: ${updated}`);
+        });
+
+        test('error: non-task line returns no actions', async () => {
+            const editor = await openEditor('# Just a heading\n');
+            const doc = editor.document;
+            const range = makeRange(0, 0, doc.lineAt(0).text.length);
+            const token = new vscode.CancellationTokenSource().token;
+            const ctrl = createMockCtrl();
+
+            const provider = new OpenTaskActions(ctrl);
+            const result = await provider.provideCodeActions(doc, range, makeContext(), token);
+
+            assert.ok(!result || (Array.isArray(result) && result.length === 0), 'expected no actions for non-task line');
+        });
+    });
+
+    suite('CompletedTaskActions (completed → open)', () => {
+        test('happy: completed-task line returns Reopen action; applying edit restores [ ] and strips annotation', async () => {
+            const editor = await openEditor('- [x] write tests (done: 2026-05-15 10:00)\n');
+            const doc = editor.document;
+            const range = makeRange(0, 0, doc.lineAt(0).text.length);
+            const token = new vscode.CancellationTokenSource().token;
+            const ctrl = createMockCtrl();
+
+            const provider = new CompletedTaskActions(ctrl);
+            const actions = await provider.provideCodeActions(doc, range, makeContext(), token) as vscode.CodeAction[];
+
+            assert.ok(Array.isArray(actions) && actions.length > 0, 'expected at least one action');
+            const reopenAction = actions[0];
+            assert.ok(reopenAction.edit, 'action must have a WorkspaceEdit');
+
+            await vscode.workspace.applyEdit(reopenAction.edit!);
+
+            const updated = doc.getText();
+            assert.ok(updated.includes('[ ]'), `expected [ ] in: ${updated}`);
+            assert.ok(!updated.includes('done:'), `expected done: annotation removed, got: ${updated}`);
+        });
+
+        test('error: open-task line returns no actions', async () => {
+            const editor = await openEditor('- [ ] still open\n');
+            const doc = editor.document;
+            const range = makeRange(0, 0, doc.lineAt(0).text.length);
+            const token = new vscode.CancellationTokenSource().token;
+            const ctrl = createMockCtrl();
+
+            const provider = new CompletedTaskActions(ctrl);
+            const result = await provider.provideCodeActions(doc, range, makeContext(), token);
+
+            assert.ok(!result || (Array.isArray(result) && result.length === 0), 'expected no actions for open-task line');
+        });
+    });
+});

src/test/suite/commands-entry.test.ts

@@ -1,11 +1,25 @@
 import * as assert from 'assert';
+import * as os from 'os';
+import * as path from 'path';
 import * as vscode from 'vscode';
 import * as J from '../..';
 import { ShowEntryForInputCommand } from '../../provider/commands/show-entry-for-input';
 import { ShowEntryForTodayCommand } from '../../provider/commands/show-entry-for-today';
 import { ShowEntryForTomorrowCommand } from '../../provider/commands/show-entry-for-tomorrow';
 import { ShowEntryForYesterdayCommand } from '../../provider/commands/show-entry-for-yesterday';
 import { createMockCtrl, tick } from './command-test-helpers';
+import { TestLogger } from '../test-logger';
+import { fileExists } from '../../util/fs-exists';
+
+async function buildCtrl(tmpBase: string): Promise<{ ctrl: J.Util.Ctrl; logger: TestLogger }> {
+    const config = vscode.workspace.getConfiguration('journal');
+    await config.update('base', tmpBase, vscode.ConfigurationTarget.Workspace);
+    const refreshed = vscode.workspace.getConfiguration('journal');
+    const ctrl = new J.Util.Ctrl(refreshed);
+    const logger = new TestLogger(false);
+    ctrl.logger = logger;
+    return { ctrl, logger };
+}
 
 suite('Command suites - entry commands', () => {
     test('exposes command metadata for entry command classes', async () => {
@@ -187,3 +201,87 @@ suite('Command suites - entry commands', () => {
         }
     });
 });
+
+suite('Entry commands — real filesystem', function () {
+    this.slow(8000);
+
+    let originalBase: string | undefined;
+    let tmpBase: string;
+    let ctrl: J.Util.Ctrl;
+    let logger: TestLogger;
+
+    setup(async () => {
+        const config = vscode.workspace.getConfiguration('journal');
+        originalBase = config.get<string>('base');
+        tmpBase = path.join(os.tmpdir(), `entry-real-${Date.now()}`);
+        await vscode.workspace.fs.createDirectory(vscode.Uri.file(tmpBase));
+        ({ ctrl, logger } = await buildCtrl(tmpBase));
+        (ctrl.ui as any).showDocument = async (_doc: vscode.TextDocument) => undefined;
+    });
+
+    teardown(async () => {
+        const config = vscode.workspace.getConfiguration('journal');
+        await config.update('base', originalBase, vscode.ConfigurationTarget.Workspace);
+        await vscode.commands.executeCommand('workbench.action.closeAllEditors');
+        try { await vscode.workspace.fs.delete(vscode.Uri.file(tmpBase), { recursive: true }); } catch { /* ignore */ }
+    });
+
+    test('happy: ShowEntryForTodayCommand creates today\'s entry file', async () => {
+        const input = new J.Model.Input(0);
+        const cmd = new (ShowEntryForTodayCommand as any)(ctrl) as ShowEntryForTodayCommand;
+        await cmd.execute(input);
+
+        const today = new Date();
+        const year = String(today.getFullYear());
+        const month = String(today.getMonth() + 1).padStart(2, '0');
+        const day = String(today.getDate()).padStart(2, '0');
+        const expected = vscode.Uri.file(path.join(tmpBase, year, month, `${day}.md`));
+
+        assert.ok(await fileExists(expected), `today's entry should exist at ${expected.fsPath}`);
+        assert.strictEqual(logger.errors.length, 0, `unexpected errors: ${JSON.stringify(logger.errors)}`);
+    });
+
+    test('happy: ShowEntryForYesterdayCommand creates yesterday\'s entry file', async () => {
+        const input = new J.Model.Input(-1);
+        const cmd = new (ShowEntryForYesterdayCommand as any)(ctrl) as ShowEntryForYesterdayCommand;
+        await cmd.execute(input);
+
+        const yesterday = new Date();
+        yesterday.setDate(yesterday.getDate() - 1);
+        const year = String(yesterday.getFullYear());
+        const month = String(yesterday.getMonth() + 1).padStart(2, '0');
+        const day = String(yesterday.getDate()).padStart(2, '0');
+        const expected = vscode.Uri.file(path.join(tmpBase, year, month, `${day}.md`));
+
+        assert.ok(await fileExists(expected), `yesterday's entry should exist at ${expected.fsPath}`);
+        assert.strictEqual(logger.errors.length, 0, `unexpected errors: ${JSON.stringify(logger.errors)}`);
+    });
+
+    test('happy: ShowEntryForTomorrowCommand creates tomorrow\'s entry file', async () => {
+        const input = new J.Model.Input(1);
+        const cmd = new (ShowEntryForTomorrowCommand as any)(ctrl) as ShowEntryForTomorrowCommand;
+        await cmd.execute(input);
+
+        const tomorrow = new Date();
+        tomorrow.setDate(tomorrow.getDate() + 1);
+        const year = String(tomorrow.getFullYear());
+        const month = String(tomorrow.getMonth() + 1).padStart(2, '0');
+        const day = String(tomorrow.getDate()).padStart(2, '0');
+        const expected = vscode.Uri.file(path.join(tmpBase, year, month, `${day}.md`));
+
+        assert.ok(await fileExists(expected), `tomorrow's entry should exist at ${expected.fsPath}`);
+        assert.strictEqual(logger.errors.length, 0, `unexpected errors: ${JSON.stringify(logger.errors)}`);
+    });
+
+    test('error: reader throws — showError is called', async () => {
+        let errorCalled = false;
+        (ctrl.reader as any).loadEntryForInput = async () => { throw new Error('simulated reader failure'); };
+        (ctrl.ui as any).showError = async (_msg: string) => { errorCalled = true; };
+
+        const input = new J.Model.Input(0);
+        const cmd = new (ShowEntryForTodayCommand as any)(ctrl) as ShowEntryForTodayCommand;
+        await cmd.execute(input);
+
+        assert.ok(errorCalled, 'expected showError to be called when reader throws');
+    });
+});

src/test/suite/commands-inject.test.ts

@@ -0,0 +1,88 @@
+import * as assert from 'assert';
+import * as os from 'os';
+import * as path from 'path';
+import * as vscode from 'vscode';
+import * as J from '../..';
+import { TestLogger } from '../test-logger';
+
+async function buildCtrl(tmpBase: string): Promise<{ ctrl: J.Util.Ctrl; logger: TestLogger }> {
+    const config = vscode.workspace.getConfiguration('journal');
+    await config.update('base', tmpBase, vscode.ConfigurationTarget.Workspace);
+    const refreshed = vscode.workspace.getConfiguration('journal');
+    const ctrl = new J.Util.Ctrl(refreshed);
+    const logger = new TestLogger(false);
+    ctrl.logger = logger;
+    return { ctrl, logger };
+}
+
+suite('Inject — memo and task insertion', function () {
+    this.slow(5000);
+
+    let originalBase: string | undefined;
+    let tmpBase: string;
+    let ctrl: J.Util.Ctrl;
+    let logger: TestLogger;
+
+    setup(async () => {
+        const config = vscode.workspace.getConfiguration('journal');
+        originalBase = config.get<string>('base');
+        tmpBase = path.join(os.tmpdir(), `inject-base-${Date.now()}`);
+        await vscode.workspace.fs.createDirectory(vscode.Uri.file(tmpBase));
+        ({ ctrl, logger } = await buildCtrl(tmpBase));
+    });
+
+    teardown(async () => {
+        const config = vscode.workspace.getConfiguration('journal');
+        await config.update('base', originalBase, vscode.ConfigurationTarget.Workspace);
+        await vscode.commands.executeCommand('workbench.action.closeAllEditors');
+        try { await vscode.workspace.fs.delete(vscode.Uri.file(tmpBase), { recursive: true }); } catch { /* ignore */ }
+    });
+
+    test('happy: memo text is injected into today\'s entry', async () => {
+        const doc = await ctrl.reader.loadEntryForDay(new Date());
+        assert.ok(doc, 'expected today\'s entry document');
+
+        const input = new J.Model.Input(0);
+        input.flags = 'memo';
+        input.text = 'lorem ipsum memo';
+
+        await ctrl.inject.injectInput(doc, input);
+
+        // applyEdit modifies the in-memory document; getText() reflects the change without a disk save
+        const content = doc.getText();
+        assert.ok(content.includes('lorem ipsum memo'), `memo not found in entry. Content: ${content}`);
+        assert.strictEqual(logger.errors.length, 0, `unexpected errors: ${JSON.stringify(logger.errors)}`);
+    });
+
+    test('happy: task text is injected into today\'s entry', async () => {
+        const doc = await ctrl.reader.loadEntryForDay(new Date());
+        assert.ok(doc, 'expected today\'s entry document');
+
+        const input = new J.Model.Input(0);
+        input.flags = 'task';
+        input.text = 'implement something';
+
+        await ctrl.inject.injectInput(doc, input);
+
+        const content = doc.getText();
+        assert.ok(content.includes('implement something'), `task text not found in entry. Content: ${content}`);
+        assert.ok(content.includes('[]') || content.includes('[ ]'), `task bullet not found in entry. Content: ${content}`);
+        assert.strictEqual(logger.errors.length, 0, `unexpected errors: ${JSON.stringify(logger.errors)}`);
+    });
+
+    test('error: empty memo text — injectInput returns early, no error logged, doc unchanged', async () => {
+        const doc = await ctrl.reader.loadEntryForDay(new Date());
+        const contentBefore = doc.getText();
+
+        const input = new J.Model.Input(0);
+        // hasMemo() requires text.length > 0 — empty text causes early return
+        input.flags = 'memo';
+        input.text = '';
+
+        const result = await ctrl.inject.injectInput(doc, input);
+
+        assert.ok(result, 'injectInput should return the document');
+        assert.strictEqual(logger.errors.length, 0, `unexpected errors: ${JSON.stringify(logger.errors)}`);
+        assert.strictEqual(result.getText(), contentBefore, 'document should be unchanged for empty memo');
+    });
+});

src/test/suite/commands-note.test.ts

@@ -0,0 +1,69 @@
+import * as assert from 'assert';
+import * as os from 'os';
+import * as path from 'path';
+import * as vscode from 'vscode';
+import * as J from '../..';
+import { ShowNoteCommand } from '../../provider/commands/show-note';
+import { TestLogger } from '../test-logger';
+import { fileExists } from '../../util/fs-exists';
+
+async function buildCtrl(tmpBase: string): Promise<{ ctrl: J.Util.Ctrl; logger: TestLogger }> {
+    const config = vscode.workspace.getConfiguration('journal');
+    await config.update('base', tmpBase, vscode.ConfigurationTarget.Workspace);
+    const refreshed = vscode.workspace.getConfiguration('journal');
+    const ctrl = new J.Util.Ctrl(refreshed);
+    const logger = new TestLogger(false);
+    ctrl.logger = logger;
+    return { ctrl, logger };
+}
+
+suite('ShowNoteCommand — note creation', function () {
+    this.slow(5000);
+
+    let originalBase: string | undefined;
+    let tmpBase: string;
+    let ctrl: J.Util.Ctrl;
+    let logger: TestLogger;
+
+    setup(async () => {
+        const config = vscode.workspace.getConfiguration('journal');
+        originalBase = config.get<string>('base');
+        tmpBase = path.join(os.tmpdir(), `note-base-${Date.now()}`);
+        await vscode.workspace.fs.createDirectory(vscode.Uri.file(tmpBase));
+        ({ ctrl, logger } = await buildCtrl(tmpBase));
+    });
+
+    teardown(async () => {
+        const config = vscode.workspace.getConfiguration('journal');
+        await config.update('base', originalBase, vscode.ConfigurationTarget.Workspace);
+        await vscode.commands.executeCommand('workbench.action.closeAllEditors');
+        try { await vscode.workspace.fs.delete(vscode.Uri.file(tmpBase), { recursive: true }); } catch { /* ignore */ }
+    });
+
+    test('happy: note file is created and shown when user provides a title', async () => {
+        let shownDoc: vscode.TextDocument | undefined;
+        (ctrl.ui as any).getUserInput = async (_tip: string) => 'my test note';
+        (ctrl.ui as any).showDocument = async (doc: vscode.TextDocument) => {
+            shownDoc = doc;
+            return undefined;
+        };
+
+        const cmd = new (ShowNoteCommand as any)(ctrl) as ShowNoteCommand;
+        await cmd.execute();
+
+        assert.ok(shownDoc, 'expected showDocument to be called');
+        assert.ok(await fileExists(shownDoc!.uri), `note file should exist at ${shownDoc!.uri.fsPath}`);
+        assert.strictEqual(logger.errors.length, 0, `unexpected errors: ${JSON.stringify(logger.errors)}`);
+    });
+
+    test('error: showError called when getUserInput throws (user cancels)', async () => {
+        let errorCalled = false;
+        (ctrl.ui as any).getUserInput = async (_tip: string) => { throw new Error('user cancelled'); };
+        (ctrl.ui as any).showError = async (_msg: string) => { errorCalled = true; };
+
+        const cmd = new (ShowNoteCommand as any)(ctrl) as ShowNoteCommand;
+        await cmd.execute();
+
+        assert.ok(errorCalled, 'expected showError to be called on cancellation');
+    });
+});