INTER-2348: Close coverage gaps and drop dead wait-until helper

__tests__/detect-env.test.ts

@@ -1,8 +1,14 @@
 import { detectEnvironment } from '../src/detect-env'
 import { Env } from '../src/env.types'
-import { describe, it, expect } from 'vitest'
+import { afterEach, describe, expect, it, vi } from 'vitest'
 
 describe('Detect user env', () => {
+  afterEach(() => {
+    document.getElementById('__NEXT_DATA__')?.remove()
+    Reflect.deleteProperty(window, 'next')
+    vi.restoreAllMocks()
+  })
+
   describe('Preact', () => {
     it('should detect preact if class components receive any arguments in render', () => {
       const env = detectEnvironment({
@@ -67,5 +73,89 @@ describe('Detect user env', () => {
         version,
       })
     })
+
+    it('should skip Next detection when window is unavailable', () => {
+      const originalWindow = globalThis.window
+      Object.defineProperty(globalThis, 'window', {
+        value: undefined,
+        configurable: true,
+      })
+
+      try {
+        const env = detectEnvironment({
+          context: { classRenderReceivesAnyArguments: false },
+        })
+
+        expect(env).toEqual({
+          name: Env.React,
+        })
+      } finally {
+        Object.defineProperty(globalThis, 'window', {
+          value: originalWindow,
+          configurable: true,
+          writable: true,
+        })
+      }
+    })
+  })
+})
+
+describe('getEnvironment', () => {
+  afterEach(() => {
+    vi.resetModules()
+    vi.doUnmock('../src/env')
+  })
+
+  it('returns parsed env details when the build-time env placeholder is valid JSON', async () => {
+    vi.resetModules()
+    vi.doMock('../src/env', () => ({
+      env: JSON.stringify({ name: 'react', version: '18.0.0' }),
+    }))
+
+    const { getEnvironment: getEnvironmentFresh } = await import('../src/get-env')
+
+    expect(
+      getEnvironmentFresh({
+        context: { classRenderReceivesAnyArguments: false },
+      })
+    ).toEqual({
+      name: 'react',
+      version: '18.0.0',
+    })
+  })
+
+  it('falls back to detection when the build-time env JSON is not env details', async () => {
+    vi.resetModules()
+    vi.doMock('../src/env', () => ({
+      env: JSON.stringify({ foo: 'bar' }),
+    }))
+
+    const { getEnvironment: getEnvironmentFresh } = await import('../src/get-env')
+
+    expect(
+      getEnvironmentFresh({
+        // absence of classRenderReceivesAnyArguments is React signal
+        context: { classRenderReceivesAnyArguments: false },
+      })
+    ).toEqual({
+      name: Env.React,
+    })
+  })
+
+  it('falls back to detection when the build-time env is invalid', async () => {
+    vi.resetModules()
+    vi.doMock('../src/env', () => ({
+      env: '%DETECTED_ENV%',
+    }))
+
+    const { getEnvironment: getEnvironmentFresh } = await import('../src/get-env')
+
+    expect(
+      getEnvironmentFresh({
+        context: { classRenderReceivesAnyArguments: false },
+      })
+    ).toEqual({
+      name: Env.React,
+    })
   })
 })

__tests__/fpjs-provider.test.tsx

@@ -1,16 +1,58 @@
-import { useContext } from 'react'
-import { renderHook } from '@testing-library/react'
-import { FingerprintContext } from '../src'
+import { PropsWithChildren, useContext } from 'react'
+import { act, render, renderHook } from '@testing-library/react'
+import { FingerprintContext, FingerprintProvider, FingerprintProviderOptions, useVisitorData } from '../src'
 import { createWrapper, getDefaultLoadOptions } from './helpers'
 import { version } from '../package.json'
-import { describe, it, expect, vi } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import * as agent from '@fingerprint/agent'
+import type { GetOptions } from '@fingerprint/agent'
+import * as ssr from '../src/ssr'
 
 vi.mock('@fingerprint/agent', { spy: true })
 
+const mockGet = vi.fn()
+const mockAgent = {
+  get: mockGet,
+  collect: vi.fn(),
+}
+
 const mockStart = vi.mocked(agent.start)
 
+type InternalFingerprintProviderOptions = FingerprintProviderOptions & {
+  customAgent?: Pick<typeof agent, 'start'>
+  getOptions?: GetOptions
+}
+
+const InternalFingerprintProvider = (props: PropsWithChildren<InternalFingerprintProviderOptions>) => (
+  <FingerprintProvider {...props} />
+)
+
+const renderProvider = (props: Partial<FingerprintProviderOptions> = {}) =>
+  render(
+    <FingerprintProvider {...getDefaultLoadOptions()} {...props}>
+      <div />
+    </FingerprintProvider>
+  )
+
 describe('FingerprintProvider', () => {
+  beforeEach(() => {
+    vi.resetAllMocks()
+    mockStart.mockReturnValue(mockAgent)
+    mockGet.mockResolvedValue({
+      visitor_id: 'visitor',
+      event_id: 'event',
+      sealed_result: null,
+      cache_hit: false,
+      suspect_score: 0,
+    })
+  })
+
+  afterEach(() => {
+    document.getElementById('__NEXT_DATA__')?.remove()
+    Reflect.deleteProperty(window, 'next')
+    vi.restoreAllMocks()
+  })
+
   it('should configure an instance of the Fp Agent', () => {
     const loadOptions = getDefaultLoadOptions()
     const wrapper = createWrapper({
@@ -33,4 +75,118 @@ describe('FingerprintProvider', () => {
       },
     })
   })
+
+  it('should include next version in integrationInfo when Next.js is detected', () => {
+    Object.assign(window, { next: { version: '14.2.0' } })
+
+    renderProvider()
+
+    expect(mockStart).toHaveBeenCalledWith(
+      expect.objectContaining({
+        integrationInfo: [`react-sdk/${version}/next/14.2.0`],
+      })
+    )
+  })
+
+  it('should rebuild the agent when forceRebuild is enabled and options change', () => {
+    const { rerender } = renderProvider({ apiKey: 'key-a', forceRebuild: true })
+
+    expect(mockStart).toHaveBeenCalledTimes(1)
+
+    rerender(
+      <FingerprintProvider apiKey='key-b' forceRebuild>
+        <div />
+      </FingerprintProvider>
+    )
+
+    expect(mockStart).toHaveBeenCalledTimes(2)
+    expect(mockStart).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        apiKey: 'key-b',
+      })
+    )
+  })
+
+  it('should not rebuild the agent when options change without forceRebuild', () => {
+    const { rerender } = renderProvider({ apiKey: 'key-a' })
+
+    expect(mockStart).toHaveBeenCalledTimes(1)
+
+    rerender(
+      <FingerprintProvider apiKey='key-b'>
+        <div />
+      </FingerprintProvider>
+    )
+
+    expect(mockStart).toHaveBeenCalledTimes(1)
+  })
+
+  it('should use customAgent.start when a valid custom agent loader is provided', async () => {
+    const customStart = vi.fn().mockReturnValue(mockAgent)
+    const wrapper = ({ children }: PropsWithChildren) => (
+      <InternalFingerprintProvider {...getDefaultLoadOptions()} customAgent={{ start: customStart }}>
+        {children}
+      </InternalFingerprintProvider>
+    )
+
+    const { result } = renderHook(() => useVisitorData({ immediate: false }), { wrapper })
+
+    await act(async () => {
+      await result.current.getData()
+    })
+
+    expect(customStart).toHaveBeenCalled()
+    expect(mockStart).not.toHaveBeenCalled()
+  })
+
+  it('should fall back to the default agent when customAgent is invalid', async () => {
+    const wrapper = ({ children }: PropsWithChildren) => (
+      <InternalFingerprintProvider
+        {...getDefaultLoadOptions()}
+        // @ts-expect-error intentionally invalid runtime shape
+        customAgent={{ start: 'not-a-function' }}
+      >
+        {children}
+      </InternalFingerprintProvider>
+    )
+
+    const { result } = renderHook(() => useVisitorData({ immediate: false }), { wrapper })
+
+    await act(async () => {
+      await result.current.getData()
+    })
+
+    expect(mockStart).toHaveBeenCalled()
+  })
+
+  it('should merge provider getOptions into visitor data requests', async () => {
+    const wrapper = ({ children }: PropsWithChildren) => (
+      <InternalFingerprintProvider
+        {...getDefaultLoadOptions()}
+        getOptions={{ linkedId: 'from-provider', tag: { source: 'provider' } }}
+      >
+        {children}
+      </InternalFingerprintProvider>
+    )
+
+    const { result } = renderHook(() => useVisitorData({ immediate: false }), { wrapper })
+
+    await act(async () => {
+      await result.current.getData({ tag: { source: 'getData' } })
+    })
+
+    expect(mockGet).toHaveBeenCalledWith({
+      linkedId: 'from-provider',
+      tag: { source: 'getData' },
+    })
+  })
+
+  it('should throw when the client is used during SSR', async () => {
+    vi.spyOn(ssr, 'isSSR').mockReturnValue(true)
+
+    const wrapper = createWrapper()
+    const { result } = renderHook(() => useVisitorData({ immediate: false }), { wrapper })
+
+    await expect(result.current.getData()).rejects.toThrow('FingerprintProvider client cannot be used in SSR')
+  })
 })