chore: import upstream snapshot with attribution

2026-07-13 12:47:58 +08:00
commit b16403ea71
789 changed files with 115226 additions and 0 deletions
@@ -0,0 +1,314 @@
+import {
+  expect,
+  test,
+  describe,
+  beforeAll,
+  afterAll,
+  beforeEach,
+  vi,
+} from 'vitest'
+import { writeFile, mkdir, rm, symlink, readFile, access } from 'fs/promises'
+import fs from 'node:fs'
+import { Readable } from 'node:stream'
+import { pipeline } from 'node:stream/promises'
+import { join } from 'path'
+import { tmpdir } from 'os'
+import { tarFileStream } from '../../../src/template/utils'
+import * as tar from 'tar'
+import { ReadEntry } from 'tar'
+
+describe('tarFileStream', () => {
+  const testDir = join(__dirname, 'tar-test-folder')
+
+  beforeAll(async () => {
+    await rm(testDir, { recursive: true, force: true })
+    await mkdir(testDir, { recursive: true })
+  })
+
+  afterAll(async () => {
+    await rm(testDir, { recursive: true, force: true })
+  })
+
+  beforeEach(async () => {
+    await rm(testDir, { recursive: true, force: true })
+    await mkdir(testDir, { recursive: true })
+  })
+
+  /**
+   * Wait until a path no longer exists. Cleanup runs asynchronously from the
+   * stream's `close` handler, so it may not complete in the same tick.
+   */
+  async function waitUntilGone(target: string): Promise<void> {
+    for (let i = 0; i < 100; i++) {
+      try {
+        await access(target)
+      } catch {
+        return
+      }
+      await new Promise((resolve) => setTimeout(resolve, 10))
+    }
+    throw new Error(`path was not removed: ${target}`)
+  }
+
+  /**
+   * Pipe an archive stream into tar's extractor and collect its entries.
+   */
+  async function extractTarStream(
+    stream: Readable
+  ): Promise<{ extractDir: string; members: ReadEntry[] }> {
+    const extractDir = join(
+      tmpdir(),
+      `tar-extract-${Date.now()}-${Math.random()}`
+    )
+    await mkdir(extractDir, { recursive: true })
+
+    const members: ReadEntry[] = []
+    await pipeline(
+      stream,
+      tar.extract({
+        cwd: extractDir,
+        gzip: true,
+        onentry: (entry: ReadEntry) => {
+          members.push(entry)
+        },
+      })
+    )
+
+    return { extractDir, members }
+  }
+
+  /**
+   * Extract archive contents into a map of path -> file contents.
+   */
+  async function extractTarContents(
+    stream: Readable
+  ): Promise<Map<string, Buffer | null>> {
+    const { extractDir, members } = await extractTarStream(stream)
+    const contents = new Map<string, Buffer | null>()
+
+    for (const member of members) {
+      if (member.type === 'File') {
+        try {
+          contents.set(
+            member.path,
+            await readFile(join(extractDir, member.path))
+          )
+        } catch {
+          // File might not exist
+        }
+      } else if (member.type === 'Directory') {
+        contents.set(member.path, null)
+      } else if (member.type === 'SymbolicLink') {
+        contents.set(member.path, Buffer.from(member.linkpath || ''))
+      }
+    }
+
+    await rm(extractDir, { recursive: true, force: true })
+    return contents
+  }
+
+  /**
+   * Extract archive members into a map of path -> entry.
+   */
+  async function getTarMembers(
+    stream: Readable
+  ): Promise<Map<string, ReadEntry>> {
+    const { extractDir, members } = await extractTarStream(stream)
+    const map = new Map<string, ReadEntry>()
+    for (const member of members) {
+      map.set(member.path, member)
+    }
+    await rm(extractDir, { recursive: true, force: true })
+    return map
+  }
+
+  test('should create tar with simple files', async () => {
+    await writeFile(join(testDir, 'file1.txt'), 'content1')
+    await writeFile(join(testDir, 'file2.txt'), 'content2')
+
+    const { stream, size } = await tarFileStream(
+      '*.txt',
+      testDir,
+      [],
+      false,
+      true
+    )
+    expect(size).toBeGreaterThan(0)
+
+    const contents = await extractTarContents(stream)
+
+    expect(contents.size).toBe(2)
+    expect(contents.get('file1.txt')?.toString()).toBe('content1')
+    expect(contents.get('file2.txt')?.toString()).toBe('content2')
+  })
+
+  test('should create an uncompressed tar when gzip is disabled', async () => {
+    await writeFile(join(testDir, 'file1.txt'), 'content1')
+    await writeFile(join(testDir, 'file2.txt'), 'content2')
+
+    const { stream } = await tarFileStream('*.txt', testDir, [], false, false)
+
+    // Buffer the archive so we can both assert it is not gzipped and extract it
+    const chunks: Buffer[] = []
+    for await (const chunk of stream as unknown as AsyncIterable<Buffer>) {
+      chunks.push(Buffer.from(chunk))
+    }
+    const archive = Buffer.concat(chunks)
+
+    // gzip streams start with the magic bytes 0x1f 0x8b — an uncompressed tar must not
+    expect(archive[0]).not.toBe(0x1f)
+    expect(archive.subarray(0, 2).equals(Buffer.from([0x1f, 0x8b]))).toBe(false)
+
+    // And it should still extract to the original files
+    const tarFile = join(tmpdir(), `tar-uncompressed-${Date.now()}.tar`)
+    await writeFile(tarFile, archive)
+    const extractDir = join(tmpdir(), `tar-uncompressed-extract-${Date.now()}`)
+    await mkdir(extractDir, { recursive: true })
+    await tar.extract({ file: tarFile, cwd: extractDir })
+    expect((await readFile(join(extractDir, 'file1.txt'))).toString()).toBe(
+      'content1'
+    )
+    expect((await readFile(join(extractDir, 'file2.txt'))).toString()).toBe(
+      'content2'
+    )
+    await rm(tarFile, { force: true })
+    await rm(extractDir, { recursive: true, force: true })
+  })
+
+  test('should respect ignore patterns', async () => {
+    await writeFile(join(testDir, 'file1.txt'), 'content1')
+    await writeFile(join(testDir, 'file2.txt'), 'content2')
+    await writeFile(join(testDir, 'temp.txt'), 'temp content')
+    await writeFile(join(testDir, 'backup.txt'), 'backup content')
+
+    const { stream } = await tarFileStream(
+      '*.txt',
+      testDir,
+      ['temp*', 'backup*'],
+      false,
+      true
+    )
+
+    const contents = await extractTarContents(stream)
+
+    expect(contents.size).toBe(2)
+    expect(contents.get('file1.txt')?.toString()).toBe('content1')
+    expect(contents.get('file2.txt')?.toString()).toBe('content2')
+    expect(contents.has('temp.txt')).toBe(false)
+    expect(contents.has('backup.txt')).toBe(false)
+  })
+
+  test('should handle nested files', async () => {
+    const nestedDir = join(testDir, 'src', 'components')
+    await mkdir(nestedDir, { recursive: true })
+
+    await writeFile(join(testDir, 'src', 'index.ts'), 'index content')
+    await writeFile(join(nestedDir, 'Button.tsx'), 'button content')
+
+    const { stream } = await tarFileStream('src', testDir, [], false, true)
+
+    const contents = await extractTarContents(stream)
+    const paths = Array.from(contents.keys())
+    expect(paths.some((p) => p.includes('src'))).toBe(true)
+    expect(paths.some((p) => p.includes('index.ts'))).toBe(true)
+    expect(paths.some((p) => p.includes('Button.tsx'))).toBe(true)
+  })
+
+  test('should resolve symlinks when enabled', async () => {
+    await writeFile(join(testDir, 'original.txt'), 'original content')
+
+    try {
+      await symlink('original.txt', join(testDir, 'link.txt'))
+    } catch (error: any) {
+      // Skip test if symlinks are not supported on this platform
+      if (error.code === 'ENOSYS' || error.code === 'EPERM') {
+        return
+      }
+      throw error
+    }
+
+    // Test with resolveSymlinks=true
+    const { stream } = await tarFileStream('*.txt', testDir, [], true, true)
+
+    const contents = await extractTarContents(stream)
+    expect(contents.get('original.txt')?.toString()).toBe('original content')
+    // Symlink should be resolved (contain actual content, not link)
+    expect(contents.get('link.txt')?.toString()).toBe('original content')
+  })
+
+  test('should preserve symlinks when disabled', async () => {
+    await writeFile(join(testDir, 'original.txt'), 'original content')
+
+    try {
+      await symlink('original.txt', join(testDir, 'link.txt'))
+    } catch (error: any) {
+      // Skip test if symlinks are not supported on this platform
+      if (error.code === 'ENOSYS' || error.code === 'EPERM') {
+        return
+      }
+      throw error
+    }
+
+    // Test with resolveSymlinks=false
+    const { stream } = await tarFileStream('*.txt', testDir, [], false, true)
+
+    const members = await getTarMembers(stream)
+    expect(members.get('original.txt')?.type).toBe('File')
+    const link = members.get('link.txt')!
+    expect(link.type).toBe('SymbolicLink')
+    expect(link.linkpath).toBe('original.txt')
+  })
+
+  test('removes the spooled archive once the stream is consumed', async () => {
+    await writeFile(join(testDir, 'file1.txt'), 'content1')
+
+    // Capture the temp dir the helper creates so we can assert it is gone.
+    let tmpDir: string | undefined
+    const mkdtemp = fs.promises.mkdtemp.bind(fs.promises)
+    const spy = vi
+      .spyOn(fs.promises, 'mkdtemp')
+      .mockImplementation(async (prefix: any, ...rest: any[]) => {
+        const dir = await mkdtemp(prefix, ...rest)
+        tmpDir = dir
+        return dir
+      })
+
+    try {
+      const { stream } = await tarFileStream('*.txt', testDir, [], false)
+      expect(tmpDir).toBeDefined()
+      await access(tmpDir!)
+
+      // Drain the stream to completion; the `close` handler then removes the
+      // spooled archive.
+      stream.resume()
+      await waitUntilGone(tmpDir!)
+    } finally {
+      spy.mockRestore()
+    }
+  })
+
+  test('cleans up the spooled archive if it is never consumed', async () => {
+    await writeFile(join(testDir, 'file1.txt'), 'content1')
+
+    let tmpDir: string | undefined
+    const mkdtemp = fs.promises.mkdtemp.bind(fs.promises)
+    const spy = vi
+      .spyOn(fs.promises, 'mkdtemp')
+      .mockImplementation(async (prefix: any, ...rest: any[]) => {
+        const dir = await mkdtemp(prefix, ...rest)
+        tmpDir = dir
+        return dir
+      })
+
+    try {
+      const { stream } = await tarFileStream('*.txt', testDir, [], false)
+      await access(tmpDir!)
+
+      // Destroying without reading still fires `close` and removes the file.
+      stream.destroy()
+      await waitUntilGone(tmpDir!)
+    } finally {
+      spy.mockRestore()
+    }
+  })
+})