@aaronshaf/ger 1.2.10 → 2.0.0

package/tests/unit/git-branch-detection.test.ts

@@ -0,0 +1,82 @@
+import { describe, test, expect } from 'bun:test'
+import { Effect, Layer } from 'effect'
+import { GitWorktreeService } from '@/services/git-worktree'
+
+describe('Git Worktree Creation', () => {
+  test('should handle commit-based worktree creation in service interface', async () => {
+    // This test verifies that the GitWorktreeService creates worktrees using
+    // commit hashes to avoid branch conflicts (detached HEAD approach)
+
+    const mockGitService = {
+      validatePreconditions: () => Effect.succeed(undefined),
+      createWorktree: (changeId: string) => {
+        // Simulate commit-based worktree creation (detached HEAD)
+        return Effect.succeed({
+          path: `/tmp/test-worktree-${changeId}`,
+          changeId,
+          originalCwd: process.cwd(),
+          timestamp: Date.now(),
+          pid: process.pid,
+        })
+      },
+      fetchAndCheckoutPatchset: () => Effect.succeed(undefined),
+      cleanup: () => Effect.succeed(undefined),
+      getChangedFiles: () => Effect.succeed(['test.ts']),
+    }
+
+    const result = await Effect.runPromise(
+      Effect.gen(function* () {
+        const service = yield* GitWorktreeService
+
+        // This call should work without specifying a base branch
+        // The implementation will auto-detect main vs master vs other
+        const worktree = yield* service.createWorktree('12345')
+
+        return worktree
+      }).pipe(Effect.provide(Layer.succeed(GitWorktreeService, mockGitService))),
+    )
+
+    expect(result.changeId).toBe('12345')
+    expect(result.path).toContain('12345')
+  })
+
+  test('should demonstrate branch detection scenarios', () => {
+    // Test various branch detection patterns that the real implementation should handle
+    const testCases = [
+      { input: 'refs/remotes/origin/main', expected: 'main' },
+      { input: 'refs/remotes/origin/master', expected: 'master' },
+      { input: 'refs/remotes/origin/develop', expected: 'develop' },
+    ]
+
+    testCases.forEach(({ input, expected }) => {
+      // Simulate the regex pattern used in getDefaultBranch
+      const match = input.match(/refs\/remotes\/origin\/(.+)$/)
+      const result = match ? match[1] : 'main'
+      expect(result).toBe(expected)
+    })
+  })
+
+  test('should handle branch list parsing scenarios', () => {
+    // Test branch list parsing scenarios
+    const testCases = [
+      { input: '  origin/main\n  origin/feature-branch', expected: 'main' },
+      { input: '  origin/master\n  origin/develop', expected: 'master' },
+      { input: '  origin/main\n  origin/master', expected: 'main' }, // main takes precedence
+      { input: '  origin/feature-only', expected: 'main' }, // fallback
+      { input: '', expected: 'main' }, // empty fallback
+    ]
+
+    testCases.forEach(({ input, expected }) => {
+      // Simulate the branch detection logic
+      let result: string
+      if (input.includes('origin/main')) {
+        result = 'main'
+      } else if (input.includes('origin/master')) {
+        result = 'master'
+      } else {
+        result = 'main' // fallback
+      }
+      expect(result).toBe(expected)
+    })
+  })
+})

package/tests/unit/git-worktree.test.ts

@@ -0,0 +1,55 @@
+import { describe, test, expect } from 'bun:test'
+import { Effect, Layer } from 'effect'
+import { GitWorktreeService, WorktreeInfo } from '@/services/git-worktree'
+
+describe('GitWorktreeService Types and Structure', () => {
+  test('should export WorktreeInfo interface with correct structure', () => {
+    const mockWorktreeInfo: WorktreeInfo = {
+      path: '/tmp/test-worktree',
+      changeId: '12345',
+      originalCwd: '/test/current',
+      timestamp: Date.now(),
+      pid: process.pid,
+    }
+
+    expect(mockWorktreeInfo.path).toBe('/tmp/test-worktree')
+    expect(mockWorktreeInfo.changeId).toBe('12345')
+    expect(mockWorktreeInfo.originalCwd).toBe('/test/current')
+    expect(typeof mockWorktreeInfo.timestamp).toBe('number')
+    expect(typeof mockWorktreeInfo.pid).toBe('number')
+  })
+
+  test('should create service tag correctly', () => {
+    expect(GitWorktreeService).toBeDefined()
+    expect(typeof GitWorktreeService).toBe('object')
+    expect(GitWorktreeService.key).toBe('GitWorktreeService')
+  })
+
+  test('should be able to create mock service implementation', async () => {
+    const mockService = {
+      validatePreconditions: () => Effect.succeed(undefined),
+      createWorktree: (changeId: string) =>
+        Effect.succeed({
+          path: `/tmp/test-worktree-${changeId}`,
+          changeId,
+          originalCwd: process.cwd(),
+          timestamp: Date.now(),
+          pid: process.pid,
+        }),
+      fetchAndCheckoutPatchset: () => Effect.succeed(undefined),
+      cleanup: () => Effect.succeed(undefined),
+      getChangedFiles: () => Effect.succeed(['test.ts']),
+    }
+
+    const result = await Effect.runPromise(
+      Effect.gen(function* () {
+        const service = yield* GitWorktreeService
+        const worktree = yield* service.createWorktree('12345')
+        return worktree
+      }).pipe(Effect.provide(Layer.succeed(GitWorktreeService, mockService))),
+    )
+
+    expect(result.changeId).toBe('12345')
+    expect(result.path).toContain('12345')
+  })
+})

package/tests/unit/patterns/push-patterns.test.ts

@@ -0,0 +1,148 @@
+import { describe, test, expect } from 'bun:test'
+import { CHANGE_ID_PATTERN } from '@/services/commit-hook'
+
+// Pattern matching tests for push command output parsing
+// These test regex patterns and string parsing logic used by the push command
+// Unit tests for buildPushRefspec are in tests/unit/commands/push.test.ts
+
+describe('Push Command', () => {
+  describe('remote detection logic', () => {
+    test('should handle SSH remote format', () => {
+      const sshRemote = 'git@gerrit.example.com:project.git'
+
+      // Extract hostname from SSH format
+      const hostname = sshRemote.split('@')[1].split(':')[0]
+      expect(hostname).toBe('gerrit.example.com')
+    })
+
+    test('should handle HTTPS remote format', () => {
+      const httpsRemote = 'https://gerrit.example.com/project'
+
+      const url = new URL(httpsRemote)
+      expect(url.hostname).toBe('gerrit.example.com')
+    })
+
+    test('should parse remote output format', () => {
+      const remoteOutput = `origin\thttps://gerrit.example.com/project\t(fetch)
+origin\thttps://gerrit.example.com/project\t(push)
+upstream\tgit@github.com:org/project.git\t(fetch)
+upstream\tgit@github.com:org/project.git\t(push)`
+
+      const remotes: Record<string, string> = {}
+      for (const line of remoteOutput.split('\n')) {
+        const match = line.match(/^(\S+)\s+(\S+)\s+\(push\)$/)
+        if (match) {
+          remotes[match[1]] = match[2]
+        }
+      }
+
+      expect(remotes['origin']).toBe('https://gerrit.example.com/project')
+      expect(remotes['upstream']).toBe('git@github.com:org/project.git')
+    })
+  })
+
+  // Note: refspec building tests are in tests/unit/commands/push.test.ts
+
+  describe('change URL extraction', () => {
+    test('should extract change URL from push output', () => {
+      const output = `Enumerating objects: 5, done.
+Counting objects: 100% (5/5), done.
+Delta compression using up to 8 threads
+Compressing objects: 100% (3/3), done.
+Writing objects: 100% (3/3), 512 bytes | 512.00 KiB/s, done.
+Total 3 (delta 2), reused 0 (delta 0), pack-reused 0
+remote: Resolving deltas: 100% (2/2)
+remote: Processing changes: refs: 1, new: 1, done
+remote:
+remote: SUCCESS
+remote:
+remote:   https://gerrit.example.com/c/project/+/12345 Fix auth bug [NEW]
+remote:
+To https://gerrit.example.com/project
+ * [new reference]   HEAD -> refs/for/master`
+
+      const urlMatch = output.match(/remote:\s+(https?:\/\/\S+\/c\/\S+\/\+\/\d+)/)
+      expect(urlMatch).not.toBeNull()
+      expect(urlMatch![1]).toBe('https://gerrit.example.com/c/project/+/12345')
+    })
+
+    test('should handle output without change URL', () => {
+      const output = `Everything up-to-date
+remote: no new changes`
+
+      const urlMatch = output.match(/remote:\s+(https?:\/\/\S+\/c\/\S+\/\+\/\d+)/)
+      expect(urlMatch).toBeNull()
+    })
+  })
+
+  describe('commit-msg hook detection', () => {
+    test('should check for Change-Id in commit message', () => {
+      const commitWithChangeId = `Fix authentication bug
+
+This commit fixes the login issue.
+
+Change-Id: I1234567890123456789012345678901234567890`
+
+      expect(CHANGE_ID_PATTERN.test(commitWithChangeId)).toBe(true)
+    })
+
+    test('should detect missing Change-Id', () => {
+      const commitWithoutChangeId = `Fix authentication bug
+
+This commit fixes the login issue.`
+
+      expect(CHANGE_ID_PATTERN.test(commitWithoutChangeId)).toBe(false)
+    })
+  })
+
+  describe('error handling', () => {
+    test('should detect permission denied error', () => {
+      const errorOutput = 'fatal: remote error: Permission denied (prohibited by Gerrit)'
+
+      expect(errorOutput).toContain('prohibited by Gerrit')
+    })
+
+    test('should detect network error', () => {
+      const errorOutput =
+        "fatal: unable to access 'https://gerrit.example.com/': Could not resolve host"
+
+      expect(errorOutput).toContain('Could not resolve host')
+    })
+
+    test('should detect invalid ref error', () => {
+      const errorOutput = 'fatal: invalid refspec'
+
+      expect(errorOutput).toContain('invalid refspec')
+    })
+
+    test('should detect no new changes', () => {
+      const output = 'Everything up-to-date\nremote: no new changes'
+
+      expect(output).toContain('no new changes')
+    })
+
+    test('should detect authentication failure', () => {
+      const errorOutput = 'fatal: Authentication failed for'
+
+      expect(errorOutput).toContain('Authentication failed')
+    })
+  })
+
+  describe('git command patterns', () => {
+    test('should build correct push command args', () => {
+      const remote = 'origin'
+      const refspec = 'refs/for/master%topic=test'
+
+      const args = ['push', remote, `HEAD:${refspec}`]
+      expect(args).toEqual(['push', 'origin', 'HEAD:refs/for/master%topic=test'])
+    })
+
+    test('should build correct dry-run push command args', () => {
+      const remote = 'origin'
+      const refspec = 'refs/for/master'
+
+      const args = ['push', '--dry-run', remote, `HEAD:${refspec}`]
+      expect(args).toEqual(['push', '--dry-run', 'origin', 'HEAD:refs/for/master'])
+    })
+  })
+})

package/tests/unit/schemas/gerrit.test.ts

@@ -0,0 +1,85 @@
+import { describe, expect, test } from 'bun:test'
+import { Schema } from '@effect/schema'
+import { CommentInput, GerritCredentials } from '@/schemas/gerrit'
+
+describe('Gerrit Schemas', () => {
+  describe('GerritCredentials', () => {
+    test('should validate valid credentials', () => {
+      const validCredentials = {
+        host: 'https://gerrit.example.com',
+        username: 'testuser',
+        password: 'testpass123',
+      }
+
+      const result = Schema.decodeUnknownSync(GerritCredentials)(validCredentials)
+      expect(result).toEqual(validCredentials)
+    })
+
+    test('should reject invalid URL', () => {
+      const invalidCredentials = {
+        host: 'not-a-url',
+        username: 'testuser',
+        password: 'testpass123',
+      }
+
+      expect(() => {
+        Schema.decodeUnknownSync(GerritCredentials)(invalidCredentials)
+      }).toThrow()
+    })
+
+    test('should reject empty username', () => {
+      const invalidCredentials = {
+        host: 'https://gerrit.example.com',
+        username: '',
+        password: 'testpass123',
+      }
+
+      expect(() => {
+        Schema.decodeUnknownSync(GerritCredentials)(invalidCredentials)
+      }).toThrow()
+    })
+
+    test('should reject empty password', () => {
+      const invalidCredentials = {
+        host: 'https://gerrit.example.com',
+        username: 'testuser',
+        password: '',
+      }
+
+      expect(() => {
+        Schema.decodeUnknownSync(GerritCredentials)(invalidCredentials)
+      }).toThrow()
+    })
+  })
+
+  describe('CommentInput', () => {
+    test('should validate valid comment input', () => {
+      const validComment = {
+        message: 'This is a test comment',
+        unresolved: true,
+      }
+
+      const result = Schema.decodeUnknownSync(CommentInput)(validComment)
+      expect(result).toEqual(validComment)
+    })
+
+    test('should validate comment without unresolved flag', () => {
+      const validComment = {
+        message: 'This is a test comment',
+      }
+
+      const result = Schema.decodeUnknownSync(CommentInput)(validComment)
+      expect(result).toEqual(validComment)
+    })
+
+    test('should reject empty message', () => {
+      const invalidComment = {
+        message: '',
+      }
+
+      expect(() => {
+        Schema.decodeUnknownSync(CommentInput)(invalidComment)
+      }).toThrow()
+    })
+  })
+})

package/tests/unit/services/commit-hook.test.ts

@@ -0,0 +1,132 @@
+import { test, expect, describe } from 'bun:test'
+import { CHANGE_ID_PATTERN } from '@/services/commit-hook'
+
+// Tests for commit-hook service patterns
+// Note: Tests that require actual git operations are skipped in the full test suite
+// due to mock pollution from other test files. Run these tests in isolation for full coverage:
+// bun test tests/unit/services/commit-hook.test.ts
+
+describe('Commit Hook Service', () => {
+  describe('CHANGE_ID_PATTERN', () => {
+    test('should match valid Change-Id', () => {
+      const validIds = [
+        'Change-Id: I1234567890123456789012345678901234567890',
+        'Change-Id: Iabcdefabcdefabcdefabcdefabcdefabcdefabcd',
+        'Change-Id: I0000000000000000000000000000000000000000',
+        'Change-Id: Iffffffffffffffffffffffffffffffffffffffff',
+      ]
+
+      for (const id of validIds) {
+        expect(CHANGE_ID_PATTERN.test(id)).toBe(true)
+      }
+    })
+
+    test('should not match invalid Change-Id', () => {
+      const invalidIds = [
+        'Change-Id: 1234567890123456789012345678901234567890', // Missing I prefix
+        'Change-Id: I123456789012345678901234567890123456789', // Too short (39 chars)
+        'Change-Id: I12345678901234567890123456789012345678901', // Too long (41 chars)
+        'Change-Id: IGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG', // Invalid hex chars
+        'Change-Id: i1234567890123456789012345678901234567890', // Lowercase I
+        'change-id: I1234567890123456789012345678901234567890', // Lowercase prefix
+      ]
+
+      for (const id of invalidIds) {
+        expect(CHANGE_ID_PATTERN.test(id)).toBe(false)
+      }
+    })
+
+    test('should match Change-Id in multiline commit message', () => {
+      const commitMessage = `Fix authentication bug
+
+This commit fixes the login issue where users
+were being logged out unexpectedly.
+
+Change-Id: I1234567890123456789012345678901234567890
+Signed-off-by: Test User <test@example.com>`
+
+      expect(CHANGE_ID_PATTERN.test(commitMessage)).toBe(true)
+    })
+
+    test('should not match Change-Id in wrong position', () => {
+      // Change-Id should be at start of line
+      const wrongPosition = '  Change-Id: I1234567890123456789012345678901234567890'
+      expect(CHANGE_ID_PATTERN.test(wrongPosition)).toBe(false)
+    })
+  })
+
+  describe('hook path patterns', () => {
+    test('should construct correct hooks directory path', () => {
+      const gitDir = '.git'
+      const hooksDir = `${gitDir}/hooks`
+      expect(hooksDir).toBe('.git/hooks')
+    })
+
+    test('should construct correct commit-msg hook path', () => {
+      const gitDir = '.git'
+      const hookPath = `${gitDir}/hooks/commit-msg`
+      expect(hookPath).toBe('.git/hooks/commit-msg')
+    })
+
+    test('should handle absolute git dir path', () => {
+      const gitDir = '/home/user/project/.git'
+      const hookPath = `${gitDir}/hooks/commit-msg`
+      expect(hookPath).toBe('/home/user/project/.git/hooks/commit-msg')
+    })
+  })
+
+  describe('hook URL construction', () => {
+    test('should construct correct hook URL', () => {
+      const host = 'https://gerrit.example.com'
+      const hookUrl = `${host}/tools/hooks/commit-msg`
+      expect(hookUrl).toBe('https://gerrit.example.com/tools/hooks/commit-msg')
+    })
+
+    test('should handle host with trailing slash', () => {
+      const host = 'https://gerrit.example.com/'
+      const normalizedHost = host.replace(/\/$/, '')
+      const hookUrl = `${normalizedHost}/tools/hooks/commit-msg`
+      expect(hookUrl).toBe('https://gerrit.example.com/tools/hooks/commit-msg')
+    })
+  })
+
+  describe('hook content validation', () => {
+    test('should validate shell script header', () => {
+      const validHook = '#!/bin/sh\necho "Adding Change-Id"'
+      expect(validHook.startsWith('#!')).toBe(true)
+    })
+
+    test('should reject non-script content', () => {
+      const invalidHook = 'This is not a script'
+      expect(invalidHook.startsWith('#!')).toBe(false)
+    })
+
+    test('should validate bash script header', () => {
+      const bashHook = '#!/bin/bash\necho "Adding Change-Id"'
+      expect(bashHook.startsWith('#!')).toBe(true)
+    })
+  })
+
+  describe('executable bit checking', () => {
+    test('should identify executable mode', () => {
+      const executableMode = 0o755
+      const ownerExecuteBit = 0o100
+
+      expect((executableMode & ownerExecuteBit) !== 0).toBe(true)
+    })
+
+    test('should identify non-executable mode', () => {
+      const nonExecutableMode = 0o644
+      const ownerExecuteBit = 0o100
+
+      expect((nonExecutableMode & ownerExecuteBit) !== 0).toBe(false)
+    })
+
+    test('should handle read-only mode', () => {
+      const readOnlyMode = 0o444
+      const ownerExecuteBit = 0o100
+
+      expect((readOnlyMode & ownerExecuteBit) !== 0).toBe(false)
+    })
+  })
+})