@ksw8954/git-ai-commit 1.0.0

package/src/__tests__/integration.test.ts

@@ -0,0 +1,138 @@
+import { loadEnv } from '../commands/loadEnv';
+
+// Load environment variables from .env file before tests
+loadEnv();
+
+import { AIService } from '../commands/ai';
+import { GitService } from '../commands/git';
+import { ConfigService } from '../commands/config';
+
+const hasApiKey = Boolean(
+  process.env.OPENAI_API_KEY ||
+  process.env.AI_API_KEY
+);
+
+describe('Integration Tests with Real API', () => {
+  let aiService: AIService;
+
+  beforeEach(() => {
+    if (!hasApiKey) {
+      return;
+    }
+
+    const config = ConfigService.getConfig();
+    ConfigService.validateConfig(config);
+    aiService = new AIService({
+      apiKey: config.apiKey!,
+      baseURL: config.baseURL,
+      model: config.model,
+      language: config.language
+    });
+  });
+
+  const describeIfApiKey = hasApiKey ? describe : describe.skip;
+
+  describeIfApiKey('Real API Integration', () => {
+    it('should generate commit message using real API', async () => {
+      // Sample git diff for testing
+      const sampleDiff = `diff --git a/package.json b/package.json
+index 1a2b3c4..5d6e7f8 100644
+--- a/package.json
++++ b/package.json
+@@ -1,6 +1,6 @@
+ {
+   "name": "test-project",
+-  "version": "1.0.0",
++  "version": "1.1.0",
+   "description": "Test project",
+   "main": "index.js"
+ }
+diff --git a/src/index.ts b/src/index.ts
+index abc123..def456 100644
+--- a/src/index.ts
++++ b/src/index.ts
+@@ -1,5 +1,8 @@
+ console.log('Hello World');
++
++// Add new feature
++console.log('New feature added');
+`;
+
+      console.log('Testing with real API...');
+      console.log('Sample diff:', sampleDiff);
+
+      const result = await aiService.generateCommitMessage(sampleDiff);
+
+      console.log('API Response:', result);
+
+      expect(result.success).toBe(true);
+      expect(result.message).toBeDefined();
+      expect(result.message!.length).toBeGreaterThan(0);
+      
+      // Check if the message follows conventional commit format
+      expect(result.message).toMatch(/^(feat|fix|docs|style|refactor|test|chore|build|ci|perf|revert)(\(.+\))?!?: .+/);
+    }, 30000); // 30 second timeout for real API call
+
+    it('should handle API errors gracefully', async () => {
+      // Test with empty diff to potentially trigger API error
+      const emptyDiff = '';
+
+      const result = await aiService.generateCommitMessage(emptyDiff);
+
+      console.log('Empty diff test result:', result);
+
+      // The API might still return a message, but if it fails, it should handle gracefully
+      if (!result.success) {
+        expect(result.error).toBeDefined();
+        expect(result.error!.length).toBeGreaterThan(0);
+      }
+    }, 60000);
+  });
+
+  describe('Git Service Integration', () => {
+    it('should get actual git diff if available', async () => {
+      const result = await GitService.getStagedDiff();
+
+      console.log('Git diff result:', result);
+
+      // If there are staged changes, success should be true
+      // If no staged changes, success should be false with appropriate error
+      if (result.success) {
+        expect(result.diff).toBeDefined();
+        expect(result.diff!.length).toBeGreaterThan(0);
+      } else {
+        expect(result.error).toBeDefined();
+        expect(result.error).toContain('No staged changes');
+      }
+    });
+  });
+
+  describe('Configuration Integration', () => {
+    const itIfApiKey = hasApiKey ? it : it.skip;
+
+    itIfApiKey('should load configuration from environment', () => {
+      const config = ConfigService.getConfig();
+      ConfigService.validateConfig(config);
+
+      console.log('Loaded config:', {
+        apiKey: config.apiKey ? `${config.apiKey.slice(0, 8)}...${config.apiKey.slice(-4)}` : 'undefined',
+        baseURL: config.baseURL || 'undefined',
+        model: config.model || 'undefined',
+        language: config.language,
+        autoPush: config.autoPush
+      });
+
+      expect(config.apiKey).toBeDefined();
+      expect(config.apiKey!.length).toBeGreaterThan(0);
+      
+      // Should have model from .env or default
+      expect(config.model).toBeDefined();
+    });
+
+    itIfApiKey('should validate configuration successfully', () => {
+      const config = ConfigService.getConfig();
+      
+      expect(() => ConfigService.validateConfig(config)).not.toThrow();
+    });
+  });
+});

package/src/__tests__/prCommand.test.ts

@@ -0,0 +1,121 @@
+import { PullRequestCommand } from '../commands/prCommand';
+import { GitService } from '../commands/git';
+import { AIService } from '../commands/ai';
+import { ConfigService } from '../commands/config';
+
+const mockGeneratePullRequestMessage = jest.fn();
+
+jest.mock('../commands/git', () => ({
+  GitService: {
+    getBranchDiff: jest.fn()
+  }
+}));
+
+jest.mock('../commands/ai', () => ({
+  AIService: jest.fn().mockImplementation(() => ({
+    generatePullRequestMessage: mockGeneratePullRequestMessage
+  }))
+}));
+
+jest.mock('../commands/config', () => ({
+  ConfigService: {
+    getConfig: jest.fn(),
+    validateConfig: jest.fn()
+  }
+}));
+
+describe('PullRequestCommand', () => {
+  const exitSpy = jest.spyOn(process, 'exit').mockImplementation((() => undefined) as any);
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    (ConfigService.getConfig as jest.Mock).mockReturnValue({
+      apiKey: 'config-key',
+      baseURL: 'https://api.test',
+      model: 'test-model',
+      language: 'ko',
+      autoPush: false
+    });
+
+    (ConfigService.validateConfig as jest.Mock).mockReturnValue(undefined);
+
+    (GitService.getBranchDiff as jest.Mock).mockResolvedValue({
+      success: true,
+      diff: 'diff --git a/file b/file'
+    });
+
+    mockGeneratePullRequestMessage.mockResolvedValue({
+      success: true,
+      message: 'Add caching layer\n\n## Summary\n- ...\n\n## Testing\n- ...'
+    });
+  });
+
+  afterAll(() => {
+    exitSpy.mockRestore();
+  });
+
+  const createCommand = () => new PullRequestCommand();
+
+  it('prints generated pull request message on success', async () => {
+    const command = createCommand();
+    const logSpy = jest.spyOn(console, 'log').mockImplementation(() => undefined);
+
+    try {
+      await (command as any).handlePullRequest({ base: 'main', compare: 'feature/cache' });
+
+      expect(ConfigService.validateConfig).toHaveBeenCalledWith({
+        apiKey: 'config-key',
+        language: 'ko'
+      });
+      expect(GitService.getBranchDiff).toHaveBeenCalledWith('main', 'feature/cache');
+      expect(mockGeneratePullRequestMessage).toHaveBeenCalledWith(
+        'main',
+        'feature/cache',
+        'diff --git a/file b/file'
+      );
+      expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Add caching layer'));
+      expect(exitSpy).not.toHaveBeenCalled();
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+
+  it('exits when diff retrieval fails', async () => {
+    (GitService.getBranchDiff as jest.Mock).mockResolvedValueOnce({
+      success: false,
+      error: 'diff error'
+    });
+
+    const command = createCommand();
+    const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => undefined);
+
+    try {
+      await (command as any).handlePullRequest({ base: 'main', compare: 'feature/cache' });
+
+      expect(errorSpy).toHaveBeenCalledWith('Error:', 'diff error');
+      expect(exitSpy).toHaveBeenCalledWith(1);
+    } finally {
+      errorSpy.mockRestore();
+    }
+  });
+
+  it('exits when AI generation fails', async () => {
+    mockGeneratePullRequestMessage.mockResolvedValueOnce({
+      success: false,
+      error: 'ai error'
+    });
+
+    const command = createCommand();
+    const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => undefined);
+
+    try {
+      await (command as any).handlePullRequest({ base: 'main', compare: 'feature/cache' });
+
+      expect(errorSpy).toHaveBeenCalledWith('Error:', 'ai error');
+      expect(exitSpy).toHaveBeenCalledWith(1);
+    } finally {
+      errorSpy.mockRestore();
+    }
+  });
+});

package/src/__tests__/tagCommand.test.ts

@@ -0,0 +1,197 @@
+import { TagCommand } from '../commands/tag';
+import { GitService } from '../commands/git';
+import { AIService } from '../commands/ai';
+import { ConfigService } from '../commands/config';
+
+jest.mock('../commands/git', () => ({
+  GitService: {
+    getLatestTag: jest.fn(),
+    getCommitSummariesSince: jest.fn(),
+    createAnnotatedTag: jest.fn(),
+    pushTag: jest.fn()
+  }
+}));
+
+const mockGenerateTagNotes = jest.fn();
+
+jest.mock('../commands/ai', () => ({
+  AIService: jest.fn().mockImplementation(() => ({
+    generateTagNotes: mockGenerateTagNotes
+  }))
+}));
+
+jest.mock('../commands/config', () => ({
+  ConfigService: {
+    getConfig: jest.fn(),
+    validateConfig: jest.fn()
+  }
+}));
+
+describe('TagCommand', () => {
+  const exitSpy = jest.spyOn(process, 'exit').mockImplementation((() => undefined) as any);
+  let confirmSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    (ConfigService.getConfig as jest.Mock).mockReturnValue({
+      apiKey: 'env-key',
+      baseURL: 'https://env.test',
+      model: 'env-model',
+      language: 'ko',
+      autoPush: false
+    });
+
+    (ConfigService.validateConfig as jest.Mock).mockReturnValue(undefined);
+
+    // Confirm creation by default
+    jest
+      .spyOn(TagCommand.prototype as any, 'confirmTagCreate')
+      .mockResolvedValue(true);
+
+    // Do not push by default
+    confirmSpy = jest
+      .spyOn(TagCommand.prototype as any, 'confirmTagPush')
+      .mockResolvedValue(false);
+  });
+
+  afterEach(() => {
+    confirmSpy.mockRestore();
+  });
+
+  afterAll(() => {
+    exitSpy.mockRestore();
+  });
+
+  const getTagCommand = () => new TagCommand();
+
+  it('should create tag with provided message without invoking AI', async () => {
+    (GitService.createAnnotatedTag as jest.Mock).mockResolvedValue(true);
+
+    const command = getTagCommand();
+
+    await (command as any).handleTag('v1.2.3', { message: 'Manual release notes' });
+
+    expect(GitService.createAnnotatedTag).toHaveBeenCalledWith('v1.2.3', 'Manual release notes');
+    expect(AIService).not.toHaveBeenCalled();
+    expect(GitService.pushTag).not.toHaveBeenCalled();
+    expect(exitSpy).not.toHaveBeenCalled();
+  });
+
+  it('should generate tag notes using AI when message is not provided', async () => {
+    (GitService.getCommitSummariesSince as jest.Mock).mockResolvedValue({
+      success: true,
+      log: '- feat: add feature\n- fix: bug fix'
+    });
+    (GitService.createAnnotatedTag as jest.Mock).mockResolvedValue(true);
+
+    mockGenerateTagNotes.mockResolvedValue({
+      success: true,
+      notes: '- Added feature\n- Fixed bug'
+    });
+
+    const command = getTagCommand();
+
+    await (command as any).handleTag('v1.3.0', {
+      apiKey: 'test-key',
+      baseUrl: 'https://api.test',
+      model: 'gpt-test',
+      baseTag: 'v1.2.0'
+    });
+
+    expect(GitService.getCommitSummariesSince).toHaveBeenCalledWith('v1.2.0');
+    expect(AIService).toHaveBeenCalledWith({
+      apiKey: 'test-key',
+      baseURL: 'https://api.test',
+      model: 'gpt-test',
+      language: 'ko'
+    });
+    expect(mockGenerateTagNotes).toHaveBeenCalledWith('v1.3.0', '- feat: add feature\n- fix: bug fix', undefined);
+    expect(GitService.createAnnotatedTag).toHaveBeenCalledWith('v1.3.0', '- Added feature\n- Fixed bug');
+    expect(GitService.pushTag).not.toHaveBeenCalled();
+  });
+
+  it('should exit when commit history cannot be read', async () => {
+    (GitService.getCommitSummariesSince as jest.Mock).mockResolvedValue({
+      success: false,
+      error: 'No commits found'
+    });
+    (GitService.getLatestTag as jest.Mock).mockResolvedValue({
+      success: false,
+      error: 'No tags'
+    });
+
+    const command = getTagCommand();
+
+    await (command as any).handleTag('v2.0.0', { apiKey: 'test-key' });
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
+    expect(GitService.createAnnotatedTag).not.toHaveBeenCalled();
+    expect(GitService.pushTag).not.toHaveBeenCalled();
+  });
+
+  it('should use environment config when API key is not provided', async () => {
+    (GitService.getCommitSummariesSince as jest.Mock).mockResolvedValue({
+      success: true,
+      log: '- chore: update deps'
+    });
+    (GitService.createAnnotatedTag as jest.Mock).mockResolvedValue(true);
+    mockGenerateTagNotes.mockResolvedValue({
+      success: true,
+      notes: '- Updated dependencies'
+    });
+    (ConfigService.getConfig as jest.Mock).mockReturnValue({
+      apiKey: 'env-key',
+      baseURL: 'https://env.test',
+      model: 'env-model',
+      language: 'ko',
+      autoPush: false
+    });
+    (GitService.getLatestTag as jest.Mock).mockResolvedValue({
+      success: true,
+      tag: 'v1.0.0'
+    });
+
+    const command = getTagCommand();
+
+    await (command as any).handleTag('v1.1.0', {});
+
+    expect(GitService.getLatestTag).toHaveBeenCalled();
+    expect(AIService).toHaveBeenCalledWith({
+      apiKey: 'env-key',
+      baseURL: 'https://env.test',
+      model: 'env-model',
+      language: 'ko'
+    });
+    expect(GitService.createAnnotatedTag).toHaveBeenCalledWith('v1.1.0', '- Updated dependencies');
+    expect(GitService.pushTag).not.toHaveBeenCalled();
+  });
+
+  it('should push tag when user confirms', async () => {
+    (GitService.createAnnotatedTag as jest.Mock).mockResolvedValue(true);
+    (GitService.pushTag as jest.Mock).mockResolvedValue(true);
+    confirmSpy.mockResolvedValueOnce(true);
+
+    const command = getTagCommand();
+
+    await (command as any).handleTag('v2.0.0', { message: 'Release notes' });
+
+    expect(GitService.createAnnotatedTag).toHaveBeenCalledWith('v2.0.0', 'Release notes');
+    expect(GitService.pushTag).toHaveBeenCalledWith('v2.0.0');
+    expect(exitSpy).not.toHaveBeenCalled();
+  });
+
+  it('should exit when tag push fails after confirmation', async () => {
+    (GitService.createAnnotatedTag as jest.Mock).mockResolvedValue(true);
+    (GitService.pushTag as jest.Mock).mockResolvedValue(false);
+    confirmSpy.mockResolvedValueOnce(true);
+
+    const command = getTagCommand();
+
+    await (command as any).handleTag('v3.0.0', { message: 'Release notes' });
+
+    expect(GitService.createAnnotatedTag).toHaveBeenCalledWith('v3.0.0', 'Release notes');
+    expect(GitService.pushTag).toHaveBeenCalledWith('v3.0.0');
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+});