From f625acf95049a54299da7dd67821b979dc1e819d Mon Sep 17 00:00:00 2001 From: Talisson Costa Date: Thu, 19 Nov 2026 09:29:57 -0300 Subject: [PATCH 1/3] fix(Onboarding): Keep a new user on the flow they were assigned A reload before onboarding had created the organisation logged in again without isGettingStarted, so a single_page user was sent to /create. Submitting it opened the onboarding flow, which read a stale organisation list and created a second organisation. Route by the stored variant when there is one, and wait for the organisation list to finish refetching before onboarding creates one. The E2E test pins the variant so it runs whatever the flag is set to. Co-Authored-By: Claude Opus 5.5 --- api/app/settings/common.py | 2 + api/e2etests/e2e_seed_data.py | 3 + .../utils/__tests__/onboardingEntry.test.ts | 48 ++++++++++++++ frontend/common/utils/onboardingEntry.ts | 9 +++ frontend/e2e/config.ts | 1 + frontend/e2e/tests/onboarding-tests.pw.ts | 65 ++++++++++++++++++- frontend/web/components/App.js | 7 +- .../hooks/useEnsureOnboardingResources.ts | 8 ++- 8 files changed, 136 insertions(+), 7 deletions(-) diff --git a/api/app/settings/common.py b/api/app/settings/common.py index d36b8f64d5b3..1fd243a2bd8a 100644 --- a/api/app/settings/common.py +++ b/api/app/settings/common.py @@ -661,6 +661,8 @@ f"e2e_non_admin_user_with_a_role@{E2E_TEST_EMAIL_DOMAIN}" ) E2E_SEPARATE_TEST_USER = f"e2e_separate_test_user@{E2E_TEST_EMAIL_DOMAIN}" +# New user for the onboarding E2E test that reloads before the organisation exists +E2E_ONBOARDING_RELOAD_USER = f"e2e_onboarding_reload_user@{E2E_TEST_EMAIL_DOMAIN}" # User on a Free-plan organisation, used by the Billing tab E2E tests # that need to exercise the "no active subscription" payment flow. E2E_BILLING_USER = f"e2e_billing_user@{E2E_TEST_EMAIL_DOMAIN}" diff --git a/api/e2etests/e2e_seed_data.py b/api/e2etests/e2e_seed_data.py index 2a3aec35b666..8e4df8626dc0 100644 --- a/api/e2etests/e2e_seed_data.py +++ b/api/e2etests/e2e_seed_data.py @@ -65,6 +65,9 @@ def teardown() -> None: ) delete_user_and_its_organisations(user_email=settings.E2E_SEPARATE_TEST_USER) delete_user_and_its_organisations(user_email=settings.E2E_BILLING_USER) + delete_user_and_its_organisations( + user_email=settings.E2E_ONBOARDING_RELOAD_USER + ) def seed_data() -> None: diff --git a/frontend/common/utils/__tests__/onboardingEntry.test.ts b/frontend/common/utils/__tests__/onboardingEntry.test.ts index cf2ff8c3d5f6..9d9c383efe17 100644 --- a/frontend/common/utils/__tests__/onboardingEntry.test.ts +++ b/frontend/common/utils/__tests__/onboardingEntry.test.ts @@ -4,6 +4,7 @@ import { getStoredOnboardingTargetingKey, getStoredOnboardingVariant, persistOnboardingEntry, + resolveOnboardingVariant, } from 'common/utils/onboardingEntry' jest.mock('@flagsmith/flagsmith', () => ({ @@ -96,3 +97,50 @@ describe('persistOnboardingEntry', () => { expect(getStoredOnboardingTargetingKey()).toBeNull() }) }) + +describe('resolveOnboardingVariant', () => { + beforeEach(() => { + storage.clear() + }) + + it.each` + stored | decision | expected + ${'single_page'} | ${null} | ${'single_page'} + ${'single_page'} | ${{ targetingKey: 'anon-1', variant: 'control' }} | ${'single_page'} + ${'control'} | ${{ targetingKey: 'anon-1', variant: 'single_page' }} | ${'control'} + ${null} | ${{ targetingKey: 'anon-1', variant: 'single_page' }} | ${'single_page'} + ${null} | ${null} | ${'control'} + `( + 'stored $stored with decision $decision routes as $expected', + ({ decision, expected, stored }) => { + expect(resolveOnboardingVariant(stored, decision)).toBe(expected) + }, + ) + + it('keeps the stored variant instead of persisting a new decision', () => { + // Given + storage.set('onboarding_variant', 'single_page') + + // When + resolveOnboardingVariant('single_page', { + targetingKey: 'anon-2', + variant: 'control', + }) + + // Then + expect(getStoredOnboardingVariant()).toBe('single_page') + expect(getStoredOnboardingTargetingKey()).toBeNull() + }) + + it('persists a new decision when nothing is stored', () => { + // When + resolveOnboardingVariant(null, { + targetingKey: 'anon-3', + variant: 'single_page', + }) + + // Then + expect(getStoredOnboardingVariant()).toBe('single_page') + expect(getStoredOnboardingTargetingKey()).toBe('anon-3') + }) +}) diff --git a/frontend/common/utils/onboardingEntry.ts b/frontend/common/utils/onboardingEntry.ts index fcb6ed90c453..4e6f9e49ed57 100644 --- a/frontend/common/utils/onboardingEntry.ts +++ b/frontend/common/utils/onboardingEntry.ts @@ -55,6 +55,15 @@ export function persistOnboardingEntry( return variant } +// A variant stored earlier in the session wins over a new decision. A reload +// during onboarding logs in again without isGettingStarted, and must not send +// a single_page user to /create. +export const resolveOnboardingVariant = ( + stored: OnboardingVariant | null, + decision: OnboardingEntryDecision | null, +): OnboardingVariant => + stored ?? (decision ? persistOnboardingEntry(decision) : 'control') + export const getStoredOnboardingVariant = (): OnboardingVariant | null => { const variant = storageGet(VARIANT_STORAGE_KEY) return variant === 'single_page' || variant === 'control' ? variant : null diff --git a/frontend/e2e/config.ts b/frontend/e2e/config.ts index e7d3146d6fea..7cda72548101 100644 --- a/frontend/e2e/config.ts +++ b/frontend/e2e/config.ts @@ -1,5 +1,6 @@ const E2E_EMAIL_DOMAIN = 'flagsmithe2etestdomain.io' export const E2E_SIGN_UP_USER = `e2e_signup_user@${E2E_EMAIL_DOMAIN}` +export const E2E_ONBOARDING_RELOAD_USER = `e2e_onboarding_reload_user@${E2E_EMAIL_DOMAIN}` export const E2E_USER = `e2e_user@${E2E_EMAIL_DOMAIN}` export const E2E_NON_ADMIN_USER = `e2e_user@${E2E_EMAIL_DOMAIN}` //e2e_non_admin_user_with_project_permissions@flagsmithe2etestdomain.io diff --git a/frontend/e2e/tests/onboarding-tests.pw.ts b/frontend/e2e/tests/onboarding-tests.pw.ts index b0d3cf7258a9..7f7d87b130bf 100644 --- a/frontend/e2e/tests/onboarding-tests.pw.ts +++ b/frontend/e2e/tests/onboarding-tests.pw.ts @@ -1,6 +1,10 @@ import { test, expect } from '../test-setup'; import { byId, createHelpers, getFlagsmith, log, visualSnapshot } from '../helpers'; -import { E2E_SIGN_UP_USER, PASSWORD } from '../config'; +import { + E2E_ONBOARDING_RELOAD_USER, + E2E_SIGN_UP_USER, + PASSWORD, +} from '../config'; // The single-page onboarding flow (onboarding_quickstart_flow), at // /getting-started. Runs only when the flag is on (the legacy signup test runs @@ -182,4 +186,63 @@ test.describe('Onboarding', () => { await page.getByRole('button', { name: /Experiment/ }).click(); await expect(page).toHaveURL(/\/experiments$/); }); + + // Pins the variant instead of reading the real flag, so this runs whatever + // the experiment is set to. A reload before the organisation exists used to + // send the user to /create, and onboarding then made a second organisation. + test('A reload before the organisation exists keeps a new user on the onboarding flow @oss', async ({ + page, + }) => { + const { addErrorLogging, click, setText, waitForElementVisible } = + createHelpers(page); + await addErrorLogging(); + + // Flagsmith-on-Flagsmith requests carry the environment key header; the + // app's own API calls don't. + await page.route('**/identities/', async (route) => { + if (!route.request().headers()['x-environment-key']) { + return route.fallback(); + } + const response = await route.fetch(); + const json = await response.json(); + json.flags = (json.flags ?? []).map((flag) => + flag.feature?.name === 'onboarding_quickstart_flow' + ? { ...flag, enabled: true, variant: 'single_page' } + : flag, + ); + await route.fulfill({ json, response }); + }); + + // Fail the first organisation create, so the reload below happens while + // the user still has no organisation. + const createOrganisation = '**/api/v1/organisations/'; + await page.route(createOrganisation, (route) => + route.request().method() === 'POST' ? route.abort() : route.fallback(), + ); + + log('Sign up'); + await page.goto('/'); + await click(byId('jsSignup')); + await waitForElementVisible(byId('firstName')); + await setText(byId('firstName'), 'Bullet'); + await setText(byId('lastName'), 'Train'); + await setText(byId('email'), E2E_ONBOARDING_RELOAD_USER); + await setText(byId('password'), PASSWORD); + await click(byId('signup-btn')); + await page.waitForURL((url) => url.pathname === '/getting-started', { + timeout: 30000, + }); + + log('Reload before the organisation exists'); + await page.unroute(createOrganisation); + await page.reload(); + + await expect( + page.getByRole('heading', { name: /Welcome/ }), + ).toBeVisible({ timeout: 30000 }); + expect(new URL(page.url()).pathname).toBe('/getting-started'); + await expect( + page.getByRole('heading', { name: 'Create your organisation' }), + ).not.toBeVisible(); + }); }); diff --git a/frontend/web/components/App.js b/frontend/web/components/App.js index 58bbad3e30da..123afbc13aff 100644 --- a/frontend/web/components/App.js +++ b/frontend/web/components/App.js @@ -15,7 +15,7 @@ import ProjectStore from 'common/stores/project-store' import { decideOnboardingEntry, getStoredOnboardingVariant, - persistOnboardingEntry, + resolveOnboardingVariant, } from 'common/utils/onboardingEntry' import { AUTHORISE_PATH } from 'common/utils/pendingAuthorisation' import { Provider } from 'react-redux' @@ -163,8 +163,9 @@ const App = class extends Component { // targeting key, so bucketing never diverges from this decision. // Capped at 2s: a degraded flags API falls back to the legacy page // instead of blocking the redirect. + const storedVariant = getStoredOnboardingVariant() Promise.race([ - AccountStore.getUser()?.isGettingStarted + !storedVariant && AccountStore.getUser()?.isGettingStarted ? decideOnboardingEntry(AccountStore.getUser()?.email).catch( () => null, ) @@ -173,7 +174,7 @@ const App = class extends Component { ]).then((decision) => { // Only an accepted decision is persisted: a decision losing the // race must not store its assignment after routing has happened. - const variant = decision ? persistOnboardingEntry(decision) : 'control' + const variant = resolveOnboardingVariant(storedVariant, decision) // Restore the logged-in identity for the rest of the app. Promise.resolve(API.flagsmithIdentify()).catch(() => {}) if (variant === 'single_page') { diff --git a/frontend/web/components/pages/onboarding/hooks/useEnsureOnboardingResources.ts b/frontend/web/components/pages/onboarding/hooks/useEnsureOnboardingResources.ts index 574ae4f0f2bd..48c10eae9a67 100644 --- a/frontend/web/components/pages/onboarding/hooks/useEnsureOnboardingResources.ts +++ b/frontend/web/components/pages/onboarding/hooks/useEnsureOnboardingResources.ts @@ -30,7 +30,9 @@ export type OnboardingResources = { */ export const useEnsureOnboardingResources = (): OnboardingResources => { const { data: profile } = useGetProfileQuery({}) - const { data: organisations, isLoading: orgsLoading } = + // isFetching, not isLoading: after /create invalidates the list, the cached + // one is stale and would read as "no organisation". + const { data: organisations, isFetching: orgsFetching } = useGetOrganisationsQuery({}) const defaults = useSmartDefaults( profile?.email ?? '', @@ -55,7 +57,7 @@ export const useEnsureOnboardingResources = (): OnboardingResources => { useEffect(() => { // Run once, and only after the profile + organisations have loaded so the // reuse-vs-create decision is made against real data. - if (ranRef.current || !profile || orgsLoading) { + if (ranRef.current || !profile || orgsFetching) { return } ranRef.current = true @@ -83,7 +85,7 @@ export const useEnsureOnboardingResources = (): OnboardingResources => { setError(e) setStatus('error') }) - }, [profile, orgsLoading, organisations, selectedOrganisation, defaults]) + }, [profile, orgsFetching, organisations, selectedOrganisation, defaults]) return { caseSensitive, From fd3b40f87aa8dd0040beb7f789f4bf01dcbf5b03 Mon Sep 17 00:00:00 2001 From: Talisson Costa Date: Thu, 19 Nov 2026 09:46:15 -0300 Subject: [PATCH 2/3] fix(Onboarding): Label both experiment arms at the entry decision The onboarding_variant trait was set on /getting-started. Single-page users reach it straight after signup, but control users only after /create, so control users who left on /create were never labelled. Set it where the variant is resolved instead. Co-Authored-By: Claude Opus 5.5 --- frontend/web/components/App.js | 5 +++++ .../components/pages/onboarding/GettingStartedGate.tsx | 8 +------- 2 files changed, 6 insertions(+), 7 deletions(-) diff --git a/frontend/web/components/App.js b/frontend/web/components/App.js index 123afbc13aff..d9a28dab2ef4 100644 --- a/frontend/web/components/App.js +++ b/frontend/web/components/App.js @@ -175,6 +175,11 @@ const App = class extends Component { // Only an accepted decision is persisted: a decision losing the // race must not store its assignment after routing has happened. const variant = resolveOnboardingVariant(storedVariant, decision) + // Label both arms here, at the decision. On /getting-started, control + // was only labelled after /create, so its drop-offs were never counted. + if (storedVariant || decision) { + API.trackTraits({ onboarding_variant: variant }) + } // Restore the logged-in identity for the rest of the app. Promise.resolve(API.flagsmithIdentify()).catch(() => {}) if (variant === 'single_page') { diff --git a/frontend/web/components/pages/onboarding/GettingStartedGate.tsx b/frontend/web/components/pages/onboarding/GettingStartedGate.tsx index d786523e9856..ce06f862bf89 100644 --- a/frontend/web/components/pages/onboarding/GettingStartedGate.tsx +++ b/frontend/web/components/pages/onboarding/GettingStartedGate.tsx @@ -1,7 +1,6 @@ -import React, { FC, useEffect } from 'react' +import React, { FC } from 'react' import ConfigProvider from 'common/providers/ConfigProvider' import { getStoredOnboardingVariant } from 'common/utils/onboardingEntry' -import API from 'project/api' import GettingStartedPage from 'components/pages/GettingStartedPage' import OnboardingFlow from './OnboardingFlow' @@ -11,11 +10,6 @@ const GettingStartedGate: FC = () => { // legacy page. const variant = getStoredOnboardingVariant() - useEffect(() => { - if (!variant) return - API.trackTraits({ onboarding_variant: variant }) - }, [variant]) - return variant === 'single_page' ? : } From 1921d7385bab2c815293e24364496d5c89cb18ca Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Thu, 19 Nov 2026 13:01:48 +0000 Subject: [PATCH 3/3] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- api/e2etests/e2e_seed_data.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/api/e2etests/e2e_seed_data.py b/api/e2etests/e2e_seed_data.py index 8e4df8626dc0..fed44b387e11 100644 --- a/api/e2etests/e2e_seed_data.py +++ b/api/e2etests/e2e_seed_data.py @@ -65,9 +65,7 @@ def teardown() -> None: ) delete_user_and_its_organisations(user_email=settings.E2E_SEPARATE_TEST_USER) delete_user_and_its_organisations(user_email=settings.E2E_BILLING_USER) - delete_user_and_its_organisations( - user_email=settings.E2E_ONBOARDING_RELOAD_USER - ) + delete_user_and_its_organisations(user_email=settings.E2E_ONBOARDING_RELOAD_USER) def seed_data() -> None: