test: add unit tests for commandStore, extensionStore, widgetStore (STORE-04) (#10647)

## Summary

Adds 43 unit tests covering three priority Pinia stores that previously
had zero test coverage.

### commandStore (18 tests)
- `registerCommand` / `registerCommands` — single and batch
registration, duplicate warning
- `getCommand` — retrieval and undefined for missing
- `execute` — successful execution, metadata passing, error handler
delegation, missing command error
- `isRegistered` — presence check
- `loadExtensionCommands` — extension command registration with source,
skip when no commands
- `ComfyCommandImpl` — label/icon/tooltip resolution (string vs
function), menubarLabel defaulting

### extensionStore (16 tests)
- `registerExtension` — name validation, duplicate detection, disabled
extension warning
- `isExtensionEnabled` / `loadDisabledExtensionNames` — enable/disable
lifecycle
- Always-disabled hardcoded extensions (pysssss.Locking,
pysssss.SnapToGrid, pysssss.FaviconStatus, KJNodes.browserstatus)
- `enabledExtensions` — computed filter
- `isExtensionReadOnly` — hardcoded list check
- `inactiveDisabledExtensionNames` — ghost extension tracking
- Core extension capture and `hasThirdPartyExtensions` detection

### widgetStore (9 tests)
- Core widget availability via `ComfyWidgets`
- Custom widget registration and core/custom precedence
- `inputIsWidget` for both v1 array and v2 object InputSpec formats

## Part of
Test Coverage Q2 Overhaul — Phase 5 (Unit & Component Tests)

┆Issue is synchronized with this [Notion
page](https://www.notion.so/PR-10647-test-add-unit-tests-for-commandStore-extensionStore-widgetStore-STORE-04-3316d73d365081e0b4f6ce913130e489)
by [Unito](https://www.unito.io)

---------

Co-authored-by: GitHub Action <action@github.com>
Co-authored-by: Amp <amp@ampcode.com>
Co-authored-by: Alexander Brown <drjkl@comfy.org>
Co-authored-by: Alexander Brown <448862+DrJKL@users.noreply.github.com>

Author: 4 people

src/stores/commandStore.test.ts

@@ -0,0 +1,197 @@
+import { createTestingPinia } from '@pinia/testing'
+import { setActivePinia } from 'pinia'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { useCommandStore } from '@/stores/commandStore'
+
+vi.mock('@/composables/useErrorHandling', () => ({
+  useErrorHandling: () => ({
+    wrapWithErrorHandlingAsync:
+      (fn: () => Promise<void>, errorHandler?: (e: unknown) => void) =>
+      async () => {
+        try {
+          await fn()
+        } catch (e) {
+          if (errorHandler) errorHandler(e)
+          else throw e
+        }
+      }
+  })
+}))
+
+vi.mock('@/platform/keybindings/keybindingStore', () => ({
+  useKeybindingStore: () => ({
+    getKeybindingByCommandId: () => null
+  })
+}))
+
+describe('commandStore', () => {
+  beforeEach(() => {
+    setActivePinia(createTestingPinia({ stubActions: false }))
+  })
+
+  describe('registerCommand', () => {
+    it('registers a command by id', () => {
+      const store = useCommandStore()
+      store.registerCommand({
+        id: 'test.command',
+        function: vi.fn()
+      })
+      expect(store.isRegistered('test.command')).toBe(true)
+    })
+
+    it('warns on duplicate registration and overwrites with new function', async () => {
+      const store = useCommandStore()
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+
+      const originalFn = vi.fn()
+      const replacementFn = vi.fn()
+      store.registerCommand({ id: 'dup', function: originalFn })
+      store.registerCommand({ id: 'dup', function: replacementFn })
+
+      expect(warnSpy).toHaveBeenCalledWith('Command dup already registered')
+      warnSpy.mockRestore()
+
+      await store.getCommand('dup')?.function()
+      expect(replacementFn).toHaveBeenCalled()
+      expect(originalFn).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('getCommand', () => {
+    it('returns the registered command', () => {
+      const store = useCommandStore()
+      const fn = vi.fn()
+      store.registerCommand({ id: 'get.test', function: fn, label: 'Test' })
+      const cmd = store.getCommand('get.test')
+      expect(cmd).toBeDefined()
+      expect(cmd?.label).toBe('Test')
+    })
+
+    it('returns undefined for unregistered command', () => {
+      const store = useCommandStore()
+      expect(store.getCommand('nonexistent')).toBeUndefined()
+    })
+  })
+
+  describe('execute', () => {
+    it('executes a registered command', async () => {
+      const store = useCommandStore()
+      const fn = vi.fn()
+      store.registerCommand({ id: 'exec.test', function: fn })
+      await store.execute('exec.test')
+      expect(fn).toHaveBeenCalled()
+    })
+
+    it('throws for unregistered command', async () => {
+      const store = useCommandStore()
+      await expect(store.execute('missing')).rejects.toThrow(
+        'Command missing not found'
+      )
+    })
+
+    it('passes metadata to the command function', async () => {
+      const store = useCommandStore()
+      const fn = vi.fn()
+      store.registerCommand({ id: 'meta.test', function: fn })
+      await store.execute('meta.test', { metadata: { source: 'keyboard' } })
+      expect(fn).toHaveBeenCalledWith({ source: 'keyboard' })
+    })
+
+    it('calls errorHandler on failure', async () => {
+      const store = useCommandStore()
+      const error = new Error('fail')
+      store.registerCommand({
+        id: 'err.test',
+        function: () => {
+          throw error
+        }
+      })
+      const handler = vi.fn()
+      await store.execute('err.test', { errorHandler: handler })
+      expect(handler).toHaveBeenCalledWith(error)
+    })
+  })
+
+  describe('isRegistered', () => {
+    it('returns false for unregistered command', () => {
+      const store = useCommandStore()
+      expect(store.isRegistered('nope')).toBe(false)
+    })
+  })
+
+  describe('loadExtensionCommands', () => {
+    it('registers commands from an extension', () => {
+      const store = useCommandStore()
+      store.loadExtensionCommands({
+        name: 'test-ext',
+        commands: [
+          { id: 'ext.cmd1', function: vi.fn(), label: 'Cmd 1' },
+          { id: 'ext.cmd2', function: vi.fn(), label: 'Cmd 2' }
+        ]
+      })
+      expect(store.isRegistered('ext.cmd1')).toBe(true)
+      expect(store.isRegistered('ext.cmd2')).toBe(true)
+      expect(store.getCommand('ext.cmd1')?.source).toBe('test-ext')
+      expect(store.getCommand('ext.cmd2')?.source).toBe('test-ext')
+    })
+
+    it('skips extensions without commands', () => {
+      const store = useCommandStore()
+      store.loadExtensionCommands({ name: 'no-commands' })
+      expect(store.commands).toHaveLength(0)
+    })
+  })
+
+  describe('getCommand resolves dynamic properties', () => {
+    it('resolves label as function', () => {
+      const store = useCommandStore()
+      store.registerCommand({
+        id: 'label.fn',
+        function: vi.fn(),
+        label: () => 'Dynamic'
+      })
+      expect(store.getCommand('label.fn')?.label).toBe('Dynamic')
+    })
+
+    it('resolves tooltip as function', () => {
+      const store = useCommandStore()
+      store.registerCommand({
+        id: 'tip.fn',
+        function: vi.fn(),
+        tooltip: () => 'Dynamic tip'
+      })
+      expect(store.getCommand('tip.fn')?.tooltip).toBe('Dynamic tip')
+    })
+
+    it('uses explicit menubarLabel over label', () => {
+      const store = useCommandStore()
+      store.registerCommand({
+        id: 'mbl.explicit',
+        function: vi.fn(),
+        label: 'Label',
+        menubarLabel: 'Menu Label'
+      })
+      expect(store.getCommand('mbl.explicit')?.menubarLabel).toBe('Menu Label')
+    })
+
+    it('falls back menubarLabel to label', () => {
+      const store = useCommandStore()
+      store.registerCommand({
+        id: 'mbl.default',
+        function: vi.fn(),
+        label: 'My Label'
+      })
+      expect(store.getCommand('mbl.default')?.menubarLabel).toBe('My Label')
+    })
+  })
+
+  describe('formatKeySequence', () => {
+    it('returns empty string when command has no keybinding', () => {
+      const store = useCommandStore()
+      store.registerCommand({ id: 'no.kb', function: vi.fn() })
+      const cmd = store.getCommand('no.kb')!
+      expect(store.formatKeySequence(cmd)).toBe('')
+    })
+  })
+})

src/stores/extensionStore.test.ts

@@ -0,0 +1,152 @@
+import { createTestingPinia } from '@pinia/testing'
+import { setActivePinia } from 'pinia'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { useExtensionStore } from '@/stores/extensionStore'
+
+describe('extensionStore', () => {
+  beforeEach(() => {
+    setActivePinia(createTestingPinia({ stubActions: false }))
+  })
+
+  describe('registerExtension', () => {
+    it('registers an extension by name', () => {
+      const store = useExtensionStore()
+      store.registerExtension({ name: 'test.ext' })
+      expect(store.isExtensionInstalled('test.ext')).toBe(true)
+    })
+
+    it('throws for extension without name', () => {
+      const store = useExtensionStore()
+      expect(() => store.registerExtension({ name: '' })).toThrow(
+        "Extensions must have a 'name' property."
+      )
+    })
+
+    it('throws for duplicate registration', () => {
+      const store = useExtensionStore()
+      store.registerExtension({ name: 'dup' })
+      expect(() => store.registerExtension({ name: 'dup' })).toThrow(
+        "Extension named 'dup' already registered."
+      )
+    })
+
+    it('warns when registering a disabled extension but still installs it', () => {
+      const store = useExtensionStore()
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+      try {
+        store.loadDisabledExtensionNames(['disabled.ext'])
+        store.registerExtension({ name: 'disabled.ext' })
+        expect(warnSpy).toHaveBeenCalledWith(
+          'Extension disabled.ext is disabled.'
+        )
+        expect(store.isExtensionInstalled('disabled.ext')).toBe(true)
+        expect(store.isExtensionEnabled('disabled.ext')).toBe(false)
+      } finally {
+        warnSpy.mockRestore()
+      }
+    })
+  })
+
+  describe('isExtensionInstalled', () => {
+    it('returns false for uninstalled extension', () => {
+      const store = useExtensionStore()
+      expect(store.isExtensionInstalled('missing')).toBe(false)
+    })
+  })
+
+  describe('isExtensionEnabled / loadDisabledExtensionNames', () => {
+    it('all extensions are enabled by default', () => {
+      const store = useExtensionStore()
+      store.registerExtension({ name: 'fresh' })
+      expect(store.isExtensionEnabled('fresh')).toBe(true)
+    })
+
+    it('disables extensions from provided list', () => {
+      const store = useExtensionStore()
+      store.loadDisabledExtensionNames(['off.ext'])
+      store.registerExtension({ name: 'off.ext' })
+      expect(store.isExtensionEnabled('off.ext')).toBe(false)
+    })
+
+    it('always disables hardcoded extensions', () => {
+      const store = useExtensionStore()
+      store.loadDisabledExtensionNames([])
+      store.registerExtension({ name: 'pysssss.Locking' })
+      store.registerExtension({ name: 'regular.ext' })
+
+      expect(store.isExtensionEnabled('pysssss.Locking')).toBe(false)
+      expect(store.isExtensionEnabled('pysssss.SnapToGrid')).toBe(false)
+      expect(store.isExtensionEnabled('pysssss.FaviconStatus')).toBe(false)
+      expect(store.isExtensionEnabled('KJNodes.browserstatus')).toBe(false)
+      expect(store.isExtensionEnabled('regular.ext')).toBe(true)
+    })
+  })
+
+  describe('enabledExtensions', () => {
+    it('filters out disabled extensions', () => {
+      const store = useExtensionStore()
+      store.loadDisabledExtensionNames(['ext.off'])
+      store.registerExtension({ name: 'ext.on' })
+      store.registerExtension({ name: 'ext.off' })
+
+      const enabled = store.enabledExtensions
+      expect(enabled).toHaveLength(1)
+      expect(enabled[0].name).toBe('ext.on')
+    })
+  })
+
+  describe('isExtensionReadOnly', () => {
+    it('returns true for always-disabled extensions', () => {
+      const store = useExtensionStore()
+      expect(store.isExtensionReadOnly('pysssss.Locking')).toBe(true)
+    })
+
+    it('returns false for normal extensions', () => {
+      const store = useExtensionStore()
+      expect(store.isExtensionReadOnly('some.custom.ext')).toBe(false)
+    })
+  })
+
+  describe('inactiveDisabledExtensionNames', () => {
+    it('returns disabled names not currently installed', () => {
+      const store = useExtensionStore()
+      store.loadDisabledExtensionNames(['ghost.ext', 'installed.ext'])
+      store.registerExtension({ name: 'installed.ext' })
+
+      expect(store.inactiveDisabledExtensionNames).toContain('ghost.ext')
+      expect(store.inactiveDisabledExtensionNames).not.toContain(
+        'installed.ext'
+      )
+    })
+  })
+
+  describe('core extensions', () => {
+    it('captures current extensions as core', () => {
+      const store = useExtensionStore()
+      store.registerExtension({ name: 'core.a' })
+      store.registerExtension({ name: 'core.b' })
+      store.captureCoreExtensions()
+
+      expect(store.isCoreExtension('core.a')).toBe(true)
+      expect(store.isCoreExtension('core.b')).toBe(true)
+    })
+
+    it('identifies third-party extensions registered after capture', () => {
+      const store = useExtensionStore()
+      store.registerExtension({ name: 'core.x' })
+      store.captureCoreExtensions()
+
+      expect(store.hasThirdPartyExtensions).toBe(false)
+
+      store.registerExtension({ name: 'third.party' })
+      expect(store.hasThirdPartyExtensions).toBe(true)
+    })
+
+    it('returns false for isCoreExtension before capture', () => {
+      const store = useExtensionStore()
+      store.registerExtension({ name: 'ext.pre' })
+      expect(store.isCoreExtension('ext.pre')).toBe(false)
+    })
+  })
+})