@avalix/chroma 0.0.11 → 0.0.13

package/src/context-playwright/wallet-factory.test.ts

@@ -0,0 +1,106 @@
+import type { BrowserContext, Page } from '@playwright/test'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import {
+  createPolkadotJsWallet,
+  createTalismanWallet,
+  walletFactories,
+} from './wallet-factory.js'
+
+// Mock wallet implementations
+vi.mock('../wallets/polkadot-js.js', () => ({
+  importPolkadotJSAccount: vi.fn(),
+  authorizePolkadotJS: vi.fn(),
+  approvePolkadotJSTx: vi.fn(),
+  rejectPolkadotJSTx: vi.fn(),
+}))
+
+vi.mock('../wallets/talisman.js', () => ({
+  importPolkadotMnemonic: vi.fn(),
+  importEthPrivateKey: vi.fn(),
+  authorizeTalisman: vi.fn(),
+  approveTalismanTx: vi.fn(),
+  rejectTalismanTx: vi.fn(),
+}))
+
+// Create mock browser context
+function createMockContext(): BrowserContext {
+  const mockPage = {
+    url: () => 'https://example.com',
+    __extensionContext: null,
+    __extensionId: '',
+  } as unknown as Page
+
+  return {
+    pages: vi.fn().mockReturnValue([mockPage]),
+    newPage: vi.fn().mockResolvedValue(mockPage),
+  } as unknown as BrowserContext
+}
+
+describe('wallet-factory', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  describe('walletFactories', () => {
+    it('should have polkadot-js factory', () => {
+      expect(walletFactories['polkadot-js']).toBeDefined()
+      expect(typeof walletFactories['polkadot-js']).toBe('function')
+    })
+
+    it('should have talisman factory', () => {
+      expect(walletFactories.talisman).toBeDefined()
+      expect(typeof walletFactories.talisman).toBe('function')
+    })
+  })
+
+  describe('createPolkadotJsWallet', () => {
+    const extensionId = 'test-extension-id'
+    let mockContext: BrowserContext
+
+    beforeEach(() => {
+      mockContext = createMockContext()
+    })
+
+    it('should create wallet with correct type and extensionId', () => {
+      const wallet = createPolkadotJsWallet(extensionId, mockContext)
+
+      expect(wallet.type).toBe('polkadot-js')
+      expect(wallet.extensionId).toBe(extensionId)
+    })
+
+    it('should have all required methods', () => {
+      const wallet = createPolkadotJsWallet(extensionId, mockContext)
+
+      expect(typeof wallet.importMnemonic).toBe('function')
+      expect(typeof wallet.authorize).toBe('function')
+      expect(typeof wallet.approveTx).toBe('function')
+      expect(typeof wallet.rejectTx).toBe('function')
+    })
+  })
+
+  describe('createTalismanWallet', () => {
+    const extensionId = 'test-extension-id'
+    let mockContext: BrowserContext
+
+    beforeEach(() => {
+      mockContext = createMockContext()
+    })
+
+    it('should create wallet with correct type and extensionId', () => {
+      const wallet = createTalismanWallet(extensionId, mockContext)
+
+      expect(wallet.type).toBe('talisman')
+      expect(wallet.extensionId).toBe(extensionId)
+    })
+
+    it('should have all required methods', () => {
+      const wallet = createTalismanWallet(extensionId, mockContext)
+
+      expect(typeof wallet.importPolkadotMnemonic).toBe('function')
+      expect(typeof wallet.importEthPrivateKey).toBe('function')
+      expect(typeof wallet.authorize).toBe('function')
+      expect(typeof wallet.approveTx).toBe('function')
+      expect(typeof wallet.rejectTx).toBe('function')
+    })
+  })
+})

package/src/context-playwright/wallet-factory.ts

@@ -1,11 +1,5 @@
 import type { BrowserContext, Page } from '@playwright/test'
-import type {
-  BaseWalletInstance,
-  PolkadotJsWalletInstance,
-  TalismanWalletInstance,
-  WalletAccount,
-  WalletInstance,
-} from './types.js'
+import type { WalletAccount } from './types.js'
 import {
   approvePolkadotJSTx,
   authorizePolkadotJS,
@@ -16,125 +10,107 @@ import {
   approveTalismanTx,
   authorizeTalisman,
   importEthPrivateKey,
+  importPolkadotMnemonic,
   rejectTalismanTx,
 } from '../wallets/talisman.js'
 
 // Helper to create extended page with wallet context
+/* c8 ignore start */
 function createExtendedPage(page: Page, context: BrowserContext, extensionId: string) {
   const extPage = page as Page & { __extensionContext: BrowserContext, __extensionId: string }
   extPage.__extensionContext = context
   extPage.__extensionId = extensionId
   return extPage
 }
+/* c8 ignore stop */
 
-// Create wallet instance helper with proper typing
-export function createWalletInstance(
-  walletType: string,
-  extensionId: string,
-  context: BrowserContext,
-): WalletInstance {
-  // Store the imported account name for later use
-  let importedAccountName: string | undefined
-
-  // Common methods for all wallets
-  const baseInstance: BaseWalletInstance = {
+/*
+ * Factory function for Polkadot-JS wallet
+ * Coverage excluded: methods interact with Chrome extension APIs via browser context.
+ */
+/* c8 ignore start */
+export function createPolkadotJsWallet(extensionId: string, context: BrowserContext) {
+  return {
     extensionId,
+    type: 'polkadot-js' as const,
     importMnemonic: async (options: WalletAccount) => {
       const page = context.pages()[0] || await context.newPage()
       const extPage = createExtendedPage(page, context, extensionId)
+      await importPolkadotJSAccount(extPage, options)
+    },
+    authorize: async () => {
+      const page = context.pages()[0] || await context.newPage()
+      const extPage = createExtendedPage(page, context, extensionId)
+      await authorizePolkadotJS(extPage)
+    },
+    approveTx: async (options: { password?: string } = {}) => {
+      const page = context.pages()[0] || await context.newPage()
+      const extPage = createExtendedPage(page, context, extensionId)
+      await approvePolkadotJSTx(extPage, options)
+    },
+    rejectTx: async () => {
+      const page = context.pages()[0] || await context.newPage()
+      const extPage = createExtendedPage(page, context, extensionId)
+      await rejectPolkadotJSTx(extPage)
+    },
+  }
+}
+/* c8 ignore stop */
 
-      // Store the account name for future authorize calls
-      importedAccountName = options.name || 'Test Account'
+/*
+ * Factory function for Talisman wallet
+ * Coverage excluded: methods interact with Chrome extension APIs via browser context.
+ */
+/* c8 ignore start */
+export function createTalismanWallet(extensionId: string, context: BrowserContext) {
+  let importedAccountName: string | undefined
 
-      switch (walletType) {
-        case 'polkadot-js':
-          await importPolkadotJSAccount(extPage, options)
-          break
-        case 'talisman':
-          throw new Error('Talisman importMnemonic is not yet implemented.')
-        default:
-          throw new Error(`Unsupported wallet type: ${walletType}`)
-      }
+  return {
+    extensionId,
+    type: 'talisman' as const,
+    importPolkadotMnemonic: async (options: WalletAccount) => {
+      const page = context.pages()[0] || await context.newPage()
+      const extPage = createExtendedPage(page, context, extensionId)
+      importedAccountName = options.name || 'Test Account'
+      await importPolkadotMnemonic(extPage, options)
+    },
+    importEthPrivateKey: async (options: { privateKey: string, name?: string, password?: string }) => {
+      const page = context.pages()[0] || await context.newPage()
+      const extPage = createExtendedPage(page, context, extensionId)
+      importedAccountName = options.name || 'Test Account'
+      await importEthPrivateKey(extPage, {
+        seed: options.privateKey,
+        name: options.name,
+        password: options.password,
+      })
     },
     authorize: async (options: { accountName?: string } = {}) => {
       const page = context.pages()[0] || await context.newPage()
       const extPage = createExtendedPage(page, context, extensionId)
-
-      // Use provided account name or fall back to the imported one
       const accountName = options.accountName || importedAccountName
-
-      switch (walletType) {
-        case 'polkadot-js':
-          await authorizePolkadotJS(extPage)
-          break
-        case 'talisman':
-          await authorizeTalisman(extPage, { accountName })
-          break
-        default:
-          throw new Error(`Unsupported wallet type: ${walletType}`)
-      }
+      await authorizeTalisman(extPage, { accountName })
     },
-    approveTx: async (options: { password?: string } = {}) => {
+    approveTx: async () => {
       const page = context.pages()[0] || await context.newPage()
       const extPage = createExtendedPage(page, context, extensionId)
-
-      switch (walletType) {
-        case 'polkadot-js':
-          await approvePolkadotJSTx(extPage, options)
-          break
-        case 'talisman':
-          await approveTalismanTx(extPage)
-          break
-        default:
-          throw new Error(`Unsupported wallet type: ${walletType}`)
-      }
+      await approveTalismanTx(extPage)
     },
     rejectTx: async () => {
       const page = context.pages()[0] || await context.newPage()
       const extPage = createExtendedPage(page, context, extensionId)
-
-      switch (walletType) {
-        case 'polkadot-js':
-          await rejectPolkadotJSTx(extPage)
-          break
-        case 'talisman':
-          await rejectTalismanTx(extPage)
-          break
-        default:
-          throw new Error(`Unsupported wallet type: ${walletType}`)
-      }
+      await rejectTalismanTx(extPage)
     },
   }
+}
+/* c8 ignore stop */
 
-  // Return wallet-specific instance with type discriminator
-  switch (walletType) {
-    case 'polkadot-js':
-      return {
-        ...baseInstance,
-        type: 'polkadot-js',
-      } as PolkadotJsWalletInstance
-
-    case 'talisman':
-      return {
-        ...baseInstance,
-        type: 'talisman',
-        importEthPrivateKey: async (options: { privateKey: string, name?: string, password?: string }) => {
-          const page = context.pages()[0] || await context.newPage()
-          const extPage = createExtendedPage(page, context, extensionId)
-
-          // Store the account name for future authorize calls
-          importedAccountName = options.name || 'Test Account'
-
-          // Use the seed property to pass the private key
-          await importEthPrivateKey(extPage, {
-            seed: options.privateKey,
-            name: options.name,
-            password: options.password,
-          })
-        },
-      } as TalismanWalletInstance
-
-    default:
-      throw new Error(`Unsupported wallet type: ${walletType}`)
-  }
+// Wallet factories map - auto-inferred types
+export const walletFactories = {
+  'polkadot-js': createPolkadotJsWallet,
+  'talisman': createTalismanWallet,
 }
+
+// Auto-inferred types from factory functions
+export type PolkadotJsWalletInstance = ReturnType<typeof createPolkadotJsWallet>
+export type TalismanWalletInstance = ReturnType<typeof createTalismanWallet>
+export type WalletInstance = PolkadotJsWalletInstance | TalismanWalletInstance

package/src/index.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it, vi } from 'vitest'
+
+// Mock playwright before importing
+vi.mock('@playwright/test', () => ({
+  test: {
+    extend: vi.fn().mockReturnValue({}),
+  },
+  chromium: {
+    launchPersistentContext: vi.fn(),
+  },
+  expect: vi.fn(),
+}))
+
+vi.mock('./wallets/polkadot-js.js', () => ({
+  getPolkadotJSExtensionPath: vi.fn().mockResolvedValue('/mock/path'),
+}))
+
+vi.mock('./wallets/talisman.js', () => ({
+  getTalismanExtensionPath: vi.fn().mockResolvedValue('/mock/path'),
+}))
+
+vi.mock('./context-playwright/wallet-factory.js', () => ({
+  walletFactories: {
+    'polkadot-js': vi.fn(),
+    'talisman': vi.fn(),
+  },
+}))
+
+describe('index exports', () => {
+  it('should export createWalletTest function', async () => {
+    const { createWalletTest } = await import('./index.js')
+    expect(createWalletTest).toBeDefined()
+    expect(typeof createWalletTest).toBe('function')
+  })
+
+  it('should export test function', async () => {
+    const { test } = await import('./index.js')
+    expect(test).toBeDefined()
+  })
+
+  it('should export expect function', async () => {
+    const { expect: playwrightExpect } = await import('./index.js')
+    expect(playwrightExpect).toBeDefined()
+  })
+
+  it('should be able to call createWalletTest', async () => {
+    const { createWalletTest } = await import('./index.js')
+    const result = createWalletTest()
+    expect(result).toBeDefined()
+  })
+
+  it('should be able to call createWalletTest with options', async () => {
+    const { createWalletTest } = await import('./index.js')
+    const result = createWalletTest({ headless: true })
+    expect(result).toBeDefined()
+  })
+})

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/polkadot-js.test.ts

@@ -0,0 +1,97 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import {
+  getPolkadotJSExtensionPath,
+  POLKADOT_JS_CONFIG,
+} from './polkadot-js.js'
+
+// Mock node: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(),
+    },
+    existsSync: vi.fn(),
+    readdirSync: vi.fn(),
+  }
+})
+
+describe('polkadot-js wallet', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  describe('polkadot_js_config', () => {
+    it('should have correct extension name format', () => {
+      expect(POLKADOT_JS_CONFIG.extensionName).toMatch(/^polkadot-extension-\d+\.\d+\.\d+$/)
+    })
+
+    it('should have valid download URL', () => {
+      expect(POLKADOT_JS_CONFIG.downloadUrl).toContain('github.com')
+      expect(POLKADOT_JS_CONFIG.downloadUrl).toContain('polkadot-js/extension')
+      expect(POLKADOT_JS_CONFIG.downloadUrl.endsWith('.zip')).toBe(true)
+    })
+  })
+
+  describe('getPolkadotJSExtensionPath', () => {
+    it('should return extension path when extension exists', async () => {
+      const mockedFs = vi.mocked(fs)
+      mockedFs.existsSync.mockReturnValue(true)
+      mockedFs.readdirSync.mockReturnValue(['manifest.json'] as any)
+
+      const result = await getPolkadotJSExtensionPath()
+
+      expect(result).toContain('.chroma')
+      expect(result).toContain(POLKADOT_JS_CONFIG.extensionName)
+      expect(mockedFs.existsSync).toHaveBeenCalled()
+    })
+
+    it('should throw error when extension directory does not exist', async () => {
+      const mockedFs = vi.mocked(fs)
+      mockedFs.existsSync.mockReturnValue(false)
+
+      await expect(getPolkadotJSExtensionPath()).rejects.toThrow(
+        'Polkadot-JS extension not found',
+      )
+    })
+
+    it('should throw error when extension directory is empty', async () => {
+      const mockedFs = vi.mocked(fs)
+      mockedFs.existsSync.mockReturnValue(true)
+      mockedFs.readdirSync.mockReturnValue([])
+
+      await expect(getPolkadotJSExtensionPath()).rejects.toThrow(
+        'Polkadot-JS extension not found',
+      )
+    })
+
+    it('should include download instructions in error message', async () => {
+      const mockedFs = vi.mocked(fs)
+      mockedFs.existsSync.mockReturnValue(false)
+
+      await expect(getPolkadotJSExtensionPath()).rejects.toThrow(
+        'npx @avalix/chroma download-extensions',
+      )
+    })
+
+    it('should use correct path structure', async () => {
+      const mockedFs = vi.mocked(fs)
+      mockedFs.existsSync.mockReturnValue(true)
+      mockedFs.readdirSync.mockReturnValue(['manifest.json'] as any)
+
+      const result = await getPolkadotJSExtensionPath()
+
+      const expectedPath = path.join(process.cwd(), '.chroma', POLKADOT_JS_CONFIG.extensionName)
+      expect(result).toBe(expectedPath)
+    })
+  })
+})

package/src/wallets/polkadot-js.ts

@@ -12,7 +12,11 @@ export const POLKADOT_JS_CONFIG = {
   extensionName: `polkadot-extension-${VERSION}`,
 } as const
 
-// Helper function to find extension popup
+/*
+ * Helper function to find extension popup
+ * Coverage excluded: requires real browser context with Chrome extension APIs.
+ */
+/* c8 ignore start */
 async function findExtensionPopup(context: BrowserContext, extensionId: string): Promise<Page> {
   // Wait for extension popup to appear with retry logic
   const maxAttempts = 10
@@ -35,6 +39,7 @@ async function findExtensionPopup(context: BrowserContext, extensionId: string):
 
   throw new Error(`Extension popup not found for ID: ${extensionId}`)
 }
+/* c8 ignore stop */
 
 // Get Polkadot-JS extension path
 export async function getPolkadotJSExtensionPath(): Promise<string> {
@@ -53,6 +58,13 @@ export async function getPolkadotJSExtensionPath(): Promise<string> {
   return extensionDir
 }
 
+/*
+ * Wallet interaction functions below are excluded from coverage because:
+ * - They require a real Chromium browser with extension support
+ * - They interact with Chrome extension popup pages
+ */
+/* c8 ignore start */
+
 // Polkadot-JS specific account import implementation
 export async function importPolkadotJSAccount(
   page: Page & { __extensionContext: BrowserContext, __extensionId: string },
@@ -142,3 +154,5 @@ export async function rejectPolkadotJSTx(
   const extensionPopup = await findExtensionPopup(context, extensionId)
   await extensionPopup.getByRole('link', { name: 'Cancel' }).click()
 }
+
+/* c8 ignore stop */

package/src/wallets/talisman.test.ts

@@ -0,0 +1,97 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import {
+  getTalismanExtensionPath,
+  TALISMAN_CONFIG,
+} from './talisman.js'
+
+// Mock node: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(),
+    },
+    existsSync: vi.fn(),
+    readdirSync: vi.fn(),
+  }
+})
+
+describe('talisman wallet', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  describe('talisman_config', () => {
+    it('should have correct extension name format', () => {
+      expect(TALISMAN_CONFIG.extensionName).toMatch(/^talisman-extension-\d+\.\d+\.\d+$/)
+    })
+
+    it('should have valid download URL', () => {
+      expect(TALISMAN_CONFIG.downloadUrl).toContain('github.com')
+      expect(TALISMAN_CONFIG.downloadUrl).toContain('talisman')
+      expect(TALISMAN_CONFIG.downloadUrl.endsWith('.zip')).toBe(true)
+    })
+  })
+
+  describe('getTalismanExtensionPath', () => {
+    it('should return extension path when extension exists', async () => {
+      const mockedFs = vi.mocked(fs)
+      mockedFs.existsSync.mockReturnValue(true)
+      mockedFs.readdirSync.mockReturnValue(['manifest.json'] as any)
+
+      const result = await getTalismanExtensionPath()
+
+      expect(result).toContain('.chroma')
+      expect(result).toContain(TALISMAN_CONFIG.extensionName)
+      expect(mockedFs.existsSync).toHaveBeenCalled()
+    })
+
+    it('should throw error when extension directory does not exist', async () => {
+      const mockedFs = vi.mocked(fs)
+      mockedFs.existsSync.mockReturnValue(false)
+
+      await expect(getTalismanExtensionPath()).rejects.toThrow(
+        'Talisman extension not found',
+      )
+    })
+
+    it('should throw error when extension directory is empty', async () => {
+      const mockedFs = vi.mocked(fs)
+      mockedFs.existsSync.mockReturnValue(true)
+      mockedFs.readdirSync.mockReturnValue([])
+
+      await expect(getTalismanExtensionPath()).rejects.toThrow(
+        'Talisman extension not found',
+      )
+    })
+
+    it('should include download instructions in error message', async () => {
+      const mockedFs = vi.mocked(fs)
+      mockedFs.existsSync.mockReturnValue(false)
+
+      await expect(getTalismanExtensionPath()).rejects.toThrow(
+        'npx @avalix/chroma download-extensions',
+      )
+    })
+
+    it('should use correct path structure', async () => {
+      const mockedFs = vi.mocked(fs)
+      mockedFs.existsSync.mockReturnValue(true)
+      mockedFs.readdirSync.mockReturnValue(['manifest.json'] as any)
+
+      const result = await getTalismanExtensionPath()
+
+      const expectedPath = path.join(process.cwd(), '.chroma', TALISMAN_CONFIG.extensionName)
+      expect(result).toBe(expectedPath)
+    })
+  })
+})