Road to No explicit any: Group 8 (part 8) test files (#8496)

## Summary

This PR removes unsafe type assertions ("as unknown as Type") from test
files and improves type safety across the codebase.

### Key Changes

#### Type Safety Improvements
- Removed improper `as unknown as Type` patterns from test files in
Group 8 part 8
- Replaced with proper TypeScript patterns using Pinia store testing
patterns
- Fixed parameter shadowing issue in typeGuardUtil.test.ts (constructor
→ nodeConstructor)
- Fixed stale mock values in useConflictDetection.test.ts using getter
functions
- Refactored useManagerState tests to follow proper Pinia store testing
patterns with createTestingPinia

### Files Changed

Test files (Group 8 part 8 - utils and manager composables):
- src/utils/typeGuardUtil.test.ts - Fixed parameter shadowing
- src/utils/graphTraversalUtil.test.ts - Removed unsafe type assertions
- src/utils/litegraphUtil.test.ts - Improved type handling
- src/workbench/extensions/manager/composables/useManagerState.test.ts -
Complete rewrite using Pinia testing patterns
-
src/workbench/extensions/manager/composables/useConflictDetection.test.ts
- Fixed stale mock values with getters
- src/workbench/extensions/manager/composables/useManagerQueue.test.ts -
Type safety improvements
-
src/workbench/extensions/manager/composables/nodePack/useMissingNodes.test.ts
- Removed unsafe casts
-
src/workbench/extensions/manager/composables/nodePack/usePacksSelection.test.ts
- Type improvements
-
src/workbench/extensions/manager/composables/nodePack/usePacksStatus.test.ts
- Type improvements
- src/workbench/extensions/manager/utils/versionUtil.test.ts - Type
safety fixes

Source files (minor type fixes):
- src/utils/fuseUtil.ts - Type improvements
- src/utils/linkFixer.ts - Type safety fixes
- src/utils/syncUtil.ts - Type improvements
-
src/workbench/extensions/manager/composables/nodePack/useWorkflowPacks.ts
- Type fix
-
src/workbench/extensions/manager/composables/useConflictAcknowledgment.ts
- Type fix

### Testing
- All TypeScript type checking passes (`pnpm typecheck`)
- All affected test files pass (`pnpm test:unit`)
- Linting passes without errors (`pnpm lint`)
- Code formatting applied (`pnpm format`)

Part of the "Road to No Explicit Any" initiative, cleaning up type
casting issues from branch `fix/remove-any-types-part8`.

### Previous PRs in this series:
- Part 2: #7401
- Part 3: #7935
- Part 4: #7970
- Part 5: #8064
- Part 6: #8083
- Part 7: #8092
- Part 8 Group 1: #8253
- Part 8 Group 2: #8258
- Part 8 Group 3: #8304
- Part 8 Group 4: #8314
- Part 8 Group 5: #8329
- Part 8 Group 6: #8344
- Part 8 Group 7: #8459
- Part 8 Group 8: #8496 (this PR)

┆Issue is synchronized with this [Notion
page](https://www.notion.so/PR-8496-Road-to-No-explicit-any-Group-8-part-8-test-files-2f86d73d365081f3afdcf8d01fba81e1)
by [Unito](https://www.unito.io)

---------

Co-authored-by: GitHub Action <action@github.com>

src/workbench/extensions/manager/composables/useManagerState.test.ts

@@ -1,45 +1,45 @@
+import { createTestingPinia } from '@pinia/testing'
+import { setActivePinia } from 'pinia'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { ref } from 'vue'
 
-import { useFeatureFlags } from '@/composables/useFeatureFlags'
 import { api } from '@/scripts/api'
-import { useExtensionStore } from '@/stores/extensionStore'
 import { useSystemStatsStore } from '@/stores/systemStatsStore'
 import {
   ManagerUIState,
   useManagerState
 } from '@/workbench/extensions/manager/composables/useManagerState'
 
-// Mock dependencies
+// Mock dependencies that are not stores
 vi.mock('@/scripts/api', () => ({
   api: {
     getClientFeatureFlags: vi.fn(),
-    getServerFeature: vi.fn()
+    getServerFeature: vi.fn(),
+    getSystemStats: vi.fn()
   }
 }))
 
-vi.mock('@/composables/useFeatureFlags', () => ({
-  useFeatureFlags: vi.fn(() => ({
-    flags: { supportsManagerV4: false },
-    featureFlag: vi.fn()
-  }))
-}))
+vi.mock('@/composables/useFeatureFlags', () => {
+  const featureFlag = vi.fn()
+  return {
+    useFeatureFlags: vi.fn(() => ({
+      flags: { supportsManagerV4: false },
+      featureFlag
+    }))
+  }
+})
 
-vi.mock('@/stores/extensionStore', () => ({
-  useExtensionStore: vi.fn()
-}))
-
-vi.mock('@/stores/systemStatsStore', () => ({
-  useSystemStatsStore: vi.fn()
-}))
-
-vi.mock('@/services/dialogService', () => ({
-  useDialogService: vi.fn(() => ({
-    showManagerPopup: vi.fn(),
-    showLegacyManagerPopup: vi.fn(),
-    showSettingsDialog: vi.fn()
-  }))
-}))
+vi.mock('@/services/dialogService', () => {
+  const showManagerPopup = vi.fn()
+  const showLegacyManagerPopup = vi.fn()
+  const showSettingsDialog = vi.fn()
+  return {
+    useDialogService: vi.fn(() => ({
+      showManagerPopup,
+      showLegacyManagerPopup,
+      showSettingsDialog
+    }))
+  }
+})
 
 vi.mock('@/stores/commandStore', () => ({
   useCommandStore: vi.fn(() => ({
@@ -47,198 +47,223 @@ vi.mock('@/stores/commandStore', () => ({
   }))
 }))
 
-vi.mock('@/stores/toastStore', () => ({
-  useToastStore: vi.fn(() => ({
-    add: vi.fn()
-  }))
-}))
+vi.mock('@/platform/updates/common/toastStore', () => {
+  const add = vi.fn()
+  return {
+    useToastStore: vi.fn(() => ({
+      add
+    }))
+  }
+})
 
-vi.mock('@/workbench/extensions/manager/composables/useManagerDialog', () => ({
-  useManagerDialog: vi.fn(() => ({
-    show: vi.fn(),
-    hide: vi.fn()
-  }))
-}))
+vi.mock('@/workbench/extensions/manager/composables/useManagerDialog', () => {
+  const show = vi.fn()
+  const hide = vi.fn()
+  return {
+    useManagerDialog: vi.fn(() => ({
+      show,
+      hide
+    }))
+  }
+})
 
 describe('useManagerState', () => {
+  let systemStatsStore: ReturnType<typeof useSystemStatsStore>
+
   beforeEach(() => {
-    vi.clearAllMocks()
+    // Create a fresh testing pinia and activate it for each test
+    setActivePinia(
+      createTestingPinia({
+        stubActions: false,
+        createSpy: vi.fn
+      })
+    )
+
+    // Initialize stores
+    systemStatsStore = useSystemStatsStore()
+
+    // Reset all mocks
+    vi.resetAllMocks()
+
+    // Set default mock returns
+    vi.mocked(api.getClientFeatureFlags).mockReturnValue({})
+    vi.mocked(api.getServerFeature).mockReturnValue(undefined)
   })
 
   describe('managerUIState property', () => {
     it('should return DISABLED state when --enable-manager is NOT present', () => {
-      vi.mocked(useSystemStatsStore).mockReturnValue({
-        systemStats: ref({
-          system: { argv: ['python', 'main.py'] } // No --enable-manager flag
-        }),
-        isInitialized: ref(true)
-      } as any)
-      vi.mocked(api.getClientFeatureFlags).mockReturnValue({})
-      vi.mocked(useExtensionStore).mockReturnValue({
-        extensions: []
-      } as any)
+      // Set up store state
+      systemStatsStore.$patch({
+        systemStats: {
+          system: {
+            os: 'Test OS',
+            python_version: '3.10',
+            embedded_python: false,
+            comfyui_version: '1.0.0',
+            pytorch_version: '2.0.0',
+            argv: ['python', 'main.py'], // No --enable-manager flag
+            ram_total: 16000000000,
+            ram_free: 8000000000
+          },
+          devices: []
+        },
+        isInitialized: true
+      })
 
       const managerState = useManagerState()
-
       expect(managerState.managerUIState.value).toBe(ManagerUIState.DISABLED)
     })
 
     it('should return LEGACY_UI state when --enable-manager-legacy-ui is present', () => {
-      vi.mocked(useSystemStatsStore).mockReturnValue({
-        systemStats: ref({
+      // Set up store state
+      systemStatsStore.$patch({
+        systemStats: {
           system: {
+            os: 'Test OS',
+            python_version: '3.10',
+            embedded_python: false,
+            comfyui_version: '1.0.0',
+            pytorch_version: '2.0.0',
             argv: [
               'python',
               'main.py',
               '--enable-manager',
               '--enable-manager-legacy-ui'
-            ]
-          } // Both flags needed
-        }),
-        isInitialized: ref(true)
-      } as any)
-      vi.mocked(api.getClientFeatureFlags).mockReturnValue({})
-      vi.mocked(useExtensionStore).mockReturnValue({
-        extensions: []
-      } as any)
+            ],
+            ram_total: 16000000000,
+            ram_free: 8000000000
+          },
+          devices: []
+        },
+        isInitialized: true
+      })
 
       const managerState = useManagerState()
-
       expect(managerState.managerUIState.value).toBe(ManagerUIState.LEGACY_UI)
     })
 
     it('should return NEW_UI state when client and server both support v4', () => {
-      vi.mocked(useSystemStatsStore).mockReturnValue({
-        systemStats: ref({
-          system: { argv: ['python', 'main.py', '--enable-manager'] }
-        }), // Need --enable-manager
-        isInitialized: ref(true)
-      } as any)
+      // Set up store state
+      systemStatsStore.$patch({
+        systemStats: {
+          system: {
+            os: 'Test OS',
+            python_version: '3.10',
+            embedded_python: false,
+            comfyui_version: '1.0.0',
+            pytorch_version: '2.0.0',
+            argv: ['python', 'main.py', '--enable-manager'],
+            ram_total: 16000000000,
+            ram_free: 8000000000
+          },
+          devices: []
+        },
+        isInitialized: true
+      })
+
       vi.mocked(api.getClientFeatureFlags).mockReturnValue({
         supports_manager_v4_ui: true
       })
       vi.mocked(api.getServerFeature).mockReturnValue(true)
-      vi.mocked(useFeatureFlags).mockReturnValue({
-        flags: { supportsManagerV4: true },
-        featureFlag: vi.fn()
-      } as any)
-      vi.mocked(useExtensionStore).mockReturnValue({
-        extensions: []
-      } as any)
 
       const managerState = useManagerState()
-
       expect(managerState.managerUIState.value).toBe(ManagerUIState.NEW_UI)
     })
 
     it('should return LEGACY_UI state when server supports v4 but client does not', () => {
-      vi.mocked(useSystemStatsStore).mockReturnValue({
-        systemStats: ref({
-          system: { argv: ['python', 'main.py', '--enable-manager'] }
-        }), // Need --enable-manager
-        isInitialized: ref(true)
-      } as any)
+      // Set up store state
+      systemStatsStore.$patch({
+        systemStats: {
+          system: {
+            os: 'Test OS',
+            python_version: '3.10',
+            embedded_python: false,
+            comfyui_version: '1.0.0',
+            pytorch_version: '2.0.0',
+            argv: ['python', 'main.py', '--enable-manager'],
+            ram_total: 16000000000,
+            ram_free: 8000000000
+          },
+          devices: []
+        },
+        isInitialized: true
+      })
+
       vi.mocked(api.getClientFeatureFlags).mockReturnValue({
         supports_manager_v4_ui: false
       })
       vi.mocked(api.getServerFeature).mockReturnValue(true)
-      vi.mocked(useFeatureFlags).mockReturnValue({
-        flags: { supportsManagerV4: true },
-        featureFlag: vi.fn()
-      } as any)
-      vi.mocked(useExtensionStore).mockReturnValue({
-        extensions: []
-      } as any)
 
       const managerState = useManagerState()
-
       expect(managerState.managerUIState.value).toBe(ManagerUIState.LEGACY_UI)
     })
 
-    it('should return LEGACY_UI state when legacy manager extension exists', () => {
-      vi.mocked(useSystemStatsStore).mockReturnValue({
-        systemStats: ref({
-          system: { argv: ['python', 'main.py', '--enable-manager'] }
-        }), // Need --enable-manager
-        isInitialized: ref(true)
-      } as any)
+    it('should return LEGACY_UI state when server does not support v4', () => {
+      // Set up store state
+      systemStatsStore.$patch({
+        systemStats: {
+          system: {
+            os: 'Test OS',
+            python_version: '3.10',
+            embedded_python: false,
+            comfyui_version: '1.0.0',
+            pytorch_version: '2.0.0',
+            argv: ['python', 'main.py', '--enable-manager'],
+            ram_total: 16000000000,
+            ram_free: 8000000000
+          },
+          devices: []
+        },
+        isInitialized: true
+      })
+
       vi.mocked(api.getClientFeatureFlags).mockReturnValue({})
-      vi.mocked(useFeatureFlags).mockReturnValue({
-        flags: { supportsManagerV4: false },
-        featureFlag: vi.fn()
-      } as any)
-      vi.mocked(useExtensionStore).mockReturnValue({
-        extensions: [{ name: 'Comfy.CustomNodesManager' }]
-      } as any)
+      vi.mocked(api.getServerFeature).mockReturnValue(false)
 
       const managerState = useManagerState()
-
       expect(managerState.managerUIState.value).toBe(ManagerUIState.LEGACY_UI)
     })
 
     it('should return NEW_UI state when server feature flags are undefined', () => {
-      vi.mocked(useSystemStatsStore).mockReturnValue({
-        systemStats: ref({
-          system: { argv: ['python', 'main.py', '--enable-manager'] }
-        }), // Need --enable-manager
-        isInitialized: ref(true)
-      } as any)
+      // Set up store state
+      systemStatsStore.$patch({
+        systemStats: {
+          system: {
+            os: 'Test OS',
+            python_version: '3.10',
+            embedded_python: false,
+            comfyui_version: '1.0.0',
+            pytorch_version: '2.0.0',
+            argv: ['python', 'main.py', '--enable-manager'],
+            ram_total: 16000000000,
+            ram_free: 8000000000
+          },
+          devices: []
+        },
+        isInitialized: true
+      })
+
       vi.mocked(api.getClientFeatureFlags).mockReturnValue({})
       vi.mocked(api.getServerFeature).mockReturnValue(undefined)
-      vi.mocked(useFeatureFlags).mockReturnValue({
-        flags: { supportsManagerV4: undefined },
-        featureFlag: vi.fn()
-      } as any)
-      vi.mocked(useExtensionStore).mockReturnValue({
-        extensions: []
-      } as any)
 
       const managerState = useManagerState()
-
+      // When server feature flags haven't loaded yet, default to NEW_UI
       expect(managerState.managerUIState.value).toBe(ManagerUIState.NEW_UI)
     })
 
-    it('should return LEGACY_UI state when server does not support v4', () => {
-      vi.mocked(useSystemStatsStore).mockReturnValue({
-        systemStats: ref({
-          system: { argv: ['python', 'main.py', '--enable-manager'] }
-        }), // Need --enable-manager
-        isInitialized: ref(true)
-      } as any)
-      vi.mocked(api.getClientFeatureFlags).mockReturnValue({})
-      vi.mocked(api.getServerFeature).mockReturnValue(false)
-      vi.mocked(useFeatureFlags).mockReturnValue({
-        flags: { supportsManagerV4: false },
-        featureFlag: vi.fn()
-      } as any)
-      vi.mocked(useExtensionStore).mockReturnValue({
-        extensions: []
-      } as any)
-
-      const managerState = useManagerState()
-
-      expect(managerState.managerUIState.value).toBe(ManagerUIState.LEGACY_UI)
-    })
-
     it('should handle null systemStats gracefully', () => {
-      vi.mocked(useSystemStatsStore).mockReturnValue({
-        systemStats: ref(null),
-        isInitialized: ref(true)
-      } as any)
+      // Set up store state
+      systemStatsStore.$patch({
+        systemStats: null,
+        isInitialized: true
+      })
+
       vi.mocked(api.getClientFeatureFlags).mockReturnValue({
         supports_manager_v4_ui: true
       })
       vi.mocked(api.getServerFeature).mockReturnValue(true)
-      vi.mocked(useFeatureFlags).mockReturnValue({
-        flags: { supportsManagerV4: true },
-        featureFlag: vi.fn()
-      } as any)
-      vi.mocked(useExtensionStore).mockReturnValue({
-        extensions: []
-      } as any)
 
       const managerState = useManagerState()
-
       // When systemStats is null, we can't check for --enable-manager flag, so manager is disabled
       expect(managerState.managerUIState.value).toBe(ManagerUIState.DISABLED)
     })
@@ -246,115 +271,163 @@ describe('useManagerState', () => {
 
   describe('helper properties', () => {
     it('isManagerEnabled should return true when state is not DISABLED', () => {
-      vi.mocked(useSystemStatsStore).mockReturnValue({
-        systemStats: ref({
-          system: { argv: ['python', 'main.py', '--enable-manager'] }
-        }), // Need --enable-manager
-        isInitialized: ref(true)
-      } as any)
+      // Set up store state
+      systemStatsStore.$patch({
+        systemStats: {
+          system: {
+            os: 'Test OS',
+            python_version: '3.10',
+            embedded_python: false,
+            comfyui_version: '1.0.0',
+            pytorch_version: '2.0.0',
+            argv: ['python', 'main.py', '--enable-manager'],
+            ram_total: 16000000000,
+            ram_free: 8000000000
+          },
+          devices: []
+        },
+        isInitialized: true
+      })
+
       vi.mocked(api.getClientFeatureFlags).mockReturnValue({
         supports_manager_v4_ui: true
       })
       vi.mocked(api.getServerFeature).mockReturnValue(true)
-      vi.mocked(useExtensionStore).mockReturnValue({
-        extensions: []
-      } as any)
 
       const managerState = useManagerState()
       expect(managerState.isManagerEnabled.value).toBe(true)
     })
 
     it('isManagerEnabled should return false when state is DISABLED', () => {
-      vi.mocked(useSystemStatsStore).mockReturnValue({
-        systemStats: ref({
-          system: { argv: ['python', 'main.py'] } // No --enable-manager flag means disabled
-        }),
-        isInitialized: ref(true)
-      } as any)
-      vi.mocked(api.getClientFeatureFlags).mockReturnValue({})
-      vi.mocked(useExtensionStore).mockReturnValue({
-        extensions: []
-      } as any)
+      // Set up store state
+      systemStatsStore.$patch({
+        systemStats: {
+          system: {
+            os: 'Test OS',
+            python_version: '3.10',
+            embedded_python: false,
+            comfyui_version: '1.0.0',
+            pytorch_version: '2.0.0',
+            argv: ['python', 'main.py'], // No --enable-manager flag
+            ram_total: 16000000000,
+            ram_free: 8000000000
+          },
+          devices: []
+        },
+        isInitialized: true
+      })
 
       const managerState = useManagerState()
       expect(managerState.isManagerEnabled.value).toBe(false)
     })
 
     it('isNewManagerUI should return true when state is NEW_UI', () => {
-      vi.mocked(useSystemStatsStore).mockReturnValue({
-        systemStats: ref({
-          system: { argv: ['python', 'main.py', '--enable-manager'] }
-        }), // Need --enable-manager
-        isInitialized: ref(true)
-      } as any)
+      // Set up store state
+      systemStatsStore.$patch({
+        systemStats: {
+          system: {
+            os: 'Test OS',
+            python_version: '3.10',
+            embedded_python: false,
+            comfyui_version: '1.0.0',
+            pytorch_version: '2.0.0',
+            argv: ['python', 'main.py', '--enable-manager'],
+            ram_total: 16000000000,
+            ram_free: 8000000000
+          },
+          devices: []
+        },
+        isInitialized: true
+      })
+
       vi.mocked(api.getClientFeatureFlags).mockReturnValue({
         supports_manager_v4_ui: true
       })
       vi.mocked(api.getServerFeature).mockReturnValue(true)
-      vi.mocked(useExtensionStore).mockReturnValue({
-        extensions: []
-      } as any)
 
       const managerState = useManagerState()
       expect(managerState.isNewManagerUI.value).toBe(true)
     })
 
     it('isLegacyManagerUI should return true when state is LEGACY_UI', () => {
-      vi.mocked(useSystemStatsStore).mockReturnValue({
-        systemStats: ref({
+      // Set up store state
+      systemStatsStore.$patch({
+        systemStats: {
           system: {
+            os: 'Test OS',
+            python_version: '3.10',
+            embedded_python: false,
+            comfyui_version: '1.0.0',
+            pytorch_version: '2.0.0',
             argv: [
               'python',
               'main.py',
               '--enable-manager',
               '--enable-manager-legacy-ui'
-            ]
-          } // Both flags needed
-        }),
-        isInitialized: ref(true)
-      } as any)
-      vi.mocked(api.getClientFeatureFlags).mockReturnValue({})
-      vi.mocked(useExtensionStore).mockReturnValue({
-        extensions: []
-      } as any)
+            ],
+            ram_total: 16000000000,
+            ram_free: 8000000000
+          },
+          devices: []
+        },
+        isInitialized: true
+      })
 
       const managerState = useManagerState()
       expect(managerState.isLegacyManagerUI.value).toBe(true)
     })
 
     it('shouldShowInstallButton should return true only for NEW_UI', () => {
-      vi.mocked(useSystemStatsStore).mockReturnValue({
-        systemStats: ref({
-          system: { argv: ['python', 'main.py', '--enable-manager'] }
-        }), // Need --enable-manager
-        isInitialized: ref(true)
-      } as any)
+      // Set up store state
+      systemStatsStore.$patch({
+        systemStats: {
+          system: {
+            os: 'Test OS',
+            python_version: '3.10',
+            embedded_python: false,
+            comfyui_version: '1.0.0',
+            pytorch_version: '2.0.0',
+            argv: ['python', 'main.py', '--enable-manager'],
+            ram_total: 16000000000,
+            ram_free: 8000000000
+          },
+          devices: []
+        },
+        isInitialized: true
+      })
+
       vi.mocked(api.getClientFeatureFlags).mockReturnValue({
         supports_manager_v4_ui: true
       })
       vi.mocked(api.getServerFeature).mockReturnValue(true)
-      vi.mocked(useExtensionStore).mockReturnValue({
-        extensions: []
-      } as any)
 
       const managerState = useManagerState()
       expect(managerState.shouldShowInstallButton.value).toBe(true)
     })
 
     it('shouldShowManagerButtons should return true when not DISABLED', () => {
-      vi.mocked(useSystemStatsStore).mockReturnValue({
-        systemStats: ref({
-          system: { argv: ['python', 'main.py', '--enable-manager'] }
-        }), // Need --enable-manager
-        isInitialized: ref(true)
-      } as any)
+      // Set up store state
+      systemStatsStore.$patch({
+        systemStats: {
+          system: {
+            os: 'Test OS',
+            python_version: '3.10',
+            embedded_python: false,
+            comfyui_version: '1.0.0',
+            pytorch_version: '2.0.0',
+            argv: ['python', 'main.py', '--enable-manager'],
+            ram_total: 16000000000,
+            ram_free: 8000000000
+          },
+          devices: []
+        },
+        isInitialized: true
+      })
+
       vi.mocked(api.getClientFeatureFlags).mockReturnValue({
         supports_manager_v4_ui: true
       })
       vi.mocked(api.getServerFeature).mockReturnValue(true)
-      vi.mocked(useExtensionStore).mockReturnValue({
-        extensions: []
-      } as any)
 
       const managerState = useManagerState()
       expect(managerState.shouldShowManagerButtons.value).toBe(true)