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..fed44b387e11 100644 --- a/api/e2etests/e2e_seed_data.py +++ b/api/e2etests/e2e_seed_data.py @@ -65,6 +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) 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..d9a28dab2ef4 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,12 @@ 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) + // 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' ? : } 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,