@taskforcehq/taskforce 0.3.305 → 0.3.307

package/dist/components/views/PlansPage.test.js

@@ -1,10 +1,11 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { act, fireEvent, render, screen, waitFor } from '@testing-library/react';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import { MemoryRouter } from 'react-router-dom';
 import { PlansPage } from './PlansPage';
+import { ACCOUNT_PROFILE_SUMMARY_PATH, invalidateAccountProfileSummaryCache } from '../../utils/accountProfileSummaryCache';
 vi.mock('./PlanComparisonPage', () => ({
-    PlanComparisonPage: ({ heading, statusBanner, topActions, onSelectPlan, onBack, backLabel, backDisabled }) => (_jsxs("div", { children: [_jsx("h1", { children: heading }), statusBanner?.message ? _jsx("div", { "data-status-type": statusBanner.type, children: statusBanner.message }) : null, topActions, onSelectPlan ? (_jsx("button", { onClick: () => onSelectPlan({
+    PlanComparisonPage: ({ heading, pricingEndpoint, statusBanner, topActions, onSelectPlan, onBack, backLabel, backDisabled }) => (_jsxs("div", { children: [_jsx("h1", { children: heading }), pricingEndpoint ? _jsx("div", { "data-testid": "pricing-endpoint", children: pricingEndpoint }) : null, statusBanner?.message ? _jsx("div", { "data-status-type": statusBanner.type, children: statusBanner.message }) : null, topActions, onSelectPlan ? (_jsx("button", { onClick: () => onSelectPlan({
                     planId: 'free',
                     planVersionId: 'free-v1',
                     interval: 'month',
@@ -17,7 +18,16 @@ describe('PlansPage', () => {
         vi.useRealTimers();
         vi.unstubAllGlobals();
     });
+    it('builds the pricing endpoint through resolveCloudAuthUrl', async () => {
+        vi.stubGlobal('fetch', vi.fn(async () => ({
+            ok: true,
+            json: async () => ({})
+        })));
+        render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans'], children: _jsx(PlansPage, { isAuthenticated: false, runtimeMode: "local", authSessionResolved: true, apiBaseUrl: "https://performance-app.taskforcehq.ai/api", resolveCloudAuthUrl: (path) => `/api/proxy?path=${encodeURIComponent(path)}` }) }));
+        expect(await screen.findByTestId('pricing-endpoint')).toHaveTextContent('/api/proxy?path=%2Fapi%2Ftaskforce%2Fpublic%2Fpricing');
+    });
     it('shows recovery messaging only after bounded retries are exhausted', async () => {
+        vi.useFakeTimers();
         let profileSummaryCalls = 0;
         let confirmCalls = 0;
         const fetchMock = vi.fn(async (url) => {
@@ -65,14 +75,16 @@ describe('PlansPage', () => {
         });
         vi.stubGlobal('fetch', fetchMock);
         render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&checkout=success&session_id=cs_test_123'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u1", runtimeMode: "cloud", authSessionResolved: true, resolveCloudAuthUrl: (path) => path }) }));
-        expect(await screen.findByText('Checkout completed successfully. Finalizing your plan...')).toBeInTheDocument();
+        expect(screen.getByText('Checkout completed successfully. Finalizing your plan...')).toBeInTheDocument();
+        await act(async () => {
+            await Promise.resolve();
+        });
         expect(confirmCalls).toBe(1);
-        await waitFor(() => {
-            expect(confirmCalls).toBe(4);
-        }, { timeout: 4500 });
-        await waitFor(() => {
-            expect(screen.getByText('Your previous checkout expired. Choose a plan to continue.')).toBeInTheDocument();
+        await act(async () => {
+            await vi.advanceTimersByTimeAsync(50000);
         });
+        expect(confirmCalls).toBeGreaterThanOrEqual(12);
+        expect(screen.getByText('Your previous checkout expired. Choose a plan to continue.')).toBeInTheDocument();
         expect(screen.queryByText('Checkout completed successfully.')).not.toBeInTheDocument();
     }, 10000);
     it('retries checkout confirmation when the first confirm is incomplete and later succeeds', async () => {
@@ -134,8 +146,153 @@ describe('PlansPage', () => {
         expect(await screen.findByText('Checkout completed successfully.')).toBeInTheDocument();
         expect(confirmCalls).toBe(2);
     }, 10000);
-    it('does not attempt checkout confirmation before auth session is resolved', async () => {
+    it('treats an active entitlement summary as checkout success even when confirm still reports incomplete', async () => {
+        let profileSummaryCalls = 0;
+        let confirmCalls = 0;
+        const fetchMock = vi.fn(async (url) => {
+            if (url.includes('/api/taskforce/account/profile-summary')) {
+                profileSummaryCalls += 1;
+                if (profileSummaryCalls === 1) {
+                    return {
+                        ok: true,
+                        json: async () => ({
+                            planId: 'basic',
+                            planVersionId: 'basic-v1',
+                            entitlementState: 'checkout_pending',
+                            gate: 'checkout_pending',
+                            message: 'Complete checkout to continue.'
+                        })
+                    };
+                }
+                return {
+                    ok: true,
+                    json: async () => ({
+                        entitlementState: 'active',
+                        planId: 'basic',
+                        planVersionId: 'basic-v1',
+                        billingInterval: 'month',
+                        gate: 'ok',
+                        message: null
+                    })
+                };
+            }
+            if (url.includes('/api/taskforce/billing/checkout-session/confirm')) {
+                confirmCalls += 1;
+                return {
+                    ok: false,
+                    status: 409,
+                    json: async () => ({
+                        error: 'Checkout session is still finalizing your plan.',
+                        code: 'CHECKOUT_SESSION_INCOMPLETE'
+                    })
+                };
+            }
+            return {
+                ok: true,
+                json: async () => ({})
+            };
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&checkout=success&session_id=cs_test_summary_settled'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u1", runtimeMode: "cloud", authSessionResolved: true, resolveCloudAuthUrl: (path) => path }) }));
+        expect(await screen.findByText('Checkout completed successfully. Finalizing your plan...')).toBeInTheDocument();
+        expect(await screen.findByText('Checkout completed successfully.')).toBeInTheDocument();
+        expect(confirmCalls).toBe(1);
+    }, 10000);
+    it('does not treat an already-active account as settled until the requested interval change is visible', async () => {
+        vi.useFakeTimers();
+        let confirmCalls = 0;
+        const fetchMock = vi.fn(async (url) => {
+            if (url.includes('/api/taskforce/account/profile-summary')) {
+                return {
+                    ok: true,
+                    json: async () => ({
+                        entitlementState: 'active',
+                        planId: 'basic',
+                        planVersionId: 'basic-v1',
+                        billingInterval: 'month',
+                        gate: 'ok',
+                        message: null
+                    })
+                };
+            }
+            if (url.includes('/api/taskforce/billing/checkout-session/confirm')) {
+                confirmCalls += 1;
+                return {
+                    ok: false,
+                    status: 409,
+                    json: async () => ({
+                        error: 'Checkout session is still finalizing your plan.',
+                        code: 'CHECKOUT_SESSION_INCOMPLETE'
+                    })
+                };
+            }
+            return {
+                ok: true,
+                json: async () => ({})
+            };
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&checkout=success&session_id=cs_test_existing_active_interval&planId=basic&planVersionId=basic-v1&interval=year'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u1", runtimeMode: "cloud", authSessionResolved: true, resolveCloudAuthUrl: (path) => path }) }));
+        expect(screen.getByText('Checkout completed successfully. Finalizing your plan...')).toBeInTheDocument();
+        await act(async () => {
+            await Promise.resolve();
+        });
+        expect(confirmCalls).toBe(1);
+        expect(screen.queryByText('Checkout completed successfully.')).not.toBeInTheDocument();
+        await act(async () => {
+            await vi.advanceTimersByTimeAsync(50000);
+        });
+        expect(confirmCalls).toBeGreaterThanOrEqual(12);
+        expect(screen.queryByText('Checkout completed successfully.')).not.toBeInTheDocument();
+    }, 10000);
+    it('does not retry checkout confirmation for account mismatch responses', async () => {
+        let confirmCalls = 0;
+        const fetchMock = vi.fn(async (url) => {
+            if (url.includes('/api/taskforce/account/profile-summary')) {
+                return {
+                    ok: true,
+                    json: async () => ({
+                        planId: 'basic',
+                        planVersionId: 'basic-v1',
+                        entitlementState: 'checkout_pending',
+                        gate: 'checkout_pending',
+                        message: 'Complete checkout to continue.'
+                    })
+                };
+            }
+            if (url.includes('/api/taskforce/billing/checkout-session/confirm')) {
+                confirmCalls += 1;
+                return {
+                    ok: false,
+                    status: 403,
+                    json: async () => ({
+                        error: 'Checkout session does not belong to the current account.',
+                        code: 'CHECKOUT_SESSION_ACCOUNT_MISMATCH'
+                    })
+                };
+            }
+            return {
+                ok: true,
+                json: async () => ({})
+            };
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&checkout=success&session_id=cs_test_wrong_account'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u1", runtimeMode: "cloud", authSessionResolved: true, resolveCloudAuthUrl: (path) => path }) }));
+        expect(await screen.findByText('Checkout completed successfully. Finalizing your plan...')).toBeInTheDocument();
+        await waitFor(() => {
+            expect(confirmCalls).toBe(1);
+        });
+        await act(async () => {
+            await new Promise((resolve) => setTimeout(resolve, 1200));
+        });
+        expect(confirmCalls).toBe(1);
+        expect(screen.queryByText('Checkout completed successfully.')).not.toBeInTheDocument();
+        expect(screen.getByText('Checkout session does not belong to the current account.')).toBeInTheDocument();
+        expect(screen.queryByText('Complete checkout to continue.')).not.toBeInTheDocument();
+    }, 10000);
+    it('attempts checkout confirmation immediately when the user is already authenticated even if auth session is still resolving', async () => {
         let profileSummaryCalls = 0;
+        let confirmCalls = 0;
         const fetchMock = vi.fn(async (url) => {
             if (url.includes('/api/taskforce/account/profile-summary')) {
                 profileSummaryCalls += 1;
@@ -163,6 +320,7 @@ describe('PlansPage', () => {
                 };
             }
             if (url.includes('/api/taskforce/billing/checkout-session/confirm')) {
+                confirmCalls += 1;
                 return {
                     ok: true,
                     status: 200,
@@ -177,12 +335,112 @@ describe('PlansPage', () => {
         vi.stubGlobal('fetch', fetchMock);
         const view = render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&checkout=success&session_id=cs_test_auth_wait'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u_auth", runtimeMode: "cloud", authSessionResolved: false, resolveCloudAuthUrl: (path) => path }) }));
         expect(await screen.findByText('Checkout completed successfully. Finalizing your plan...')).toBeInTheDocument();
-        expect(fetchMock.mock.calls.some(([url]) => String(url).includes('/api/taskforce/billing/checkout-session/confirm'))).toBe(false);
+        await waitFor(() => {
+            expect(confirmCalls).toBe(1);
+        });
+    });
+    it('waits to confirm checkout when auth is still unresolved and the user is not yet authenticated', async () => {
+        let profileSummaryCalls = 0;
+        let confirmCalls = 0;
+        const fetchMock = vi.fn(async (url) => {
+            if (url.includes('/api/taskforce/account/profile-summary')) {
+                profileSummaryCalls += 1;
+                return {
+                    ok: true,
+                    json: async () => ({
+                        planId: 'basic',
+                        planVersionId: 'basic-v1',
+                        entitlementState: 'checkout_pending',
+                        gate: 'checkout_pending',
+                        message: 'Complete checkout to continue.'
+                    })
+                };
+            }
+            if (url.includes('/api/taskforce/billing/checkout-session/confirm')) {
+                confirmCalls += 1;
+                return {
+                    ok: true,
+                    status: 200,
+                    json: async () => ({ success: true })
+                };
+            }
+            return {
+                ok: true,
+                json: async () => ({})
+            };
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const view = render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&checkout=success&session_id=cs_test_auth_wait'], children: _jsx(PlansPage, { isAuthenticated: false, authUserId: "u_auth", runtimeMode: "cloud", authSessionResolved: false, resolveCloudAuthUrl: (path) => path }) }));
+        expect(await screen.findByText('Checkout completed successfully. Finalizing your plan...')).toBeInTheDocument();
+        expect(confirmCalls).toBe(0);
         view.rerender(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&checkout=success&session_id=cs_test_auth_wait'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u_auth", runtimeMode: "cloud", authSessionResolved: true, resolveCloudAuthUrl: (path) => path }) }));
         await waitFor(() => {
             expect(fetchMock.mock.calls.some(([url]) => String(url).includes('/api/taskforce/billing/checkout-session/confirm'))).toBe(true);
         });
     });
+    it('restarts checkout confirmation after a mid-flight rerender before the first confirm attempt', async () => {
+        let confirmCalls = 0;
+        let profileSummaryCalls = 0;
+        let releaseBlockedProfileSummaries = false;
+        const blockedProfileSummaryResolvers = [];
+        const fetchMock = vi.fn(async (url) => {
+            if (url.includes('/api/taskforce/account/profile-summary')) {
+                profileSummaryCalls += 1;
+                if (!releaseBlockedProfileSummaries) {
+                    return await new Promise((resolve) => {
+                        blockedProfileSummaryResolvers.push(resolve);
+                    });
+                }
+                return {
+                    ok: true,
+                    json: async () => ({
+                        entitlementState: 'checkout_pending',
+                        planId: 'basic',
+                        planVersionId: 'basic-v1',
+                        gate: 'checkout_pending',
+                        message: 'Complete checkout to continue.'
+                    })
+                };
+            }
+            if (url.includes('/api/taskforce/billing/checkout-session/confirm')) {
+                confirmCalls += 1;
+                return {
+                    ok: true,
+                    status: 200,
+                    json: async () => ({ success: true })
+                };
+            }
+            return {
+                ok: true,
+                json: async () => ({})
+            };
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const firstResolveCloudAuthUrl = (path) => path;
+        const secondResolveCloudAuthUrl = (path) => path;
+        const view = render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&checkout=success&session_id=cs_test_rerender'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u_rerender", runtimeMode: "cloud", authSessionResolved: true, resolveCloudAuthUrl: firstResolveCloudAuthUrl }) }));
+        await waitFor(() => {
+            expect(profileSummaryCalls).toBeGreaterThan(0);
+        });
+        view.rerender(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&checkout=success&session_id=cs_test_rerender'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u_rerender", runtimeMode: "cloud", authSessionResolved: true, resolveCloudAuthUrl: secondResolveCloudAuthUrl }) }));
+        releaseBlockedProfileSummaries = true;
+        for (const resolve of blockedProfileSummaryResolvers.splice(0)) {
+            resolve({
+                ok: true,
+                json: async () => ({
+                    entitlementState: 'checkout_pending',
+                    planId: 'basic',
+                    planVersionId: 'basic-v1',
+                    gate: 'checkout_pending',
+                    message: 'Complete checkout to continue.'
+                })
+            });
+        }
+        await waitFor(() => {
+            expect(confirmCalls).toBe(1);
+        });
+        expect(await screen.findByText('Checkout completed successfully.')).toBeInTheDocument();
+    });
     it('shows conflict-specific recovery messaging when the account lands on plans already blocked', async () => {
         const fetchMock = vi.fn()
             .mockResolvedValueOnce({
@@ -258,7 +516,8 @@ describe('PlansPage', () => {
         });
         vi.stubGlobal('fetch', fetchMock);
         render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&gate=plan_selection_required'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u4", runtimeMode: "cloud", authSessionResolved: true, resolveCloudAuthUrl: (path) => path, onContinueToTaskforce: onContinueToTaskforce }) }));
-        expect(await screen.findByText('Choose a plan to continue.')).toBeInTheDocument();
+        await screen.findByRole('heading', { name: 'Subscription Plans' });
+        expect(screen.queryByText('Choose a plan to continue.')).not.toBeInTheDocument();
         fireEvent.click(screen.getByRole('button', { name: 'Select Free Plan' }));
         await waitFor(() => {
             expect(onContinueToTaskforce).toHaveBeenCalledTimes(1);
@@ -278,7 +537,7 @@ describe('PlansPage', () => {
         vi.stubGlobal('fetch', fetchMock);
         render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&gate=plan_selection_required'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u5", runtimeMode: "cloud", authSessionResolved: true, resolveCloudAuthUrl: (path) => path }) }));
         expect(await screen.findByRole('button', { name: 'Back to App' })).toBeDisabled();
-        expect(screen.getByText('Choose a plan to continue.')).toHaveAttribute('data-status-type', 'info');
+        expect(screen.queryByText('Choose a plan to continue.')).not.toBeInTheDocument();
     });
     it('does not auto-continue after an in-place paid interval update for an already active account', async () => {
         const onContinueToTaskforce = vi.fn();
@@ -390,6 +649,29 @@ describe('PlansPage', () => {
         expect(await screen.findByText(/Your trial is active through/)).toBeInTheDocument();
         expect(screen.getByRole('button', { name: 'Take Me to Taskforce' })).toBeEnabled();
     });
+    it('does not claim an expired trial is still active through a past date', async () => {
+        const nowSpy = vi.spyOn(Date, 'now').mockReturnValue(new Date('2026-04-20T12:00:00.000Z').getTime());
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                entitlementState: 'trialing',
+                planId: 'starter',
+                planVersionId: 'starter-v1',
+                gate: 'ok',
+                trialEnd: '2026-04-12T16:09:09.000Z'
+            })
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        invalidateAccountProfileSummaryCache(ACCOUNT_PROFILE_SUMMARY_PATH, { identityKey: 'u8' });
+        try {
+            render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u8", runtimeMode: "cloud", authSessionResolved: true, resolveCloudAuthUrl: (path) => path, onContinueToTaskforce: vi.fn() }) }));
+            expect(await screen.findByText('Your trial end date has passed. Billing status is updating.')).toBeInTheDocument();
+            expect(screen.queryByText(/Your trial is active through/)).not.toBeInTheDocument();
+        }
+        finally {
+            nowSpy.mockRestore();
+        }
+    });
     it('shows suspended accounts a billing-recovery message and keeps return blocked', async () => {
         const fetchMock = vi.fn().mockResolvedValue({
             ok: true,