feat(secret): add test cases and improve decompress logic

- Add comprehensive test cases for crypto & compress utilities
- Improve `decompress` function to handle empty/invalid input gracefully
- Update error logging in `decompress` from error to warn level
- Refactor path utility tests with real filesystem operations
- Add `resolvePath` utility and enhance `mkdirp`/`rmrf` tests

Author: ryanuo

README.md

@@ -91,6 +91,8 @@ pnpm build
 # docs
 cd docs
 pnpm run predocs:dev
+
+# add test cases
 ```
 
 ## License

src/common/secret.ts

@@ -64,14 +64,16 @@ export function compress(str: string): string {
  * @returns The original decompressed string.
  */
 export function decompress(str: string): string {
+  if (!str)
+    return '' // 空字符串直接返回
   try {
     const decodedBase64 = decodeURIComponent(str)
     const binary = atob(decodedBase64)
     const bytes = Uint8Array.from(binary, c => c.charCodeAt(0))
     return new TextDecoder().decode(bytes)
   }
   catch (err) {
-    console.error('Decompress error:', err)
+    console.warn('Decompress error: Invalid input', err)
     return ''
   }
 }

test/common/secret.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it } from 'vitest'
+import { compress, decompress, decrypt, encrypt, xor } from '../../src/common/secret'
+
+describe('crypto & Compress Utils', () => {
+  const plainText = 'Hello World! 123'
+  const key = 'mysecret'
+
+  it('xor should be reversible', () => {
+    const encrypted = xor(plainText, key)
+    const decrypted = xor(encrypted, key)
+    expect(decrypted).toBe(plainText)
+  })
+
+  it('encrypt and decrypt should be reversible', () => {
+    const enc = encrypt(plainText, key)
+    const dec = decrypt(enc, key)
+    expect(dec).toBe(plainText)
+  })
+
+  it('encrypt produces URI-safe string', () => {
+    const enc = encrypt(plainText, key)
+    expect(enc).not.toContain(' ')
+    expect(enc).not.toContain('+')
+    expect(enc).not.toContain('=')
+  })
+
+  it('compress and decompress should be reversible', () => {
+    const compressed = compress(plainText)
+    const decompressed = decompress(compressed)
+    expect(decompressed).toBe(plainText)
+  })
+
+  it('decompress should return empty string on invalid input', () => {
+  // 非合法 URI
+    expect(decompress('%%%')).toBe('')
+    // 空字符串
+    expect(decompress('')).toBe('')
+  // undefined 需要先断言类型
+  })
+
+  it('decrypt should return empty string on invalid input', () => {
+    const result = decrypt('invalid%%%')
+    expect(result).toBe('')
+  })
+
+  it('xor with default key works', () => {
+    const encrypted = xor(plainText)
+    const decrypted = xor(encrypted)
+    expect(decrypted).toBe(plainText)
+  })
+
+  it('encrypt and decrypt with default key works', () => {
+    const enc = encrypt(plainText)
+    const dec = decrypt(enc)
+    expect(dec).toBe(plainText)
+  })
+})

test/node/path.test.ts

@@ -1,105 +1,48 @@
-import { access, mkdir, readdir, rm, stat } from 'node:fs/promises' // 根据实际情况调整导入
-import { dirname, join } from 'node:path'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { mkdirp, rmrf } from '../../src/node/path'
+import { existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { mkdirp, projectRoot, resolvePath, rmrf } from '../../src/node/path'
 
-// 模拟 fs/promises 和 path 模块
-vi.mock('fs/promises', async () => {
-  const actual = await vi.importActual('fs/promises')
-  return {
-    ...actual,
-    access: vi.fn(),
-    mkdir: vi.fn(),
-    stat: vi.fn(),
-    readdir: vi.fn(),
-    rm: vi.fn(),
-  }
-})
-
-// 修改:合并所有对 path 模块的模拟，避免重复定义
-vi.mock('path', () => ({
-  dirname: vi.fn(),
-  join: vi.fn(),
-  normalize: vi.fn(),
-}))
-
-describe('mkdirp', () => {
-  let accessMock: any
-  let mkdirMock: any
-  let dirnameMock: any
-
-  beforeEach(() => {
-    accessMock = vi.mocked(access)
-    mkdirMock = vi.mocked(mkdir)
-    dirnameMock = vi.mocked(dirname)
-  })
-
-  it('should not create directory if it already exists', async () => {
-    accessMock.mockResolvedValueOnce()
-
-    await mkdirp('/mock/path')
+describe('path Utils', () => {
+  const testDir = join(projectRoot, 'test-temp')
 
-    expect(accessMock).toHaveBeenCalledWith('/mock/path')
-    expect(mkdirMock).not.toHaveBeenCalled()
+  // 测试前确保目录不存在
+  beforeEach(async () => {
+    await rmrf(testDir).catch(() => {})
   })
 
-  it('should recursively create directories', async () => {
-    accessMock.mockRejectedValueOnce(new Error('ENOENT')) // 第一次访问失败
-    accessMock.mockResolvedValueOnce() // 父目录存在
-    dirnameMock.mockReturnValueOnce('/mock') // 第一次 dirname 调用
-
-    await mkdirp('/mock/path')
-
-    expect(accessMock).toHaveBeenNthCalledWith(1, '/mock/path')
-    expect(dirnameMock).toHaveBeenCalledWith('/mock/path')
-    expect(mkdirMock).toHaveBeenCalledWith('/mock/path')
+  // 测试后清理
+  afterEach(async () => {
+    await rmrf(testDir).catch(() => {})
   })
-})
-
-describe('rmrf', () => {
-  let statMock: any
-  let readdirMock: any
-  let rmMock: any
-  let joinMock: any
 
-  beforeEach(() => {
-    statMock = vi.mocked(stat)
-    readdirMock = vi.mocked(readdir)
-    rmMock = vi.mocked(rm)
-    joinMock = vi.mocked(join)
+  it('should resolvePath correctly', () => {
+    const path = resolvePath('foo/bar')
+    expect(path).toBe(join(projectRoot, 'foo/bar'))
   })
 
-  beforeEach(() => {
-    statMock.mockClear()
-    readdirMock.mockClear()
-    rmMock.mockClear()
-    joinMock.mockClear()
+  it('should create directory recursively', async () => {
+    const nestedDir = join(testDir, 'a/b/c')
+    await mkdirp(nestedDir)
+    expect(existsSync(nestedDir)).toBe(true)
   })
 
-  it('should delete a file', async () => {
-    statMock.mockResolvedValueOnce({ isDirectory: () => false })
+  it('should remove directory recursively', async () => {
+    const nestedDir = join(testDir, 'x/y/z')
+    await mkdirp(nestedDir)
+    expect(existsSync(nestedDir)).toBe(true)
 
-    await rmrf('/mock/path/to/file')
-
-    expect(statMock).toHaveBeenCalledWith('/mock/path/to/file')
-    expect(rmMock).toHaveBeenCalledWith('/mock/path/to/file')
-    expect(joinMock).not.toHaveBeenCalled()
-    expect(readdirMock).not.toHaveBeenCalled()
+    await rmrf(testDir)
+    expect(existsSync(testDir)).toBe(false)
   })
 
-  it('should handle errors gracefully', async () => {
-    const testError = new Error('Test error')
-    statMock.mockRejectedValue(testError)
-
-    try {
-      await rmrf('/mock/path/to/error')
-    }
-    catch (error) {
-      expect(error).toBe(testError)
-    }
+  it('rmrf should not throw if path does not exist', async () => {
+    await expect(rmrf(join(testDir, 'nonexistent'))).resolves.not.toThrow()
+  })
 
-    expect(statMock).toHaveBeenCalledWith('/mock/path/to/error')
-    expect(readdirMock).not.toHaveBeenCalled()
-    expect(rmMock).not.toHaveBeenCalled()
+  it('mkdirp should not throw if directory already exists', async () => {
+    const dir = join(testDir, 'already')
+    await mkdirp(dir)
+    await expect(mkdirp(dir)).resolves.not.toThrow()
   })
 })