From 3c30f8a40c873d372923ae93d7a18257b52c2ffd Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Wed, 5 Aug 2026 02:00:00 +0000 Subject: [PATCH 1/5] fix: preserve payment recovery rollback behavior Co-authored-by: Amp Amp-Thread-ID: https://ampcode.com/threads/T-019fc867-33d7-7463-b4d0-ab1c1cb297de --- .../CloudRunButtonWrapper.test.ts | 171 +++++++++++++++++- .../ComfyRunButton/CloudRunButtonWrapper.vue | 104 +++++++++-- .../ComfyRunButton/ComfyQueueButton.test.ts | 38 +++- .../ComfyRunButton/ComfyQueueButton.vue | 10 +- src/composables/billing/types.ts | 6 +- src/composables/billing/useBillingContext.ts | 12 +- src/locales/en/main.json | 12 +- .../workspace/api/workspaceApi.test.ts | 19 ++ src/platform/workspace/api/workspaceApi.ts | 10 +- .../settings/BillingStatusBanner.test.ts | 75 ++++++-- .../dialogs/settings/BillingStatusBanner.vue | 54 +++++- .../composables/deriveBillingBanner.test.ts | 25 ++- .../composables/useBillingBanner.test.ts | 20 ++ .../workspace/composables/useBillingBanner.ts | 27 ++- .../composables/useWorkspaceBilling.test.ts | 115 ++++++++++++ .../composables/useWorkspaceBilling.ts | 62 ++++++- 16 files changed, 684 insertions(+), 76 deletions(-) diff --git a/src/components/actionbar/ComfyRunButton/CloudRunButtonWrapper.test.ts b/src/components/actionbar/ComfyRunButton/CloudRunButtonWrapper.test.ts index accd895a849..df70c43b93a 100644 --- a/src/components/actionbar/ComfyRunButton/CloudRunButtonWrapper.test.ts +++ b/src/components/actionbar/ComfyRunButton/CloudRunButtonWrapper.test.ts @@ -7,8 +7,8 @@ import CloudRunButtonWrapper from './CloudRunButtonWrapper.vue' const mockCanRunWorkflows = ref(true) const mockBillingStatus = ref('paid') +const mockV1PaymentRecovery = ref(true) const state = vi.hoisted(() => ({ - v1PaymentRecovery: true, canManageSubscription: true, manageSubscription: vi.fn(), fetchStatus: vi.fn(), @@ -33,7 +33,7 @@ vi.mock('@/composables/useFeatureFlags', () => ({ useFeatureFlags: () => ({ flags: { get v1PaymentRecovery() { - return state.v1PaymentRecovery + return mockV1PaymentRecovery.value } } }) @@ -90,7 +90,7 @@ describe('CloudRunButtonWrapper', () => { beforeEach(() => { mockCanRunWorkflows.value = true mockBillingStatus.value = 'paid' - state.v1PaymentRecovery = true + mockV1PaymentRecovery.value = true state.canManageSubscription = true vi.clearAllMocks() }) @@ -196,6 +196,49 @@ describe('CloudRunButtonWrapper', () => { expect(state.fetchBalance).toHaveBeenCalledOnce() }) + it('finishes the balance refresh after status unlocks recovery', async () => { + let resolveStatus!: () => void + let resolveBalance!: () => void + let balanceCommitted = false + state.fetchStatus.mockImplementationOnce( + (signal?: AbortSignal) => + new Promise((resolve) => { + resolveStatus = () => { + if (!signal?.aborted) { + mockBillingStatus.value = 'paid' + mockCanRunWorkflows.value = true + } + resolve() + } + }) + ) + state.fetchBalance.mockImplementationOnce( + (signal?: AbortSignal) => + new Promise((resolve) => { + resolveBalance = () => { + if (!signal?.aborted) balanceCommitted = true + resolve() + } + }) + ) + mockCanRunWorkflows.value = false + mockBillingStatus.value = 'paused' + renderWrapper() + + await userEvent.click( + screen.getByRole('button', { name: 'Update payment to run' }) + ) + const dialog = state.showLayoutDialog.mock.calls[0][0] + await dialog.props.onUpdatePayment() + window.dispatchEvent(new Event('focus')) + + resolveStatus() + await nextTick() + resolveBalance() + + await waitFor(() => expect(balanceCommitted).toBe(true)) + }) + it('reuses a pending portal request across rapid clicks and reopen', async () => { let resolvePortal!: () => void state.manageSubscription.mockImplementationOnce( @@ -255,7 +298,7 @@ describe('CloudRunButtonWrapper', () => { resolvePortal() await portalRequest - expect(state.closeDialog).not.toHaveBeenCalled() + expect(state.closeDialog).toHaveBeenCalledOnce() expect(state.updateDialog).toHaveBeenCalledTimes(1) expect(state.updateDialog).toHaveBeenCalledWith({ key: 'subscription-paused', @@ -263,6 +306,19 @@ describe('CloudRunButtonWrapper', () => { }) }) + it('blocks a captured payment action after unmount', async () => { + mockCanRunWorkflows.value = false + mockBillingStatus.value = 'paused' + const { unmount } = renderWrapper() + + await userEvent.click(screen.getByTestId('queue-button')) + const dialog = state.showLayoutDialog.mock.calls[0][0] + unmount() + await dialog.props.onUpdatePayment() + + expect(state.manageSubscription).not.toHaveBeenCalled() + }) + it('opens member-safe recovery copy without a payment action', async () => { mockCanRunWorkflows.value = false mockBillingStatus.value = 'paused' @@ -284,13 +340,118 @@ describe('CloudRunButtonWrapper', () => { it('keeps generic inactive behavior when payment recovery is disabled', () => { mockCanRunWorkflows.value = false mockBillingStatus.value = 'paused' - state.v1PaymentRecovery = false + mockV1PaymentRecovery.value = false renderWrapper() expect(screen.getByTestId('subscribe-to-run-button')).toBeInTheDocument() expect(screen.queryByTestId('queue-group')).not.toBeInTheDocument() }) + it('closes recovery and blocks a captured payment action after rollback', async () => { + mockCanRunWorkflows.value = false + mockBillingStatus.value = 'paused' + renderWrapper() + + await userEvent.click(screen.getByTestId('queue-button')) + const dialogOptions = state.showLayoutDialog.mock.calls[0][0] + + mockV1PaymentRecovery.value = false + await nextTick() + + expect(state.closeDialog).toHaveBeenCalledWith({ + key: 'subscription-paused' + }) + await dialogOptions.props.onUpdatePayment() + expect(state.manageSubscription).not.toHaveBeenCalled() + }) + + it('does not resume recovery UI after rollback during a portal request', async () => { + let resolvePortal!: () => void + state.manageSubscription.mockImplementationOnce( + () => + new Promise((resolve) => { + resolvePortal = resolve + }) + ) + mockCanRunWorkflows.value = false + mockBillingStatus.value = 'paused' + renderWrapper() + + await userEvent.click(screen.getByTestId('queue-button')) + const dialogOptions = state.showLayoutDialog.mock.calls[0][0] + const portalRequest = dialogOptions.props.onUpdatePayment() + + mockV1PaymentRecovery.value = false + await nextTick() + resolvePortal() + await portalRequest + + expect(state.closeDialog).toHaveBeenCalledOnce() + expect(state.updateDialog).toHaveBeenCalledOnce() + expect(state.updateDialog).toHaveBeenCalledWith({ + key: 'subscription-paused', + contentProps: { isUpdatingPayment: true } + }) + }) + + it('isolates a re-enabled recovery dialog from an older portal request', async () => { + let resolveOldPortal!: () => void + state.manageSubscription.mockImplementationOnce( + () => + new Promise((resolve) => { + resolveOldPortal = resolve + }) + ) + mockCanRunWorkflows.value = false + mockBillingStatus.value = 'paused' + renderWrapper() + + await userEvent.click(screen.getByTestId('queue-button')) + const oldDialog = state.showLayoutDialog.mock.calls[0][0] + const oldRequest = oldDialog.props.onUpdatePayment() + + mockV1PaymentRecovery.value = false + await nextTick() + mockV1PaymentRecovery.value = true + await nextTick() + + await userEvent.click(screen.getByTestId('queue-button')) + const newDialog = state.showLayoutDialog.mock.calls.at(-1)?.[0] + const newRequest = newDialog.props.onUpdatePayment() + + expect(newRequest).not.toBe(oldRequest) + expect(state.manageSubscription).toHaveBeenCalledTimes(2) + await newRequest + const closeCount = state.closeDialog.mock.calls.length + const updateCount = state.updateDialog.mock.calls.length + + resolveOldPortal() + await oldRequest + + expect(state.closeDialog).toHaveBeenCalledTimes(closeCount) + expect(state.updateDialog).toHaveBeenCalledTimes(updateCount) + }) + + it('ignores a close callback captured by an older recovery dialog', async () => { + mockCanRunWorkflows.value = false + mockBillingStatus.value = 'paused' + renderWrapper() + + await userEvent.click(screen.getByTestId('queue-button')) + const oldDialog = state.showLayoutDialog.mock.calls[0][0] + + mockV1PaymentRecovery.value = false + await nextTick() + mockV1PaymentRecovery.value = true + await nextTick() + await userEvent.click(screen.getByTestId('queue-button')) + const closeCount = state.closeDialog.mock.calls.length + + oldDialog.props.onClose() + + expect(state.closeDialog).toHaveBeenCalledTimes(closeCount) + }) + it('keeps generic inactive behavior for non-paused statuses', () => { mockCanRunWorkflows.value = false mockBillingStatus.value = 'inactive' diff --git a/src/components/actionbar/ComfyRunButton/CloudRunButtonWrapper.vue b/src/components/actionbar/ComfyRunButton/CloudRunButtonWrapper.vue index e0fba1aa9d0..01552990052 100644 --- a/src/components/actionbar/ComfyRunButton/CloudRunButtonWrapper.vue +++ b/src/components/actionbar/ComfyRunButton/CloudRunButtonWrapper.vue @@ -8,7 +8,7 @@ diff --git a/src/platform/workspace/composables/deriveBillingBanner.test.ts b/src/platform/workspace/composables/deriveBillingBanner.test.ts index 732c40daa89..8426a9f988b 100644 --- a/src/platform/workspace/composables/deriveBillingBanner.test.ts +++ b/src/platform/workspace/composables/deriveBillingBanner.test.ts @@ -54,9 +54,28 @@ describe('deriveBillingBanner', () => { ) }) - it('hides payment recovery states when their flag is off', () => { - expect(derive({ ...paymentFailed, v1PaymentRecovery: false })).toBeNull() - expect(derive({ ...paused, v1PaymentRecovery: false })).toBeNull() + it('preserves legacy recovery banners when the new flag is off', () => { + expect(derive({ ...paymentFailed, v1PaymentRecovery: false })).toBe( + 'paymentFailed' + ) + expect(derive({ ...paused, v1PaymentRecovery: false })).toBe('paused') + }) + + it('hides recovery banners when both billing flags are off', () => { + expect( + derive({ + ...paymentFailed, + billingControlEnabled: false, + v1PaymentRecovery: false + }) + ).toBeNull() + expect( + derive({ + ...paused, + billingControlEnabled: false, + v1PaymentRecovery: false + }) + ).toBeNull() }) it('does not move existing notices onto the payment recovery flag', () => { diff --git a/src/platform/workspace/composables/useBillingBanner.test.ts b/src/platform/workspace/composables/useBillingBanner.test.ts index 39765e94107..a44ca620940 100644 --- a/src/platform/workspace/composables/useBillingBanner.test.ts +++ b/src/platform/workspace/composables/useBillingBanner.test.ts @@ -134,4 +134,24 @@ describe('useBillingBanner', () => { expect(b.fetchStatus).not.toHaveBeenCalled() expect(b.fetchBalance).not.toHaveBeenCalled() }) + + it('cancels an in-flight payment refresh when the flag is rolled back', async () => { + const b = mocks.billing! + b.fetchStatus.mockReturnValueOnce(new Promise(() => {})) + b.fetchBalance.mockReturnValueOnce(new Promise(() => {})) + useBillingBanner() + b.billingStatus.value = 'payment_failed' + + window.dispatchEvent(new Event('focus')) + const statusSignal = b.fetchStatus.mock.calls[0][0] + const balanceSignal = b.fetchBalance.mock.calls[0][0] + expect(statusSignal).toBeInstanceOf(AbortSignal) + expect(balanceSignal).toBeInstanceOf(AbortSignal) + + mocks.v1PaymentRecovery!.value = false + await nextTick() + + expect(statusSignal.aborted).toBe(true) + expect(balanceSignal.aborted).toBe(true) + }) }) diff --git a/src/platform/workspace/composables/useBillingBanner.ts b/src/platform/workspace/composables/useBillingBanner.ts index 6203bb1a88d..e9a352e51da 100644 --- a/src/platform/workspace/composables/useBillingBanner.ts +++ b/src/platform/workspace/composables/useBillingBanner.ts @@ -37,7 +37,7 @@ export function deriveBillingBanner( return null } - if (inputs.v1PaymentRecovery) { + if (inputs.billingControlEnabled || inputs.v1PaymentRecovery) { if (inputs.billingStatus === 'paused') return 'paused' if (inputs.billingStatus === 'payment_failed' && inputs.canManage) { return 'paymentFailed' @@ -70,6 +70,7 @@ function useBillingBannerInternal() { const { flags } = useFeatureFlags() const dismissed = ref(false) + let paymentRefreshController: AbortController | null = null const kind = computed(() => { if (!isCloud) return null @@ -99,9 +100,29 @@ function useBillingBannerInternal() { if (!exhausted) dismissed.value = false }) + watch( + () => flags.v1PaymentRecovery, + (enabled) => { + if (enabled) return + paymentRefreshController?.abort() + paymentRefreshController = null + } + ) + useEventListener(window, 'focus', () => { - if (kind.value !== 'paymentFailed') return - void Promise.allSettled([fetchStatus(), fetchBalance()]) + if (!flags.v1PaymentRecovery || kind.value !== 'paymentFailed') return + + paymentRefreshController?.abort() + const controller = new AbortController() + paymentRefreshController = controller + void Promise.allSettled([ + fetchStatus(controller.signal), + fetchBalance(controller.signal) + ]).finally(() => { + if (paymentRefreshController === controller) { + paymentRefreshController = null + } + }) }) function dismiss() { diff --git a/src/platform/workspace/composables/useWorkspaceBilling.test.ts b/src/platform/workspace/composables/useWorkspaceBilling.test.ts index 8b81964658e..c00c349a5c6 100644 --- a/src/platform/workspace/composables/useWorkspaceBilling.test.ts +++ b/src/platform/workspace/composables/useWorkspaceBilling.test.ts @@ -455,6 +455,22 @@ describe('useWorkspaceBilling', () => { expect(billing.subscription.value?.planSlug).toBe('pro-monthly') }) + it('does not commit status after its caller aborts the read', async () => { + const status = createDeferred() + mockWorkspaceApi.getBillingStatus.mockReturnValue(status.promise) + const controller = new AbortController() + const billing = setupBilling() + + const request = billing.fetchStatus(controller.signal) + controller.abort() + expect(billing.isLoading.value).toBe(false) + status.resolve(activeStatus) + await request + + expect(billing.subscription.value).toBeNull() + expect(billing.error.value).toBeNull() + }) + it('surfaces a team credit stop from the status response', async () => { const teamStop = { id: 'team_2500', @@ -523,6 +539,22 @@ describe('useWorkspaceBilling', () => { expect(billing.balance.value?.amountMicros).toBe(5_000_000) }) + + it('does not commit balance after its caller aborts the read', async () => { + const balance = createDeferred() + mockWorkspaceApi.getBillingBalance.mockReturnValue(balance.promise) + const controller = new AbortController() + const billing = setupBilling() + + const request = billing.fetchBalance(controller.signal) + controller.abort() + expect(billing.isLoading.value).toBe(false) + balance.resolve(positiveBalance) + await request + + expect(billing.balance.value).toBeNull() + expect(billing.error.value).toBeNull() + }) }) describe('subscribe', () => { @@ -799,6 +831,89 @@ describe('useWorkspaceBilling', () => { await expect(billing.manageSubscription()).rejects.toThrow('portal down') expect(billing.error.value).toBe('portal down') }) + + it('does not open a portal from a request aborted during rollback', async () => { + const portal = createDeferred<{ url: string }>() + const openSpy = vi.fn() + vi.stubGlobal('open', openSpy) + mockWorkspaceApi.getPaymentPortalUrl.mockReturnValue(portal.promise) + const controller = new AbortController() + const billing = setupBilling() + + const request = billing.manageSubscription(controller.signal) + controller.abort() + portal.resolve({ url: 'https://billing.example/old-portal' }) + await request + + expect(openSpy).not.toHaveBeenCalled() + expect(billing.error.value).toBeNull() + }) + + it('keeps an older portal response out of a newer recovery session', async () => { + const oldPortal = createDeferred<{ url: string }>() + const openSpy = vi.fn() + vi.stubGlobal('open', openSpy) + mockWorkspaceApi.getPaymentPortalUrl + .mockReturnValueOnce(oldPortal.promise) + .mockResolvedValueOnce({ url: 'https://billing.example/new-portal' }) + const oldController = new AbortController() + const billing = setupBilling() + + const oldRequest = billing.manageSubscription(oldController.signal) + oldController.abort() + await billing.manageSubscription(new AbortController().signal) + oldPortal.resolve({ url: 'https://billing.example/old-portal' }) + await oldRequest + + expect(openSpy).toHaveBeenCalledOnce() + expect(openSpy).toHaveBeenCalledWith( + 'https://billing.example/new-portal', + '_blank' + ) + expect(billing.isLoading.value).toBe(false) + }) + + it('preserves concurrent legacy portal requests without a signal', async () => { + const firstPortal = createDeferred<{ url: string }>() + const openSpy = vi.fn() + vi.stubGlobal('open', openSpy) + mockWorkspaceApi.getPaymentPortalUrl + .mockReturnValueOnce(firstPortal.promise) + .mockResolvedValueOnce({ url: 'https://billing.example/second-portal' }) + const billing = setupBilling() + + const firstRequest = billing.manageSubscription() + await billing.manageSubscription() + firstPortal.resolve({ url: 'https://billing.example/first-portal' }) + await firstRequest + + expect(openSpy).toHaveBeenCalledTimes(2) + expect(openSpy).toHaveBeenNthCalledWith( + 1, + 'https://billing.example/second-portal', + '_blank' + ) + expect(openSpy).toHaveBeenNthCalledWith( + 2, + 'https://billing.example/first-portal', + '_blank' + ) + }) + + it('does not open a recovery portal after the workspace changes', async () => { + const portal = createDeferred<{ url: string }>() + const openSpy = vi.fn() + vi.stubGlobal('open', openSpy) + mockWorkspaceApi.getPaymentPortalUrl.mockReturnValue(portal.promise) + const billing = setupBilling() + + const request = billing.manageSubscription(new AbortController().signal) + mockActiveWorkspaceId.value = 'workspace-2' + portal.resolve({ url: 'https://billing.example/workspace-1-portal' }) + await request + + expect(openSpy).not.toHaveBeenCalled() + }) }) describe('cancelSubscription', () => { diff --git a/src/platform/workspace/composables/useWorkspaceBilling.ts b/src/platform/workspace/composables/useWorkspaceBilling.ts index a75538b59bb..ec12fd91b8b 100644 --- a/src/platform/workspace/composables/useWorkspaceBilling.ts +++ b/src/platform/workspace/composables/useWorkspaceBilling.ts @@ -82,6 +82,21 @@ export function useWorkspaceBilling(): BillingState & BillingActions { const balanceData = shallowRef(null) // Prevent older status and balance responses from overwriting newer state. const latestBillingReadIds = { status: 0, balance: 0 } + let latestPortalRequestId = 0 + + function clearLoadingOnAbort( + signal: AbortSignal | undefined, + isCurrentRequest: () => boolean + ): () => void { + if (!signal) return () => {} + + const handleAbort = () => { + if (isCurrentRequest()) isLoading.value = false + } + signal.addEventListener('abort', handleAbort, { once: true }) + if (signal.aborted) handleAbort() + return () => signal.removeEventListener('abort', handleAbort) + } const canAccessSubscriptionFeatures = computed( () => statusData.value?.is_active ?? false @@ -170,14 +185,20 @@ export function useWorkspaceBilling(): BillingState & BillingActions { } } - async function fetchStatus(): Promise { + async function fetchStatus(signal?: AbortSignal): Promise { + if (signal?.aborted) return const requestId = ++latestBillingReadIds.status const workspaceId = workspaceStore.activeWorkspace?.id isLoading.value = true error.value = null + const stopWatchingAbort = clearLoadingOnAbort( + signal, + () => requestId === latestBillingReadIds.status + ) try { - const status = await workspaceApi.getBillingStatus() + const status = await workspaceApi.getBillingStatus(signal) if ( + signal?.aborted || requestId !== latestBillingReadIds.status || workspaceId !== workspaceStore.activeWorkspace?.id ) { @@ -216,32 +237,41 @@ export function useWorkspaceBilling(): BillingState & BillingActions { ) } } catch (err) { + if (signal?.aborted) return if (requestId === latestBillingReadIds.status) { error.value = err instanceof Error ? err.message : 'Failed to fetch billing status' } throw err } finally { + stopWatchingAbort() if (requestId === latestBillingReadIds.status) isLoading.value = false } } - async function fetchBalance(): Promise { + async function fetchBalance(signal?: AbortSignal): Promise { + if (signal?.aborted) return const requestId = ++latestBillingReadIds.balance isLoading.value = true error.value = null + const stopWatchingAbort = clearLoadingOnAbort( + signal, + () => requestId === latestBillingReadIds.balance + ) try { - const balance = await workspaceApi.getBillingBalance() - if (requestId === latestBillingReadIds.balance) { + const balance = await workspaceApi.getBillingBalance(signal) + if (!signal?.aborted && requestId === latestBillingReadIds.balance) { balanceData.value = balance } } catch (err) { + if (signal?.aborted) return if (requestId === latestBillingReadIds.balance) { error.value = err instanceof Error ? err.message : 'Failed to fetch balance' } throw err } finally { + stopWatchingAbort() if (requestId === latestBillingReadIds.balance) isLoading.value = false } } @@ -326,21 +356,37 @@ export function useWorkspaceBilling(): BillingState & BillingActions { } } - async function manageSubscription(): Promise { + async function manageSubscription(signal?: AbortSignal): Promise { + if (signal?.aborted) return + const requestId = signal ? ++latestPortalRequestId : null + const workspaceId = signal ? workspaceStore.activeWorkspace?.id : null + const isCurrentRequest = () => + requestId === null || requestId === latestPortalRequestId + const isCurrentWorkspace = () => + workspaceId === null || workspaceId === workspaceStore.activeWorkspace?.id isLoading.value = true error.value = null + const stopWatchingAbort = clearLoadingOnAbort(signal, isCurrentRequest) try { const returnUrl = window.location.href const response = await workspaceApi.getPaymentPortalUrl(returnUrl) - if (response.url) { + if ( + !signal?.aborted && + isCurrentRequest() && + isCurrentWorkspace() && + response.url + ) { window.open(response.url, '_blank') } } catch (err) { + if (signal?.aborted || !isCurrentRequest() || !isCurrentWorkspace()) + return error.value = err instanceof Error ? err.message : 'Failed to open billing portal' throw err } finally { - isLoading.value = false + stopWatchingAbort() + if (isCurrentRequest()) isLoading.value = false } } From c6d1f2693905143130d871f2ea5c460753f0e468 Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Wed, 5 Aug 2026 02:49:38 +0000 Subject: [PATCH 2/5] fix: address payment recovery review feedback Amp-Thread-ID: https://ampcode.com/threads/T-019fc867-33d7-7463-b4d0-ab1c1cb297de Co-authored-by: Amp --- .../settings/BillingStatusBanner.test.ts | 16 ++++ .../composables/deriveBillingBanner.test.ts | 17 ++++ .../composables/useBillingBanner.test.ts | 45 +++++++++-- .../workspace/composables/useBillingBanner.ts | 7 +- .../composables/useWorkspaceBilling.test.ts | 29 +++++++ .../composables/useWorkspaceBilling.ts | 81 +++++++++---------- 6 files changed, 143 insertions(+), 52 deletions(-) diff --git a/src/platform/workspace/components/dialogs/settings/BillingStatusBanner.test.ts b/src/platform/workspace/components/dialogs/settings/BillingStatusBanner.test.ts index a0d0a46540b..90f56dea586 100644 --- a/src/platform/workspace/components/dialogs/settings/BillingStatusBanner.test.ts +++ b/src/platform/workspace/components/dialogs/settings/BillingStatusBanner.test.ts @@ -352,6 +352,22 @@ describe('BillingStatusBanner', () => { expect(signal.aborted).toBe(true) }) + it('aborts a recovery banner portal request on unmount', async () => { + state.manageSubscription.mockReturnValueOnce(new Promise(() => {})) + pausedState() + const { unmount } = renderBanner() + + await userEvent.click( + screen.getByRole('button', { name: 'Update payment' }) + ) + const signal = state.manageSubscription.mock.calls[0][0] + expect(signal).toBeInstanceOf(AbortSignal) + + unmount() + + expect(signal.aborted).toBe(true) + }) + it('lets a promoted owner reactivate an ending plan', async () => { state.subscription = { hasFunds: true, diff --git a/src/platform/workspace/composables/deriveBillingBanner.test.ts b/src/platform/workspace/composables/deriveBillingBanner.test.ts index 8426a9f988b..ef0b2a09422 100644 --- a/src/platform/workspace/composables/deriveBillingBanner.test.ts +++ b/src/platform/workspace/composables/deriveBillingBanner.test.ts @@ -61,6 +61,23 @@ describe('deriveBillingBanner', () => { expect(derive({ ...paused, v1PaymentRecovery: false })).toBe('paused') }) + it('shows recovery banners when only the recovery flag is on', () => { + expect( + derive({ + ...paymentFailed, + billingControlEnabled: false, + v1PaymentRecovery: true + }) + ).toBe('paymentFailed') + expect( + derive({ + ...paused, + billingControlEnabled: false, + v1PaymentRecovery: true + }) + ).toBe('paused') + }) + it('hides recovery banners when both billing flags are off', () => { expect( derive({ diff --git a/src/platform/workspace/composables/useBillingBanner.test.ts b/src/platform/workspace/composables/useBillingBanner.test.ts index a44ca620940..f5694434582 100644 --- a/src/platform/workspace/composables/useBillingBanner.test.ts +++ b/src/platform/workspace/composables/useBillingBanner.test.ts @@ -1,5 +1,5 @@ -import { beforeEach, describe, expect, it, vi } from 'vitest' -import { nextTick } from 'vue' +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' +import { effectScope, nextTick } from 'vue' const mocks = vi.hoisted(() => ({ billing: null as { @@ -65,6 +65,15 @@ vi.mock('@/platform/workspace/composables/useWorkspaceUI', async () => { import { useBillingBanner } from './useBillingBanner' +let scope: ReturnType | undefined + +function setupBanner() { + scope = effectScope() + const banner = scope.run(() => useBillingBanner()) + if (!banner) throw new Error('Failed to create billing banner composable') + return banner +} + describe('useBillingBanner', () => { beforeEach(() => { const b = mocks.billing! @@ -78,9 +87,14 @@ describe('useBillingBanner', () => { b.fetchBalance.mockClear() }) + afterEach(() => { + scope?.stop() + scope = undefined + }) + it('suppresses the banner entirely when billing control is rolled back', async () => { const b = mocks.billing! - const { kind } = useBillingBanner() + const { kind } = setupBanner() b.subscription.value = { hasFunds: false } await nextTick() @@ -93,7 +107,7 @@ describe('useBillingBanner', () => { it('re-shows the out-of-credits banner after a top-up and a later exhaustion', async () => { const b = mocks.billing! - const { kind, dismiss } = useBillingBanner() + const { kind, dismiss } = setupBanner() b.subscription.value = { hasFunds: false } await nextTick() @@ -112,7 +126,7 @@ describe('useBillingBanner', () => { it('refreshes status and balance on focus while payment recovery is visible', async () => { const b = mocks.billing! - useBillingBanner() + setupBanner() b.billingStatus.value = 'payment_failed' window.dispatchEvent(new Event('focus')) @@ -124,7 +138,7 @@ describe('useBillingBanner', () => { it('does not refresh payment recovery on focus when the flag is off', async () => { const b = mocks.billing! - useBillingBanner() + setupBanner() b.billingStatus.value = 'payment_failed' mocks.v1PaymentRecovery!.value = false @@ -139,7 +153,7 @@ describe('useBillingBanner', () => { const b = mocks.billing! b.fetchStatus.mockReturnValueOnce(new Promise(() => {})) b.fetchBalance.mockReturnValueOnce(new Promise(() => {})) - useBillingBanner() + setupBanner() b.billingStatus.value = 'payment_failed' window.dispatchEvent(new Event('focus')) @@ -154,4 +168,21 @@ describe('useBillingBanner', () => { expect(statusSignal.aborted).toBe(true) expect(balanceSignal.aborted).toBe(true) }) + + it('cancels an in-flight payment refresh when its scope is disposed', () => { + const b = mocks.billing! + b.fetchStatus.mockReturnValueOnce(new Promise(() => {})) + b.fetchBalance.mockReturnValueOnce(new Promise(() => {})) + setupBanner() + b.billingStatus.value = 'payment_failed' + + window.dispatchEvent(new Event('focus')) + const statusSignal = b.fetchStatus.mock.calls[0][0] + const balanceSignal = b.fetchBalance.mock.calls[0][0] + + scope?.stop() + + expect(statusSignal.aborted).toBe(true) + expect(balanceSignal.aborted).toBe(true) + }) }) diff --git a/src/platform/workspace/composables/useBillingBanner.ts b/src/platform/workspace/composables/useBillingBanner.ts index e9a352e51da..685ff3eefc4 100644 --- a/src/platform/workspace/composables/useBillingBanner.ts +++ b/src/platform/workspace/composables/useBillingBanner.ts @@ -1,5 +1,5 @@ import { createSharedComposable, useEventListener } from '@vueuse/core' -import { computed, ref, watch } from 'vue' +import { computed, onScopeDispose, ref, watch } from 'vue' import { useBillingContext } from '@/composables/billing/useBillingContext' import { useFeatureFlags } from '@/composables/useFeatureFlags' @@ -109,6 +109,11 @@ function useBillingBannerInternal() { } ) + onScopeDispose(() => { + paymentRefreshController?.abort() + paymentRefreshController = null + }) + useEventListener(window, 'focus', () => { if (!flags.v1PaymentRecovery || kind.value !== 'paymentFailed') return diff --git a/src/platform/workspace/composables/useWorkspaceBilling.test.ts b/src/platform/workspace/composables/useWorkspaceBilling.test.ts index c00c349a5c6..46a9f331041 100644 --- a/src/platform/workspace/composables/useWorkspaceBilling.test.ts +++ b/src/platform/workspace/composables/useWorkspaceBilling.test.ts @@ -3,6 +3,7 @@ import { effectScope } from 'vue' import type { BillingStatusResponse, + CreateTopupResponse, SubscribeResponse } from '@/platform/workspace/api/workspaceApi' import { useWorkspaceBilling } from '@/platform/workspace/composables/useWorkspaceBilling' @@ -471,6 +472,34 @@ describe('useWorkspaceBilling', () => { expect(billing.error.value).toBeNull() }) + it('keeps loading while another billing operation remains pending', async () => { + const status = createDeferred() + const topup = createDeferred() + mockWorkspaceApi.getBillingStatus.mockReturnValue(status.promise) + mockWorkspaceApi.createTopup.mockReturnValue(topup.promise) + const controller = new AbortController() + const billing = setupBilling() + + const topupRequest = billing.topup(500) + const statusRequest = billing.fetchStatus(controller.signal) + controller.abort() + + expect(billing.isLoading.value).toBe(true) + + status.resolve(activeStatus) + await statusRequest + expect(billing.isLoading.value).toBe(true) + + topup.resolve({ + billing_op_id: 'op-topup', + topup_id: 'topup-1', + status: 'pending', + amount_cents: 500 + }) + await topupRequest + expect(billing.isLoading.value).toBe(false) + }) + it('surfaces a team credit stop from the status response', async () => { const teamStop = { id: 'team_2500', diff --git a/src/platform/workspace/composables/useWorkspaceBilling.ts b/src/platform/workspace/composables/useWorkspaceBilling.ts index ec12fd91b8b..4f975d90b1d 100644 --- a/src/platform/workspace/composables/useWorkspaceBilling.ts +++ b/src/platform/workspace/composables/useWorkspaceBilling.ts @@ -83,19 +83,24 @@ export function useWorkspaceBilling(): BillingState & BillingActions { // Prevent older status and balance responses from overwriting newer state. const latestBillingReadIds = { status: 0, balance: 0 } let latestPortalRequestId = 0 + let activeLoadingOperations = 0 - function clearLoadingOnAbort( - signal: AbortSignal | undefined, - isCurrentRequest: () => boolean - ): () => void { - if (!signal) return () => {} - - const handleAbort = () => { - if (isCurrentRequest()) isLoading.value = false + function beginLoading(signal?: AbortSignal): () => void { + activeLoadingOperations++ + isLoading.value = true + let released = false + + const release = () => { + if (released) return + released = true + signal?.removeEventListener('abort', release) + activeLoadingOperations-- + isLoading.value = activeLoadingOperations > 0 } - signal.addEventListener('abort', handleAbort, { once: true }) - if (signal.aborted) handleAbort() - return () => signal.removeEventListener('abort', handleAbort) + + signal?.addEventListener('abort', release, { once: true }) + if (signal?.aborted) release() + return release } const canAccessSubscriptionFeatures = computed( @@ -167,7 +172,7 @@ export function useWorkspaceBilling(): BillingState & BillingActions { async function initialize(): Promise { if (isInitialized.value) return - isLoading.value = true + const releaseLoading = beginLoading() error.value = null try { await Promise.all([fetchStatus(), fetchBalance(), fetchPlans()]) @@ -181,7 +186,7 @@ export function useWorkspaceBilling(): BillingState & BillingActions { err instanceof Error ? err.message : 'Failed to initialize billing' throw err } finally { - isLoading.value = false + releaseLoading() } } @@ -189,12 +194,8 @@ export function useWorkspaceBilling(): BillingState & BillingActions { if (signal?.aborted) return const requestId = ++latestBillingReadIds.status const workspaceId = workspaceStore.activeWorkspace?.id - isLoading.value = true + const releaseLoading = beginLoading(signal) error.value = null - const stopWatchingAbort = clearLoadingOnAbort( - signal, - () => requestId === latestBillingReadIds.status - ) try { const status = await workspaceApi.getBillingStatus(signal) if ( @@ -244,20 +245,15 @@ export function useWorkspaceBilling(): BillingState & BillingActions { } throw err } finally { - stopWatchingAbort() - if (requestId === latestBillingReadIds.status) isLoading.value = false + releaseLoading() } } async function fetchBalance(signal?: AbortSignal): Promise { if (signal?.aborted) return const requestId = ++latestBillingReadIds.balance - isLoading.value = true + const releaseLoading = beginLoading(signal) error.value = null - const stopWatchingAbort = clearLoadingOnAbort( - signal, - () => requestId === latestBillingReadIds.balance - ) try { const balance = await workspaceApi.getBillingBalance(signal) if (!signal?.aborted && requestId === latestBillingReadIds.balance) { @@ -271,8 +267,7 @@ export function useWorkspaceBilling(): BillingState & BillingActions { } throw err } finally { - stopWatchingAbort() - if (requestId === latestBillingReadIds.balance) isLoading.value = false + releaseLoading() } } @@ -325,17 +320,17 @@ export function useWorkspaceBilling(): BillingState & BillingActions { planSlug: string, options?: SubscribeOptions ): Promise { - isLoading.value = true + const releaseLoading = beginLoading() error.value = null try { const response = await workspaceApi.subscribe(planSlug, options) - isLoading.value = false void reconcileBillingStateAfterSubscribe() return response } catch (err) { error.value = err instanceof Error ? err.message : 'Failed to subscribe' - isLoading.value = false throw err + } finally { + releaseLoading() } } @@ -343,7 +338,7 @@ export function useWorkspaceBilling(): BillingState & BillingActions { planSlug: string, options?: PreviewSubscribeOptions ): Promise { - isLoading.value = true + const releaseLoading = beginLoading() error.value = null try { return await workspaceApi.previewSubscribe(planSlug, options) @@ -352,7 +347,7 @@ export function useWorkspaceBilling(): BillingState & BillingActions { err instanceof Error ? err.message : 'Failed to preview subscription' throw err } finally { - isLoading.value = false + releaseLoading() } } @@ -364,9 +359,8 @@ export function useWorkspaceBilling(): BillingState & BillingActions { requestId === null || requestId === latestPortalRequestId const isCurrentWorkspace = () => workspaceId === null || workspaceId === workspaceStore.activeWorkspace?.id - isLoading.value = true + const releaseLoading = beginLoading(signal) error.value = null - const stopWatchingAbort = clearLoadingOnAbort(signal, isCurrentRequest) try { const returnUrl = window.location.href const response = await workspaceApi.getPaymentPortalUrl(returnUrl) @@ -385,13 +379,12 @@ export function useWorkspaceBilling(): BillingState & BillingActions { err instanceof Error ? err.message : 'Failed to open billing portal' throw err } finally { - stopWatchingAbort() - if (isCurrentRequest()) isLoading.value = false + releaseLoading() } } async function cancelSubscription(): Promise { - isLoading.value = true + const releaseLoading = beginLoading() error.value = null try { const response = await workspaceApi.cancelSubscription() @@ -417,12 +410,12 @@ export function useWorkspaceBilling(): BillingState & BillingActions { err instanceof Error ? err.message : 'Failed to cancel subscription' throw err } finally { - isLoading.value = false + releaseLoading() } } async function resubscribe(): Promise { - isLoading.value = true + const releaseLoading = beginLoading() error.value = null try { await workspaceApi.resubscribe() @@ -442,12 +435,12 @@ export function useWorkspaceBilling(): BillingState & BillingActions { error.value = err instanceof Error ? err.message : 'Failed to resubscribe' throw err } finally { - isLoading.value = false + releaseLoading() } } async function topup(amountCents: number): Promise { - isLoading.value = true + const releaseLoading = beginLoading() error.value = null try { return await workspaceApi.createTopup(amountCents) @@ -456,12 +449,12 @@ export function useWorkspaceBilling(): BillingState & BillingActions { err instanceof Error ? err.message : 'Failed to top up credits' throw err } finally { - isLoading.value = false + releaseLoading() } } async function fetchPlans(): Promise { - isLoading.value = true + const releaseLoading = beginLoading() error.value = null try { await billingPlans.fetchPlans() @@ -469,7 +462,7 @@ export function useWorkspaceBilling(): BillingState & BillingActions { error.value = billingPlans.error.value } } finally { - isLoading.value = false + releaseLoading() } } From f052aa776796569036b5f1c7ce70dd686e0cbe67 Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Wed, 5 Aug 2026 03:10:30 +0000 Subject: [PATCH 3/5] fix: fence billing requests by workspace Amp-Thread-ID: https://ampcode.com/threads/T-019fc867-33d7-7463-b4d0-ab1c1cb297de Co-authored-by: Amp --- .../workspace/api/workspaceApi.test.ts | 8 +++-- src/platform/workspace/api/workspaceApi.ts | 5 +-- .../composables/useWorkspaceBilling.test.ts | 36 ++++++++++++++++--- .../composables/useWorkspaceBilling.ts | 19 +++++++--- 4 files changed, 55 insertions(+), 13 deletions(-) diff --git a/src/platform/workspace/api/workspaceApi.test.ts b/src/platform/workspace/api/workspaceApi.test.ts index a7c64845639..8bddddc0de6 100644 --- a/src/platform/workspace/api/workspaceApi.test.ts +++ b/src/platform/workspace/api/workspaceApi.test.ts @@ -570,18 +570,20 @@ describe('workspaceApi', () => { }) describe('payment', () => { - it('getPaymentPortalUrl() sends POST with return_url', async () => { + it('getPaymentPortalUrl() sends POST with return_url and abort signal', async () => { const data = { url: 'https://stripe.com/portal' } mockAxiosInstance.post.mockResolvedValue({ data }) + const controller = new AbortController() const result = await workspaceApi.getPaymentPortalUrl( - 'https://app.com/settings' + 'https://app.com/settings', + controller.signal ) expect(mockAxiosInstance.post).toHaveBeenCalledWith( '/api/billing/payment-portal', { return_url: 'https://app.com/settings' }, - { headers: AUTH_HEADER } + { headers: AUTH_HEADER, signal: controller.signal } ) expect(result).toEqual(data) }) diff --git a/src/platform/workspace/api/workspaceApi.ts b/src/platform/workspace/api/workspaceApi.ts index 08b7a0fcf4f..7e588d6d497 100644 --- a/src/platform/workspace/api/workspaceApi.ts +++ b/src/platform/workspace/api/workspaceApi.ts @@ -788,14 +788,15 @@ export const workspaceApi = { * POST /api/billing/payment-portal */ async getPaymentPortalUrl( - returnUrl?: string + returnUrl?: string, + signal?: AbortSignal ): Promise { const headers = await getAuthHeaderOrThrow() try { const response = await workspaceApiClient.post( api.apiURL('/billing/payment-portal'), { return_url: returnUrl } satisfies PaymentPortalRequest, - { headers } + { headers, ...(signal ? { signal } : {}) } ) return response.data } catch (err) { diff --git a/src/platform/workspace/composables/useWorkspaceBilling.test.ts b/src/platform/workspace/composables/useWorkspaceBilling.test.ts index 46a9f331041..6937ff559da 100644 --- a/src/platform/workspace/composables/useWorkspaceBilling.test.ts +++ b/src/platform/workspace/composables/useWorkspaceBilling.test.ts @@ -336,12 +336,15 @@ describe('useWorkspaceBilling', () => { ) }) - it('does not recover an operation from a stale workspace response', async () => { + it('does not publish billing data from a stale workspace response', async () => { const status = createDeferred() + const balance = createDeferred() mockWorkspaceApi.getBillingStatus.mockReturnValue(status.promise) + mockWorkspaceApi.getBillingBalance.mockReturnValue(balance.promise) const billing = setupBilling() - const fetch = billing.fetchStatus() + const statusRequest = billing.fetchStatus() + const balanceRequest = billing.fetchBalance() mockActiveWorkspaceId.value = 'workspace-2' status.resolve({ ...activeStatus, @@ -349,10 +352,30 @@ describe('useWorkspaceBilling', () => { pending_billing_op_id: 'op-workspace-1', action_url: 'https://invoice.stripe.com/sensitive-token' }) - await fetch + balance.resolve(positiveBalance) + await Promise.all([statusRequest, balanceRequest]) expect(mockStartOperation).not.toHaveBeenCalled() expect(billing.subscription.value).toBeNull() + expect(billing.balance.value).toBeNull() + expect(billing.error.value).toBeNull() + }) + + it('does not publish billing errors from stale workspace requests', async () => { + const status = createDeferred() + const balance = createDeferred() + mockWorkspaceApi.getBillingStatus.mockReturnValue(status.promise) + mockWorkspaceApi.getBillingBalance.mockReturnValue(balance.promise) + const billing = setupBilling() + + const statusRequest = billing.fetchStatus() + const balanceRequest = billing.fetchBalance() + mockActiveWorkspaceId.value = 'workspace-2' + status.reject(new Error('old workspace status failed')) + balance.reject(new Error('old workspace balance failed')) + await Promise.allSettled([statusRequest, balanceRequest]) + + expect(billing.error.value).toBeNull() }) it("keeps a 'scheduled' subscription on the active treatment", async () => { @@ -825,7 +848,8 @@ describe('useWorkspaceBilling', () => { await billing.manageSubscription() expect(mockWorkspaceApi.getPaymentPortalUrl).toHaveBeenCalledWith( - 'https://app.example/settings' + 'https://app.example/settings', + undefined ) expect(openSpy).toHaveBeenCalledWith( 'https://billing.example/portal', @@ -870,6 +894,10 @@ describe('useWorkspaceBilling', () => { const billing = setupBilling() const request = billing.manageSubscription(controller.signal) + expect(mockWorkspaceApi.getPaymentPortalUrl).toHaveBeenCalledWith( + 'https://app.example/settings', + controller.signal + ) controller.abort() portal.resolve({ url: 'https://billing.example/old-portal' }) await request diff --git a/src/platform/workspace/composables/useWorkspaceBilling.ts b/src/platform/workspace/composables/useWorkspaceBilling.ts index 4f975d90b1d..6150fff7fde 100644 --- a/src/platform/workspace/composables/useWorkspaceBilling.ts +++ b/src/platform/workspace/composables/useWorkspaceBilling.ts @@ -239,7 +239,10 @@ export function useWorkspaceBilling(): BillingState & BillingActions { } } catch (err) { if (signal?.aborted) return - if (requestId === latestBillingReadIds.status) { + if ( + requestId === latestBillingReadIds.status && + workspaceId === workspaceStore.activeWorkspace?.id + ) { error.value = err instanceof Error ? err.message : 'Failed to fetch billing status' } @@ -252,16 +255,24 @@ export function useWorkspaceBilling(): BillingState & BillingActions { async function fetchBalance(signal?: AbortSignal): Promise { if (signal?.aborted) return const requestId = ++latestBillingReadIds.balance + const workspaceId = workspaceStore.activeWorkspace?.id const releaseLoading = beginLoading(signal) error.value = null try { const balance = await workspaceApi.getBillingBalance(signal) - if (!signal?.aborted && requestId === latestBillingReadIds.balance) { + if ( + !signal?.aborted && + requestId === latestBillingReadIds.balance && + workspaceId === workspaceStore.activeWorkspace?.id + ) { balanceData.value = balance } } catch (err) { if (signal?.aborted) return - if (requestId === latestBillingReadIds.balance) { + if ( + requestId === latestBillingReadIds.balance && + workspaceId === workspaceStore.activeWorkspace?.id + ) { error.value = err instanceof Error ? err.message : 'Failed to fetch balance' } @@ -363,7 +374,7 @@ export function useWorkspaceBilling(): BillingState & BillingActions { error.value = null try { const returnUrl = window.location.href - const response = await workspaceApi.getPaymentPortalUrl(returnUrl) + const response = await workspaceApi.getPaymentPortalUrl(returnUrl, signal) if ( !signal?.aborted && isCurrentRequest() && From e12d1fa51d084138e08253e3c746402b7aad5e6f Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Wed, 5 Aug 2026 14:54:34 +0000 Subject: [PATCH 4/5] fix: close payment recovery cancellation gaps Amp-Thread-ID: https://ampcode.com/threads/T-019fc867-33d7-7463-b4d0-ab1c1cb297de Co-authored-by: Amp --- .../CloudRunButtonWrapper.test.ts | 92 ++++++++++++++++++- .../billing/useBillingContext.test.ts | 20 ++++ .../settings/BillingStatusBanner.test.ts | 65 ++++++++++--- .../dialogs/settings/BillingStatusBanner.vue | 21 +++-- 4 files changed, 172 insertions(+), 26 deletions(-) diff --git a/src/components/actionbar/ComfyRunButton/CloudRunButtonWrapper.test.ts b/src/components/actionbar/ComfyRunButton/CloudRunButtonWrapper.test.ts index df70c43b93a..d485362d0d1 100644 --- a/src/components/actionbar/ComfyRunButton/CloudRunButtonWrapper.test.ts +++ b/src/components/actionbar/ComfyRunButton/CloudRunButtonWrapper.test.ts @@ -8,8 +8,8 @@ import CloudRunButtonWrapper from './CloudRunButtonWrapper.vue' const mockCanRunWorkflows = ref(true) const mockBillingStatus = ref('paid') const mockV1PaymentRecovery = ref(true) +const mockCanManageSubscription = ref(true) const state = vi.hoisted(() => ({ - canManageSubscription: true, manageSubscription: vi.fn(), fetchStatus: vi.fn(), fetchBalance: vi.fn(), @@ -48,7 +48,7 @@ vi.mock('@/platform/workspace/composables/useWorkspaceUI', async () => { return { useWorkspaceUI: () => ({ permissions: computed(() => ({ - canManageSubscription: state.canManageSubscription + canManageSubscription: mockCanManageSubscription.value })) }) } @@ -91,7 +91,7 @@ describe('CloudRunButtonWrapper', () => { mockCanRunWorkflows.value = true mockBillingStatus.value = 'paid' mockV1PaymentRecovery.value = true - state.canManageSubscription = true + mockCanManageSubscription.value = true vi.clearAllMocks() }) @@ -294,8 +294,10 @@ describe('CloudRunButtonWrapper', () => { ) const dialog = state.showLayoutDialog.mock.calls[0][0] const portalRequest = dialog.props.onUpdatePayment() + const signal = state.manageSubscription.mock.calls[0][0] unmount() + expect(signal.aborted).toBe(true) resolvePortal() await portalRequest expect(state.closeDialog).toHaveBeenCalledOnce() @@ -322,7 +324,7 @@ describe('CloudRunButtonWrapper', () => { it('opens member-safe recovery copy without a payment action', async () => { mockCanRunWorkflows.value = false mockBillingStatus.value = 'paused' - state.canManageSubscription = false + mockCanManageSubscription.value = false renderWrapper() expect(screen.getByTestId('queue-button')).toHaveTextContent('Run') @@ -380,11 +382,14 @@ describe('CloudRunButtonWrapper', () => { await userEvent.click(screen.getByTestId('queue-button')) const dialogOptions = state.showLayoutDialog.mock.calls[0][0] const portalRequest = dialogOptions.props.onUpdatePayment() + const signal = state.manageSubscription.mock.calls[0][0] mockV1PaymentRecovery.value = false await nextTick() + expect(signal.aborted).toBe(true) resolvePortal() await portalRequest + window.dispatchEvent(new Event('focus')) expect(state.closeDialog).toHaveBeenCalledOnce() expect(state.updateDialog).toHaveBeenCalledOnce() @@ -392,8 +397,87 @@ describe('CloudRunButtonWrapper', () => { key: 'subscription-paused', contentProps: { isUpdatingPayment: true } }) + expect(state.fetchStatus).not.toHaveBeenCalled() + expect(state.fetchBalance).not.toHaveBeenCalled() + }) + + it('aborts portal-return refreshes on rollback', async () => { + state.fetchStatus.mockReturnValueOnce(new Promise(() => {})) + state.fetchBalance.mockReturnValueOnce(new Promise(() => {})) + mockCanRunWorkflows.value = false + mockBillingStatus.value = 'paused' + renderWrapper() + + await userEvent.click(screen.getByTestId('queue-button')) + const dialog = state.showLayoutDialog.mock.calls[0][0] + await dialog.props.onUpdatePayment() + window.dispatchEvent(new Event('focus')) + const statusSignal = state.fetchStatus.mock.calls[0][0] + const balanceSignal = state.fetchBalance.mock.calls[0][0] + + mockV1PaymentRecovery.value = false + await nextTick() + + expect(statusSignal.aborted).toBe(true) + expect(balanceSignal.aborted).toBe(true) + }) + + it('aborts portal-return refreshes on unmount', async () => { + state.fetchStatus.mockReturnValueOnce(new Promise(() => {})) + state.fetchBalance.mockReturnValueOnce(new Promise(() => {})) + mockCanRunWorkflows.value = false + mockBillingStatus.value = 'paused' + const { unmount } = renderWrapper() + + await userEvent.click(screen.getByTestId('queue-button')) + const dialog = state.showLayoutDialog.mock.calls[0][0] + await dialog.props.onUpdatePayment() + window.dispatchEvent(new Event('focus')) + const statusSignal = state.fetchStatus.mock.calls[0][0] + const balanceSignal = state.fetchBalance.mock.calls[0][0] + + unmount() + + expect(statusSignal.aborted).toBe(true) + expect(balanceSignal.aborted).toBe(true) }) + it.for([ + [ + 'owner loses permission', + () => { + mockCanManageSubscription.value = false + } + ], + [ + 'billing recovers', + () => { + mockBillingStatus.value = 'paid' + } + ] + ] as const)( + 'invalidates payment recovery when %s', + async ([, invalidateRecovery]) => { + state.manageSubscription.mockReturnValueOnce(new Promise(() => {})) + mockCanRunWorkflows.value = false + mockBillingStatus.value = 'paused' + renderWrapper() + + await userEvent.click(screen.getByTestId('queue-button')) + const dialog = state.showLayoutDialog.mock.calls[0][0] + void dialog.props.onUpdatePayment() + const signal = state.manageSubscription.mock.calls[0][0] + + invalidateRecovery() + await nextTick() + + expect(signal.aborted).toBe(true) + expect(state.closeDialog).toHaveBeenCalledWith({ + key: 'subscription-paused' + }) + } + ) + it('isolates a re-enabled recovery dialog from an older portal request', async () => { let resolveOldPortal!: () => void state.manageSubscription.mockImplementationOnce( diff --git a/src/composables/billing/useBillingContext.test.ts b/src/composables/billing/useBillingContext.test.ts index d6a7adc6bf7..331b33fa5bc 100644 --- a/src/composables/billing/useBillingContext.test.ts +++ b/src/composables/billing/useBillingContext.test.ts @@ -186,6 +186,7 @@ vi.mock('@/platform/workspace/api/workspaceApi', () => ({ amount_micros: 10000000, currency: 'usd' }), + getPaymentPortalUrl: vi.fn().mockResolvedValue({ url: null }), subscribe: vi.fn().mockResolvedValue({ status: 'subscribed' }), previewSubscribe: vi.fn().mockResolvedValue({ allowed: true }) } @@ -293,6 +294,25 @@ describe('useBillingContext', () => { await expect(manageSubscription()).resolves.toBeUndefined() }) + it('forwards billing abort signals through the workspace adapter', async () => { + mockTeamWorkspacesEnabled.value = true + mockIsPersonal.value = false + const signal = new AbortController().signal + const { fetchStatus, fetchBalance, manageSubscription } = + useBillingContext() + + await fetchStatus(signal) + await fetchBalance(signal) + await manageSubscription(signal) + + expect(workspaceApi.getBillingStatus).toHaveBeenCalledWith(signal) + expect(workspaceApi.getBillingBalance).toHaveBeenCalledWith(signal) + expect(workspaceApi.getPaymentPortalUrl).toHaveBeenCalledWith( + window.location.href, + signal + ) + }) + it('converts topup cents to whole dollars for the legacy credit endpoint', async () => { const { topup } = useBillingContext() await topup(500) diff --git a/src/platform/workspace/components/dialogs/settings/BillingStatusBanner.test.ts b/src/platform/workspace/components/dialogs/settings/BillingStatusBanner.test.ts index 90f56dea586..a1cb6b698af 100644 --- a/src/platform/workspace/components/dialogs/settings/BillingStatusBanner.test.ts +++ b/src/platform/workspace/components/dialogs/settings/BillingStatusBanner.test.ts @@ -11,6 +11,8 @@ import type { import BillingStatusBanner from '@/platform/workspace/components/dialogs/settings/BillingStatusBanner.vue' const mockV1PaymentRecovery = ref(true) +const mockBillingStatus = ref('paid') +const mockCanManageSubscription = ref(true) interface Subscription { hasFunds: boolean @@ -22,7 +24,6 @@ const state = vi.hoisted(() => ({ billingControlEnabled: true, isActiveSubscription: true, isTeamPlan: true, - billingStatus: 'paid' as string | null, subscription: { hasFunds: true, isCancelled: false, @@ -30,7 +31,6 @@ const state = vi.hoisted(() => ({ } as Subscription | null, renewalDate: null as string | null, workspaceType: 'team' as string, - canManageSubscription: true, canManageSubscriptionLifecycle: true, canTopUp: true, showTopUpCreditsDialog: vi.fn(), @@ -57,7 +57,7 @@ vi.mock('@/composables/billing/useBillingContext', () => ({ useBillingContext: () => ({ isActiveSubscription: computed(() => state.isActiveSubscription), isTeamPlan: computed(() => state.isTeamPlan), - billingStatus: computed(() => state.billingStatus as BillingStatus | null), + billingStatus: computed(() => mockBillingStatus.value), subscription: computed(() => state.subscription), renewalDate: computed(() => state.renewalDate), manageSubscription: state.manageSubscription, @@ -69,7 +69,7 @@ vi.mock('@/composables/billing/useBillingContext', () => ({ vi.mock('@/platform/workspace/composables/useWorkspaceUI', () => ({ useWorkspaceUI: () => ({ permissions: computed(() => ({ - canManageSubscription: state.canManageSubscription, + canManageSubscription: mockCanManageSubscription.value, canManageSubscriptionLifecycle: state.canManageSubscriptionLifecycle, canTopUp: state.canTopUp })), @@ -165,12 +165,12 @@ function exhausted() { // The spend gate folds billing_status into is_active, so the backend never emits // paused alongside an active subscription. function pausedState() { - state.billingStatus = 'paused' + mockBillingStatus.value = 'paused' state.isActiveSubscription = false } function paymentFailedState() { - state.billingStatus = 'payment_failed' + mockBillingStatus.value = 'payment_failed' state.isActiveSubscription = false } @@ -178,13 +178,13 @@ describe('BillingStatusBanner', () => { beforeEach(() => { state.billingControlEnabled = true mockV1PaymentRecovery.value = true + mockCanManageSubscription.value = true state.isActiveSubscription = true state.isTeamPlan = true - state.billingStatus = 'paid' + mockBillingStatus.value = 'paid' state.subscription = { hasFunds: true, isCancelled: false, endDate: null } state.renewalDate = null state.workspaceType = 'team' - state.canManageSubscription = true state.canManageSubscriptionLifecycle = true state.canTopUp = true vi.clearAllMocks() @@ -213,7 +213,7 @@ describe('BillingStatusBanner', () => { it('shows out-of-credits contact-admin copy without an Add credits action for members', () => { state.subscription = { hasFunds: false, isCancelled: false, endDate: null } - state.canManageSubscription = false + mockCanManageSubscription.value = false state.canTopUp = false renderBanner() @@ -265,7 +265,7 @@ describe('BillingStatusBanner', () => { it('shows the paused member notice without an action', () => { pausedState() - state.canManageSubscription = false + mockCanManageSubscription.value = false state.canTopUp = false renderBanner() @@ -292,7 +292,7 @@ describe('BillingStatusBanner', () => { it('does not expose payment controls to members', () => { paymentFailedState() - state.canManageSubscription = false + mockCanManageSubscription.value = false renderBanner() expect(screen.queryByRole('status')).not.toBeInTheDocument() @@ -305,8 +305,10 @@ describe('BillingStatusBanner', () => { it('restores the previous recovery banners and copy when the new flag is off', async () => { mockV1PaymentRecovery.value = false paymentFailedState() + state.renewalDate = '2026-08-01T00:00:00Z' const { unmount } = renderBanner() expect(screen.getByRole('status')).toHaveTextContent('Payment declined') + expect(screen.getByRole('status')).toHaveTextContent('will pause on') await userEvent.click( screen.getByRole('button', { name: 'Update payment' }) ) @@ -315,7 +317,7 @@ describe('BillingStatusBanner', () => { unmount() pausedState() - state.canManageSubscription = false + mockCanManageSubscription.value = false renderBanner() expect(screen.getByRole('status')).toHaveTextContent( 'Your workspace admins need to update the payment method' @@ -368,6 +370,43 @@ describe('BillingStatusBanner', () => { expect(signal.aborted).toBe(true) }) + it('aborts a recovery portal request when the owner loses permission', async () => { + state.manageSubscription.mockReturnValueOnce(new Promise(() => {})) + pausedState() + renderBanner() + + await userEvent.click( + screen.getByRole('button', { name: 'Update payment' }) + ) + const signal = state.manageSubscription.mock.calls[0][0] + + mockCanManageSubscription.value = false + await nextTick() + + expect(signal.aborted).toBe(true) + expect( + screen.queryByRole('button', { name: 'Update payment' }) + ).not.toBeInTheDocument() + }) + + it('aborts a recovery portal request when billing recovers', async () => { + state.manageSubscription.mockReturnValueOnce(new Promise(() => {})) + pausedState() + renderBanner() + + await userEvent.click( + screen.getByRole('button', { name: 'Update payment' }) + ) + const signal = state.manageSubscription.mock.calls[0][0] + + mockBillingStatus.value = 'paid' + state.isActiveSubscription = true + await nextTick() + + expect(signal.aborted).toBe(true) + expect(screen.queryByRole('status')).not.toBeInTheDocument() + }) + it('lets a promoted owner reactivate an ending plan', async () => { state.subscription = { hasFunds: true, @@ -391,7 +430,7 @@ describe('BillingStatusBanner', () => { isCancelled: true, endDate: '2026-08-01T00:00:00Z' } - state.canManageSubscription = false + mockCanManageSubscription.value = false state.canManageSubscriptionLifecycle = false renderBanner() diff --git a/src/platform/workspace/components/dialogs/settings/BillingStatusBanner.vue b/src/platform/workspace/components/dialogs/settings/BillingStatusBanner.vue index 232e7311e79..aa3686f7b8a 100644 --- a/src/platform/workspace/components/dialogs/settings/BillingStatusBanner.vue +++ b/src/platform/workspace/components/dialogs/settings/BillingStatusBanner.vue @@ -84,15 +84,6 @@ const { permissions } = useWorkspaceUI() const { kind, dismiss } = useBillingBanner() const { isResubscribing, handleResubscribe } = useResubscribe() let recoveryPortalController: AbortController | null = null - -watch( - () => flags.v1PaymentRecovery, - (enabled) => { - if (!enabled) recoveryPortalController?.abort() - } -) - -onUnmounted(() => recoveryPortalController?.abort()) const dialogService = useDialogService() const canManage = computed(() => permissions.value.canManageSubscription) @@ -101,6 +92,18 @@ const canManageLifecycle = computed( ) const canTopUp = computed(() => permissions.value.canTopUp) +watch( + () => + flags.v1PaymentRecovery && + canManage.value && + (kind.value === 'paused' || kind.value === 'paymentFailed'), + (canUseRecoveryPortal) => { + if (!canUseRecoveryPortal) recoveryPortalController?.abort() + } +) + +onUnmounted(() => recoveryPortalController?.abort()) + const cycleResetDate = computed(() => { const raw = renewalDate.value return raw ? d(new Date(raw), { month: 'short', day: 'numeric' }) : '' From 73a5b71f0da595feabe2cf88cd066d88cb5cbeb6 Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Wed, 5 Aug 2026 15:16:17 +0000 Subject: [PATCH 5/5] fix: block stale payment recovery controls Amp-Thread-ID: https://ampcode.com/threads/T-019fc867-33d7-7463-b4d0-ab1c1cb297de Co-authored-by: Amp --- .../dialogs/settings/BillingStatusBanner.test.ts | 15 +++++++++++++++ .../dialogs/settings/BillingStatusBanner.vue | 3 +++ 2 files changed, 18 insertions(+) diff --git a/src/platform/workspace/components/dialogs/settings/BillingStatusBanner.test.ts b/src/platform/workspace/components/dialogs/settings/BillingStatusBanner.test.ts index a1cb6b698af..cf099f2560d 100644 --- a/src/platform/workspace/components/dialogs/settings/BillingStatusBanner.test.ts +++ b/src/platform/workspace/components/dialogs/settings/BillingStatusBanner.test.ts @@ -302,6 +302,21 @@ describe('BillingStatusBanner', () => { expect(state.manageSubscription).not.toHaveBeenCalled() }) + it('blocks stale payment controls immediately after permission loss', async () => { + paymentFailedState() + renderBanner() + const updatePayment = screen.getByRole('button', { + name: 'Update payment' + }) + + mockCanManageSubscription.value = false + updatePayment.click() + + expect(state.manageSubscription).not.toHaveBeenCalled() + await nextTick() + expect(screen.queryByRole('status')).not.toBeInTheDocument() + }) + it('restores the previous recovery banners and copy when the new flag is off', async () => { mockV1PaymentRecovery.value = false paymentFailedState() diff --git a/src/platform/workspace/components/dialogs/settings/BillingStatusBanner.vue b/src/platform/workspace/components/dialogs/settings/BillingStatusBanner.vue index aa3686f7b8a..5ec896fa254 100644 --- a/src/platform/workspace/components/dialogs/settings/BillingStatusBanner.vue +++ b/src/platform/workspace/components/dialogs/settings/BillingStatusBanner.vue @@ -141,6 +141,8 @@ const banner = computed(() => { } } case 'paymentFailed': { + if (flags.v1PaymentRecovery && !canManage.value) return null + const warningKey = flags.v1PaymentRecovery ? `${bs}.recoveryWarning` : `${bs}.warning` @@ -189,6 +191,7 @@ function handleUpdatePayment() { void manageSubscription() return } + if (!canManage.value) return recoveryPortalController?.abort() const controller = new AbortController()