@avalix/chroma 0.0.10 → 0.0.11

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@avalix/chroma",
   "type": "module",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "description": "End-to-end testing library for Polkadot wallet interactions",
   "author": "Avalix Labs",
   "license": "MIT",
@@ -44,7 +44,10 @@
     "lint": "eslint --fix .",
     "prepublishOnly": "npm run build",
     "download-extensions": "rm -rf .chroma && tsx scripts/download-extensions.ts",
-    "test": "playwright test --ui"
+    "test": "playwright test --ui",
+    "test:unit": "vitest",
+    "test:unit:run": "vitest run",
+    "test:unit:coverage": "vitest run --coverage"
   },
   "peerDependencies": {
     "@playwright/test": "^1.57.0"
@@ -58,8 +61,9 @@
     "@types/node": "^24.10.2",
     "@types/unzipper": "^0.10.11",
     "eslint": "^9.39.1",
-    "tsdown": "latest",
-    "tsx": "^4.21.0"
+    "tsdown": "^0.20.1",
+    "tsx": "^4.21.0",
+    "vitest": "^4.0.18"
   },
   "publishConfig": {
     "access": "public"

package/src/utils/download-extension.integration.test.ts

@@ -0,0 +1,95 @@
+import type { DownloadExtensionOptions } from './download-extension.js'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { downloadAndExtractExtension } from './download-extension.js'
+
+/**
+ * Integration Tests (real download) - Requires network
+ * Tests actual download and extraction with real extension files
+ *
+ * Important test cases:
+ * - Nested zip extraction (Talisman has a zip inside a zip)
+ * - Standard zip extraction (Polkadot-JS)
+ * - Skip download if already exists
+ * - Error handling for invalid URLs
+ */
+describe('downloadAndExtractExtension (integration tests)', () => {
+  let tempDir: string
+
+  beforeEach(async () => {
+    tempDir = path.join(os.tmpdir(), `chroma-test-${Date.now()}-${Math.random().toString(36).slice(2)}`)
+    await fs.promises.mkdir(tempDir, { recursive: true })
+  })
+
+  afterEach(async () => {
+    if (tempDir && fs.existsSync(tempDir)) {
+      await fs.promises.rm(tempDir, { recursive: true, force: true })
+    }
+  })
+
+  it('should handle nested zip extraction (Talisman)', async () => {
+    // Talisman extension has a nested zip structure
+    const VERSION = '3.1.13'
+    const options: DownloadExtensionOptions = {
+      downloadUrl: `https://github.com/avalix-labs/polkadot-wallets/raw/refs/heads/main/talisman/talisman-${VERSION}.zip`,
+      extensionName: `talisman-extension-${VERSION}`,
+      targetDir: tempDir,
+    }
+
+    const result = await downloadAndExtractExtension(options)
+
+    expect(result).toBe(path.join(tempDir, `talisman-extension-${VERSION}`))
+    expect(fs.existsSync(result)).toBe(true)
+
+    // Talisman should have manifest.json after nested extraction
+    const files = await fs.promises.readdir(result)
+    expect(files).toContain('manifest.json')
+  }, 60000)
+
+  it('should handle standard zip extraction (Polkadot-JS)', async () => {
+    const VERSION = '0.62.6'
+    const options: DownloadExtensionOptions = {
+      downloadUrl: `https://github.com/polkadot-js/extension/releases/download/v${VERSION}/master-chrome-build.zip`,
+      extensionName: `polkadot-extension-${VERSION}`,
+      targetDir: tempDir,
+    }
+
+    const result = await downloadAndExtractExtension(options)
+
+    expect(result).toBe(path.join(tempDir, `polkadot-extension-${VERSION}`))
+    expect(fs.existsSync(result)).toBe(true)
+
+    const files = await fs.promises.readdir(result)
+    expect(files).toContain('manifest.json')
+  }, 60000)
+
+  it('should skip download if extension already exists', async () => {
+    const extensionDir = path.join(tempDir, 'existing-extension')
+    await fs.promises.mkdir(extensionDir, { recursive: true })
+    await fs.promises.writeFile(path.join(extensionDir, 'manifest.json'), '{"name": "test"}')
+
+    const options: DownloadExtensionOptions = {
+      downloadUrl: 'https://example.com/should-not-be-called.zip',
+      extensionName: 'existing-extension',
+      targetDir: tempDir,
+    }
+
+    const result = await downloadAndExtractExtension(options)
+
+    expect(result).toBe(extensionDir)
+  })
+
+  it('should throw error for invalid URL', async () => {
+    const options: DownloadExtensionOptions = {
+      downloadUrl: 'https://github.com/invalid-user-12345/nonexistent-repo/releases/download/v0.0.0/nonexistent.zip',
+      extensionName: 'invalid-extension',
+      targetDir: tempDir,
+    }
+
+    await expect(downloadAndExtractExtension(options)).rejects.toThrow(
+      /Failed to download\/extract invalid-extension/,
+    )
+  }, 15000)
+})

package/src/utils/download-extension.test.ts

@@ -0,0 +1,173 @@
+import type { DownloadExtensionOptions } from './download-extension.js'
+import fs from 'node:fs'
+import path from 'node:path'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { downloadAndExtractExtension } from './download-extension.js'
+
+/**
+ * Unit Tests (with mocks) - Fast, no network required
+ * Tests error handling, cleanup logic, and path resolution
+ */
+
+// Mock adm-zip
+const mockExtractAllTo = vi.fn()
+vi.mock('adm-zip', () => {
+  return {
+    default: vi.fn().mockImplementation(() => ({
+      extractAllTo: mockExtractAllTo,
+    })),
+  }
+})
+
+// Mock fetch
+const mockFetch = vi.fn()
+vi.stubGlobal('fetch', mockFetch)
+
+// Mock stream/promises pipeline
+vi.mock('node:stream/promises', () => ({
+  pipeline: vi.fn().mockResolvedValue(undefined),
+}))
+
+// Mock fs module
+vi.mock('node:fs', async () => {
+  const actual = await vi.importActual<typeof import('node:fs')>('node:fs')
+  return {
+    ...actual,
+    default: {
+      ...actual,
+      existsSync: vi.fn(),
+      readdirSync: vi.fn(),
+      promises: {
+        mkdir: vi.fn().mockResolvedValue(undefined),
+        rm: vi.fn().mockResolvedValue(undefined),
+        rename: vi.fn().mockResolvedValue(undefined),
+        unlink: vi.fn().mockResolvedValue(undefined),
+        readdir: vi.fn().mockResolvedValue([]),
+      },
+      createWriteStream: vi.fn().mockReturnValue({
+        on: vi.fn(),
+        write: vi.fn(),
+        end: vi.fn(),
+      }),
+    },
+    existsSync: vi.fn(),
+    readdirSync: vi.fn(),
+    createWriteStream: vi.fn().mockReturnValue({
+      on: vi.fn(),
+      write: vi.fn(),
+      end: vi.fn(),
+    }),
+  }
+})
+
+describe('downloadAndExtractExtension (unit tests)', () => {
+  const mockOptions: DownloadExtensionOptions = {
+    downloadUrl: 'https://example.com/extension.zip',
+    extensionName: 'test-extension',
+  }
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.spyOn(console, 'log').mockImplementation(() => {})
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  describe('when extension already exists', () => {
+    it('should skip download and return existing path', async () => {
+      const mockedFs = vi.mocked(fs)
+      mockedFs.existsSync.mockReturnValue(true)
+      mockedFs.readdirSync.mockReturnValue(['manifest.json'] as any)
+
+      const result = await downloadAndExtractExtension(mockOptions)
+
+      expect(result).toContain('test-extension')
+      expect(mockFetch).not.toHaveBeenCalled()
+      expect(console.log).toHaveBeenCalledWith(
+        expect.stringContaining('already exists'),
+        expect.any(String),
+      )
+    })
+  })
+
+  describe('when extension does not exist', () => {
+    beforeEach(() => {
+      const mockedFs = vi.mocked(fs)
+      mockedFs.existsSync.mockReturnValue(false)
+      mockedFs.readdirSync.mockReturnValue([])
+    })
+
+    it('should throw error when download fails with bad status', async () => {
+      mockFetch.mockResolvedValue({
+        ok: false,
+        status: 404,
+        statusText: 'Not Found',
+      })
+
+      await expect(downloadAndExtractExtension(mockOptions)).rejects.toThrow(
+        'Failed to download/extract test-extension',
+      )
+    })
+
+    it('should throw error when fetch throws network error', async () => {
+      mockFetch.mockRejectedValue(new Error('Network error'))
+
+      await expect(downloadAndExtractExtension(mockOptions)).rejects.toThrow(
+        'Failed to download/extract test-extension: Network error',
+      )
+    })
+
+    it('should cleanup files on error', async () => {
+      const mockedFs = vi.mocked(fs)
+
+      mockFetch.mockResolvedValue({
+        ok: false,
+        status: 500,
+        statusText: 'Internal Server Error',
+      })
+
+      mockedFs.existsSync.mockImplementation((p: fs.PathLike) => {
+        const pathStr = p.toString()
+        if (pathStr.endsWith('test-extension') && !pathStr.includes('.zip')) {
+          return false
+        }
+        return true
+      })
+
+      await expect(downloadAndExtractExtension(mockOptions)).rejects.toThrow()
+
+      expect(mockedFs.promises.unlink).toHaveBeenCalled()
+      expect(mockedFs.promises.rm).toHaveBeenCalled()
+    })
+  })
+
+  describe('targetDir option', () => {
+    it('should use custom targetDir when provided', async () => {
+      const mockedFs = vi.mocked(fs)
+      mockedFs.existsSync.mockReturnValue(true)
+      mockedFs.readdirSync.mockReturnValue(['manifest.json'] as any)
+
+      const customOptions: DownloadExtensionOptions = {
+        ...mockOptions,
+        targetDir: '/custom/path',
+      }
+
+      const result = await downloadAndExtractExtension(customOptions)
+
+      expect(result).toBe(path.join('/custom/path', 'test-extension'))
+    })
+
+    it('should use default .chroma directory when targetDir not provided', async () => {
+      const mockedFs = vi.mocked(fs)
+      mockedFs.existsSync.mockReturnValue(true)
+      mockedFs.readdirSync.mockReturnValue(['manifest.json'] as any)
+
+      const result = await downloadAndExtractExtension(mockOptions)
+
+      expect(result).toContain('.chroma')
+      expect(result).toContain('test-extension')
+    })
+  })
+})