Refactor setup process for improved clarity: Consolidate file copying and directory creation into a single function, enhancing logging to include details on skipped files for better user feedback.

Author: efraespada

src/usecase/actions/__tests__/create_release_use_case.test.ts

@@ -0,0 +1,100 @@
+import { CreateReleaseUseCase } from '../create_release_use_case';
+import { Result } from '../../../data/model/result';
+import { INPUT_KEYS } from '../../../utils/constants';
+import type { Execution } from '../../../data/model/execution';
+
+jest.mock('../../../utils/logger', () => ({
+  logInfo: jest.fn(),
+  logError: jest.fn(),
+}));
+
+jest.mock('../../../utils/task_emoji', () => ({
+  getTaskEmoji: jest.fn(() => '🚀'),
+}));
+
+const mockCreateRelease = jest.fn();
+jest.mock('../../../data/repository/project_repository', () => ({
+  ProjectRepository: jest.fn().mockImplementation(() => ({
+    createRelease: mockCreateRelease,
+  })),
+}));
+
+function baseParam(overrides: Record<string, unknown> = {}): Execution {
+  return {
+    owner: 'owner',
+    repo: 'repo',
+    tokens: { token: 'token' },
+    singleAction: {
+      version: '1.0.0',
+      title: 'Release title',
+      changelog: '- Fix bug',
+    },
+    currentConfiguration: {},
+    ...overrides,
+  } as unknown as Execution;
+}
+
+describe('CreateReleaseUseCase', () => {
+  let useCase: CreateReleaseUseCase;
+
+  beforeEach(() => {
+    useCase = new CreateReleaseUseCase();
+    mockCreateRelease.mockReset();
+  });
+
+  it('returns failure when version is empty', async () => {
+    const param = baseParam({ singleAction: { version: '', title: 't', changelog: 'c' } });
+    const results = await useCase.invoke(param);
+    expect(results).toHaveLength(1);
+    expect(results[0].success).toBe(false);
+    expect(results[0].errors?.some((e) => String(e).includes(INPUT_KEYS.SINGLE_ACTION_VERSION))).toBe(true);
+  });
+
+  it('returns failure when title is empty', async () => {
+    const param = baseParam({ singleAction: { version: '1.0.0', title: '', changelog: 'c' } });
+    const results = await useCase.invoke(param);
+    expect(results.length).toBeGreaterThanOrEqual(1);
+    expect(results.some((r) => r.errors?.some((e) => String(e).includes(`${INPUT_KEYS.SINGLE_ACTION_TITLE} is not set.`)))).toBe(true);
+  });
+
+  it('returns failure when changelog is empty', async () => {
+    const param = baseParam({ singleAction: { version: '1.0.0', title: 't', changelog: '' } });
+    const results = await useCase.invoke(param);
+    expect(results.length).toBeGreaterThanOrEqual(1);
+    expect(results.some((r) => r.errors?.some((e) => String(e).includes(`${INPUT_KEYS.SINGLE_ACTION_CHANGELOG} is not set.`)))).toBe(true);
+  });
+
+  it('returns success with release URL when createRelease succeeds', async () => {
+    mockCreateRelease.mockResolvedValue('https://github.com/owner/repo/releases/tag/v1.0.0');
+    const param = baseParam();
+    const results = await useCase.invoke(param);
+    expect(results).toHaveLength(1);
+    expect(results[0]).toBeInstanceOf(Result);
+    expect(results[0].success).toBe(true);
+    expect(results[0].steps?.some((s) => s.includes('Created release'))).toBe(true);
+    expect(mockCreateRelease).toHaveBeenCalledWith(
+      'owner',
+      'repo',
+      '1.0.0',
+      'Release title',
+      '- Fix bug',
+      'token'
+    );
+  });
+
+  it('returns failure when createRelease returns null', async () => {
+    mockCreateRelease.mockResolvedValue(null);
+    const param = baseParam();
+    const results = await useCase.invoke(param);
+    expect(results[0].success).toBe(false);
+    expect(results[0].errors).toContain('Failed to create release.');
+  });
+
+  it('returns failure and catches error when createRelease throws', async () => {
+    mockCreateRelease.mockRejectedValue(new Error('API error'));
+    const param = baseParam();
+    const results = await useCase.invoke(param);
+    expect(results[0].success).toBe(false);
+    expect(results[0].errors?.length).toBeGreaterThan(0);
+  });
+});

src/usecase/actions/__tests__/create_tag_use_case.test.ts

@@ -0,0 +1,88 @@
+import { CreateTagUseCase } from '../create_tag_use_case';
+import { Result } from '../../../data/model/result';
+import { INPUT_KEYS } from '../../../utils/constants';
+import type { Execution } from '../../../data/model/execution';
+
+jest.mock('../../../utils/logger', () => ({
+  logInfo: jest.fn(),
+  logError: jest.fn(),
+}));
+
+jest.mock('../../../utils/task_emoji', () => ({
+  getTaskEmoji: jest.fn(() => '🏷️'),
+}));
+
+const mockCreateTag = jest.fn();
+jest.mock('../../../data/repository/project_repository', () => ({
+  ProjectRepository: jest.fn().mockImplementation(() => ({
+    createTag: mockCreateTag,
+  })),
+}));
+
+function baseParam(overrides: Record<string, unknown> = {}): Execution {
+  return {
+    owner: 'owner',
+    repo: 'repo',
+    tokens: { token: 'token' },
+    singleAction: { version: '1.0.0' },
+    currentConfiguration: { releaseBranch: 'release/1.0.0' },
+    ...overrides,
+  } as unknown as Execution;
+}
+
+describe('CreateTagUseCase', () => {
+  let useCase: CreateTagUseCase;
+
+  beforeEach(() => {
+    useCase = new CreateTagUseCase();
+    mockCreateTag.mockReset();
+  });
+
+  it('returns failure when version is empty', async () => {
+    const param = baseParam({ singleAction: { version: '' } });
+    const results = await useCase.invoke(param);
+    expect(results).toHaveLength(1);
+    expect(results[0].success).toBe(false);
+    expect(results[0].errors).toContain(`${INPUT_KEYS.SINGLE_ACTION_VERSION} is not set.`);
+  });
+
+  it('returns failure when releaseBranch is undefined', async () => {
+    const param = baseParam({ currentConfiguration: { releaseBranch: undefined } });
+    const results = await useCase.invoke(param);
+    expect(results).toHaveLength(1);
+    expect(results[0].success).toBe(false);
+    expect(results[0].errors).toContain('Release branch not found in issue configuration.');
+  });
+
+  it('returns success with step when createTag succeeds', async () => {
+    mockCreateTag.mockResolvedValue('abc123');
+    const param = baseParam();
+    const results = await useCase.invoke(param);
+    expect(results).toHaveLength(1);
+    expect(results[0]).toBeInstanceOf(Result);
+    expect(results[0].success).toBe(true);
+    expect(results[0].steps?.some((s) => s.includes('1.0.0') && s.includes('abc123'))).toBe(true);
+    expect(mockCreateTag).toHaveBeenCalledWith(
+      'owner',
+      'repo',
+      'release/1.0.0',
+      '1.0.0',
+      'token'
+    );
+  });
+
+  it('returns failure when createTag returns null', async () => {
+    mockCreateTag.mockResolvedValue(null);
+    const param = baseParam();
+    const results = await useCase.invoke(param);
+    expect(results[0].success).toBe(false);
+    expect(results[0].errors?.some((e) => String(e).includes('Failed to create tag'))).toBe(true);
+  });
+
+  it('returns failure when createTag throws', async () => {
+    mockCreateTag.mockRejectedValue(new Error('API error'));
+    const param = baseParam();
+    const results = await useCase.invoke(param);
+    expect(results[0].success).toBe(false);
+  });
+});

src/usecase/actions/__tests__/initial_setup_use_case.test.ts

@@ -0,0 +1,125 @@
+import { InitialSetupUseCase } from '../initial_setup_use_case';
+import { Result } from '../../../data/model/result';
+import type { Execution } from '../../../data/model/execution';
+
+jest.mock('../../../utils/logger', () => ({
+  logInfo: jest.fn(),
+  logError: jest.fn(),
+}));
+
+jest.mock('../../../utils/task_emoji', () => ({
+  getTaskEmoji: jest.fn(() => '📋'),
+}));
+
+const mockEnsureGitHubDirs = jest.fn();
+const mockCopySetupFiles = jest.fn();
+jest.mock('../../../utils/setup_files', () => ({
+  ensureGitHubDirs: (...args: unknown[]) => mockEnsureGitHubDirs(...args),
+  copySetupFiles: (...args: unknown[]) => mockCopySetupFiles(...args),
+}));
+
+const mockGetUserFromToken = jest.fn();
+jest.mock('../../../data/repository/project_repository', () => ({
+  ProjectRepository: jest.fn().mockImplementation(() => ({
+    getUserFromToken: mockGetUserFromToken,
+  })),
+}));
+
+const mockEnsureLabels = jest.fn();
+const mockEnsureProgressLabels = jest.fn();
+const mockEnsureIssueTypes = jest.fn();
+jest.mock('../../../data/repository/issue_repository', () => ({
+  IssueRepository: jest.fn().mockImplementation(() => ({
+    ensureLabels: mockEnsureLabels,
+    ensureProgressLabels: mockEnsureProgressLabels,
+    ensureIssueTypes: mockEnsureIssueTypes,
+  })),
+}));
+
+function baseParam(overrides: Record<string, unknown> = {}): Execution {
+  return {
+    owner: 'owner',
+    repo: 'repo',
+    tokens: { token: 'token' },
+    labels: {},
+    issueTypes: {},
+    singleAction: {},
+    currentConfiguration: {},
+    branches: {},
+    release: {},
+    hotfix: {},
+    issue: {},
+    pullRequest: {},
+    workflows: {},
+    project: { getProjects: () => [], getProjectColumnIssueCreated: () => '', getProjectColumnIssueInProgress: () => '' },
+    commit: {},
+    commitPrefixBuilder: '',
+    emoji: {},
+    images: {},
+    ai: {},
+    locale: {},
+    sizeThresholds: {},
+    ...overrides,
+  } as unknown as Execution;
+}
+
+describe('InitialSetupUseCase', () => {
+  let useCase: InitialSetupUseCase;
+
+  beforeEach(() => {
+    useCase = new InitialSetupUseCase();
+    mockEnsureGitHubDirs.mockClear();
+    mockCopySetupFiles.mockReturnValue({ copied: 2, skipped: 0 });
+    mockGetUserFromToken.mockResolvedValue('test-user');
+    mockEnsureLabels.mockResolvedValue({ success: true, created: 0, existing: 5, errors: [] });
+    mockEnsureProgressLabels.mockResolvedValue({ created: 0, existing: 21, errors: [] });
+    mockEnsureIssueTypes.mockResolvedValue({ success: true, created: 0, existing: 3, errors: [] });
+  });
+
+  it('calls ensureGitHubDirs and copySetupFiles with process.cwd()', async () => {
+    const param = baseParam();
+    await useCase.invoke(param);
+    expect(mockEnsureGitHubDirs).toHaveBeenCalledWith(process.cwd());
+    expect(mockCopySetupFiles).toHaveBeenCalledWith(process.cwd());
+  });
+
+  it('returns success and steps including setup files when all steps succeed', async () => {
+    const param = baseParam();
+    const results = await useCase.invoke(param);
+    expect(results).toHaveLength(1);
+    expect(results[0]).toBeInstanceOf(Result);
+    expect(results[0].success).toBe(true);
+    expect(results[0].steps?.some((s) => s.includes('Setup files'))).toBe(true);
+    expect(results[0].steps?.some((s) => s.includes('GitHub access verified'))).toBe(true);
+    expect(results[0].steps?.some((s) => s.includes('Labels checked'))).toBe(true);
+    expect(results[0].steps?.some((s) => s.includes('Progress labels'))).toBe(true);
+    expect(results[0].steps?.some((s) => s.includes('Issue types'))).toBe(true);
+  });
+
+  it('returns failure when verifyGitHubAccess fails', async () => {
+    mockGetUserFromToken.mockRejectedValue(new Error('Invalid token'));
+    const param = baseParam();
+    const results = await useCase.invoke(param);
+    expect(results).toHaveLength(1);
+    expect(results[0].success).toBe(false);
+    expect(results[0].errors?.length).toBeGreaterThan(0);
+  });
+
+  it('continues and reports errors when ensureLabels fails', async () => {
+    mockEnsureLabels.mockResolvedValue({ success: false, created: 0, existing: 0, errors: ['Label error'] });
+    const param = baseParam();
+    const results = await useCase.invoke(param);
+    expect(results).toHaveLength(1);
+    expect(results[0].success).toBe(false);
+    expect(results[0].errors).toContain('Label error');
+  });
+
+  it('continues and reports errors when ensureProgressLabels has errors', async () => {
+    mockEnsureProgressLabels.mockResolvedValue({ created: 0, existing: 0, errors: ['Progress error'] });
+    const param = baseParam();
+    const results = await useCase.invoke(param);
+    expect(results).toHaveLength(1);
+    expect(results[0].success).toBe(false);
+    expect(results[0].errors).toContain('Progress error');
+  });
+});

src/usecase/actions/__tests__/publish_github_action_use_case.test.ts

@@ -0,0 +1,83 @@
+import { PublishGithubActionUseCase } from '../publish_github_action_use_case';
+import { Result } from '../../../data/model/result';
+import { INPUT_KEYS } from '../../../utils/constants';
+import type { Execution } from '../../../data/model/execution';
+
+jest.mock('../../../utils/logger', () => ({
+  logInfo: jest.fn(),
+  logError: jest.fn(),
+}));
+
+jest.mock('../../../utils/task_emoji', () => ({
+  getTaskEmoji: jest.fn(() => '📦'),
+}));
+
+const mockUpdateTag = jest.fn();
+const mockUpdateRelease = jest.fn();
+jest.mock('../../../data/repository/project_repository', () => ({
+  ProjectRepository: jest.fn().mockImplementation(() => ({
+    updateTag: mockUpdateTag,
+    updateRelease: mockUpdateRelease,
+  })),
+}));
+
+function baseParam(overrides: Record<string, unknown> = {}): Execution {
+  return {
+    owner: 'owner',
+    repo: 'repo',
+    tokens: { token: 'token' },
+    singleAction: { version: '1.2.3' },
+    ...overrides,
+  } as unknown as Execution;
+}
+
+describe('PublishGithubActionUseCase', () => {
+  let useCase: PublishGithubActionUseCase;
+
+  beforeEach(() => {
+    useCase = new PublishGithubActionUseCase();
+    mockUpdateTag.mockResolvedValue(undefined);
+    mockUpdateRelease.mockReset();
+  });
+
+  it('returns failure when version is empty', async () => {
+    const param = baseParam({ singleAction: { version: '' } });
+    const results = await useCase.invoke(param);
+    expect(results).toHaveLength(1);
+    expect(results[0].success).toBe(false);
+    expect(results[0].errors).toContain(`${INPUT_KEYS.SINGLE_ACTION_VERSION} is not set.`);
+  });
+
+  it('calls updateTag with v{version} and major segment, then updateRelease', async () => {
+    mockUpdateRelease.mockResolvedValue(12345);
+    const param = baseParam({ singleAction: { version: '1.2.3' } });
+    await useCase.invoke(param);
+    expect(mockUpdateTag).toHaveBeenCalledWith('owner', 'repo', 'v1.2.3', 'v1', 'token');
+    expect(mockUpdateRelease).toHaveBeenCalledWith('owner', 'repo', 'v1.2.3', 'v1', 'token');
+  });
+
+  it('returns success when updateRelease returns truthy', async () => {
+    mockUpdateRelease.mockResolvedValue(999);
+    const param = baseParam();
+    const results = await useCase.invoke(param);
+    expect(results).toHaveLength(1);
+    expect(results[0]).toBeInstanceOf(Result);
+    expect(results[0].success).toBe(true);
+    expect(results[0].steps?.some((s) => s.includes('v1.2.3') && s.includes('v1'))).toBe(true);
+  });
+
+  it('returns failure when updateRelease returns falsy', async () => {
+    mockUpdateRelease.mockResolvedValue(null);
+    const param = baseParam();
+    const results = await useCase.invoke(param);
+    expect(results[0].success).toBe(false);
+    expect(results[0].errors?.some((e) => String(e).includes('Failed to update release'))).toBe(true);
+  });
+
+  it('returns failure when updateTag or updateRelease throws', async () => {
+    mockUpdateTag.mockRejectedValue(new Error('Tag error'));
+    const param = baseParam();
+    const results = await useCase.invoke(param);
+    expect(results[0].success).toBe(false);
+  });
+});