@avalix/chroma 0.0.10 → 0.0.12

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')
+    })
+  })
+})

package/src/utils/download-extension.ts

@@ -34,7 +34,7 @@ export async function downloadAndExtractExtension(options: DownloadExtensionOpti
   }
 
   try {
-    console.log(`📥 Downloading ${extensionName}...`)
+    console.log(`\n📥 Downloading ${extensionName}...`)
 
     // Download the ZIP file
     const response = await fetch(downloadUrl)

package/src/wallets/talisman.ts

@@ -54,65 +54,114 @@ export async function getTalismanExtensionPath(): Promise<string> {
   return extensionDir
 }
 
-// Talisman specific Ethereum private key import implementation
-export async function importEthPrivateKey(
+// Helper function to find Talisman onboarding page
+async function findOnboardingPage(
+  context: BrowserContext,
+  extensionId: string,
+): Promise<Page> {
+  // Open new dashboard page
+  const popupUrl = `chrome-extension://${extensionId}/dashboard.html`
+  const newPage = await context.newPage()
+  await newPage.goto(popupUrl)
+  await newPage.waitForLoadState('domcontentloaded')
+
+  // Close any other extension tabs that may have been opened automatically
+  for (const p of context.pages()) {
+    if (p !== newPage && p.url().includes(`chrome-extension://${extensionId}/`)) {
+      await p.close()
+    }
+  }
+
+  return newPage
+}
+
+// Helper function to complete Talisman onboarding flow
+async function completeOnboarding(
+  extensionPage: Page,
+  password: string,
+): Promise<void> {
+  // Bring the onboarding page to front
+  await extensionPage.bringToFront()
+
+  // Wait for the page to load and become interactive
+  await extensionPage.waitForLoadState('domcontentloaded')
+
+  if (await extensionPage.getByRole('button', { name: 'Settings' }).isVisible()) {
+    await extensionPage.getByRole('button', { name: 'Settings' }).click({ force: true })
+    return
+  }
+
+  // Click the get started button
+  await extensionPage.getByTestId('onboarding-get-started-button').click()
+
+  // Fill the password
+  await extensionPage.getByRole('textbox', { name: 'Enter password' }).fill(password)
+  await extensionPage.getByRole('textbox', { name: 'Confirm password' }).fill(password)
+  await extensionPage.getByTestId('onboarding-password-confirm-button').click()
+
+  // Click the no thanks button
+  await extensionPage.getByRole('button', { name: 'No thanks' }).click()
+  await extensionPage.getByTestId('onboarding-enter-talisman-button').click()
+
+  // Navigate directly to settings/general page
+  const extensionId = extensionPage.url().match(/chrome-extension:\/\/([^/]+)/)?.[1]
+  await extensionPage.goto(`chrome-extension://${extensionId}/dashboard.html#/settings/general`)
+  await extensionPage.waitForLoadState('domcontentloaded')
+  await extensionPage.getByRole('link', { name: 'Security & Privacy' }).click()
+
+  // Toggle the risk scan setting
+  await extensionPage.getByTestId('component-toggle-button').first().click()
+}
+
+// Talisman specific Polkadot mnemonic import implementation
+export async function importPolkadotMnemonic(
   page: Page & { __extensionContext: BrowserContext, __extensionId: string },
   { seed, name = 'Test Account', password = 'h3llop0lkadot!' }: WalletAccount,
 ): Promise<void> {
   const context = page.__extensionContext
   const extensionId = page.__extensionId
 
-  // Wait for Talisman to open its onboarding tab with retry logic
-  const maxAttempts = 20
-  const retryDelay = 500
-  let extensionPage: Page | null = null
-
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    const pages = context.pages()
+  const extensionPage = await findOnboardingPage(context, extensionId)
 
-    for (const p of pages) {
-      const url = p.url()
-      if (url.includes('onboarding.html') || url.includes(`chrome-extension://${extensionId}/`)) {
-        extensionPage = p
-        break
-      }
-    }
+  try {
+    await completeOnboarding(extensionPage, password!)
 
-    if (extensionPage) {
-      break
-    }
+    // Import Polkadot account via Recovery Phrase
+    await extensionPage.getByRole('link', { name: 'Manage Accounts' }).click()
+    await extensionPage.getByRole('button', { name: 'Get Started' }).click()
+    await extensionPage.getByRole('button', { name: 'Add Account' }).click()
+    await extensionPage.getByRole('button', { name: 'Import Import an existing' }).click()
+    await extensionPage.getByRole('button', { name: 'Import via Recovery Phrase' }).click()
+    await extensionPage.getByRole('button', { name: 'Polkadot Relay Chain, Asset' }).click()
+    await extensionPage.getByRole('textbox', { name: 'Choose a name' }).fill(name!)
+    await extensionPage.getByRole('textbox', { name: 'Enter your 12 or 24 word' }).fill(seed!)
+    await extensionPage.getByTestId('account-add-mnemonic-import-button').click()
 
-    // If not found, wait before retrying
-    if (attempt < maxAttempts - 1) {
-      await new Promise(resolve => setTimeout(resolve, retryDelay))
-    }
+    await extensionPage.close()
   }
-
-  if (!extensionPage) {
-    throw new Error(`Talisman onboarding page not found after ${maxAttempts} attempts`)
+  catch (error) {
+    console.error('❌ Error during Talisman Polkadot account import:', error)
+    throw error
   }
+}
 
-  try {
-    // Bring the onboarding page to front
-    await extensionPage.bringToFront()
-
-    // Wait for the page to load and become interactive
-    await extensionPage.waitForLoadState('domcontentloaded')
-
-    // Click the get started button
-    await extensionPage.getByTestId('onboarding-get-started-button').click()
+// Talisman specific Ethereum private key import implementation
+export async function importEthPrivateKey(
+  page: Page & { __extensionContext: BrowserContext, __extensionId: string },
+  { seed, name = 'Test Account', password = 'h3llop0lkadot!' }: WalletAccount,
+): Promise<void> {
+  const context = page.__extensionContext
+  const extensionId = page.__extensionId
 
-    // Fill the password
-    await extensionPage.getByRole('textbox', { name: 'Enter password' }).fill(password!)
-    await extensionPage.getByRole('textbox', { name: 'Confirm password' }).fill(password!)
-    await extensionPage.getByTestId('onboarding-password-confirm-button').click()
+  const extensionPage = await findOnboardingPage(context, extensionId)
 
-    // Click the no thanks button
-    await extensionPage.getByRole('button', { name: 'No thanks' }).click()
-    await extensionPage.getByTestId('onboarding-enter-talisman-button').click()
+  try {
+    await completeOnboarding(extensionPage, password!)
 
-    // Import Ethereum account
-    await extensionPage.getByRole('button', { name: 'Add account Create or import' }).click()
+    // Import Ethereum account via Private Key
+    await extensionPage.getByRole('link', { name: 'Manage Accounts' }).click()
+    await extensionPage.getByRole('button', { name: 'Get Started' }).click()
+    await extensionPage.getByRole('button', { name: 'Add Account' }).click()
     await extensionPage.getByRole('button', { name: 'Import Import an existing' }).click()
     await extensionPage.getByRole('button', { name: 'Import via Private Key' }).click()
     await extensionPage.getByRole('button', { name: 'Select account platform' }).click()
@@ -124,7 +173,7 @@ export async function importEthPrivateKey(
     await extensionPage.close()
   }
   catch (error) {
-    console.error('❌ Error during Talisman account import:', error)
+    console.error('❌ Error during Talisman Ethereum account import:', error)
     throw error
   }
 }
@@ -134,14 +183,18 @@ export async function authorizeTalisman(
   page: Page & { __extensionContext: BrowserContext, __extensionId: string },
   options: { accountName?: string } = {},
 ): Promise<void> {
-  const { accountName = 'Test Account' } = options
   const context = page.__extensionContext
   const extensionId = page.__extensionId
+  const { accountName = 'Test Account' } = options
 
   const extensionPopup = await findExtensionPopup(context, extensionId)
+  await extensionPopup.waitForLoadState('domcontentloaded')
 
   // Authorize Talisman account
-  await extensionPopup.getByRole('button', { name: accountName }).click()
+  const accountButton = extensionPopup.getByRole('button', { name: accountName })
+  await accountButton.waitFor({ state: 'visible' })
+  await accountButton.scrollIntoViewIfNeeded()
+  await accountButton.click({ force: true })
   await extensionPopup.getByTestId('connection-connect-button').click()
 
   try {
@@ -161,12 +214,9 @@ export async function approveTalismanTx(
 
   const extensionPopup = await findExtensionPopup(context, extensionId)
 
-  try {
+  if (await extensionPopup.getByRole('button', { name: 'Yes' }).isVisible()) {
     await extensionPopup.getByRole('button', { name: 'Yes' }).click()
   }
-  catch {
-    console.log('No another popup found, skipping')
-  }
 
   await extensionPopup.getByRole('button', { name: 'Approve' }).click()
 }
@@ -179,5 +229,9 @@ export async function rejectTalismanTx(
   const extensionId = page.__extensionId
 
   const extensionPopup = await findExtensionPopup(context, extensionId)
-  await extensionPopup.getByTestId('connection-reject-button').click()
+
+  const rejectButton = extensionPopup.getByTestId('connection-reject-button')
+    .or(extensionPopup.getByRole('button', { name: 'Cancel' }))
+
+  await rejectButton.click()
 }