Skip to content

The Postgres development platform. Supabase gives you a dedicated Postgres database to build your web, mobile, and AI applications.

9.6 KB
Raw Blame
// @vitest-environment jsdom
import { renderHook } from '@testing-library/react'
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'

import {
  isInDataApiRevokeTreatment,
  useDataApiRevokeOnCreateDefaultEnabled,
  useTrackDefaultPrivilegesExposure,
} from '../useDataApiRevokeOnCreateDefault'
import { usePHFlag } from '@/hooks/ui/useFlag'
import * as constants from '@/lib/constants'
import { useTrack } from '@/lib/telemetry/track'

vi.mock('@/hooks/ui/useFlag', () => ({
  usePHFlag: vi.fn(),
}))

vi.mock('@/lib/constants', async () => {
  const actual = await vi.importActual<typeof import('@/lib/constants')>('@/lib/constants')
  return {
    ...actual,
    IS_TEST_ENV: false,
  }
})

vi.mock('@/lib/telemetry/track', () => ({
  useTrack: vi.fn(),
}))

describe('isInDataApiRevokeTreatment', () => {
  // `true` is the current rollout shape; 'test'/'control' the future multivariate shape.
  it.each([
    [true, true],
    ['test', true],
    [false, false],
    ['control', false],
    [undefined, false],
    ['something-else', false],
    ['', false],
  ])('maps flag %s to %s', (flag, expected) => {
    expect(isInDataApiRevokeTreatment(flag)).toBe(expected)
  })
})

// Flag-shape permutations are covered by isInDataApiRevokeTreatment above.
describe('useDataApiRevokeOnCreateDefaultEnabled', () => {
  afterEach(() => {
    vi.restoreAllMocks()
    vi.mocked(constants, { partial: true }).IS_TEST_ENV = false
  })

  it.each([
    [undefined, false],
    ['control', false],
    [true, true],
    ['test', true],
  ])('maps PostHog flag %s to %s', (flag, expected) => {
    vi.mocked(usePHFlag).mockReturnValue(flag)
    const { result } = renderHook(() => useDataApiRevokeOnCreateDefaultEnabled())
    expect(result.current).toBe(expected)
  })

  it('returns false in test env regardless of flag value', () => {
    vi.mocked(constants, { partial: true }).IS_TEST_ENV = true
    vi.mocked(usePHFlag).mockReturnValue(true)
    const { result } = renderHook(() => useDataApiRevokeOnCreateDefaultEnabled())
    expect(result.current).toBe(false)
  })
})

describe('useTrackDefaultPrivilegesExposure', () => {
  const track = vi.fn()

  beforeEach(() => {
    vi.mocked(useTrack).mockReturnValue(track)
  })

  it('does not fire while the flag is undefined', () => {
    vi.mocked(usePHFlag).mockReturnValue(undefined)
    renderHook(() =>
      useTrackDefaultPrivilegesExposure({
        surface: 'main',
        dataApiDefaultPrivileges: true,
        hasUserModified: false,
      })
    )
    expect(track).not.toHaveBeenCalled()
  })

  it('fires once when the flag resolves to true on the main surface', () => {
    vi.mocked(usePHFlag).mockReturnValue(true)
    renderHook(() =>
      useTrackDefaultPrivilegesExposure({
        surface: 'main',
        dataApiDefaultPrivileges: false,
        hasUserModified: false,
      })
    )
    expect(track).toHaveBeenCalledTimes(1)
    expect(track).toHaveBeenCalledWith(
      'project_creation_default_privileges_exposed',
      {
        surface: 'main',
        dataApiDefaultPrivileges: false,
        dataApiRevokeOnCreateDefaultEnabled: true,
      },
      undefined
    )
  })

  it('fires once when the flag resolves to false on the main surface', () => {
    vi.mocked(usePHFlag).mockReturnValue(false)
    renderHook(() =>
      useTrackDefaultPrivilegesExposure({
        surface: 'main',
        dataApiDefaultPrivileges: true,
        hasUserModified: false,
      })
    )
    expect(track).toHaveBeenCalledTimes(1)
    expect(track).toHaveBeenCalledWith(
      'project_creation_default_privileges_exposed',
      {
        surface: 'main',
        dataApiDefaultPrivileges: true,
        dataApiRevokeOnCreateDefaultEnabled: false,
      },
      undefined
    )
  })

  it('does not fire while the form value is stale relative to the flag (waits for sync)', () => {
    // Race: flag just resolved to true (treatment), but the caller-side sync
    // useEffect hasn't run yet, so the form value is still the legacy `true`.
    // Without the convergence gate, exposure would fire with the wrong value.
    vi.mocked(usePHFlag).mockReturnValue(true)
    renderHook(() =>
      useTrackDefaultPrivilegesExposure({
        surface: 'main',
        dataApiDefaultPrivileges: true,
        hasUserModified: false,
      })
    )
    expect(track).not.toHaveBeenCalled()
  })

  it('fires on the next render after the form syncs to match the flag', () => {
    vi.mocked(usePHFlag).mockReturnValue(true)
    const { rerender } = renderHook(
      ({ dataApiDefaultPrivileges }: { dataApiDefaultPrivileges: boolean }) =>
        useTrackDefaultPrivilegesExposure({
          surface: 'main',
          dataApiDefaultPrivileges,
          hasUserModified: false,
        }),
      { initialProps: { dataApiDefaultPrivileges: true } }
    )
    expect(track).not.toHaveBeenCalled()

    // Caller-side sync runs and updates the form value to !flag.
    rerender({ dataApiDefaultPrivileges: false })
    expect(track).toHaveBeenCalledTimes(1)
    expect(track).toHaveBeenCalledWith(
      'project_creation_default_privileges_exposed',
      expect.objectContaining({
        dataApiDefaultPrivileges: false,
        dataApiRevokeOnCreateDefaultEnabled: true,
      }),
      undefined
    )
  })

  it('fires immediately with the dirty value when the user has modified the field', () => {
    // User toggled the checkbox before the flag resolved, dirtying the field.
    // The sync gate is bypassed; exposure fires with the user's explicit value.
    vi.mocked(usePHFlag).mockReturnValue(true)
    renderHook(() =>
      useTrackDefaultPrivilegesExposure({
        surface: 'main',
        dataApiDefaultPrivileges: true, // form value disagrees with !flag=false
        hasUserModified: true,
      })
    )
    expect(track).toHaveBeenCalledTimes(1)
    expect(track).toHaveBeenCalledWith(
      'project_creation_default_privileges_exposed',
      {
        surface: 'main',
        dataApiDefaultPrivileges: true,
        dataApiRevokeOnCreateDefaultEnabled: true,
      },
      undefined
    )
  })

  it('fires on the vercel surface with the form-flag convergence gate', () => {
    vi.mocked(usePHFlag).mockReturnValue(true)
    renderHook(() =>
      useTrackDefaultPrivilegesExposure({
        surface: 'vercel',
        orgSlug: 'acme-org',
        dataApiDefaultPrivileges: false,
        hasUserModified: false,
      })
    )
    expect(track).toHaveBeenCalledWith(
      'project_creation_default_privileges_exposed',
      {
        surface: 'vercel',
        dataApiDefaultPrivileges: false,
        dataApiRevokeOnCreateDefaultEnabled: true,
      },
      { organization: 'acme-org' }
    )
  })

  it('skips emission on vercel surface when orgSlug is missing', () => {
    vi.mocked(usePHFlag).mockReturnValue(true)
    renderHook(() =>
      useTrackDefaultPrivilegesExposure({
        surface: 'vercel',
        orgSlug: undefined,
        dataApiDefaultPrivileges: false,
        hasUserModified: false,
      })
    )
    expect(track).not.toHaveBeenCalled()
  })

  it('deduplicates across re-renders', () => {
    vi.mocked(usePHFlag).mockReturnValue(true)
    const { rerender } = renderHook(() =>
      useTrackDefaultPrivilegesExposure({
        surface: 'main',
        dataApiDefaultPrivileges: false,
        hasUserModified: false,
      })
    )
    rerender()
    rerender()
    expect(track).toHaveBeenCalledTimes(1)
  })

  it('does not re-fire if the flag flips after initial exposure', () => {
    vi.mocked(usePHFlag).mockReturnValue(false)
    const { rerender } = renderHook(() =>
      useTrackDefaultPrivilegesExposure({
        surface: 'main',
        dataApiDefaultPrivileges: true,
        hasUserModified: false,
      })
    )
    vi.mocked(usePHFlag).mockReturnValue(true)
    rerender()
    expect(track).toHaveBeenCalledTimes(1)
    expect(track).toHaveBeenCalledWith(
      'project_creation_default_privileges_exposed',
      expect.objectContaining({ dataApiRevokeOnCreateDefaultEnabled: false }),
      undefined
    )
  })

  // The next two tests cover the future multivariate flag shape (GROWTH-877).
  // Today the flag returns boolean true/false; post-migration it returns the
  // variant string. The convergence gate must derive the expected default from
  // the variant, not from `!flag` directly — `!'control'` is false (truthy
  // string negation), which would have set the wrong expected default and
  // either skipped or mis-fired the exposure for control-arm users.

  it("fires for the 'test' variant with the correct convergence default (treatment)", () => {
    vi.mocked(usePHFlag).mockReturnValue('test')
    renderHook(() =>
      useTrackDefaultPrivilegesExposure({
        surface: 'main',
        dataApiDefaultPrivileges: false, // expected default for treatment
        hasUserModified: false,
      })
    )
    expect(track).toHaveBeenCalledTimes(1)
    expect(track).toHaveBeenCalledWith(
      'project_creation_default_privileges_exposed',
      {
        surface: 'main',
        dataApiDefaultPrivileges: false,
        dataApiRevokeOnCreateDefaultEnabled: 'test',
      },
      undefined
    )
  })

  it("fires for the 'control' variant with the correct convergence default (legacy)", () => {
    vi.mocked(usePHFlag).mockReturnValue('control')
    renderHook(() =>
      useTrackDefaultPrivilegesExposure({
        surface: 'main',
        dataApiDefaultPrivileges: true, // expected default for non-treatment
        hasUserModified: false,
      })
    )
    expect(track).toHaveBeenCalledTimes(1)
    expect(track).toHaveBeenCalledWith(
      'project_creation_default_privileges_exposed',
      {
        surface: 'main',
        dataApiDefaultPrivileges: true,
        dataApiRevokeOnCreateDefaultEnabled: 'control',
      },
      undefined
    )
  })
})