@aaronshaf/ger 0.3.1 → 0.3.3

package/tests/unit/commands/push.test.ts

@@ -0,0 +1,194 @@
+import { test, expect, describe } from 'bun:test'
+import { buildPushRefspec, validateEmails, PushError } from '@/cli/commands/push'
+
+describe('Push Command', () => {
+  describe('buildPushRefspec', () => {
+    test('should build basic refspec without options', () => {
+      const refspec = buildPushRefspec('master', {})
+      expect(refspec).toBe('refs/for/master')
+    })
+
+    test('should build refspec with topic', () => {
+      const refspec = buildPushRefspec('master', { topic: 'my-feature' })
+      expect(refspec).toBe('refs/for/master%topic=my-feature')
+    })
+
+    test('should URL-encode topic with special characters', () => {
+      const refspec = buildPushRefspec('master', { topic: 'feature/auth-fix' })
+      expect(refspec).toBe('refs/for/master%topic=feature%2Fauth-fix')
+    })
+
+    test('should build refspec with wip flag', () => {
+      const refspec = buildPushRefspec('master', { wip: true })
+      expect(refspec).toBe('refs/for/master%wip')
+    })
+
+    test('should build refspec with draft flag (alias for wip)', () => {
+      const refspec = buildPushRefspec('master', { draft: true })
+      expect(refspec).toBe('refs/for/master%wip')
+    })
+
+    test('should build refspec with ready flag', () => {
+      const refspec = buildPushRefspec('master', { ready: true })
+      expect(refspec).toBe('refs/for/master%ready')
+    })
+
+    test('should build refspec with private flag', () => {
+      const refspec = buildPushRefspec('master', { private: true })
+      expect(refspec).toBe('refs/for/master%private')
+    })
+
+    test('should build refspec with single reviewer', () => {
+      const refspec = buildPushRefspec('master', { reviewer: ['alice@example.com'] })
+      expect(refspec).toBe('refs/for/master%r=alice@example.com')
+    })
+
+    test('should build refspec with multiple reviewers', () => {
+      const refspec = buildPushRefspec('master', {
+        reviewer: ['alice@example.com', 'bob@example.com'],
+      })
+      expect(refspec).toBe('refs/for/master%r=alice@example.com,r=bob@example.com')
+    })
+
+    test('should build refspec with single cc', () => {
+      const refspec = buildPushRefspec('master', { cc: ['manager@example.com'] })
+      expect(refspec).toBe('refs/for/master%cc=manager@example.com')
+    })
+
+    test('should build refspec with multiple ccs', () => {
+      const refspec = buildPushRefspec('master', {
+        cc: ['manager@example.com', 'lead@example.com'],
+      })
+      expect(refspec).toBe('refs/for/master%cc=manager@example.com,cc=lead@example.com')
+    })
+
+    test('should build refspec with single hashtag', () => {
+      const refspec = buildPushRefspec('master', { hashtag: ['bugfix'] })
+      expect(refspec).toBe('refs/for/master%hashtag=bugfix')
+    })
+
+    test('should build refspec with multiple hashtags', () => {
+      const refspec = buildPushRefspec('master', { hashtag: ['bugfix', 'urgent'] })
+      expect(refspec).toBe('refs/for/master%hashtag=bugfix,hashtag=urgent')
+    })
+
+    test('should URL-encode hashtags with special characters', () => {
+      const refspec = buildPushRefspec('master', { hashtag: ['release/v1.0'] })
+      expect(refspec).toBe('refs/for/master%hashtag=release%2Fv1.0')
+    })
+
+    test('should build refspec with multiple options combined', () => {
+      const refspec = buildPushRefspec('main', {
+        topic: 'auth-refactor',
+        reviewer: ['alice@example.com'],
+        cc: ['manager@example.com'],
+        wip: true,
+        hashtag: ['security'],
+      })
+      expect(refspec).toBe(
+        'refs/for/main%topic=auth-refactor,wip,r=alice@example.com,cc=manager@example.com,hashtag=security',
+      )
+    })
+
+    test('should handle different branch names', () => {
+      expect(buildPushRefspec('main', {})).toBe('refs/for/main')
+      expect(buildPushRefspec('develop', {})).toBe('refs/for/develop')
+      expect(buildPushRefspec('feature/my-branch', {})).toBe('refs/for/feature/my-branch')
+      expect(buildPushRefspec('release/v1.0', {})).toBe('refs/for/release/v1.0')
+    })
+
+    test('should preserve order of parameters', () => {
+      // The order should be: topic, wip, ready, private, reviewers, ccs, hashtags
+      const refspec = buildPushRefspec('master', {
+        hashtag: ['tag1'],
+        reviewer: ['r@example.com'],
+        topic: 'topic1',
+        wip: true,
+        cc: ['cc@example.com'],
+        private: true,
+      })
+      // Order in the code: topic, wip, ready, private, reviewer, cc, hashtag
+      expect(refspec).toBe(
+        'refs/for/master%topic=topic1,wip,private,r=r@example.com,cc=cc@example.com,hashtag=tag1',
+      )
+    })
+
+    test('should handle empty arrays gracefully', () => {
+      const refspec = buildPushRefspec('master', {
+        reviewer: [],
+        cc: [],
+        hashtag: [],
+      })
+      expect(refspec).toBe('refs/for/master')
+    })
+
+    test('should not add wip twice when both wip and draft are true', () => {
+      const refspec = buildPushRefspec('master', { wip: true, draft: true })
+      // Both wip and draft set the wip flag, but we check wip first, so only one 'wip' should appear
+      expect(refspec).toBe('refs/for/master%wip')
+    })
+  })
+
+  describe('validateEmails', () => {
+    test('should accept valid email addresses', () => {
+      expect(() => validateEmails(['user@example.com'], 'reviewer')).not.toThrow()
+      expect(() => validateEmails(['alice@company.org'], 'cc')).not.toThrow()
+      expect(() => validateEmails(['test.user@sub.domain.com'], 'reviewer')).not.toThrow()
+    })
+
+    test('should accept multiple valid emails', () => {
+      expect(() =>
+        validateEmails(['user1@example.com', 'user2@example.com'], 'reviewer'),
+      ).not.toThrow()
+    })
+
+    test('should accept undefined', () => {
+      expect(() => validateEmails(undefined, 'reviewer')).not.toThrow()
+    })
+
+    test('should accept empty array', () => {
+      expect(() => validateEmails([], 'reviewer')).not.toThrow()
+    })
+
+    test('should reject email without @', () => {
+      expect(() => validateEmails(['userexample.com'], 'reviewer')).toThrow(PushError)
+    })
+
+    test('should reject email without domain', () => {
+      expect(() => validateEmails(['user@'], 'reviewer')).toThrow(PushError)
+    })
+
+    test('should reject email without user', () => {
+      expect(() => validateEmails(['@example.com'], 'reviewer')).toThrow(PushError)
+    })
+
+    test('should reject email with spaces', () => {
+      expect(() => validateEmails(['user @example.com'], 'reviewer')).toThrow(PushError)
+    })
+
+    test('should reject plain username', () => {
+      expect(() => validateEmails(['username'], 'reviewer')).toThrow(PushError)
+    })
+
+    test('should include field name in error message', () => {
+      try {
+        validateEmails(['invalid'], 'reviewer')
+        expect(true).toBe(false) // Should not reach here
+      } catch (e) {
+        expect(e).toBeInstanceOf(PushError)
+        expect((e as PushError).message).toContain('reviewer')
+        expect((e as PushError).message).toContain('invalid')
+      }
+    })
+
+    test('should fail on first invalid email in array', () => {
+      try {
+        validateEmails(['valid@example.com', 'invalid', 'another@example.com'], 'cc')
+        expect(true).toBe(false)
+      } catch (e) {
+        expect(e).toBeInstanceOf(PushError)
+        expect((e as PushError).message).toContain('invalid')
+      }
+    })
+  })
+})

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/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)
+    })
+  })
+})