diff --git a/__mocks__/@datadog/browser-rum.ts b/__mocks__/@datadog/browser-rum.ts new file mode 100644 index 00000000000..5f730a08b9e --- /dev/null +++ b/__mocks__/@datadog/browser-rum.ts @@ -0,0 +1,32 @@ +import { onTestFinished, vi } from 'vitest' +import type { DatadogRum as RealDatadogRum } from '@datadog/browser-rum' + +type DatadogRum = Pick< + RealDatadogRum, + | 'getGlobalContext' + | 'getInitConfiguration' + | 'init' + | 'setGlobalContextProperty' +> + +const context: ReturnType = {} +let contextCleanupRegistered = false + +export const datadogRum = vi.mockObject( + { + getGlobalContext: () => context, + getInitConfiguration: () => undefined, + init: () => {}, + setGlobalContextProperty: (key, value) => { + if (!contextCleanupRegistered) { + onTestFinished(() => { + for (const key of Object.keys(context)) delete context[key] + contextCleanupRegistered = false + }) + contextCleanupRegistered = true + } + context[key] = value + } + }, + { spy: true } +) diff --git a/__mocks__/@vueuse/core.ts b/__mocks__/@vueuse/core.ts new file mode 100644 index 00000000000..bbcb4a19eed --- /dev/null +++ b/__mocks__/@vueuse/core.ts @@ -0,0 +1,6 @@ +import { vi } from 'vitest' +import type { useEventListener as realUseEventListener } from '@vueuse/core' + +export const useEventListener = vi.fn(() => + vi.fn() +) diff --git a/__mocks__/axios.ts b/__mocks__/axios.ts new file mode 100644 index 00000000000..b44870f378a --- /dev/null +++ b/__mocks__/axios.ts @@ -0,0 +1,8 @@ +import { vi } from 'vitest' +import type realAxios from 'axios' + +const axios: Pick = { + get: vi.fn() +} + +export default axios diff --git a/__mocks__/vue-router.ts b/__mocks__/vue-router.ts new file mode 100644 index 00000000000..fb088dca78b --- /dev/null +++ b/__mocks__/vue-router.ts @@ -0,0 +1,24 @@ +import { onTestFinished, vi } from 'vitest' +import type { LocationQuery, Router } from 'vue-router' + +type VueRouterMock = { + useRoute: () => { query: LocationQuery } + useRouter: () => Pick +} + +const query: LocationQuery = {} +const router: Pick = { + replace: vi.fn(async () => {}) +} + +const vueRouter: VueRouterMock = { + useRoute: vi.fn(() => { + onTestFinished(() => { + for (const key of Object.keys(query)) delete query[key] + }) + return { query } + }), + useRouter: vi.fn(() => router) +} + +export const { useRoute, useRouter } = vueRouter diff --git a/src/__mocks__/i18n.ts b/src/__mocks__/i18n.ts new file mode 100644 index 00000000000..f28355c8434 --- /dev/null +++ b/src/__mocks__/i18n.ts @@ -0,0 +1,7 @@ +import { vi } from 'vitest' +import type { st as realSt, t as realT } from '@/i18n' + +export const t = vi.fn((key) => String(key)) +export const st = vi.fn( + (key, fallbackMessage) => fallbackMessage || key +) diff --git a/src/components/rightSidePanel/errors/MissingPackGroupRow.test.ts b/src/components/rightSidePanel/errors/MissingPackGroupRow.test.ts index e882b7b025d..cb6dd604a8d 100644 --- a/src/components/rightSidePanel/errors/MissingPackGroupRow.test.ts +++ b/src/components/rightSidePanel/errors/MissingPackGroupRow.test.ts @@ -2,18 +2,18 @@ import userEvent from '@testing-library/user-event' import { render, screen } from '@testing-library/vue' import PrimeVue from 'primevue/config' import { beforeEach, describe, expect, it, vi } from 'vitest' -import { ref } from 'vue' +import { computed, ref } from 'vue' import { createI18n } from 'vue-i18n' import type { MissingPackGroup } from '@/components/rightSidePanel/errors/useErrorGroups' +import { useManagerState } from '@/workbench/extensions/manager/composables/useManagerState' import { useComfyManagerStore } from '@/workbench/extensions/manager/stores/comfyManagerStore' import MissingPackGroupRow from './MissingPackGroupRow.vue' const mockInstallAllPacks = vi.fn() const mockIsInstalling = ref(false) -const mockShouldShowManagerButtons = { value: false } -const mockOpenManager = vi.fn() +const mockShouldShowManagerButtons = ref(false) const mockMissingNodePacks = ref>([]) const mockIsLoading = ref(false) @@ -39,17 +39,7 @@ vi.mock( }) ) -vi.mock( - import('@/workbench/extensions/manager/composables/useManagerState'), - - () => ({ - useManagerState: () => ({ - isNewManagerUI: { value: false }, - shouldShowManagerButtons: mockShouldShowManagerButtons, - openManager: mockOpenManager - }) - }) -) +vi.mock(import('@/workbench/extensions/manager/composables/useManagerState')) vi.mock( import('@/workbench/extensions/manager/types/comfyManagerTypes'), @@ -133,6 +123,9 @@ describe('MissingPackGroupRow', () => { beforeEach(() => { vi.mocked(useComfyManagerStore().isPackInstalled).mockReturnValue(false) mockShouldShowManagerButtons.value = false + useManagerState().shouldShowManagerButtons = computed( + () => mockShouldShowManagerButtons.value + ) mockIsInstalling.value = false mockMissingNodePacks.value = [] mockIsLoading.value = false diff --git a/src/composables/queue/useJobMenu.test.ts b/src/composables/queue/useJobMenu.test.ts index 2c8d8d048ff..36f7cc90d71 100644 --- a/src/composables/queue/useJobMenu.test.ts +++ b/src/composables/queue/useJobMenu.test.ts @@ -11,6 +11,7 @@ import type { Ref } from 'vue' import type { JobListItem } from '@/composables/queue/useJobList' import type { MenuEntry } from '@/composables/queue/useJobMenu' +import { useMediaAssetActions } from '@/platform/assets/composables/useMediaAssetActions' vi.mock(import('@/platform/distribution/types'), () => ({ isCloud: false @@ -35,12 +36,7 @@ vi.mock(import('@/composables/useCopyToClipboard'), () => ({ }) })) -const stMock = vi.fn((_: string, fallback?: string) => fallback ?? _) -const tMock = vi.fn((key: string) => `i18n:${key}`) -vi.mock(import('@/i18n'), () => ({ - st: (...args: Parameters) => stMock(...args), - t: (...args: Parameters) => tMock(...args) -})) +vi.mock(import('@/i18n')) const mapTaskOutputToAssetItemMock = vi.fn() vi.mock(import('@/platform/assets/composables/media/assetMappers'), () => ({ @@ -50,15 +46,7 @@ vi.mock(import('@/platform/assets/composables/media/assetMappers'), () => ({ ) => mapTaskOutputToAssetItemMock(taskItem, output) })) -const mediaAssetActionsMock = { - deleteAssets: vi.fn() -} -vi.mock( - import('@/platform/assets/composables/useMediaAssetActions'), - () => ({ - useMediaAssetActions: () => mediaAssetActionsMock - }) -) +vi.mock(import('@/platform/assets/composables/useMediaAssetActions')) let settingStoreMock: ReturnType @@ -163,7 +151,7 @@ describe('useJobMenu', () => { vi.mocked(queueStoreMock.update).mockResolvedValue(undefined) vi.mocked(queueStoreMock.delete).mockResolvedValue(undefined) cancelJobMock.mockResolvedValue(undefined) - mediaAssetActionsMock.deleteAssets.mockResolvedValue(false) + vi.mocked(useMediaAssetActions().deleteAssets).mockResolvedValue(false) mapTaskOutputToAssetItemMock.mockImplementation((task, output) => ({ task, output @@ -682,7 +670,7 @@ describe('useJobMenu', () => { }) it('does not refresh queue when delete cancelled', async () => { - mediaAssetActionsMock.deleteAssets.mockResolvedValue(false) + vi.mocked(useMediaAssetActions().deleteAssets).mockResolvedValue(false) const { jobMenuEntries } = mountJobMenu() setCurrentItem( createJobItem({ diff --git a/src/composables/useServerLogs.test.ts b/src/composables/useServerLogs.test.ts index 9964291cb8c..ea259f17d90 100644 --- a/src/composables/useServerLogs.test.ts +++ b/src/composables/useServerLogs.test.ts @@ -15,9 +15,7 @@ vi.mock(import('@/scripts/api'), () => ({ } })) -vi.mock(import('@vueuse/core'), () => ({ - useEventListener: vi.fn().mockReturnValue(vi.fn()) -})) +vi.mock(import('@vueuse/core')) describe('useServerLogs', () => { it('should initialize with empty logs array', () => { diff --git a/src/platform/assets/composables/__mocks__/useMediaAssetActions.ts b/src/platform/assets/composables/__mocks__/useMediaAssetActions.ts new file mode 100644 index 00000000000..1bb64fd214c --- /dev/null +++ b/src/platform/assets/composables/__mocks__/useMediaAssetActions.ts @@ -0,0 +1,21 @@ +import { vi } from 'vitest' +import type { useMediaAssetActions as realUseMediaAssetActions } from '../useMediaAssetActions' + +type MediaAssetActions = ReturnType + +const mediaAssetActions = vi.mockObject( + { + downloadAssets: () => {}, + deleteAssets: async () => false, + copyJobId: async () => {}, + addWorkflow: async () => {}, + addMultipleToWorkflow: async () => {}, + openWorkflow: async () => {}, + openMultipleWorkflows: async () => {}, + exportWorkflow: async () => {}, + exportMultipleWorkflows: async () => {} + }, + { spy: true } +) + +export const useMediaAssetActions = vi.fn(() => mediaAssetActions) diff --git a/src/platform/telemetry/initDatadogRum.test.ts b/src/platform/telemetry/initDatadogRum.test.ts index fc5a9bcc155..e0254ceee45 100644 --- a/src/platform/telemetry/initDatadogRum.test.ts +++ b/src/platform/telemetry/initDatadogRum.test.ts @@ -1,22 +1,9 @@ +import { datadogRum } from '@datadog/browser-rum' import { beforeEach, describe, expect, it, vi } from 'vitest' -const hoisted = vi.hoisted(() => { - const context: Record = {} +const fetchMock = vi.fn() - return { - context, - fetch: vi.fn(), - getInitConfiguration: vi.fn(), - init: vi.fn(), - setGlobalContextProperty: vi.fn((key: string, value: unknown) => { - context[key] = value - }) - } -}) - -vi.mock(import('@datadog/browser-rum'), () => ({ - datadogRum: hoisted -})) +vi.mock(import('@datadog/browser-rum')) vi.mock(import('./manualRefreshTracker'), () => ({ trackUserManualRefresh: vi.fn() })) @@ -27,15 +14,9 @@ import { trackUserManualRefresh } from './manualRefreshTracker' describe('initDatadogRum', () => { beforeEach(() => { - for (const key of Object.keys(hoisted.context)) { - delete hoisted.context[key] - } - hoisted.setGlobalContextProperty.mockImplementation((key, value) => { - hoisted.context[key] = value - }) - hoisted.fetch.mockResolvedValue(new Response(null, { status: 503 })) - hoisted.getInitConfiguration.mockReturnValue(undefined) - vi.stubGlobal('fetch', hoisted.fetch) + fetchMock.mockResolvedValue(new Response(null, { status: 503 })) + vi.mocked(datadogRum.getInitConfiguration).mockReturnValue(undefined) + vi.stubGlobal('fetch', fetchMock) }) it.for([ @@ -48,7 +29,7 @@ describe('initDatadogRum', () => { async ({ hostname, env }) => { await initDatadogRum(hostname) - expect(hoisted.init).toHaveBeenCalledWith({ + expect(datadogRum.init).toHaveBeenCalledWith({ clientToken: 'pub7704486e5b64eb4ff6f62891cda45559', applicationId: '041a9897-5516-4b1f-a245-1a9aa6895488', site: 'us5.datadoghq.com', @@ -71,13 +52,13 @@ describe('initDatadogRum', () => { it('tags canary traffic with its bucket and frontend version', async () => { let resolveProbe: (response: Response) => void - hoisted.fetch.mockReturnValue( + fetchMock.mockReturnValue( new Promise((resolve) => { resolveProbe = resolve }) ) - hoisted.init.mockImplementation(() => { - expect(hoisted.context).toEqual({ + vi.mocked(datadogRum.init).mockImplementation(() => { + expect(datadogRum.getGlobalContext()).toEqual({ bucket: 'canary', comfyui_frontend_version: __COMFYUI_FRONTEND_VERSION__, version: __COMFYUI_FRONTEND_COMMIT__ @@ -86,7 +67,7 @@ describe('initDatadogRum', () => { const initialization = initDatadogRum('cloud.comfy.org') - expect(hoisted.init).not.toHaveBeenCalled() + expect(datadogRum.init).not.toHaveBeenCalled() resolveProbe!( new Response(null, { headers: { @@ -97,17 +78,17 @@ describe('initDatadogRum', () => { ) await initialization - expect(hoisted.context).toEqual({ + expect(datadogRum.getGlobalContext()).toEqual({ bucket: 'canary', comfyui_frontend_version: __COMFYUI_FRONTEND_VERSION__, version: __COMFYUI_FRONTEND_COMMIT__ }) - expect(hoisted.init).toHaveBeenCalledOnce() + expect(datadogRum.init).toHaveBeenCalledOnce() }) it('serializes concurrent initialization', async () => { let resolveProbe: (response: Response) => void - hoisted.fetch.mockReturnValue( + fetchMock.mockReturnValue( new Promise((resolve) => { resolveProbe = resolve }) @@ -126,9 +107,9 @@ describe('initDatadogRum', () => { ) await Promise.all([firstInitialization, secondInitialization]) - expect(hoisted.fetch).toHaveBeenCalledOnce() - expect(hoisted.init).toHaveBeenCalledOnce() - expect(hoisted.context).toEqual({ + expect(fetchMock).toHaveBeenCalledOnce() + expect(datadogRum.init).toHaveBeenCalledOnce() + expect(datadogRum.getGlobalContext()).toEqual({ bucket: 'canary', comfyui_frontend_version: __COMFYUI_FRONTEND_VERSION__, version: __COMFYUI_FRONTEND_COMMIT__ @@ -136,7 +117,7 @@ describe('initDatadogRum', () => { }) it('defaults the bucket to stable and tracks its frontend version', async () => { - hoisted.fetch.mockResolvedValue( + fetchMock.mockResolvedValue( new Response(null, { headers: { 'X-Frontend-Version': __COMFYUI_FRONTEND_COMMIT__ } }) @@ -144,7 +125,7 @@ describe('initDatadogRum', () => { await initDatadogRum('cloud.comfy.org') - expect(hoisted.context).toEqual({ + expect(datadogRum.getGlobalContext()).toEqual({ bucket: 'stable', comfyui_frontend_version: __COMFYUI_FRONTEND_VERSION__, version: __COMFYUI_FRONTEND_COMMIT__ @@ -152,7 +133,7 @@ describe('initDatadogRum', () => { }) it('leaves traffic unclassified when the frontend version is absent', async () => { - hoisted.fetch.mockResolvedValue( + fetchMock.mockResolvedValue( new Response(null, { headers: { 'X-Frontend-Bucket': 'canary' } }) @@ -160,13 +141,13 @@ describe('initDatadogRum', () => { await initDatadogRum('cloud.comfy.org') - expect(hoisted.context).toEqual({ + expect(datadogRum.getGlobalContext()).toEqual({ comfyui_frontend_version: __COMFYUI_FRONTEND_VERSION__ }) }) it('leaves traffic unclassified when the probe reaches another version', async () => { - hoisted.fetch.mockResolvedValue( + fetchMock.mockResolvedValue( new Response(null, { headers: { 'X-Frontend-Bucket': 'stable', @@ -177,37 +158,37 @@ describe('initDatadogRum', () => { await initDatadogRum('cloud.comfy.org') - expect(hoisted.context).toEqual({ + expect(datadogRum.getGlobalContext()).toEqual({ comfyui_frontend_version: __COMFYUI_FRONTEND_VERSION__ }) }) it('leaves traffic unclassified when the header probe fails', async () => { - hoisted.fetch.mockResolvedValue(new Response(null, { status: 503 })) + fetchMock.mockResolvedValue(new Response(null, { status: 503 })) await initDatadogRum('cloud.comfy.org') - expect(hoisted.context).toEqual({ + expect(datadogRum.getGlobalContext()).toEqual({ comfyui_frontend_version: __COMFYUI_FRONTEND_VERSION__ }) - expect(hoisted.init).toHaveBeenCalledOnce() + expect(datadogRum.init).toHaveBeenCalledOnce() }) it('initializes RUM when the header probe rejects', async () => { - hoisted.fetch.mockRejectedValue(new Error('network error')) + fetchMock.mockRejectedValue(new Error('network error')) await initDatadogRum('cloud.comfy.org') - expect(hoisted.context).toEqual({ + expect(datadogRum.getGlobalContext()).toEqual({ comfyui_frontend_version: __COMFYUI_FRONTEND_VERSION__ }) - expect(hoisted.init).toHaveBeenCalledOnce() + expect(datadogRum.init).toHaveBeenCalledOnce() }) it('initializes RUM when the header probe times out', async () => { const abortController = new AbortController() vi.spyOn(AbortSignal, 'timeout').mockReturnValue(abortController.signal) - hoisted.fetch.mockImplementation( + fetchMock.mockImplementation( (_input, init) => new Promise((_resolve, reject) => { init?.signal?.addEventListener('abort', () => { @@ -220,10 +201,10 @@ describe('initDatadogRum', () => { abortController.abort() await initialization - expect(hoisted.context).toEqual({ + expect(datadogRum.getGlobalContext()).toEqual({ comfyui_frontend_version: __COMFYUI_FRONTEND_VERSION__ }) - expect(hoisted.init).toHaveBeenCalledOnce() + expect(datadogRum.init).toHaveBeenCalledOnce() }) it.for([ @@ -234,15 +215,18 @@ describe('initDatadogRum', () => { ])('does not initialize on unknown hostname %s', async (hostname) => { await initDatadogRum(hostname) - expect(hoisted.init).not.toHaveBeenCalled() + expect(datadogRum.init).not.toHaveBeenCalled() }) it('does not initialize twice', async () => { - hoisted.getInitConfiguration.mockReturnValue({}) + vi.mocked(datadogRum.getInitConfiguration).mockReturnValue({ + applicationId: 'initialized', + clientToken: 'initialized' + }) await initDatadogRum('cloud.comfy.org') - expect(hoisted.init).not.toHaveBeenCalled() + expect(datadogRum.init).not.toHaveBeenCalled() }) it('tracks manual refreshes only once RUM is initialized', async () => { diff --git a/src/platform/workflow/sharing/composables/useSharedWorkflowUrlLoader.test.ts b/src/platform/workflow/sharing/composables/useSharedWorkflowUrlLoader.test.ts index b03b64bc3a0..30302b1f228 100644 --- a/src/platform/workflow/sharing/composables/useSharedWorkflowUrlLoader.test.ts +++ b/src/platform/workflow/sharing/composables/useSharedWorkflowUrlLoader.test.ts @@ -3,9 +3,11 @@ import { fromPartial } from '@total-typescript/shoehorn' import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' import type { App } from 'vue' import { computed, createApp, defineComponent } from 'vue' +import { useRoute, useRouter } from 'vue-router' import { useCurrentUser } from '@/composables/auth/useCurrentUser' import { useTelemetry } from '@/platform/telemetry' +import { useWorkflowShareService } from '@/platform/workflow/sharing/services/workflowShareService' import { i18n } from '@/i18n' import { useSharedWorkflowUrlLoader as createSharedWorkflowUrlLoader } from '@/platform/workflow/sharing/composables/useSharedWorkflowUrlLoader' @@ -23,41 +25,13 @@ vi.mock( () => preservedQueryMocks ) -let mockQueryParams: Record = {} -const mockRouterReplace = vi.fn() - -vi.mock(import('vue-router'), () => ({ - useRoute: vi.fn(() => ({ - query: mockQueryParams - })), - useRouter: vi.fn(() => ({ - replace: mockRouterReplace - })) -})) - -const mockImportPublishedAssets = vi.fn() +vi.mock(import('vue-router')) vi.mock(import('@/composables/auth/useCurrentUser')) vi.mock(import('@/platform/telemetry')) -vi.mock( - import('@/platform/workflow/sharing/services/workflowShareService'), - () => ({ - SharedWorkflowLoadError: class extends Error { - readonly isRetryable: boolean - constructor(message: string, isRetryable: boolean) { - super(message) - this.name = 'SharedWorkflowLoadError' - this.isRetryable = isRetryable - } - }, - useWorkflowShareService: () => ({ - getSharedWorkflow: vi.fn(), - importPublishedAssets: mockImportPublishedAssets - }) - }) -) +vi.mock(import('@/platform/workflow/sharing/services/workflowShareService')) const mockLoadGraphData = vi.hoisted(() => vi.fn()) @@ -97,6 +71,12 @@ function useSharedWorkflowUrlLoader() { return result } +function setRouteQuery(query: Record) { + const routeQuery = useRoute().query + for (const key of Object.keys(routeQuery)) delete routeQuery[key] + Object.assign(routeQuery, query) +} + afterEach(() => apps.splice(0).forEach((app) => app.unmount())) const mockShowLayoutDialog = vi.hoisted(() => vi.fn()) @@ -194,7 +174,7 @@ beforeEach(() => { describe('useSharedWorkflowUrlLoader', () => { beforeEach(() => { - mockQueryParams = {} + setRouteQuery({}) mockDialogStack.length = 0 mockShowLayoutDialog.mockImplementation(createDialogInstance) vi.mocked(useDialogStore().updateDialog).mockImplementation( @@ -238,7 +218,7 @@ describe('useSharedWorkflowUrlLoader', () => { }) it('opens dialog immediately with shareId and loads graph on confirm', async () => { - mockQueryParams = { share: 'share-id-1' } + setRouteQuery({ share: 'share-id-1' }) const payload = makePayload() mockShowLayoutDialog.mockImplementation(() => { expect(mockLoadGraphData).not.toHaveBeenCalled() @@ -265,14 +245,14 @@ describe('useSharedWorkflowUrlLoader', () => { is_app_mode: false }) expect(preservedQueryMocks.capturePreservedQuery).not.toHaveBeenCalled() - expect(mockRouterReplace).toHaveBeenCalledWith({ query: {} }) + expect(useRouter().replace).toHaveBeenCalledWith({ query: {} }) expect(preservedQueryMocks.clearPreservedQuery).toHaveBeenCalledWith( 'share' ) }) it('does not capture share auth attribution for authenticated users', async () => { - mockQueryParams = { share: 'share-id-1' } + setRouteQuery({ share: 'share-id-1' }) useCurrentUser().isLoggedIn = computed(() => true) mockShowLayoutDialog.mockImplementation(() => { resolveDialogWithConfirm(makePayload()) @@ -292,7 +272,7 @@ describe('useSharedWorkflowUrlLoader', () => { }) it('hides template selector when user confirms opening shared workflow', async () => { - mockQueryParams = { share: 'share-id-1' } + setRouteQuery({ share: 'share-id-1' }) mockShowLayoutDialog.mockImplementation(() => { resolveDialogWithConfirm(makePayload()) }) @@ -304,7 +284,7 @@ describe('useSharedWorkflowUrlLoader', () => { }) it('keeps dialog open with opening state while shared workflow loads', async () => { - mockQueryParams = { share: 'share-id-1' } + setRouteQuery({ share: 'share-id-1' }) const graphLoad = createDeferred() mockLoadGraphData.mockReturnValue(graphLoad.promise) @@ -336,7 +316,7 @@ describe('useSharedWorkflowUrlLoader', () => { }) it('does not load graph when user cancels dialog', async () => { - mockQueryParams = { share: 'share-id-1' } + setRouteQuery({ share: 'share-id-1' }) mockShowLayoutDialog.mockImplementation(() => { resolveDialogWithCancel() }) @@ -346,7 +326,7 @@ describe('useSharedWorkflowUrlLoader', () => { expect(loaded).toBe('cancelled') expect(mockLoadGraphData).not.toHaveBeenCalled() - expect(mockRouterReplace).toHaveBeenCalledWith({ query: {} }) + expect(useRouter().replace).toHaveBeenCalledWith({ query: {} }) expect(preservedQueryMocks.clearPreservedQuery).toHaveBeenCalledWith( 'share' ) @@ -356,7 +336,7 @@ describe('useSharedWorkflowUrlLoader', () => { }) it('does not hide template selector when user cancels shared workflow dialog', async () => { - mockQueryParams = { share: 'share-id-1' } + setRouteQuery({ share: 'share-id-1' }) mockShowLayoutDialog.mockImplementation(() => { resolveDialogWithCancel() }) @@ -368,7 +348,7 @@ describe('useSharedWorkflowUrlLoader', () => { }) it('imports non-owned assets before loading graph when user confirms', async () => { - mockQueryParams = { share: 'share-id-1' } + setRouteQuery({ share: 'share-id-1' }) const payload = makePayload({ assets: [ { @@ -390,14 +370,17 @@ describe('useSharedWorkflowUrlLoader', () => { const loaded = await loadSharedWorkflowFromUrl() expect(loaded).toBe('loaded') - expect(mockImportPublishedAssets).toHaveBeenCalledWith(['a1'], 'share-id-1') - expect(mockImportPublishedAssets.mock.invocationCallOrder[0]).toBeLessThan( - mockLoadGraphData.mock.invocationCallOrder[0] - ) + expect( + useWorkflowShareService().importPublishedAssets + ).toHaveBeenCalledWith(['a1'], 'share-id-1') + expect( + vi.mocked(useWorkflowShareService().importPublishedAssets).mock + .invocationCallOrder[0] + ).toBeLessThan(mockLoadGraphData.mock.invocationCallOrder[0]) }) it('does not call import when user chooses open-only', async () => { - mockQueryParams = { share: 'share-id-1' } + setRouteQuery({ share: 'share-id-1' }) const payload = makePayload({ assets: [ { @@ -419,11 +402,13 @@ describe('useSharedWorkflowUrlLoader', () => { await loadSharedWorkflowFromUrl() expect(mockLoadGraphData).toHaveBeenCalled() - expect(mockImportPublishedAssets).not.toHaveBeenCalled() + expect( + useWorkflowShareService().importPublishedAssets + ).not.toHaveBeenCalled() }) it('hides template selector when user chooses open-only', async () => { - mockQueryParams = { share: 'share-id-1' } + setRouteQuery({ share: 'share-id-1' }) mockShowLayoutDialog.mockImplementation(() => { resolveDialogWithOpenOnly(makePayload()) }) @@ -435,7 +420,7 @@ describe('useSharedWorkflowUrlLoader', () => { }) it('shows toast on import failure and returns loaded-without-assets', async () => { - mockQueryParams = { share: 'share-id-1' } + setRouteQuery({ share: 'share-id-1' }) const payload = makePayload({ assets: [ { @@ -449,7 +434,9 @@ describe('useSharedWorkflowUrlLoader', () => { } ] }) - mockImportPublishedAssets.mockRejectedValue(new Error('Import failed')) + vi.mocked( + useWorkflowShareService().importPublishedAssets + ).mockRejectedValue(new Error('Import failed')) mockShowLayoutDialog.mockImplementation(() => { resolveDialogWithConfirm(payload) }) @@ -474,7 +461,7 @@ describe('useSharedWorkflowUrlLoader', () => { }) it('clears share intent when graph load fails after importing assets', async () => { - mockQueryParams = { share: 'share-id-1', tab: 'assets' } + setRouteQuery({ share: 'share-id-1', tab: 'assets' }) const payload = makePayload({ assets: [ { @@ -497,15 +484,19 @@ describe('useSharedWorkflowUrlLoader', () => { const loaded = await loadSharedWorkflowFromUrl() expect(loaded).toBe('failed') - expect(mockImportPublishedAssets).toHaveBeenCalledWith(['a1'], 'share-id-1') - expect(mockRouterReplace).toHaveBeenCalledWith({ query: { tab: 'assets' } }) + expect( + useWorkflowShareService().importPublishedAssets + ).toHaveBeenCalledWith(['a1'], 'share-id-1') + expect(useRouter().replace).toHaveBeenCalledWith({ + query: { tab: 'assets' } + }) expect(preservedQueryMocks.clearPreservedQuery).toHaveBeenCalledWith( 'share' ) }) it('filters out in_library assets before importing', async () => { - mockQueryParams = { share: 'share-id-1' } + setRouteQuery({ share: 'share-id-1' }) const payload = makePayload({ assets: [ { @@ -535,7 +526,9 @@ describe('useSharedWorkflowUrlLoader', () => { const { loadSharedWorkflowFromUrl } = useSharedWorkflowUrlLoader() await loadSharedWorkflowFromUrl() - expect(mockImportPublishedAssets).toHaveBeenCalledWith(['a1'], 'share-id-1') + expect( + useWorkflowShareService().importPublishedAssets + ).toHaveBeenCalledWith(['a1'], 'share-id-1') }) it('restores preserved share query before loading', async () => { @@ -552,7 +545,7 @@ describe('useSharedWorkflowUrlLoader', () => { expect(preservedQueryMocks.hydratePreservedQuery).toHaveBeenCalledWith( 'share' ) - expect(mockRouterReplace).toHaveBeenCalledWith({ + expect(useRouter().replace).toHaveBeenCalledWith({ query: { share: 'preserved-share-id' } }) const dialogCall = mockShowLayoutDialog.mock.calls[0][0] @@ -560,7 +553,7 @@ describe('useSharedWorkflowUrlLoader', () => { }) it('rejects invalid share parameter values', async () => { - mockQueryParams = { share: '../../../etc/passwd' } + setRouteQuery({ share: '../../../etc/passwd' }) const { loadSharedWorkflowFromUrl } = useSharedWorkflowUrlLoader() const loaded = await loadSharedWorkflowFromUrl() @@ -572,14 +565,14 @@ describe('useSharedWorkflowUrlLoader', () => { summary: 'Error', detail: 'Failed to load shared workflow' }) - expect(mockRouterReplace).toHaveBeenCalledWith({ query: {} }) + expect(useRouter().replace).toHaveBeenCalledWith({ query: {} }) expect(preservedQueryMocks.clearPreservedQuery).toHaveBeenCalledWith( 'share' ) }) it('uses fallback name when payload name is empty', async () => { - mockQueryParams = { share: 'share-id-1' } + setRouteQuery({ share: 'share-id-1' }) const payload = makePayload({ name: '' }) mockShowLayoutDialog.mockImplementation(() => { resolveDialogWithConfirm(payload) diff --git a/src/platform/workflow/sharing/services/__mocks__/workflowShareService.ts b/src/platform/workflow/sharing/services/__mocks__/workflowShareService.ts new file mode 100644 index 00000000000..fe201e7989e --- /dev/null +++ b/src/platform/workflow/sharing/services/__mocks__/workflowShareService.ts @@ -0,0 +1,25 @@ +import { vi } from 'vitest' +import type { useWorkflowShareService as realUseWorkflowShareService } from '../workflowShareService' + +type WorkflowShareService = ReturnType + +const workflowShareService = vi.mockObject( + { + publishWorkflow: () => + Promise.reject(new Error('publishWorkflow is not configured')), + getPublishStatus: async () => ({ + isPublished: false, + shareId: null, + shareUrl: null, + publishedAt: null, + prefill: null + }), + getShareableAssets: async () => [], + getSharedWorkflow: () => + Promise.reject(new Error('getSharedWorkflow is not configured')), + importPublishedAssets: async () => {} + }, + { spy: true } +) + +export const useWorkflowShareService = vi.fn(() => workflowShareService) diff --git a/src/workbench/extensions/manager/composables/__mocks__/useManagerState.ts b/src/workbench/extensions/manager/composables/__mocks__/useManagerState.ts new file mode 100644 index 00000000000..de7c32bdcd9 --- /dev/null +++ b/src/workbench/extensions/manager/composables/__mocks__/useManagerState.ts @@ -0,0 +1,35 @@ +import { computed } from 'vue' +import { onTestFinished, vi } from 'vitest' +import type { useManagerState as realUseManagerState } from '../useManagerState' + +type ManagerState = ReturnType +type ManagerStateMock = Pick< + ManagerState, + 'isNewManagerUI' | 'shouldShowManagerButtons' | 'openManager' +> + +const actionDefaults: Pick = { + openManager: vi.fn(async () => {}) +} + +function createDefaultManagerState(): ManagerStateMock { + return { + isNewManagerUI: computed(() => false), + shouldShowManagerButtons: computed(() => false), + ...actionDefaults + } +} + +const managerState = createDefaultManagerState() +let cleanupRegistered = false + +export const useManagerState = vi.fn(() => { + if (!cleanupRegistered) { + onTestFinished(() => { + Object.assign(managerState, createDefaultManagerState()) + cleanupRegistered = false + }) + cleanupRegistered = true + } + return managerState +})