@strivacity/sdk-react 3.0.3 → 4.0.0-beta.0

package/testing/tests/guard.spec.tsx

@@ -0,0 +1,119 @@
+import type { RedirectFlow } from '../../src/types';
+import { describe, test, expect, vi, afterEach } from 'vitest';
+import { STRIVACITY_SDK, withAuthGuard } from '../../src/hooks';
+import { createMockFlow } from '@strivacity/testing/mocks/sdk';
+import { mount, cleanupMounts, flush, act, withContext } from '../utils/common';
+
+afterEach(() => {
+	cleanupMounts();
+});
+
+function Protected({ label }: { label: string }) {
+	return <div data-testid="protected">{label}</div>;
+}
+
+describe('withAuthGuard', () => {
+	test('renders nothing while the sdk is still loading', () => {
+		const sdk = createMockFlow<RedirectFlow>();
+		const Guarded = withAuthGuard(Protected);
+
+		const { container } = mount(
+			<STRIVACITY_SDK.Provider value={withContext(sdk, true)}>
+				<Guarded label="secret" />
+			</STRIVACITY_SDK.Provider>,
+		);
+
+		expect(container.textContent).toBe('');
+		expect(sdk.checkAuthentication).not.toHaveBeenCalled();
+	});
+
+	test('renders the given onLoading placeholder while loading', () => {
+		const sdk = createMockFlow<RedirectFlow>();
+		const Guarded = withAuthGuard(Protected, { onLoading: () => <div>loading…</div> });
+
+		const { container } = mount(
+			<STRIVACITY_SDK.Provider value={withContext(sdk, true)}>
+				<Guarded label="secret" />
+			</STRIVACITY_SDK.Provider>,
+		);
+
+		expect(container.textContent).toBe('loading…');
+	});
+
+	test('checks authentication through the sdk once loading finishes, and renders the wrapped component when authenticated', async () => {
+		const sdk = createMockFlow<RedirectFlow>({ checkAuthentication: vi.fn().mockResolvedValue(true) });
+		const Guarded = withAuthGuard(Protected);
+
+		const { container } = mount(
+			<STRIVACITY_SDK.Provider value={withContext(sdk, false)}>
+				<Guarded label="secret" />
+			</STRIVACITY_SDK.Provider>,
+		);
+		await flush();
+
+		expect(sdk.checkAuthentication).toHaveBeenCalledTimes(1);
+		expect(container.textContent).toBe('secret');
+	});
+
+	test('redirects to the default login URI when checkAuthentication resolves false', async () => {
+		const originalHref = globalThis.location.href;
+		const sdk = createMockFlow<RedirectFlow>({ checkAuthentication: vi.fn().mockResolvedValue(false) });
+		const Guarded = withAuthGuard(Protected);
+
+		mount(
+			<STRIVACITY_SDK.Provider value={withContext(sdk, false)}>
+				<Guarded label="secret" />
+			</STRIVACITY_SDK.Provider>,
+		);
+		await flush();
+
+		expect(globalThis.location.href).toContain('/login');
+
+		globalThis.location.href = originalHref;
+	});
+
+	test('redirects to a custom loginUri when configured', async () => {
+		const originalHref = globalThis.location.href;
+		const sdk = createMockFlow<RedirectFlow>({ checkAuthentication: vi.fn().mockResolvedValue(false) });
+		const Guarded = withAuthGuard(Protected, { loginUri: '/custom-login' });
+
+		mount(
+			<STRIVACITY_SDK.Provider value={withContext(sdk, false)}>
+				<Guarded label="secret" />
+			</STRIVACITY_SDK.Provider>,
+		);
+		await flush();
+
+		expect(globalThis.location.href).toContain('/custom-login');
+
+		globalThis.location.href = originalHref;
+	});
+
+	test('ignores a checkAuthentication result that resolves after the component has unmounted', async () => {
+		let resolveCheck!: (value: boolean) => void;
+		const sdk = createMockFlow<RedirectFlow>({
+			checkAuthentication: vi.fn(
+				() =>
+					new Promise<boolean>((resolve) => {
+						resolveCheck = resolve;
+					}),
+			),
+		});
+		const Guarded = withAuthGuard(Protected);
+
+		mount(
+			<STRIVACITY_SDK.Provider value={withContext(sdk, false)}>
+				<Guarded label="secret" />
+			</STRIVACITY_SDK.Provider>,
+		);
+		await flush();
+
+		cleanupMounts();
+
+		expect(() => {
+			act(() => {
+				resolveCheck(true);
+			});
+		}).not.toThrow();
+	});
+});

package/testing/tests/hooks.spec.tsx

@@ -0,0 +1,418 @@
+import type { SDKContext, LoginContext, UseNativeLoginOptions, NativeFlow, NativeFlowState, SessionData } from '../../src/types';
+import { describe, test, expect, vi, afterEach } from 'vitest';
+import { FallbackError } from '@strivacity/sdk-core/utils/errors';
+import { STRIVACITY_SDK, useStrivacity, useNativeLoginContext, useNativeLogin } from '../../src/hooks';
+import { createMockFlow } from '@strivacity/testing/mocks/sdk';
+import { mount, cleanupMounts, flush, act } from '../utils/common';
+
+afterEach(() => {
+	cleanupMounts();
+});
+
+function mountNativeLogin(sdk: NativeFlow, options: UseNativeLoginOptions = {}) {
+	let latest!: LoginContext;
+
+	function Probe() {
+		latest = useNativeLogin(options);
+		return null;
+	}
+
+	mount(
+		<STRIVACITY_SDK.Provider value={{ sdk } as unknown as SDKContext<NativeFlow>}>
+			<Probe />
+		</STRIVACITY_SDK.Provider>,
+	);
+
+	return { getLogin: () => latest };
+}
+
+describe('useStrivacity', () => {
+	test('throws when used outside of a Strivacity SDK provider', () => {
+		function Consumer() {
+			useStrivacity();
+			return null;
+		}
+
+		expect(() => mount(<Consumer />)).toThrow('Missing SDK context');
+	});
+
+	test('returns the context provided by the nearest STRIVACITY_SDK provider', () => {
+		const context = { sdk: {} } as unknown as SDKContext<NativeFlow>;
+		let received: SDKContext<NativeFlow> | undefined;
+
+		function Consumer() {
+			received = useStrivacity<NativeFlow>();
+			return null;
+		}
+
+		mount(
+			<STRIVACITY_SDK.Provider value={context}>
+				<Consumer />
+			</STRIVACITY_SDK.Provider>,
+		);
+
+		expect(received).toBe(context);
+	});
+});
+
+describe('useNativeLoginContext', () => {
+	test('returns the default context when no native login session is active', () => {
+		function Consumer() {
+			const ctx = useNativeLoginContext();
+			return <div data-testid="loading">{String(ctx.loading)}</div>;
+		}
+
+		const { container } = mount(<Consumer />);
+
+		expect(container.textContent).toBe('true');
+	});
+
+	test('resolves to the live context published by an active useNativeLogin call', async () => {
+		const sdk = createMockFlow<NativeFlow>();
+		vi.mocked(sdk.startSession).mockResolvedValue({ screen: 'identifier' });
+
+		let injectedLoading: string | undefined;
+
+		function Owner() {
+			useNativeLogin();
+			return null;
+		}
+		function Consumer() {
+			const ctx = useNativeLoginContext();
+			injectedLoading = String(ctx.loading);
+			return null;
+		}
+
+		mount(
+			<STRIVACITY_SDK.Provider value={{ sdk } as unknown as SDKContext<NativeFlow>}>
+				<Owner />
+				<Consumer />
+			</STRIVACITY_SDK.Provider>,
+		);
+		await flush();
+
+		expect(injectedLoading).toBe('false');
+	});
+
+	test('resets to the default context once the owning useNativeLogin component unmounts', async () => {
+		const sdk = createMockFlow<NativeFlow>();
+		vi.mocked(sdk.startSession).mockResolvedValue({ screen: 'identifier' });
+
+		function Owner() {
+			useNativeLogin();
+			return null;
+		}
+
+		mount(
+			<STRIVACITY_SDK.Provider value={{ sdk } as unknown as SDKContext<NativeFlow>}>
+				<Owner />
+			</STRIVACITY_SDK.Provider>,
+		);
+		await flush();
+
+		cleanupMounts();
+
+		function Consumer() {
+			const ctx = useNativeLoginContext();
+			return <div>{String(ctx.loading)}</div>;
+		}
+
+		const { container } = mount(<Consumer />);
+
+		expect(container.textContent).toBe('true');
+	});
+});
+
+describe('useNativeLogin', () => {
+	test('initializes the sdk and starts a session on mount, defaulting params to an empty object', async () => {
+		const sdk = createMockFlow<NativeFlow>();
+		mountNativeLogin(sdk);
+
+		await flush();
+
+		expect(sdk.init).toHaveBeenCalledTimes(1);
+		expect(sdk.startSession).toHaveBeenCalledWith({});
+	});
+
+	test('does nothing when there is no sdk instance yet', async () => {
+		let latest!: LoginContext;
+
+		function Probe() {
+			latest = useNativeLogin();
+			return null;
+		}
+
+		mount(
+			<STRIVACITY_SDK.Provider value={{ sdk: undefined } as unknown as SDKContext<NativeFlow>}>
+				<Probe />
+			</STRIVACITY_SDK.Provider>,
+		);
+		await flush();
+
+		expect(latest.loading).toBe(true);
+	});
+
+	test('routes an sdk.init() rejection to onError, logs it, and stops loading', async () => {
+		const sdk = createMockFlow<NativeFlow>();
+		const error = new Error('init failed');
+		vi.mocked(sdk.init).mockRejectedValue(error);
+		const onError = vi.fn();
+
+		const { getLogin } = mountNativeLogin(sdk, { onError });
+		await flush();
+
+		expect(onError).toHaveBeenCalledWith(error);
+		expect(sdk.logging!.error).toHaveBeenCalledWith('Error initializing SDK', error);
+		expect(getLogin().loading).toBe(false);
+		expect(sdk.startSession).not.toHaveBeenCalled();
+	});
+
+	test('forwards the given login params to sdk.startSession', async () => {
+		const sdk = createMockFlow<NativeFlow>();
+		mountNativeLogin(sdk, { params: { sessionId: 'session-1', language: 'hu-HU' } });
+
+		await flush();
+
+		expect(sdk.startSession).toHaveBeenCalledWith({ sessionId: 'session-1', language: 'hu-HU' });
+	});
+
+	test('is loading until sdk.startSession resolves with a state that has no pending finalizeUrl', async () => {
+		const sdk = createMockFlow<NativeFlow>();
+		vi.mocked(sdk.startSession).mockResolvedValue({ screen: 'identifier' });
+		const { getLogin } = mountNativeLogin(sdk);
+
+		expect(getLogin().loading).toBe(true);
+
+		await flush();
+
+		expect(getLogin().loading).toBe(false);
+	});
+
+	test('stays loading forever if sdk.startSession resolves with no state at all', async () => {
+		const sdk = createMockFlow<NativeFlow>();
+		vi.mocked(sdk.startSession).mockResolvedValue(undefined);
+		const { getLogin } = mountNativeLogin(sdk);
+
+		await flush();
+
+		expect(getLogin().loading).toBe(true);
+	});
+
+	test('keeps loading while a finalizeUrl is still pending', async () => {
+		const sdk = createMockFlow<NativeFlow>();
+		vi.mocked(sdk.startSession).mockResolvedValue({ finalizeUrl: 'https://brandtegrity.io/finalize' });
+		const { getLogin } = mountNativeLogin(sdk);
+
+		await flush();
+
+		expect(getLogin().loading).toBe(true);
+	});
+
+	test('applies the returned flow state: resets per-form data, routes the global message, and keeps per-widget messages', async () => {
+		const state: NativeFlowState = {
+			hostedUrl: 'https://brandtegrity.io/hosted',
+			screen: 'identifier',
+			forms: [{ id: 'form1', type: 'form', widgets: [] }],
+			messages: {
+				global: { type: 'info', text: 'Welcome' },
+				form1: { field1: { type: 'error', text: 'Required' } },
+			},
+		};
+		const sdk = createMockFlow<NativeFlow>();
+		vi.mocked(sdk.startSession).mockResolvedValue(state);
+		const onGlobalMessage = vi.fn();
+
+		const { getLogin } = mountNativeLogin(sdk, { onGlobalMessage });
+		await flush();
+
+		expect(onGlobalMessage).toHaveBeenCalledWith({ type: 'info', text: 'Welcome' });
+		expect(getLogin().forms).toEqual({ form1: {} });
+		expect(getLogin().messages).toEqual({ form1: { field1: { type: 'error', text: 'Required' } } });
+		expect(getLogin().state).toEqual(state);
+	});
+
+	test('calls onLogin and leaves the tracked state untouched when the sdk already has a session', async () => {
+		const session = { access_token: 'access-token' } as unknown as SessionData;
+		const sdk = createMockFlow<NativeFlow>({ session });
+		vi.mocked(sdk.startSession).mockResolvedValue({ screen: 'identifier' });
+		const onLogin = vi.fn();
+
+		const { getLogin } = mountNativeLogin(sdk, { onLogin });
+		await flush();
+
+		expect(onLogin).toHaveBeenCalledWith(session);
+		expect(getLogin().state).toEqual({});
+	});
+
+	test('routes a FallbackError from sdk.startSession to onFallback and logs it', async () => {
+		const sdk = createMockFlow<NativeFlow>();
+		const fallbackError = new FallbackError(new URL('https://brandtegrity.io/hosted'));
+		vi.mocked(sdk.startSession).mockRejectedValue(fallbackError);
+		const onFallback = vi.fn();
+
+		mountNativeLogin(sdk, { onFallback });
+		await flush();
+
+		expect(onFallback).toHaveBeenCalledWith(fallbackError);
+		expect(sdk.logging!.error).toHaveBeenCalledWith('Fallback error occurred', fallbackError);
+	});
+
+	test('routes a non-fallback error from sdk.startSession to onError and logs it', async () => {
+		const sdk = createMockFlow<NativeFlow>();
+		const error = new Error('network down');
+		vi.mocked(sdk.startSession).mockRejectedValue(error);
+		const onError = vi.fn();
+
+		mountNativeLogin(sdk, { onError });
+		await flush();
+
+		expect(onError).toHaveBeenCalledWith(error);
+		expect(sdk.logging!.error).toHaveBeenCalledWith('Error starting session', error);
+	});
+
+	describe('submitForm', () => {
+		test('unflattens the tracked form values and calls through to sdk.submitForm', async () => {
+			const sdk = createMockFlow<NativeFlow>();
+			const initialForms = [{ id: 'form1', type: 'form' as const, widgets: [] }];
+			vi.mocked(sdk.startSession).mockResolvedValue({ screen: 'identifier', forms: initialForms });
+			vi.mocked(sdk.submitForm).mockResolvedValue({ screen: 'done' });
+
+			const { getLogin } = mountNativeLogin(sdk);
+			await flush();
+
+			act(() => {
+				getLogin().setFormValue('form1', 'address.city', 'Budapest');
+				getLogin().setFormValue('form1', 'address.zip', '');
+			});
+
+			await act(async () => {
+				await getLogin().submitForm('form1');
+			});
+
+			expect(sdk.submitForm).toHaveBeenCalledWith('form1', { address: { city: 'Budapest', zip: null } });
+			expect(getLogin().state).toEqual({
+				hostedUrl: undefined,
+				finalizeUrl: undefined,
+				screen: 'done',
+				forms: initialForms,
+				layout: undefined,
+				messages: {},
+				branding: undefined,
+			});
+		});
+
+		test('uses a given custom body instead of the tracked form values', async () => {
+			const sdk = createMockFlow<NativeFlow>();
+			vi.mocked(sdk.submitForm).mockResolvedValue({ screen: 'done' });
+
+			const { getLogin } = mountNativeLogin(sdk);
+			await flush();
+
+			await act(async () => {
+				await getLogin().submitForm('form1', { raw: true });
+			});
+
+			expect(sdk.submitForm).toHaveBeenCalledWith('form1', { raw: true });
+		});
+
+		test('routes a FallbackError to onFallback', async () => {
+			const sdk = createMockFlow<NativeFlow>();
+			const fallbackError = new FallbackError(new URL('https://brandtegrity.io/hosted'));
+			vi.mocked(sdk.submitForm).mockRejectedValue(fallbackError);
+			const onFallback = vi.fn();
+
+			const { getLogin } = mountNativeLogin(sdk, { onFallback });
+			await flush();
+
+			await act(async () => {
+				await getLogin().submitForm('form1');
+			});
+
+			expect(onFallback).toHaveBeenCalledWith(fallbackError);
+			expect(sdk.logging!.error).toHaveBeenCalledWith('Fallback error occurred', fallbackError);
+		});
+
+		test('routes a non-fallback error to onError', async () => {
+			const sdk = createMockFlow<NativeFlow>();
+			const error = new Error('submit failed');
+			vi.mocked(sdk.submitForm).mockRejectedValue(error);
+			const onError = vi.fn();
+
+			const { getLogin } = mountNativeLogin(sdk, { onError });
+			await flush();
+
+			await act(async () => {
+				await getLogin().submitForm('form1');
+			});
+
+			expect(onError).toHaveBeenCalledWith(error);
+			expect(sdk.logging!.error).toHaveBeenCalledWith('Error submitting form', error);
+		});
+	});
+
+	test('setFormValue coerces empty strings to null and lazily creates the form bucket', async () => {
+		const sdk = createMockFlow<NativeFlow>();
+		const { getLogin } = mountNativeLogin(sdk);
+		await flush();
+
+		act(() => {
+			getLogin().setFormValue('newForm', 'field', 'value');
+		});
+		act(() => {
+			getLogin().setFormValue('newForm', 'other', '');
+		});
+
+		expect(getLogin().forms.newForm).toEqual({ field: 'value', other: null });
+	});
+
+	test('setMessage lazily creates the message bucket for a form', async () => {
+		const sdk = createMockFlow<NativeFlow>();
+		const { getLogin } = mountNativeLogin(sdk);
+		await flush();
+
+		act(() => {
+			getLogin().setMessage('newForm', 'field', { type: 'error', text: 'Required' });
+		});
+
+		expect(getLogin().messages.newForm).toEqual({ field: { type: 'error', text: 'Required' } });
+	});
+
+	describe('triggerFallback', () => {
+		test('throws when no hosted URL is known yet', async () => {
+			const sdk = createMockFlow<NativeFlow>();
+			vi.mocked(sdk.startSession).mockResolvedValue({ screen: 'identifier' });
+			const { getLogin } = mountNativeLogin(sdk);
+			await flush();
+
+			expect(() => getLogin().triggerFallback()).toThrow('No hosted URL provided');
+			expect(sdk.logging!.error).toHaveBeenCalledWith('Fallback error', expect.any(Error));
+		});
+
+		test('calls onFallback with a FallbackError built from the known hosted URL', async () => {
+			const sdk = createMockFlow<NativeFlow>();
+			vi.mocked(sdk.startSession).mockResolvedValue({ hostedUrl: 'https://brandtegrity.io/hosted', screen: 'identifier' });
+			const onFallback = vi.fn();
+
+			const { getLogin } = mountNativeLogin(sdk, { onFallback });
+			await flush();
+
+			getLogin().triggerFallback('manual trigger');
+
+			expect(sdk.logging!.warn).toHaveBeenCalledWith('Triggering fallback due to: manual trigger');
+			expect(onFallback).toHaveBeenCalledWith(expect.any(FallbackError));
+			expect((onFallback.mock.calls[0][0] as FallbackError).url.toString()).toBe('https://brandtegrity.io/hosted');
+		});
+	});
+
+	test('triggerClose calls onClose and logs', async () => {
+		const sdk = createMockFlow<NativeFlow>();
+		const onClose = vi.fn();
+		const { getLogin } = mountNativeLogin(sdk, { onClose });
+		await flush();
+
+		getLogin().triggerClose();
+
+		expect(onClose).toHaveBeenCalledTimes(1);
+		expect(sdk.logging!.debug).toHaveBeenCalledWith('Triggering close');
+	});
+});

package/testing/tests/index.spec.ts

@@ -0,0 +1,105 @@
+import { test, expect } from 'vitest';
+import * as index from '../../src/index';
+
+test('should export the correct things', () => {
+	const expectedExports = [
+		'createBaseFlow',
+		'createEmbeddedFlow',
+		'createNativeFlow',
+		'createPopupFlow',
+		'createRedirectFlow',
+		'popupCallbackHandler',
+		'popupUrlHandler',
+		'redirectCallbackHandler',
+		'redirectUrlHandler',
+		'BACKCHANNEL_LOGOUT_EVENT',
+		'ConfigurationError',
+		'DEFAULT_COOKIE_MAX_AGE',
+		'DISALLOWED_PROXY_HEADERS',
+		'FallbackError',
+		'InternalError',
+		'NetworkError',
+		'OidcError',
+		'PopupBlockedError',
+		'PopupClosedError',
+		'ProtocolError',
+		'RETURN_TO_COOKIE',
+		'ServerError',
+		'SessionExpiredError',
+		'UnsupportedFlowError',
+		'assertWebAuthnCredential',
+		'buildAuthorizationUrl',
+		'buildCookieString',
+		'buildEndSessionUrl',
+		'createDefaultLogging',
+		'createHttpClient',
+		'createSession',
+		'createState',
+		'createWebAuthnCredential',
+		'decodeBase64URL',
+		'decodeJwt',
+		'decryptString',
+		'defaultOptions',
+		'encodeBase64URL',
+		'encryptString',
+		'exchangeCode',
+		'fetchFlowEntry',
+		'finalizeLoginSession',
+		'flushSetCookies',
+		'generateCodeChallenge',
+		'generateCodeVerifier',
+		'generateJwt',
+		'generateRandomHex',
+		'getDefaultFlowState',
+		'getDiscoveryDocument',
+		'getSDKOptions',
+		'getServerSDKOptions',
+		'injectScript',
+		'isSessionExpired',
+		'loadSession',
+		'parseCookieHeader',
+		'parseState',
+		'proxyResponse',
+		'pushSetCookie',
+		'refreshToken',
+		'revokeToken',
+		'serializeCookie',
+		'serializeSession',
+		'serializeState',
+		'submitLoginForm',
+		'throwHttpError',
+		'throwTokenEndpointError',
+		'timestamp',
+		'toSafeRedirect',
+		'unflattenObject',
+		'verifyIdToken',
+		'verifyJwt',
+		'StyAuthProvider',
+		'STRIVACITY_SDK',
+		'useNativeLoginContext',
+		'useStrivacity',
+		'useNativeLogin',
+		'withAuthGuard',
+		'COOKIE_CHUNK_SIZE',
+		'COOKIE_CONTEXT',
+		'createCacheAPIStorage',
+		'createEncryptedCookieStorage',
+		'createIndexedDBStorage',
+		'createLocalStorage',
+		'createMemoryStorage',
+		'createServerMemoryStorage',
+		'createServerStateStorage',
+		'createSessionIdCookieStorage',
+		'createSessionStorage',
+		'createWorkerStorage',
+		'handleWorkerStorageRequests',
+		'AlgorithmTypeList',
+		'GrantTypeList',
+		'ResponseModeList',
+		'ResponseTypeList',
+		'SubjectTypeList',
+		'TokenEndpointAuthMethodList',
+	];
+
+	expect(Object.keys(index)).toEqual(expectedExports);
+});

package/testing/tests/storages.spec.ts

@@ -0,0 +1,10 @@
+import { test, expect } from 'vitest';
+import * as reactStorages from '../../src/storages';
+import * as coreStorages from '@strivacity/sdk-core/storages';
+
+test('re-exports storages from the core sdk', () => {
+	const coreKeys = Object.keys(coreStorages);
+
+	expect(coreKeys.length).toBeGreaterThan(0);
+	expect(Object.keys(reactStorages).sort()).toEqual(coreKeys.sort());
+});

package/testing/tests/utils.spec.ts

@@ -0,0 +1,10 @@
+import { test, expect } from 'vitest';
+import * as reactUtils from '../../src/utils';
+import * as coreUtils from '@strivacity/sdk-core/utils';
+
+test('re-exports utility from the core sdk', () => {
+	const coreKeys = Object.keys(coreUtils);
+
+	expect(coreKeys.length).toBeGreaterThan(0);
+	expect(Object.keys(reactUtils).sort()).toEqual(coreKeys.sort());
+});