@taskforcehq/taskforce 0.3.303 → 0.3.305

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

@@ -1,54 +1,186 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { render, screen, waitFor } from '@testing-library/react';
+import { 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';
 vi.mock('./PlanComparisonPage', () => ({
-    PlanComparisonPage: ({ heading, statusBanner }) => (_jsxs("div", { children: [_jsx("h1", { children: heading }), statusBanner?.message ? _jsx("div", { children: statusBanner.message }) : null] }))
+    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({
+                    planId: 'free',
+                    planVersionId: 'free-v1',
+                    interval: 'month',
+                    pricingType: 'free',
+                    isCurrentPlan: false
+                }), children: "Select Free Plan" })) : null, onBack ? (_jsx("button", { onClick: onBack, disabled: backDisabled, children: backLabel || 'Back' })) : null] }))
 }));
 describe('PlansPage', () => {
     afterEach(() => {
+        vi.useRealTimers();
         vi.unstubAllGlobals();
     });
-    it('shows recovery messaging instead of false checkout success when confirmation fails', async () => {
-        const fetchMock = vi.fn()
-            .mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({
-                planId: 'pro',
-                planVersionId: 'pro-v1',
-                entitlementState: 'checkout_pending',
-                gate: 'checkout_pending',
-                message: 'Complete checkout to continue.'
-            })
-        })
-            .mockResolvedValueOnce({
-            ok: false,
-            json: async () => ({
-                error: 'Checkout session has not completed yet.',
-                code: 'CHECKOUT_SESSION_INCOMPLETE'
-            })
-        })
-            .mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({
-                planId: 'pro',
-                planVersionId: 'pro-v1',
-                entitlementState: 'checkout_pending',
-                gate: 'plan_selection_required',
-                message: 'Your previous checkout expired. Choose a plan to continue.',
-                planSelectionRequired: true
-            })
+    it('shows recovery messaging only after bounded retries are exhausted', 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 <= 2) {
+                    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 () => ({
+                        planId: 'basic',
+                        planVersionId: 'basic-v1',
+                        entitlementState: 'pending_plan_selection',
+                        gate: 'plan_selection_required',
+                        message: 'Your previous checkout expired. Choose a plan to continue.',
+                        planSelectionRequired: true
+                    })
+                };
+            }
+            if (url.includes('/api/taskforce/billing/checkout-session/confirm')) {
+                confirmCalls += 1;
+                return {
+                    ok: false,
+                    status: 409,
+                    json: async () => ({
+                        error: 'Checkout session has not completed yet.',
+                        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_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(await screen.findByText('Your previous checkout expired. Choose a plan to continue.')).toBeInTheDocument();
+        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();
+        });
         expect(screen.queryByText('Checkout completed successfully.')).not.toBeInTheDocument();
+    }, 10000);
+    it('retries checkout confirmation when the first confirm is incomplete and later succeeds', 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 <= 2) {
+                    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;
+                if (confirmCalls === 1) {
+                    return {
+                        ok: false,
+                        status: 409,
+                        json: async () => ({
+                            error: 'Checkout session has not completed yet.',
+                            code: 'CHECKOUT_SESSION_INCOMPLETE'
+                        })
+                    };
+                }
+                return {
+                    ok: true,
+                    status: 200,
+                    json: async () => ({ success: true })
+                };
+            }
+            return {
+                ok: true,
+                json: async () => ({})
+            };
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&checkout=success&session_id=cs_test_retry_success'], 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(2);
+    }, 10000);
+    it('does not attempt checkout confirmation before auth session is resolved', async () => {
+        let profileSummaryCalls = 0;
+        const fetchMock = vi.fn(async (url) => {
+            if (url.includes('/api/taskforce/account/profile-summary')) {
+                profileSummaryCalls += 1;
+                if (profileSummaryCalls <= 2) {
+                    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',
+                        gate: 'ok',
+                        message: null
+                    })
+                };
+            }
+            if (url.includes('/api/taskforce/billing/checkout-session/confirm')) {
+                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: 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);
+        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).toHaveBeenNthCalledWith(2, '/api/taskforce/billing/checkout-session/confirm', expect.objectContaining({
-                method: 'POST'
-            }));
+            expect(fetchMock.mock.calls.some(([url]) => String(url).includes('/api/taskforce/billing/checkout-session/confirm'))).toBe(true);
         });
     });
     it('shows conflict-specific recovery messaging when the account lands on plans already blocked', async () => {
@@ -56,8 +188,8 @@ describe('PlansPage', () => {
             .mockResolvedValueOnce({
             ok: true,
             json: async () => ({
-                planId: 'pro',
-                planVersionId: 'pro-v1',
+                planId: 'basic',
+                planVersionId: 'basic-v1',
                 entitlementState: 'pending_plan_selection',
                 gate: 'plan_selection_required',
                 message: 'Choose a plan to continue.',
@@ -74,8 +206,8 @@ describe('PlansPage', () => {
             .mockResolvedValueOnce({
             ok: true,
             json: async () => ({
-                planId: 'pro',
-                planVersionId: 'pro-v1',
+                planId: 'basic',
+                planVersionId: 'basic-v1',
                 entitlementState: 'checkout_pending',
                 gate: 'checkout_pending',
                 message: 'Complete checkout to continue.'
@@ -84,8 +216,8 @@ describe('PlansPage', () => {
             .mockResolvedValueOnce({
             ok: true,
             json: async () => ({
-                planId: 'pro',
-                planVersionId: 'pro-v1',
+                planId: 'basic',
+                planVersionId: 'basic-v1',
                 entitlementState: 'pending_plan_selection',
                 gate: 'plan_selection_required',
                 message: 'Choose a plan to continue.',
@@ -97,4 +229,198 @@ describe('PlansPage', () => {
         render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&checkout=cancel'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u3", runtimeMode: "cloud", authSessionResolved: true, resolveCloudAuthUrl: (path) => path }) }));
         expect(await screen.findByText('Your previous checkout expired. Choose a plan to continue.')).toBeInTheDocument();
     });
+    it('auto-continues after a free plan grant and exposes a taskforce CTA once access is active', async () => {
+        const onContinueToTaskforce = vi.fn();
+        const fetchMock = vi.fn()
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                entitlementState: 'pending_plan_selection',
+                gate: 'plan_selection_required',
+                message: 'Choose a plan to continue.'
+            })
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                checkoutState: 'free'
+            })
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                entitlementState: 'active',
+                planId: 'free',
+                planVersionId: 'free-v1',
+                gate: 'ok',
+                message: null
+            })
+        });
+        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();
+        fireEvent.click(screen.getByRole('button', { name: 'Select Free Plan' }));
+        await waitFor(() => {
+            expect(onContinueToTaskforce).toHaveBeenCalledTimes(1);
+        });
+        expect(screen.getByRole('button', { name: 'Take Me to Taskforce' })).toBeInTheDocument();
+    });
+    it('disables the back action while the account is still entitlement-blocked', async () => {
+        const fetchMock = vi.fn()
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                entitlementState: 'pending_plan_selection',
+                gate: 'plan_selection_required',
+                message: 'Choose a plan to continue.'
+            })
+        });
+        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');
+    });
+    it('does not auto-continue after an in-place paid interval update for an already active account', async () => {
+        const onContinueToTaskforce = vi.fn();
+        let profileSummaryCalls = 0;
+        const fetchMock = vi.fn(async (url) => {
+            if (url.includes('/api/taskforce/account/profile-summary')) {
+                profileSummaryCalls += 1;
+                if (profileSummaryCalls <= 2) {
+                    return {
+                        ok: true,
+                        json: async () => ({
+                            entitlementState: 'active',
+                            planId: 'basic',
+                            planVersionId: 'basic-v1',
+                            gate: 'ok',
+                            message: null
+                        })
+                    };
+                }
+                return {
+                    ok: true,
+                    json: async () => ({
+                        entitlementState: 'active',
+                        planId: 'basic',
+                        planVersionId: 'basic-v1',
+                        billingInterval: 'year',
+                        gate: 'ok',
+                        message: null
+                    })
+                };
+            }
+            if (url.includes('/api/taskforce/billing/checkout-session')) {
+                return {
+                    ok: true,
+                    json: async () => ({
+                        checkoutState: 'updated',
+                        message: 'Your subscription was updated successfully.'
+                    })
+                };
+            }
+            return {
+                ok: true,
+                json: async () => ({})
+            };
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&checkout=start&planId=basic&planVersionId=basic-v1&interval=year'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u6", runtimeMode: "local", authSessionResolved: true, resolveCloudAuthUrl: (path) => path, onContinueToTaskforce: onContinueToTaskforce }) }));
+        expect(await screen.findByText('Your subscription was updated successfully.')).toBeInTheDocument();
+        expect(onContinueToTaskforce).not.toHaveBeenCalled();
+    });
+    it('does not auto-continue after confirming checkout when the account was already active', async () => {
+        const onContinueToTaskforce = vi.fn();
+        let profileSummaryCalls = 0;
+        const fetchMock = vi.fn(async (url) => {
+            if (url.includes('/api/taskforce/account/profile-summary')) {
+                profileSummaryCalls += 1;
+                if (profileSummaryCalls <= 2) {
+                    return {
+                        ok: true,
+                        json: async () => ({
+                            entitlementState: 'active',
+                            planId: 'basic',
+                            planVersionId: 'basic-v1',
+                            gate: 'ok',
+                            message: null
+                        })
+                    };
+                }
+                return {
+                    ok: true,
+                    json: async () => ({
+                        entitlementState: 'active',
+                        planId: 'team-5',
+                        planVersionId: 'team-5-v1',
+                        gate: 'ok',
+                        message: null
+                    })
+                };
+            }
+            if (url.includes('/api/taskforce/billing/checkout-session/confirm')) {
+                return {
+                    ok: true,
+                    json: async () => ({ success: true })
+                };
+            }
+            return {
+                ok: true,
+                json: async () => ({})
+            };
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&checkout=success&session_id=cs_test_existing_active'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u7", runtimeMode: "local", authSessionResolved: true, resolveCloudAuthUrl: (path) => path, onContinueToTaskforce: onContinueToTaskforce }) }));
+        expect(await screen.findByText('Checkout completed successfully.')).toBeInTheDocument();
+        expect(onContinueToTaskforce).not.toHaveBeenCalled();
+    });
+    it('shows trial-specific messaging while still allowing return to Taskforce', async () => {
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                entitlementState: 'trialing',
+                planId: 'starter',
+                planVersionId: 'starter-v1',
+                gate: 'ok',
+                trialEnd: '2026-05-01T12:00:00.000Z'
+            })
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        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 is active through/)).toBeInTheDocument();
+        expect(screen.getByRole('button', { name: 'Take Me to Taskforce' })).toBeEnabled();
+    });
+    it('shows suspended accounts a billing-recovery message and keeps return blocked', async () => {
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                entitlementState: 'suspended',
+                planId: 'pro',
+                planVersionId: 'pro-v1',
+                gate: 'missing_entitlement',
+                stripeCustomerId: 'cus_123'
+            })
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u9", runtimeMode: "cloud", authSessionResolved: true, resolveCloudAuthUrl: (path) => path }) }));
+        expect(await screen.findByText('Your access is suspended because billing needs attention. Update billing to restore access.')).toBeInTheDocument();
+        expect(screen.getByRole('button', { name: 'Back to App' })).toBeDisabled();
+        expect(screen.getByText('Your access is suspended because billing needs attention. Update billing to restore access.')).toHaveAttribute('data-status-type', 'error');
+    });
+    it('shows canceled accounts reactivation messaging instead of generic inactive copy', async () => {
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                entitlementState: 'canceled',
+                planId: 'pro',
+                planVersionId: 'pro-v1',
+                gate: 'missing_entitlement',
+                message: 'This generic message should be ignored.'
+            })
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u10", runtimeMode: "cloud", authSessionResolved: true, resolveCloudAuthUrl: (path) => path }) }));
+        expect(await screen.findByText('Your access has ended. Choose a plan to reactivate your workspace.')).toBeInTheDocument();
+        expect(screen.queryByText('This generic message should be ignored.')).not.toBeInTheDocument();
+    });
 });