test(cli): add tests for utils modules with low coverage

Add comprehensive test coverage for:
- utils/cli/completion.mts: bash completion script generation
- utils/python/standalone.mts: Python re-exports verification
- utils/telemetry/service.mts: TelemetryService singleton pattern,
  event tracking, batching, and flushing

Author: jdalton

packages/cli/test/unit/utils/cli/completion.test.mts

@@ -1,173 +1,166 @@
 /**
- * Unit tests for CLI shell completion.
+ * Unit tests for CLI completion utilities.
  *
  * Purpose:
- * Tests shell completion generation for CLI commands. Validates bash, zsh, and fish completion scripts.
+ * Tests the bash completion script generation and configuration.
  *
  * Test Coverage:
- * - Completion script generation
- * - Command suggestion
- * - Flag completion
- * - Multi-shell support (bash, zsh, fish)
- * - Dynamic completion data
- *
- * Testing Approach:
- * Tests completion script output and validation logic.
+ * - COMPLETION_CMD_PREFIX constant
+ * - getCompletionSourcingCommand function
+ * - getBashrcDetails function
  *
  * Related Files:
  * - utils/cli/completion.mts (implementation)
  */
 
-import fs from 'node:fs'
-import path from 'node:path'
-
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
+// Mock fs.existsSync.
+const mockExistsSync = vi.hoisted(() => vi.fn())
+vi.mock('node:fs', async importOriginal => {
+  const actual = (await importOriginal()) as typeof import('node:fs')
+  return {
+    ...actual,
+    default: {
+      ...actual,
+      existsSync: mockExistsSync,
+    },
+    existsSync: mockExistsSync,
+  }
+})
+
+// Mock getSocketAppDataPath.
+const mockGetSocketAppDataPath = vi.hoisted(() => vi.fn())
+vi.mock('../../../../src/constants/paths.mts', async importOriginal => {
+  const actual =
+    (await importOriginal()) as typeof import('../../../../src/constants/paths.mts')
+  return {
+    ...actual,
+    getSocketAppDataPath: mockGetSocketAppDataPath,
+  }
+})
+
 import {
   COMPLETION_CMD_PREFIX,
   getBashrcDetails,
   getCompletionSourcingCommand,
 } from '../../../../src/utils/cli/completion.mts'
 
-// Mock node:fs.
-const mockGetSocketAppDataPath = vi.hoisted(() => vi.fn(() => '/mock/app/data'))
-
-vi.mock('node:fs', () => ({
-  default: {
-    existsSync: vi.fn(),
-  },
-}))
-
-// Mock constants/paths.
-vi.mock('../../../../src/constants/paths.mts', () => ({
-  rootPath: '/mock/dist/path',
-  getSocketAppDataPath: mockGetSocketAppDataPath,
-}))
-
-describe('completion utilities', () => {
+describe('cli/completion', () => {
   beforeEach(() => {
     vi.clearAllMocks()
   })
 
   describe('COMPLETION_CMD_PREFIX', () => {
-    it('has the expected value', () => {
+    it('has the correct prefix', () => {
       expect(COMPLETION_CMD_PREFIX).toBe('complete -F _socket_completion')
     })
   })
 
   describe('getCompletionSourcingCommand', () => {
-    it('returns sourcing command when completion script exists', () => {
-      vi.mocked(fs.existsSync).mockReturnValue(true)
+    it('returns error when completion script does not exist', () => {
+      mockExistsSync.mockReturnValue(false)
 
       const result = getCompletionSourcingCommand()
 
-      expect(result).toEqual({
-        ok: true,
-        data: 'source /mock/dist/path/data/socket-completion.bash',
-      })
-
-      // Note: On Windows, path.join returns backslashes, which are then checked by existsSync.
-      // The implementation normalizes the path display but checks existence with the actual path.
-      const expectedPath =
-        path.sep === '\\'
-          ? '\\mock\\dist\\path\\data\\socket-completion.bash'
-          : '/mock/dist/path/data/socket-completion.bash'
-      expect(fs.existsSync).toHaveBeenCalledWith(expectedPath)
+      expect(result.ok).toBe(false)
+      if (!result.ok) {
+        expect(result.message).toBe('Tab Completion script not found')
+        expect(result.cause).toContain('Expected to find completion script')
+      }
     })
 
-    it('returns error when completion script does not exist', () => {
-      vi.mocked(fs.existsSync).mockReturnValue(false)
+    it('returns sourcing command when completion script exists', () => {
+      mockExistsSync.mockReturnValue(true)
 
       const result = getCompletionSourcingCommand()
 
-      expect(result).toEqual({
-        ok: false,
-        message: 'Tab Completion script not found',
-        cause:
-          'Expected to find completion script at `/mock/dist/path/data/socket-completion.bash` but it was not there',
-      })
+      expect(result.ok).toBe(true)
+      if (result.ok) {
+        expect(result.data).toContain('source')
+        expect(result.data).toContain('socket-completion.bash')
+      }
     })
-  })
 
-  describe('getBashrcDetails', () => {
-    it('returns bashrc details when everything is configured', () => {
-      vi.mocked(fs.existsSync).mockReturnValue(true)
+    it('uses forward slashes in sourcing command', () => {
+      mockExistsSync.mockReturnValue(true)
 
-      const result = getBashrcDetails('socket')
+      const result = getCompletionSourcingCommand()
 
       expect(result.ok).toBe(true)
       if (result.ok) {
-        expect(result.data.completionCommand).toBe(
-          'complete -F _socket_completion socket',
-        )
-        expect(result.data.sourcingCommand).toBe(
-          'source /mock/dist/path/data/socket-completion.bash',
-        )
-        expect(result.data.targetName).toBe('socket')
-        expect(result.data.targetPath).toBe(
-          '/mock/app/completion/socket-completion.bash',
-        )
-        expect(result.data.toAddToBashrc).toContain(
-          '# Socket CLI completion for "socket"',
-        )
-        expect(result.data.toAddToBashrc).toContain(
-          'source "/mock/app/completion/socket-completion.bash"',
-        )
-        expect(result.data.toAddToBashrc).toContain(
-          'complete -F _socket_completion socket',
-        )
+        expect(result.data).not.toContain('\\')
       }
     })
+  })
 
-    it('returns error when completion script is missing', () => {
-      vi.mocked(fs.existsSync).mockReturnValue(false)
+  describe('getBashrcDetails', () => {
+    it('returns error when completion script does not exist', () => {
+      mockExistsSync.mockReturnValue(false)
 
       const result = getBashrcDetails('socket')
 
-      expect(result).toEqual({
-        ok: false,
-        message: 'Tab Completion script not found',
-        cause:
-          'Expected to find completion script at `/mock/dist/path/data/socket-completion.bash` but it was not there',
-      })
+      expect(result.ok).toBe(false)
+      if (!result.ok) {
+        expect(result.message).toBe('Tab Completion script not found')
+      }
     })
 
-    it('returns error when socketAppDataPath is not available', () => {
-      // This test is tricky because we need to re-mock the constants module.
-      // Since getBashrcDetails imports constants at the top level,
-      // we can't easily change it after import. Let's skip this test
-      // or mark it as todo since the logic is tested in other ways.
+    it('returns error when config directory cannot be determined', () => {
+      mockExistsSync.mockReturnValue(true)
+      mockGetSocketAppDataPath.mockReturnValue(null)
+
+      const result = getBashrcDetails('socket')
+
+      expect(result.ok).toBe(false)
+      if (!result.ok) {
+        expect(result.message).toBe('Could not determine config directory')
+      }
     })
 
-    it('handles different command names', () => {
-      vi.mocked(fs.existsSync).mockReturnValue(true)
+    it('returns bashrc details when everything is available', () => {
+      mockExistsSync.mockReturnValue(true)
+      mockGetSocketAppDataPath.mockReturnValue('/home/user/.socket/config.json')
 
-      const result = getBashrcDetails('my-custom-socket')
+      const result = getBashrcDetails('socket')
 
       expect(result.ok).toBe(true)
       if (result.ok) {
+        expect(result.data.targetName).toBe('socket')
         expect(result.data.completionCommand).toBe(
-          'complete -F _socket_completion my-custom-socket',
-        )
-        expect(result.data.targetName).toBe('my-custom-socket')
-        expect(result.data.toAddToBashrc).toContain('my-custom-socket')
-        expect(result.data.toAddToBashrc).toContain(
-          '# Socket CLI completion for "my-custom-socket"',
+          `${COMPLETION_CMD_PREFIX} socket`,
         )
+        expect(result.data.toAddToBashrc).toContain('Socket CLI completion')
+        expect(result.data.toAddToBashrc).toContain('socket')
+        expect(result.data.sourcingCommand).toContain('source')
       }
     })
 
-    it('constructs correct paths using path.join', () => {
-      vi.mocked(fs.existsSync).mockReturnValue(true)
+    it('uses forward slashes in target path', () => {
+      mockExistsSync.mockReturnValue(true)
+      mockGetSocketAppDataPath.mockReturnValue('/home/user/.socket/config.json')
 
       const result = getBashrcDetails('socket')
 
       expect(result.ok).toBe(true)
       if (result.ok) {
-        // Note: The implementation normalizes paths to forward slashes for bash compatibility.
-        expect(result.data.targetPath).toBe(
-          '/mock/app/completion/socket-completion.bash',
+        expect(result.data.targetPath).not.toContain('\\')
+      }
+    })
+
+    it('handles custom command names', () => {
+      mockExistsSync.mockReturnValue(true)
+      mockGetSocketAppDataPath.mockReturnValue('/home/user/.socket/config.json')
+
+      const result = getBashrcDetails('socket-npm')
+
+      expect(result.ok).toBe(true)
+      if (result.ok) {
+        expect(result.data.targetName).toBe('socket-npm')
+        expect(result.data.completionCommand).toBe(
+          `${COMPLETION_CMD_PREFIX} socket-npm`,
         )
+        expect(result.data.toAddToBashrc).toContain('socket-npm')
       }
     })
   })

packages/cli/test/unit/utils/python/standalone.test.mts

@@ -1,39 +1,43 @@
 /**
- * Unit tests for standalone Python utilities.
+ * Unit tests for Python standalone utilities.
  *
  * Purpose:
- * Tests standalone Python utilities. Validates Python binary detection.
+ * Tests the re-exports from the DLX spawn utilities.
  *
  * Test Coverage:
- * - ensurePython function
- * - Python binary availability
- *
- * Testing Approach:
- * Tests Python ecosystem utilities.
+ * - Re-export verification
+ * - Type export verification
  *
  * Related Files:
  * - utils/python/standalone.mts (implementation)
- * - utils/dlx/spawn.mts (actual implementation)
+ * - utils/dlx/spawn.mts (source module)
  */
 
 import { describe, expect, it } from 'vitest'
 
-import { ensurePython } from '../../../../src/utils/python/standalone.mts'
+import {
+  ensurePython,
+  ensurePythonDlx,
+  ensureSocketPyCli,
+  spawnSocketPyCli,
+} from '../../../../src/utils/python/standalone.mts'
+
+describe('python/standalone exports', () => {
+  describe('re-exported functions', () => {
+    it('exports ensurePython function', () => {
+      expect(typeof ensurePython).toBe('function')
+    })
+
+    it('exports ensurePythonDlx function', () => {
+      expect(typeof ensurePythonDlx).toBe('function')
+    })
+
+    it('exports ensureSocketPyCli function', () => {
+      expect(typeof ensureSocketPyCli).toBe('function')
+    })
 
-describe('python-standalone', () => {
-  describe('ensurePython', () => {
-    it('should ensure Python is available or throw error', async () => {
-      try {
-        const pythonBin = await ensurePython()
-        expect(typeof pythonBin).toBe('string')
-        expect(pythonBin.length).toBeGreaterThan(0)
-        expect(pythonBin).toContain('python')
-      } catch (e) {
-        // In test environment without proper constants, download might fail.
-        // This is expected and not a test failure.
-        expect(e).toBeDefined()
-      }
-      // Give it 60 seconds for potential download.
-    }, 60_000)
+    it('exports spawnSocketPyCli function', () => {
+      expect(typeof spawnSocketPyCli).toBe('function')
+    })
   })
 })