@specmarket/cli 0.0.3 → 0.0.5

package/src/commands/issues.test.ts

@@ -0,0 +1,377 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// --- Hoisted mocks (available inside vi.mock factories) ---
+
+const { mockQuery, mockMutation, mockClient, mockSpinner } = vi.hoisted(() => {
+  const mockQuery = vi.fn();
+  const mockMutation = vi.fn();
+  const mockClient = { query: mockQuery, mutation: mockMutation };
+  const mockSpinner = {
+    start: vi.fn().mockReturnThis(),
+    stop: vi.fn().mockReturnThis(),
+    succeed: vi.fn().mockReturnThis(),
+    fail: vi.fn().mockReturnThis(),
+  };
+  return { mockQuery, mockMutation, mockClient, mockSpinner };
+});
+
+vi.mock('../lib/convex-client.js', () => ({
+  getConvexClient: vi.fn().mockResolvedValue(mockClient),
+}));
+
+vi.mock('../lib/auth.js', () => ({
+  requireAuth: vi.fn().mockResolvedValue({
+    token: 'test-token',
+    username: 'testuser',
+    expiresAt: Date.now() + 3600_000,
+  }),
+}));
+
+vi.mock('ora', () => ({
+  default: vi.fn().mockReturnValue(mockSpinner),
+}));
+
+vi.mock('@specmarket/convex/api', () => ({
+  api: {
+    specs: { get: 'specs.get' },
+    issues: {
+      list: 'issues.list',
+      get: 'issues.get',
+      create: 'issues.create',
+      close: 'issues.close',
+      reopen: 'issues.reopen',
+    },
+    comments: { list: 'comments.list' },
+  },
+}));
+
+// Prevent process.exit from actually exiting in tests
+const mockExit = vi.spyOn(process, 'exit').mockImplementation((() => {
+  throw new Error('process.exit called');
+}) as any);
+
+const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+import {
+  handleIssuesList,
+  handleIssuesCreate,
+  handleIssuesView,
+  handleIssuesClose,
+  handleIssuesReopen,
+} from './issues.js';
+
+// --- Test data ---
+
+const MOCK_SPEC = {
+  _id: 'spec123',
+  scopedName: '@alice/my-spec',
+  displayName: 'My Spec',
+  status: 'published',
+};
+
+const MOCK_ISSUE = {
+  _id: 'issue456',
+  specId: 'spec123',
+  number: 1,
+  authorId: 'user789',
+  title: 'Bug in build step',
+  body: 'The build fails when using Node 22.',
+  labels: ['bug'],
+  status: 'open',
+  createdAt: Date.now() - 86400_000,
+  updatedAt: Date.now(),
+  author: { username: 'bob', displayName: 'Bob', avatarUrl: null },
+  commentCount: 3,
+};
+
+describe('handleIssuesList', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockExit.mockImplementation((() => {
+      throw new Error('process.exit called');
+    }) as any);
+  });
+
+  it('lists open issues in table format', async () => {
+    mockQuery.mockImplementation((fn: string) => {
+      if (fn === 'specs.get') return MOCK_SPEC;
+      if (fn === 'issues.list') {
+        return {
+          page: [
+            {
+              ...MOCK_ISSUE,
+              author: { username: 'bob', displayName: 'Bob', avatarUrl: null },
+            },
+          ],
+          isDone: true,
+          continueCursor: null,
+        };
+      }
+    });
+
+    await handleIssuesList('@alice/my-spec', {});
+
+    expect(mockQuery).toHaveBeenCalledWith('specs.get', {
+      scopedName: '@alice/my-spec',
+    });
+    expect(mockQuery).toHaveBeenCalledWith('issues.list', {
+      specId: 'spec123',
+      status: 'open',
+      paginationOpts: { numItems: 50, cursor: null },
+    });
+    expect(consoleSpy).toHaveBeenCalled();
+  });
+
+  it('shows empty message when no issues found', async () => {
+    mockQuery.mockImplementation((fn: string) => {
+      if (fn === 'specs.get') return MOCK_SPEC;
+      if (fn === 'issues.list') {
+        return { page: [], isDone: true, continueCursor: null };
+      }
+    });
+
+    await handleIssuesList('@alice/my-spec', {});
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('No open issues')
+    );
+  });
+
+  it('passes closed status filter to backend', async () => {
+    mockQuery.mockImplementation((fn: string) => {
+      if (fn === 'specs.get') return MOCK_SPEC;
+      if (fn === 'issues.list') {
+        return { page: [], isDone: true, continueCursor: null };
+      }
+    });
+
+    await handleIssuesList('@alice/my-spec', { status: 'closed' });
+
+    expect(mockQuery).toHaveBeenCalledWith('issues.list', {
+      specId: 'spec123',
+      status: 'closed',
+      paginationOpts: { numItems: 50, cursor: null },
+    });
+  });
+
+  it('passes undefined status for "all" filter', async () => {
+    mockQuery.mockImplementation((fn: string) => {
+      if (fn === 'specs.get') return MOCK_SPEC;
+      if (fn === 'issues.list') {
+        return { page: [], isDone: true, continueCursor: null };
+      }
+    });
+
+    await handleIssuesList('@alice/my-spec', { status: 'all' });
+
+    expect(mockQuery).toHaveBeenCalledWith('issues.list', {
+      specId: 'spec123',
+      status: undefined,
+      paginationOpts: { numItems: 50, cursor: null },
+    });
+  });
+
+  it('filters by label client-side', async () => {
+    mockQuery.mockImplementation((fn: string) => {
+      if (fn === 'specs.get') return MOCK_SPEC;
+      if (fn === 'issues.list') {
+        return {
+          page: [
+            { ...MOCK_ISSUE, labels: ['bug'] },
+            { ...MOCK_ISSUE, number: 2, labels: ['enhancement'], title: 'Add feature' },
+          ],
+          isDone: true,
+          continueCursor: null,
+        };
+      }
+    });
+
+    await handleIssuesList('@alice/my-spec', { label: 'enhancement' });
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('1 issue(s)')
+    );
+  });
+
+  it('exits with error when spec not found', async () => {
+    mockQuery.mockResolvedValue(null);
+
+    await expect(
+      handleIssuesList('@alice/nonexistent', {})
+    ).rejects.toThrow('process.exit called');
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Spec not found')
+    );
+  });
+});
+
+describe('handleIssuesView', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockExit.mockImplementation((() => {
+      throw new Error('process.exit called');
+    }) as any);
+  });
+
+  it('displays issue detail with comments', async () => {
+    mockQuery.mockImplementation((fn: string) => {
+      if (fn === 'specs.get') return MOCK_SPEC;
+      if (fn === 'issues.get') return MOCK_ISSUE;
+      if (fn === 'comments.list') {
+        return {
+          page: [
+            {
+              _id: 'comment1',
+              body: 'This needs to be fixed ASAP',
+              author: { username: 'carol', displayName: 'Carol', avatarUrl: null },
+              createdAt: Date.now() - 3600_000,
+              replies: [],
+            },
+          ],
+          isDone: true,
+          continueCursor: null,
+        };
+      }
+    });
+
+    await handleIssuesView('@alice/my-spec', 1);
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('#1: Bug in build step')
+    );
+    expect(consoleSpy).toHaveBeenCalledWith('The build fails when using Node 22.');
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('@carol')
+    );
+  });
+
+  it('exits with error when issue not found', async () => {
+    mockQuery.mockImplementation((fn: string) => {
+      if (fn === 'specs.get') return MOCK_SPEC;
+      if (fn === 'issues.get') return null;
+    });
+
+    await expect(
+      handleIssuesView('@alice/my-spec', 99)
+    ).rejects.toThrow('process.exit called');
+
+    expect(mockSpinner.fail).toHaveBeenCalledWith(
+      expect.stringContaining('Issue #99 not found')
+    );
+  });
+
+  it('shows "No comments yet" when there are none', async () => {
+    mockQuery.mockImplementation((fn: string) => {
+      if (fn === 'specs.get') return MOCK_SPEC;
+      if (fn === 'issues.get') return { ...MOCK_ISSUE, commentCount: 0 };
+      if (fn === 'comments.list') {
+        return { page: [], isDone: true, continueCursor: null };
+      }
+    });
+
+    await handleIssuesView('@alice/my-spec', 1);
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('No comments yet')
+    );
+  });
+});
+
+describe('handleIssuesClose', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockExit.mockImplementation((() => {
+      throw new Error('process.exit called');
+    }) as any);
+  });
+
+  it('closes an issue successfully', async () => {
+    mockQuery.mockImplementation((fn: string) => {
+      if (fn === 'specs.get') return MOCK_SPEC;
+      if (fn === 'issues.get') return MOCK_ISSUE;
+    });
+    mockMutation.mockResolvedValue({ success: true });
+
+    await handleIssuesClose('@alice/my-spec', 1);
+
+    expect(mockMutation).toHaveBeenCalledWith('issues.close', {
+      issueId: 'issue456',
+    });
+    expect(mockSpinner.succeed).toHaveBeenCalledWith(
+      expect.stringContaining('Issue #1 closed')
+    );
+  });
+
+  it('exits with error when issue not found', async () => {
+    mockQuery.mockImplementation((fn: string) => {
+      if (fn === 'specs.get') return MOCK_SPEC;
+      if (fn === 'issues.get') return null;
+    });
+
+    await expect(
+      handleIssuesClose('@alice/my-spec', 99)
+    ).rejects.toThrow('process.exit called');
+  });
+});
+
+describe('handleIssuesReopen', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockExit.mockImplementation((() => {
+      throw new Error('process.exit called');
+    }) as any);
+  });
+
+  it('reopens an issue successfully', async () => {
+    mockQuery.mockImplementation((fn: string) => {
+      if (fn === 'specs.get') return MOCK_SPEC;
+      if (fn === 'issues.get') return { ...MOCK_ISSUE, status: 'closed' };
+    });
+    mockMutation.mockResolvedValue({ success: true });
+
+    await handleIssuesReopen('@alice/my-spec', 1);
+
+    expect(mockMutation).toHaveBeenCalledWith('issues.reopen', {
+      issueId: 'issue456',
+    });
+    expect(mockSpinner.succeed).toHaveBeenCalledWith(
+      expect.stringContaining('Issue #1 reopened')
+    );
+  });
+});
+
+describe('handleIssuesCreate', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockExit.mockImplementation((() => {
+      throw new Error('process.exit called');
+    }) as any);
+  });
+
+  it('creates an issue with inquirer prompts', async () => {
+    const inquirerMock = await import('inquirer');
+    vi.spyOn(inquirerMock.default, 'prompt').mockResolvedValue({
+      title: 'New bug report',
+      body: 'Steps to reproduce...',
+    });
+
+    mockQuery.mockImplementation((fn: string) => {
+      if (fn === 'specs.get') return MOCK_SPEC;
+    });
+    mockMutation.mockResolvedValue({ issueId: 'newIssue1', number: 2 });
+
+    await handleIssuesCreate('@alice/my-spec');
+
+    expect(mockMutation).toHaveBeenCalledWith('issues.create', {
+      specId: 'spec123',
+      title: 'New bug report',
+      body: 'Steps to reproduce...',
+      labels: [],
+    });
+    expect(mockSpinner.succeed).toHaveBeenCalledWith(
+      expect.stringContaining('Issue #2 created')
+    );
+  });
+});