feature-296-bugbot-autofix: Enhance CLI test coverage by adding scenarios for handling non-git repository errors and validating issue number inputs. Introduce JSON output verification for the CLI command. Update common action tests to handle non-Error exceptions gracefully. This improves robustness and error handling in the CLI and action execution logic.

Author: efraespada

src/__tests__/cli.test.ts

@@ -148,5 +148,57 @@ describe('CLI', () => {
       expect(params[INPUT_KEYS.SINGLE_ACTION]).toBe(ACTIONS.INITIAL_SETUP);
       expect(params[INPUT_KEYS.WELCOME_TITLE]).toContain('Initial Setup');
     });
+
+    it('exits when not inside a git repo', async () => {
+      (execSync as jest.Mock).mockImplementation((cmd: string) => {
+        if (typeof cmd === 'string' && cmd.includes('is-inside-work-tree')) throw new Error('not a repo');
+        return Buffer.from('https://github.com/o/r.git');
+      });
+
+      await program.parseAsync(['node', 'cli', 'setup']);
+
+      expect(exitSpy).toHaveBeenCalledWith(1);
+      const { logError } = require('../utils/logger');
+      expect(logError).toHaveBeenCalledWith(expect.stringContaining('Not a git repository'));
+    });
+  });
+
+  describe('detect-potential-problems', () => {
+    it('calls runLocalAction with DETECT_POTENTIAL_PROBLEMS', async () => {
+      await program.parseAsync(['node', 'cli', 'detect-potential-problems', '-i', '10']);
+
+      expect(runLocalAction).toHaveBeenCalledTimes(1);
+      const params = (runLocalAction as jest.Mock).mock.calls[0][0];
+      expect(params[INPUT_KEYS.SINGLE_ACTION]).toBe(ACTIONS.DETECT_POTENTIAL_PROBLEMS);
+      expect(params.issue?.number).toBe(10);
+      expect(params[INPUT_KEYS.WELCOME_TITLE]).toContain('Detect potential problems');
+    });
+
+    it('shows message when issue number is missing or invalid', async () => {
+      (runLocalAction as jest.Mock).mockClear();
+      const logSpy = jest.spyOn(console, 'log').mockImplementation();
+
+      await program.parseAsync(['node', 'cli', 'detect-potential-problems', '-i', 'x']);
+
+      expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('valid issue number'));
+      expect(runLocalAction).not.toHaveBeenCalled();
+      logSpy.mockRestore();
+    });
+  });
+
+  describe('do --output json', () => {
+    it('prints JSON when --output json', async () => {
+      const { AiRepository } = require('../data/repository/ai_repository');
+      AiRepository.mockImplementation(() => ({
+        copilotMessage: jest.fn().mockResolvedValue({ text: 'Hi', sessionId: 'sid-1' }),
+      }));
+      const logSpy = jest.spyOn(console, 'log').mockImplementation();
+
+      await program.parseAsync(['node', 'cli', 'do', '-p', 'hello', '--output', 'json']);
+
+      expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('"response":'));
+      expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('"sessionId":'));
+      logSpy.mockRestore();
+    });
   });
 });

src/actions/__tests__/common_action.test.ts

@@ -296,6 +296,16 @@ describe('mainRun', () => {
     expect(results).toEqual([]);
   });
 
+  it('calls core.setFailed with String(error) when use case throws non-Error', async () => {
+    const execution = mockExecution({ isPush: true });
+    mockCommitInvoke.mockRejectedValue('plain string error');
+
+    const results = await mainRun(execution);
+
+    expect(core.setFailed).toHaveBeenCalledWith('plain string error');
+    expect(results).toEqual([]);
+  });
+
   it('exits process when waitForPreviousRuns rejects and welcome is false', async () => {
     const exitSpy = jest.spyOn(process, 'exit').mockImplementation((() => {}) as () => never);
     (waitForPreviousRuns as jest.Mock).mockRejectedValue(new Error('Queue error'));

src/data/model/__tests__/commit.test.ts

@@ -0,0 +1,46 @@
+import * as github from '@actions/github';
+import { Commit } from '../commit';
+
+jest.mock('@actions/github', () => ({
+  context: {
+    payload: {} as Record<string, unknown>,
+  },
+}));
+
+describe('Commit', () => {
+  beforeEach(() => {
+    (github.context as { payload: Record<string, unknown> }).payload = {};
+  });
+
+  it('uses inputs when provided for branchReference and branch', () => {
+    const inputs = { commits: { ref: 'refs/heads/feature/123-x' } };
+    const c = new Commit(inputs);
+    expect(c.branchReference).toBe('refs/heads/feature/123-x');
+    expect(c.branch).toBe('feature/123-x');
+  });
+
+  it('falls back to context.payload.ref when inputs have no commits.ref', () => {
+    (github.context as { payload: Record<string, unknown> }).payload = { ref: 'refs/heads/main' };
+    const c = new Commit(undefined);
+    expect(c.branchReference).toBe('refs/heads/main');
+    expect(c.branch).toBe('main');
+  });
+
+  it('returns empty string for branchReference when no inputs and no context ref', () => {
+    const c = new Commit(undefined);
+    expect(c.branchReference).toBe('');
+    expect(c.branch).toBe('');
+  });
+
+  it('returns commits from context.payload when no inputs', () => {
+    const payloadCommits = [{ id: '1', message: 'fix' }];
+    (github.context as { payload: Record<string, unknown> }).payload = { commits: payloadCommits };
+    const c = new Commit(undefined);
+    expect(c.commits).toEqual(payloadCommits);
+  });
+
+  it('returns empty array when context has no commits', () => {
+    const c = new Commit(undefined);
+    expect(c.commits).toEqual([]);
+  });
+});

src/data/model/__tests__/issue.test.ts

@@ -0,0 +1,72 @@
+import * as github from '@actions/github';
+import { Issue } from '../issue';
+
+jest.mock('@actions/github', () => ({
+  context: {
+    payload: {} as Record<string, unknown>,
+    eventName: '',
+  },
+}));
+
+function getContext(): { payload: Record<string, unknown>; eventName: string } {
+  return github.context as unknown as { payload: Record<string, unknown>; eventName: string };
+}
+
+describe('Issue', () => {
+  const issuePayload = {
+    title: 'Add feature',
+    number: 10,
+    html_url: 'https://github.com/o/r/issues/10',
+    body: 'Body text',
+    user: { login: 'bob' },
+  };
+
+  beforeEach(() => {
+    getContext().payload = {};
+    getContext().eventName = 'issues';
+  });
+
+  it('uses inputs when provided', () => {
+    const inputs = { action: 'opened', issue: issuePayload, eventName: 'issues' };
+    const i = new Issue(false, false, 1, inputs);
+    expect(i.title).toBe('Add feature');
+    expect(i.number).toBe(10);
+    expect(i.creator).toBe('bob');
+    expect(i.url).toBe('https://github.com/o/r/issues/10');
+    expect(i.body).toBe('Body text');
+    expect(i.opened).toBe(true);
+    expect(i.labeled).toBe(false);
+    expect(i.isIssue).toBe(true);
+    expect(i.isIssueComment).toBe(false);
+  });
+
+  it('falls back to context.payload when inputs missing', () => {
+    getContext().payload = {
+      action: 'opened',
+      issue: issuePayload,
+    };
+    getContext().eventName = 'issues';
+    const i = new Issue(false, false, 1, undefined);
+    expect(i.title).toBe('Add feature');
+    expect(i.number).toBe(10);
+    expect(i.isIssue).toBe(true);
+  });
+
+  it('labeled and labelAdded when action is labeled', () => {
+    const inputs = { action: 'labeled', issue: issuePayload, label: { name: 'bug' } };
+    const i = new Issue(false, false, 1, inputs);
+    expect(i.labeled).toBe(true);
+    expect(i.labelAdded).toBe('bug');
+  });
+
+  it('isIssueComment when eventName is issue_comment', () => {
+    const inputs = { eventName: 'issue_comment', issue: issuePayload, comment: { id: 5, body: 'Hi', user: { login: 'alice' }, html_url: 'url' } };
+    const i = new Issue(false, false, 1, inputs);
+    expect(i.isIssueComment).toBe(true);
+    expect(i.isIssue).toBe(false);
+    expect(i.commentId).toBe(5);
+    expect(i.commentBody).toBe('Hi');
+    expect(i.commentAuthor).toBe('alice');
+    expect(i.commentUrl).toBe('url');
+  });
+});

src/data/model/__tests__/labels.test.ts

@@ -0,0 +1,193 @@
+import { Labels } from '../labels';
+
+function createLabels(overrides: Partial<Record<keyof Labels, string>> = {}): Labels {
+  const base = {
+    branchManagementLauncherLabel: 'launch',
+    bug: 'bug',
+    bugfix: 'bugfix',
+    hotfix: 'hotfix',
+    enhancement: 'enhancement',
+    feature: 'feature',
+    release: 'release',
+    question: 'question',
+    help: 'help',
+    deploy: 'deploy',
+    deployed: 'deployed',
+    docs: 'docs',
+    documentation: 'documentation',
+    chore: 'chore',
+    maintenance: 'maintenance',
+    sizeXxl: 'size/xxl',
+    sizeXl: 'size/xl',
+    sizeL: 'size/l',
+    sizeM: 'size/m',
+    sizeS: 'size/s',
+    sizeXs: 'size/xs',
+    priorityHigh: 'priority/high',
+    priorityMedium: 'priority/medium',
+    priorityLow: 'priority/low',
+    priorityNone: 'priority/none',
+  };
+  const l = new Labels(
+    base.branchManagementLauncherLabel,
+    base.bug,
+    base.bugfix,
+    base.hotfix,
+    base.enhancement,
+    base.feature,
+    base.release,
+    base.question,
+    base.help,
+    base.deploy,
+    base.deployed,
+    base.docs,
+    base.documentation,
+    base.chore,
+    base.maintenance,
+    base.priorityHigh,
+    base.priorityMedium,
+    base.priorityLow,
+    base.priorityNone,
+    base.sizeXxl,
+    base.sizeXl,
+    base.sizeL,
+    base.sizeM,
+    base.sizeS,
+    base.sizeXs
+  );
+  Object.assign(l, overrides);
+  return l;
+}
+
+describe('Labels', () => {
+  it('isMandatoryBranchedLabel is true when isHotfix or isRelease', () => {
+    const l = createLabels();
+    l.currentIssueLabels = [];
+    expect(l.isMandatoryBranchedLabel).toBe(false);
+    l.currentIssueLabels = [l.hotfix];
+    expect(l.isMandatoryBranchedLabel).toBe(true);
+    l.currentIssueLabels = [l.release];
+    expect(l.isMandatoryBranchedLabel).toBe(true);
+  });
+
+  it('containsBranchedLabel reflects branchManagementLauncherLabel in currentIssueLabels', () => {
+    const l = createLabels();
+    l.currentIssueLabels = [];
+    expect(l.containsBranchedLabel).toBe(false);
+    l.currentIssueLabels = [l.branchManagementLauncherLabel];
+    expect(l.containsBranchedLabel).toBe(true);
+  });
+
+  it('isDeploy and isDeployed from currentIssueLabels', () => {
+    const l = createLabels();
+    l.currentIssueLabels = [l.deploy];
+    expect(l.isDeploy).toBe(true);
+    expect(l.isDeployed).toBe(false);
+    l.currentIssueLabels = [l.deployed];
+    expect(l.isDeploy).toBe(false);
+    expect(l.isDeployed).toBe(true);
+  });
+
+  it('isHelp and isQuestion from currentIssueLabels', () => {
+    const l = createLabels();
+    l.currentIssueLabels = [l.help];
+    expect(l.isHelp).toBe(true);
+    expect(l.isQuestion).toBe(false);
+    l.currentIssueLabels = [l.question];
+    expect(l.isQuestion).toBe(true);
+  });
+
+  it('isFeature, isEnhancement, isBugfix, isBug, isHotfix, isRelease', () => {
+    const l = createLabels();
+    l.currentIssueLabels = [l.feature];
+    expect(l.isFeature).toBe(true);
+    l.currentIssueLabels = [l.enhancement];
+    expect(l.isEnhancement).toBe(true);
+    l.currentIssueLabels = [l.bugfix];
+    expect(l.isBugfix).toBe(true);
+    l.currentIssueLabels = [l.bug];
+    expect(l.isBug).toBe(true);
+    l.currentIssueLabels = [l.hotfix];
+    expect(l.isHotfix).toBe(true);
+    l.currentIssueLabels = [l.release];
+    expect(l.isRelease).toBe(true);
+  });
+
+  it('isDocs, isDocumentation, isChore, isMaintenance', () => {
+    const l = createLabels();
+    l.currentIssueLabels = [l.docs];
+    expect(l.isDocs).toBe(true);
+    l.currentIssueLabels = [l.documentation];
+    expect(l.isDocumentation).toBe(true);
+    l.currentIssueLabels = [l.chore];
+    expect(l.isChore).toBe(true);
+    l.currentIssueLabels = [l.maintenance];
+    expect(l.isMaintenance).toBe(true);
+  });
+
+  it('sizedLabelOnIssue returns first matching size label', () => {
+    const l = createLabels();
+    l.currentIssueLabels = [l.sizeM];
+    expect(l.sizedLabelOnIssue).toBe(l.sizeM);
+    l.currentIssueLabels = [l.sizeXxl, l.sizeM];
+    expect(l.sizedLabelOnIssue).toBe(l.sizeXxl);
+    l.currentIssueLabels = [];
+    expect(l.sizedLabelOnIssue).toBeUndefined();
+  });
+
+  it('sizedLabelOnPullRequest returns first matching size label', () => {
+    const l = createLabels();
+    l.currentPullRequestLabels = [l.sizeS];
+    expect(l.sizedLabelOnPullRequest).toBe(l.sizeS);
+    l.currentPullRequestLabels = [];
+    expect(l.sizedLabelOnPullRequest).toBeUndefined();
+  });
+
+  it('isIssueSized and isPullRequestSized', () => {
+    const l = createLabels();
+    l.currentIssueLabels = [];
+    l.currentPullRequestLabels = [];
+    expect(l.isIssueSized).toBe(false);
+    expect(l.isPullRequestSized).toBe(false);
+    l.currentIssueLabels = [l.sizeM];
+    expect(l.isIssueSized).toBe(true);
+    l.currentPullRequestLabels = [l.sizeL];
+    expect(l.isPullRequestSized).toBe(true);
+  });
+
+  it('sizeLabels and priorityLabels return arrays', () => {
+    const l = createLabels();
+    expect(l.sizeLabels).toEqual([l.sizeXxl, l.sizeXl, l.sizeL, l.sizeM, l.sizeS, l.sizeXs]);
+    expect(l.priorityLabels).toEqual([l.priorityHigh, l.priorityMedium, l.priorityLow, l.priorityNone]);
+  });
+
+  it('priorityLabelOnIssue and priorityLabelOnPullRequest', () => {
+    const l = createLabels();
+    l.currentIssueLabels = [l.priorityHigh];
+    l.currentPullRequestLabels = [l.priorityLow];
+    expect(l.priorityLabelOnIssue).toBe(l.priorityHigh);
+    expect(l.priorityLabelOnPullRequest).toBe(l.priorityLow);
+    l.currentIssueLabels = [];
+    expect(l.priorityLabelOnIssue).toBeUndefined();
+  });
+
+  it('priorityLabelOnIssueProcessable and priorityLabelOnPullRequestProcessable', () => {
+    const l = createLabels();
+    l.currentIssueLabels = [l.priorityNone];
+    expect(l.priorityLabelOnIssueProcessable).toBe(false);
+    l.currentIssueLabels = [l.priorityHigh];
+    expect(l.priorityLabelOnIssueProcessable).toBe(true);
+    l.currentPullRequestLabels = [l.priorityMedium];
+    expect(l.priorityLabelOnPullRequestProcessable).toBe(true);
+  });
+
+  it('isIssuePrioritized and isPullRequestPrioritized', () => {
+    const l = createLabels();
+    l.currentIssueLabels = [l.priorityHigh];
+    expect(l.isIssuePrioritized).toBe(true);
+    l.currentIssueLabels = [l.priorityNone];
+    expect(l.isIssuePrioritized).toBe(false);
+    l.currentPullRequestLabels = [l.priorityLow];
+    expect(l.isPullRequestPrioritized).toBe(true);
+  });
+});