ClaudeCodeInstaller/tests/constants.test.ts

import { describe, it, expect } from 'vitest'
import {
  FALLBACK_VERSIONS,
  ERROR_MESSAGES,
  STATUS_MESSAGES,
  NPM_REGISTRY,
  GIT_MIRRORS,
  NODEJS_MIRRORS,
  VSCODE_API,
  MIN_SUPPORTED_NODE_VERSION,
  MAX_MAJOR_VERSIONS,
  REQUEST_TIMEOUT,
  MAX_RETRIES,
  RETRY_DELAY,
  VERSION_CACHE_TTL,
  SOURCE_UPDATE_CACHE_TTL,
  BREW_PACKAGES,
  APP_NAME
} from '../electron/modules/constants'

describe('constants', () => {
  describe('FALLBACK_VERSIONS', () => {
    it('should have valid Node.js version format', () => {
      expect(FALLBACK_VERSIONS.nodejs).toMatch(/^\d+\.\d+\.\d+$/)
    })

    it('should have valid VS Code version format', () => {
      expect(FALLBACK_VERSIONS.vscode).toMatch(/^\d+\.\d+\.\d+$/)
    })

    it('should have valid Git version format', () => {
      expect(FALLBACK_VERSIONS.git).toMatch(/^\d+\.\d+\.\d+$/)
    })
  })

  describe('ERROR_MESSAGES', () => {
    it('should have all required error messages', () => {
      expect(ERROR_MESSAGES.NETWORK_ERROR).toBeDefined()
      expect(ERROR_MESSAGES.TIMEOUT_ERROR).toBeDefined()
      expect(ERROR_MESSAGES.VERSION_FETCH_ERROR).toBeDefined()
      expect(ERROR_MESSAGES.INSTALL_ERROR).toBeDefined()
      expect(ERROR_MESSAGES.PERMISSION_ERROR).toBeDefined()
      expect(ERROR_MESSAGES.UNSUPPORTED_PLATFORM).toBeDefined()
      expect(ERROR_MESSAGES.UNKNOWN_SOFTWARE).toBeDefined()
      expect(ERROR_MESSAGES.INSTALL_CANCELLED).toBeDefined()
    })
  })

  describe('STATUS_MESSAGES', () => {
    it('should have all required status messages', () => {
      expect(STATUS_MESSAGES.PREPARING).toBeDefined()
      expect(STATUS_MESSAGES.INSTALLING).toBeDefined()
      expect(STATUS_MESSAGES.CONFIGURING).toBeDefined()
      expect(STATUS_MESSAGES.COMPLETE).toBeDefined()
      expect(STATUS_MESSAGES.READY).toBeDefined()
    })
  })

  describe('NPM_REGISTRY', () => {
    it('should be a valid URL', () => {
      expect(NPM_REGISTRY).toMatch(/^https?:\/\//)
    })
  })

  describe('GIT_MIRRORS', () => {
    it('should have huaweicloud mirror', () => {
      expect(GIT_MIRRORS.huaweicloud).toBeDefined()
      expect(GIT_MIRRORS.huaweicloud.name).toBeDefined()
      expect(GIT_MIRRORS.huaweicloud.getDownloadUrl).toBeTypeOf('function')
      expect(GIT_MIRRORS.huaweicloud.versionsUrl).toBeDefined()
    })

    it('should have github mirror', () => {
      expect(GIT_MIRRORS.github).toBeDefined()
      expect(GIT_MIRRORS.github.name).toBeDefined()
      expect(GIT_MIRRORS.github.getDownloadUrl).toBeTypeOf('function')
      expect(GIT_MIRRORS.github.versionsUrl).toBeDefined()
    })

    it('should generate valid download URLs', () => {
      const huaweiUrl = GIT_MIRRORS.huaweicloud.getDownloadUrl('2.47.1', '64')
      expect(huaweiUrl).toContain('2.47.1')
      expect(huaweiUrl).toContain('64')

      const githubUrl = GIT_MIRRORS.github.getDownloadUrl('2.47.1', '64')
      expect(githubUrl).toContain('2.47.1')
      expect(githubUrl).toContain('64')
    })
  })

  describe('NODEJS_MIRRORS', () => {
    it('should have official mirror', () => {
      expect(NODEJS_MIRRORS.official).toBeDefined()
      expect(NODEJS_MIRRORS.official.name).toBeDefined()
      expect(NODEJS_MIRRORS.official.getDownloadUrl).toBeTypeOf('function')
      expect(NODEJS_MIRRORS.official.versionsUrl).toBeDefined()
    })

    it('should have npmmirror mirror', () => {
      expect(NODEJS_MIRRORS.npmmirror).toBeDefined()
      expect(NODEJS_MIRRORS.npmmirror.name).toBeDefined()
      expect(NODEJS_MIRRORS.npmmirror.getDownloadUrl).toBeTypeOf('function')
      expect(NODEJS_MIRRORS.npmmirror.versionsUrl).toBeDefined()
    })

    it('should generate valid download URLs', () => {
      const officialUrl = NODEJS_MIRRORS.official.getDownloadUrl('22.12.0', 'x64')
      expect(officialUrl).toContain('22.12.0')
      expect(officialUrl).toContain('x64')

      const npmmirrorUrl = NODEJS_MIRRORS.npmmirror.getDownloadUrl('22.12.0', 'x64')
      expect(npmmirrorUrl).toContain('22.12.0')
      expect(npmmirrorUrl).toContain('x64')
    })
  })

  describe('VSCODE_API', () => {
    it('should have versionsUrl', () => {
      expect(VSCODE_API.versionsUrl).toBeDefined()
      expect(VSCODE_API.versionsUrl).toMatch(/^https?:\/\//)
    })

    it('should generate valid download URLs', () => {
      const url = VSCODE_API.getDownloadUrl('1.96.0', 'x64', 'user')
      expect(url).toContain('1.96.0')
      expect(url).toContain('x64')
      expect(url).toContain('user')
    })
  })

  describe('Configuration values', () => {
    it('should have valid MIN_SUPPORTED_NODE_VERSION', () => {
      expect(MIN_SUPPORTED_NODE_VERSION).toBeGreaterThanOrEqual(16)
    })

    it('should have valid MAX_MAJOR_VERSIONS', () => {
      expect(MAX_MAJOR_VERSIONS).toBeGreaterThan(0)
    })

    it('should have valid REQUEST_TIMEOUT', () => {
      expect(REQUEST_TIMEOUT).toBeGreaterThan(0)
    })

    it('should have valid MAX_RETRIES', () => {
      expect(MAX_RETRIES).toBeGreaterThan(0)
    })

    it('should have valid RETRY_DELAY', () => {
      expect(RETRY_DELAY).toBeGreaterThan(0)
    })

    it('should have valid VERSION_CACHE_TTL', () => {
      expect(VERSION_CACHE_TTL).toBeGreaterThan(0)
    })

    it('should have valid SOURCE_UPDATE_CACHE_TTL', () => {
      expect(SOURCE_UPDATE_CACHE_TTL).toBeGreaterThan(0)
    })
  })

  describe('BREW_PACKAGES', () => {
    it('should have nodejs packages', () => {
      expect(BREW_PACKAGES.nodejs).toBeDefined()
      expect(BREW_PACKAGES.nodejs.default).toBeDefined()
    })

    it('should have vscode packages', () => {
      expect(BREW_PACKAGES.vscode).toBeDefined()
      expect(BREW_PACKAGES.vscode.stable).toBeDefined()
      expect(BREW_PACKAGES.vscode.insiders).toBeDefined()
    })

    it('should have git packages', () => {
      expect(BREW_PACKAGES.git).toBeDefined()
      expect(BREW_PACKAGES.git.stable).toBeDefined()
    })
  })

  describe('APP_NAME', () => {
    it('should be defined', () => {
      expect(APP_NAME).toBeDefined()
      expect(APP_NAME).toBeTypeOf('string')
    })
  })
})