relay-ide 0.1.0

package/dist/test/integration-github.test.js

@@ -0,0 +1,220 @@
+import { test, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import express from 'express';
+import { createIntegrationGitHubRouter, } from '../server/integration-github.js';
+import { saveConfig, DEFAULTS } from '../server/config.js';
+let tmpDir;
+let configPath;
+let server;
+let baseUrl;
+const WORKSPACE_PATH_A = '/fake/workspace/repo-a';
+const WORKSPACE_PATH_B = '/fake/workspace/repo-b';
+/**
+ * Builds a minimal GhIssueItem for use in mock stdout payloads.
+ */
+function makeIssueItem(overrides) {
+    const { number = 1, title = 'Test Issue', url = `https://github.com/fake/repo/issues/${overrides.number ?? 1}`, updatedAt = '2026-03-21T00:00:00Z', createdAt = '2026-03-20T00:00:00Z', } = overrides;
+    return {
+        number,
+        title,
+        url,
+        state: 'OPEN',
+        labels: [],
+        assignees: [],
+        createdAt,
+        updatedAt,
+    };
+}
+/**
+ * Creates a mock execAsync that routes calls based on the command and cwd.
+ * - `gh issue list` in a given cwd → returns configured issues list or throws
+ */
+function makeMockExec(opts) {
+    return async (cmd, args, options) => {
+        const command = cmd;
+        const argv = args;
+        const cwd = options.cwd ?? '';
+        if (command === 'gh' && argv[0] === 'issue' && argv[1] === 'list') {
+            if (opts.globalError)
+                throw opts.globalError;
+            if (opts.errorByPath?.[cwd])
+                throw opts.errorByPath[cwd];
+            const items = opts.issuesByPath?.[cwd] ?? [];
+            return { stdout: JSON.stringify(items), stderr: '' };
+        }
+        throw new Error(`Unexpected exec call: ${command} ${argv.join(' ')}`);
+    };
+}
+function startServer(execAsyncFn) {
+    return new Promise((resolve) => {
+        const app = express();
+        app.use(express.json());
+        const deps = {
+            configPath,
+            execAsync: execAsyncFn,
+        };
+        app.use('/integration-github', createIntegrationGitHubRouter(deps));
+        server = app.listen(0, '127.0.0.1', () => {
+            const addr = server.address();
+            if (typeof addr === 'object' && addr) {
+                baseUrl = `http://127.0.0.1:${addr.port}`;
+            }
+            resolve();
+        });
+    });
+}
+function stopServer() {
+    return new Promise((resolve) => {
+        if (server)
+            server.close(() => resolve());
+        else
+            resolve();
+    });
+}
+async function getIssues() {
+    const res = await fetch(`${baseUrl}/integration-github/issues`);
+    return res.json();
+}
+before(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'integration-github-test-'));
+    configPath = path.join(tmpDir, 'config.json');
+});
+after(async () => {
+    await stopServer();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+test('returns issues from all workspace repos merged and sorted', async () => {
+    await stopServer();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        repos: [WORKSPACE_PATH_A, WORKSPACE_PATH_B],
+    });
+    const exec = makeMockExec({
+        issuesByPath: {
+            [WORKSPACE_PATH_A]: [
+                makeIssueItem({
+                    number: 10,
+                    title: 'Issue A',
+                    updatedAt: '2026-03-21T10:00:00Z',
+                }),
+                makeIssueItem({
+                    number: 11,
+                    title: 'Issue A2',
+                    updatedAt: '2026-03-19T10:00:00Z',
+                }),
+            ],
+            [WORKSPACE_PATH_B]: [
+                makeIssueItem({
+                    number: 20,
+                    title: 'Issue B',
+                    updatedAt: '2026-03-20T10:00:00Z',
+                }),
+            ],
+        },
+    });
+    await startServer(exec);
+    const data = await getIssues();
+    assert.equal(data.error, undefined, `Unexpected error: ${data.error}`);
+    assert.equal(data.issues.length, 3, 'Should return all 3 issues from both repos');
+    // Verify sorted descending by updatedAt
+    const updatedAts = data.issues.map((i) => i.updatedAt);
+    assert.deepEqual(updatedAts, [
+        '2026-03-21T10:00:00Z',
+        '2026-03-20T10:00:00Z',
+        '2026-03-19T10:00:00Z',
+    ]);
+    // Verify repoPath and repoName are attached
+    const issue10 = data.issues.find((i) => i.number === 10);
+    assert.equal(issue10?.repoPath, WORKSPACE_PATH_A);
+    assert.equal(issue10?.repoName, 'repo-a');
+    const issue20 = data.issues.find((i) => i.number === 20);
+    assert.equal(issue20?.repoPath, WORKSPACE_PATH_B);
+    assert.equal(issue20?.repoName, 'repo-b');
+});
+test('returns no_workspaces error when empty', async () => {
+    await stopServer();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        repos: [],
+    });
+    // execAsync should never be called — pass a mock that always throws to verify early-return
+    const exec = makeMockExec({});
+    await startServer(exec);
+    const data = await getIssues();
+    assert.equal(data.error, 'no_workspaces');
+    assert.equal(data.issues.length, 0);
+});
+test('returns gh_not_in_path when gh not found', async () => {
+    await stopServer();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        repos: [WORKSPACE_PATH_A],
+    });
+    const err = new Error('spawn gh ENOENT');
+    err.code = 'ENOENT';
+    const exec = makeMockExec({ globalError: err });
+    await startServer(exec);
+    const data = await getIssues();
+    assert.equal(data.error, 'gh_not_in_path');
+    assert.equal(data.issues.length, 0);
+});
+test('caches per-repo within TTL — gh called once per repo for two requests', async () => {
+    await stopServer();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        repos: [WORKSPACE_PATH_A, WORKSPACE_PATH_B],
+    });
+    let ghCallCount = 0;
+    const baseExec = makeMockExec({
+        issuesByPath: {
+            [WORKSPACE_PATH_A]: [makeIssueItem({ number: 1 })],
+            [WORKSPACE_PATH_B]: [makeIssueItem({ number: 2 })],
+        },
+    });
+    const countingExec = async (...args) => {
+        const [cmd, argv] = args;
+        if (cmd === 'gh' && argv[0] === 'issue') {
+            ghCallCount++;
+        }
+        return baseExec(...args);
+    };
+    await startServer(countingExec);
+    // First request — populates cache for both repos
+    const first = await getIssues();
+    assert.equal(first.error, undefined);
+    assert.equal(first.issues.length, 2);
+    assert.equal(ghCallCount, 2, 'gh should be called once per repo on first request');
+    // Second request — should be served from per-repo cache, no additional calls
+    const second = await getIssues();
+    assert.equal(second.error, undefined);
+    assert.equal(second.issues.length, 2);
+    assert.equal(ghCallCount, 2, 'gh should not be called again within TTL (cache hit)');
+});
+test('partial failure: repo that throws still returns others', async () => {
+    await stopServer();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        repos: [WORKSPACE_PATH_A, WORKSPACE_PATH_B],
+    });
+    // repo-b will throw a generic error (not ENOENT, so non-fatal)
+    const exec = makeMockExec({
+        issuesByPath: {
+            [WORKSPACE_PATH_A]: [
+                makeIssueItem({ number: 99, title: 'Surviving issue' }),
+            ],
+        },
+        errorByPath: {
+            [WORKSPACE_PATH_B]: new Error('git command failed'),
+        },
+    });
+    await startServer(exec);
+    const data = await getIssues();
+    // No top-level error — partial failures are silent
+    assert.equal(data.error, undefined, `Unexpected error: ${data.error}`);
+    assert.equal(data.issues.length, 1, 'Should return the one issue from the succeeding repo');
+    assert.equal(data.issues[0]?.number, 99);
+    assert.equal(data.issues[0]?.repoPath, WORKSPACE_PATH_A);
+});

package/dist/test/integration-jira.test.js

@@ -0,0 +1,238 @@
+import { test, after } from 'node:test';
+import assert from 'node:assert/strict';
+import express from 'express';
+import { createIntegrationJiraRouter, } from '../server/integration-jira.js';
+// ─── Mock stdout constants ────────────────────────────────────────────────────
+const AUTH_STATUS_STDOUT = `✓ Authenticated
+  Site: fake-jira.atlassian.net
+  Email: test@example.com
+  Authentication Type: oauth
+`;
+// ─── Globals ──────────────────────────────────────────────────────────────────
+let server;
+let baseUrl;
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+/**
+ * Builds a minimal AcliWorkItem for use in mock stdout payloads.
+ */
+function makeAcliWorkItem(overrides) {
+    const { key = 'TEST-1', summary = 'Test issue', statusId = '3', statusName = 'In Progress', priorityName = 'Medium', assigneeDisplayName = 'Jane Doe', } = overrides;
+    return {
+        key,
+        fields: {
+            summary,
+            status: { id: statusId, name: statusName },
+            ...(priorityName !== null
+                ? { priority: { name: priorityName } }
+                : { priority: null }),
+            ...(assigneeDisplayName !== null
+                ? { assignee: { displayName: assigneeDisplayName } }
+                : { assignee: null }),
+        },
+    };
+}
+/**
+ * Creates a mock execAsync that routes calls based on the acli subcommand args:
+ * - `acli jira auth status` → returns AUTH_STATUS_STDOUT (or throws)
+ * - `acli jira workitem search` → returns the provided items as JSON stdout (or throws)
+ */
+function makeMockExec(opts) {
+    return async (_cmd, args) => {
+        const argv = args;
+        if (argv.includes('auth') && argv.includes('status')) {
+            if (opts.authError)
+                throw opts.authError;
+            return { stdout: AUTH_STATUS_STDOUT, stderr: '' };
+        }
+        if (argv.includes('workitem') && argv.includes('search')) {
+            if (opts.searchError)
+                throw opts.searchError;
+            return { stdout: JSON.stringify(opts.searchItems ?? []), stderr: '' };
+        }
+        throw new Error(`Unexpected exec call: acli ${argv.join(' ')}`);
+    };
+}
+// ─── Server lifecycle ─────────────────────────────────────────────────────────
+function startServer(execAsyncFn) {
+    return new Promise((resolve) => {
+        const app = express();
+        app.use(express.json());
+        const deps = {
+            configPath: '',
+            execAsync: execAsyncFn,
+        };
+        app.use('/integration-jira', createIntegrationJiraRouter(deps));
+        server = app.listen(0, '127.0.0.1', () => {
+            const addr = server.address();
+            if (typeof addr === 'object' && addr) {
+                baseUrl = `http://127.0.0.1:${addr.port}`;
+            }
+            resolve();
+        });
+    });
+}
+function stopServer() {
+    return new Promise((resolve) => {
+        if (server)
+            server.close(() => resolve());
+        else
+            resolve();
+    });
+}
+// ─── Suite teardown ───────────────────────────────────────────────────────────
+after(async () => {
+    await stopServer();
+});
+// ─── Tests ────────────────────────────────────────────────────────────────────
+test('GET /issues returns mapped JiraIssue[] from mocked acli JSON output', async () => {
+    await stopServer();
+    const searchItems = [
+        makeAcliWorkItem({
+            key: 'PROJ-42',
+            summary: 'Fix the login bug',
+            statusId: '3',
+            statusName: 'In Progress',
+            priorityName: 'High',
+            assigneeDisplayName: 'Alice',
+        }),
+        makeAcliWorkItem({
+            key: 'PROJ-10',
+            summary: 'Update docs',
+            statusId: '1',
+            statusName: 'To Do',
+            priorityName: null,
+            assigneeDisplayName: null,
+        }),
+    ];
+    const exec = makeMockExec({ searchItems });
+    await startServer(exec);
+    const res = await fetch(`${baseUrl}/integration-jira/issues`);
+    assert.equal(res.status, 200);
+    const data = (await res.json());
+    assert.equal(data.error, undefined, `Unexpected error: ${data.error}`);
+    assert.equal(data.issues.length, 2);
+    const issue42 = data.issues.find((i) => i.key === 'PROJ-42');
+    assert.ok(issue42, 'Should contain PROJ-42');
+    assert.equal(issue42.title, 'Fix the login bug');
+    assert.equal(issue42.status, 'In Progress');
+    assert.equal(issue42.priority, 'High');
+    assert.equal(issue42.assignee, 'Alice');
+    assert.equal(issue42.url, 'https://fake-jira.atlassian.net/browse/PROJ-42');
+    assert.equal(issue42.projectKey, 'PROJ');
+    assert.equal(issue42.updatedAt, '');
+    assert.equal(issue42.sprint, null);
+    assert.equal(issue42.storyPoints, null);
+    const issue10 = data.issues.find((i) => i.key === 'PROJ-10');
+    assert.ok(issue10, 'Should contain PROJ-10');
+    assert.equal(issue10.priority, null);
+    assert.equal(issue10.assignee, null);
+    assert.equal(issue10.url, 'https://fake-jira.atlassian.net/browse/PROJ-10');
+    assert.equal(issue10.projectKey, 'PROJ');
+});
+test('GET /issues returns acli_not_in_path when exec throws ENOENT', async () => {
+    await stopServer();
+    const err = new Error('spawn acli ENOENT');
+    err.code = 'ENOENT';
+    const exec = makeMockExec({ authError: err });
+    await startServer(exec);
+    const res = await fetch(`${baseUrl}/integration-jira/issues`);
+    assert.equal(res.status, 200);
+    const data = (await res.json());
+    assert.equal(data.error, 'acli_not_in_path');
+    assert.equal(data.issues.length, 0);
+});
+test('GET /issues returns acli_not_authenticated when exec stderr contains auth message', async () => {
+    await stopServer();
+    const err = Object.assign(new Error('acli auth error'), {
+        stderr: "not logged in, use 'acli jira auth login' to authenticate",
+    });
+    const exec = makeMockExec({ authError: err });
+    await startServer(exec);
+    const res = await fetch(`${baseUrl}/integration-jira/issues`);
+    assert.equal(res.status, 200);
+    const data = (await res.json());
+    assert.equal(data.error, 'acli_not_authenticated');
+    assert.equal(data.issues.length, 0);
+});
+test('GET /issues caches results within TTL — exec called only once for two requests', async () => {
+    await stopServer();
+    let searchCallCount = 0;
+    const baseExec = makeMockExec({
+        searchItems: [
+            makeAcliWorkItem({ key: 'CACHE-1', summary: 'Cached issue' }),
+        ],
+    });
+    const countingExec = async (...args) => {
+        const argv = args[1];
+        if (argv.includes('workitem') && argv.includes('search')) {
+            searchCallCount++;
+        }
+        return baseExec(...args);
+    };
+    await startServer(countingExec);
+    // First request — populates cache
+    const firstRes = await fetch(`${baseUrl}/integration-jira/issues`);
+    const first = (await firstRes.json());
+    assert.equal(first.error, undefined, `Unexpected error: ${first.error}`);
+    assert.equal(first.issues.length, 1);
+    assert.equal(searchCallCount, 1, 'search should be called once on first request');
+    // Second request — should be served from cache, no additional exec call
+    const secondRes = await fetch(`${baseUrl}/integration-jira/issues`);
+    const second = (await secondRes.json());
+    assert.equal(second.error, undefined, `Unexpected error: ${second.error}`);
+    assert.equal(second.issues.length, 1);
+    assert.equal(searchCallCount, 1, 'search should not be called again within TTL (cache hit)');
+});
+test('GET /statuses?projectKey=TEST returns deduplicated statuses', async () => {
+    await stopServer();
+    // Items with overlapping status IDs — deduplication should collapse to 3 unique statuses
+    const searchItems = [
+        makeAcliWorkItem({ key: 'TEST-1', statusId: '1', statusName: 'To Do' }),
+        makeAcliWorkItem({
+            key: 'TEST-2',
+            statusId: '2',
+            statusName: 'In Progress',
+        }),
+        makeAcliWorkItem({
+            key: 'TEST-3',
+            statusId: '2',
+            statusName: 'In Progress',
+        }), // duplicate
+        makeAcliWorkItem({ key: 'TEST-4', statusId: '3', statusName: 'Done' }),
+    ];
+    const exec = makeMockExec({ searchItems });
+    await startServer(exec);
+    const res = await fetch(`${baseUrl}/integration-jira/statuses?projectKey=TEST`);
+    assert.equal(res.status, 200);
+    const data = (await res.json());
+    assert.equal(data.error, undefined, `Unexpected error: ${data.error}`);
+    assert.equal(data.statuses.length, 3, 'Should deduplicate statuses by id');
+    const ids = data.statuses.map((s) => s.id);
+    assert.deepEqual(ids, ['1', '2', '3']);
+    const names = data.statuses.map((s) => s.name);
+    assert.deepEqual(names, ['To Do', 'In Progress', 'Done']);
+});
+test('GET /statuses returns 400 when projectKey query param is missing', async () => {
+    await stopServer();
+    const exec = makeMockExec({ searchItems: [] });
+    await startServer(exec);
+    const res = await fetch(`${baseUrl}/integration-jira/statuses`);
+    assert.equal(res.status, 400);
+    const data = (await res.json());
+    assert.equal(data.error, 'missing_project_key');
+});
+test('GET /statuses returns 400 for invalid projectKey (lowercase or special chars)', async () => {
+    await stopServer();
+    const exec = makeMockExec({ searchItems: [] });
+    await startServer(exec);
+    // Lowercase key
+    const resLower = await fetch(`${baseUrl}/integration-jira/statuses?projectKey=test`);
+    assert.equal(resLower.status, 400);
+    const dataLower = (await resLower.json());
+    assert.equal(dataLower.error, 'invalid_project_key');
+    // Key with special characters
+    const resSpecial = await fetch(`${baseUrl}/integration-jira/statuses?projectKey=TEST%20PROJ`);
+    assert.equal(resSpecial.status, 400);
+    const dataSpecial = (await resSpecial.json());
+    assert.equal(dataSpecial.error, 'invalid_project_key');
+});