@strivacity/sdk-angular 3.0.2 → 4.0.0-beta.0

package/testing/tests/native-login.service.spec.ts

@@ -0,0 +1,311 @@
+import type { NativeFlow, NativeFlowState, SessionData } from '../../src/types';
+import { inject } from '@angular/core';
+import { TestBed } from '@angular/core/testing';
+import { describe, test, expect, vi, beforeEach } from 'vitest';
+import { initFlow } from '@strivacity/sdk-core';
+import { FallbackError } from '@strivacity/sdk-core/utils/errors';
+import { StrivacityAuthService } from '../../src/lib/services/auth.service';
+import { StrivacityNativeLoginService } from '../../src/lib/services/native-login.service';
+import { STRIVACITY_SDK } from '../../src/lib/utils';
+import { createMockFlow, createOptions } from '@strivacity/testing/mocks/sdk';
+import { mountWithProviders } from '../utils/testbed';
+
+vi.mock('@strivacity/sdk-core', async (importOriginal) => ({
+	...(await importOriginal<typeof import('@strivacity/sdk-core')>()),
+	initFlow: vi.fn(),
+}));
+
+function configure(flow: NativeFlow): StrivacityNativeLoginService {
+	vi.mocked(initFlow).mockReturnValue(flow);
+
+	TestBed.configureTestingModule({
+		providers: [{ provide: STRIVACITY_SDK, useValue: createOptions({ mode: 'native' }) }, StrivacityAuthService, StrivacityNativeLoginService],
+	});
+
+	return TestBed.inject(StrivacityNativeLoginService);
+}
+
+beforeEach(() => {
+	vi.mocked(initFlow).mockReset();
+});
+
+describe('StrivacityNativeLoginService', () => {
+	describe('start', () => {
+		test('initializes the sdk and starts a session, defaulting params to an empty object', async () => {
+			const flow = createMockFlow<NativeFlow>();
+			const login = configure(flow);
+
+			await login.start();
+
+			expect(flow.init).toHaveBeenCalledTimes(1);
+			expect(flow.startSession).toHaveBeenCalledWith({});
+		});
+
+		test('forwards the given login params to sdk.startSession', async () => {
+			const flow = createMockFlow<NativeFlow>();
+			const login = configure(flow);
+
+			await login.start({ params: { sessionId: 'session-1', language: 'hu-HU' } });
+
+			expect(flow.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 flow = createMockFlow<NativeFlow>();
+			vi.mocked(flow.startSession).mockResolvedValue({ screen: 'identifier' });
+			const login = configure(flow);
+
+			const pending = login.start();
+
+			expect(login.loading()).toBe(true);
+
+			await pending;
+
+			expect(login.loading()).toBe(false);
+		});
+
+		test('stays loading forever if sdk.startSession resolves with no state at all', async () => {
+			const flow = createMockFlow<NativeFlow>();
+			vi.mocked(flow.startSession).mockResolvedValue(undefined);
+			const login = configure(flow);
+
+			await login.start();
+
+			expect(login.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 flow = createMockFlow<NativeFlow>();
+			vi.mocked(flow.startSession).mockResolvedValue(state);
+			const onGlobalMessage = vi.fn();
+			const login = configure(flow);
+
+			await login.start({ onGlobalMessage });
+
+			expect(onGlobalMessage).toHaveBeenCalledWith({ type: 'info', text: 'Welcome' });
+			expect(login.forms()).toEqual({ form1: {} });
+			expect(login.messages()).toEqual({ form1: { field1: { type: 'error', text: 'Required' } } });
+			expect(login.state()).toEqual(state);
+		});
+
+		test('keeps loading while a finalizeUrl is still pending', async () => {
+			const flow = createMockFlow<NativeFlow>();
+			vi.mocked(flow.startSession).mockResolvedValue({ finalizeUrl: 'https://brandtegrity.io/finalize' });
+			const login = configure(flow);
+
+			await login.start();
+
+			expect(login.loading()).toBe(true);
+		});
+
+		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 flow = createMockFlow<NativeFlow>({ session });
+			vi.mocked(flow.startSession).mockResolvedValue({ screen: 'identifier' });
+			const onLogin = vi.fn();
+			const login = configure(flow);
+
+			await login.start({ onLogin });
+
+			expect(onLogin).toHaveBeenCalledWith(session);
+			expect(login.state()).toEqual({});
+		});
+
+		test('routes a FallbackError from sdk.startSession to onFallback and logs it', async () => {
+			const flow = createMockFlow<NativeFlow>();
+			const fallbackError = new FallbackError(new URL('https://brandtegrity.io/hosted'));
+			vi.mocked(flow.startSession).mockRejectedValue(fallbackError);
+			const onFallback = vi.fn();
+			const login = configure(flow);
+
+			await login.start({ onFallback });
+
+			expect(onFallback).toHaveBeenCalledWith(fallbackError);
+			expect(flow.logging!.error).toHaveBeenCalledWith('Fallback error occurred', fallbackError);
+			expect(login.loading()).toBe(true);
+		});
+
+		test('routes a non-fallback error from sdk.startSession to onError and logs it', async () => {
+			const flow = createMockFlow<NativeFlow>();
+			const error = new Error('network down');
+			vi.mocked(flow.startSession).mockRejectedValue(error);
+			const onError = vi.fn();
+			const login = configure(flow);
+
+			await login.start({ onError });
+
+			expect(onError).toHaveBeenCalledWith(error);
+			expect(flow.logging!.error).toHaveBeenCalledWith('Error starting session', error);
+			// startSession() has its own catch-all and never rethrows, so start()'s "set loading false on error" branch never runs for this path
+			expect(login.loading()).toBe(true);
+		});
+
+		test('propagates a rejection from sdk.init() as-is, since only the startSession() call is guarded by the try/catch', async () => {
+			// the AbortError short-circuit in start()'s own catch guards `this.startSession(...)`, not `await this.sdk.init()`
+			// above it - startSession() also swallows every error itself (including AbortError) and reports it through onError,
+			// so that branch is unreachable via a mocked flow; a rejecting init() is the one thing genuinely uncaught here.
+			const flow = createMockFlow<NativeFlow>();
+			const abortError = new DOMException('The operation was aborted', 'AbortError');
+			vi.mocked(flow.init).mockRejectedValue(abortError);
+			const onError = vi.fn();
+			const login = configure(flow);
+
+			await expect(login.start({ onError })).rejects.toBe(abortError);
+
+			expect(onError).not.toHaveBeenCalled();
+			expect(flow.startSession).not.toHaveBeenCalled();
+		});
+	});
+
+	describe('submitForm', () => {
+		test('unflattens the tracked form values and calls through to sdk.submitForm', async () => {
+			const flow = createMockFlow<NativeFlow>();
+			const initialForms = [{ id: 'form1', type: 'form' as const, widgets: [] }];
+			vi.mocked(flow.startSession).mockResolvedValue({ screen: 'identifier', forms: initialForms });
+			vi.mocked(flow.submitForm).mockResolvedValue({ screen: 'done' });
+			const login = configure(flow);
+
+			await login.start();
+
+			login.setFormValue('form1', 'address.city', 'Budapest');
+			login.setFormValue('form1', 'address.zip', '');
+
+			await login.submitForm('form1');
+
+			expect(flow.submitForm).toHaveBeenCalledWith('form1', { address: { city: 'Budapest', zip: null } });
+			// unspecified fields on the new state fall back to what was already tracked (except messages, which always resets)
+			expect(login.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 flow = createMockFlow<NativeFlow>();
+			vi.mocked(flow.submitForm).mockResolvedValue({ screen: 'done' });
+			const login = configure(flow);
+			await login.start();
+
+			await login.submitForm('form1', { raw: true });
+
+			expect(flow.submitForm).toHaveBeenCalledWith('form1', { raw: true });
+		});
+
+		test('routes a FallbackError to onFallback', async () => {
+			const flow = createMockFlow<NativeFlow>();
+			const fallbackError = new FallbackError(new URL('https://brandtegrity.io/hosted'));
+			vi.mocked(flow.submitForm).mockRejectedValue(fallbackError);
+			const onFallback = vi.fn();
+			const login = configure(flow);
+			await login.start({ onFallback });
+
+			await login.submitForm('form1');
+
+			expect(onFallback).toHaveBeenCalledWith(fallbackError);
+			expect(flow.logging!.error).toHaveBeenCalledWith('Fallback error occurred', fallbackError);
+		});
+
+		test('routes a non-fallback error to onError', async () => {
+			const flow = createMockFlow<NativeFlow>();
+			const error = new Error('submit failed');
+			vi.mocked(flow.submitForm).mockRejectedValue(error);
+			const onError = vi.fn();
+			const login = configure(flow);
+			await login.start({ onError });
+
+			await login.submitForm('form1');
+
+			expect(onError).toHaveBeenCalledWith(error);
+			expect(flow.logging!.error).toHaveBeenCalledWith('Error submitting form', error);
+		});
+	});
+
+	test('setFormValue coerces empty strings to null and lazily creates the form bucket', async () => {
+		const flow = createMockFlow<NativeFlow>();
+		const login = configure(flow);
+		await login.start();
+
+		login.setFormValue('newForm', 'field', 'value');
+		login.setFormValue('newForm', 'other', '');
+
+		expect(login.forms().newForm).toEqual({ field: 'value', other: null });
+	});
+
+	test('setMessage lazily creates the message bucket for a form', async () => {
+		const flow = createMockFlow<NativeFlow>();
+		const login = configure(flow);
+		await login.start();
+
+		login.setMessage('newForm', 'field', { type: 'error', text: 'Required' });
+
+		expect(login.messages().newForm).toEqual({ field: { type: 'error', text: 'Required' } });
+	});
+
+	describe('triggerFallback', () => {
+		test('throws when no hosted URL is known yet', async () => {
+			const flow = createMockFlow<NativeFlow>();
+			vi.mocked(flow.startSession).mockResolvedValue({ screen: 'identifier' });
+			const login = configure(flow);
+			await login.start();
+
+			expect(() => login.triggerFallback()).toThrow('No hosted URL provided');
+			expect(flow.logging!.error).toHaveBeenCalledWith('Fallback error', expect.any(Error));
+		});
+
+		test('calls onFallback with a FallbackError built from the known hosted URL', async () => {
+			const flow = createMockFlow<NativeFlow>();
+			vi.mocked(flow.startSession).mockResolvedValue({ hostedUrl: 'https://brandtegrity.io/hosted', screen: 'identifier' });
+			const onFallback = vi.fn();
+			const login = configure(flow);
+			await login.start({ onFallback });
+
+			login.triggerFallback('manual trigger');
+
+			expect(flow.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 flow = createMockFlow<NativeFlow>();
+		const onClose = vi.fn();
+		const login = configure(flow);
+		await login.start({ onClose });
+
+		login.triggerClose();
+
+		expect(onClose).toHaveBeenCalledTimes(1);
+		expect(flow.logging!.debug).toHaveBeenCalledWith('Triggering close');
+	});
+
+	test('aborts the in-flight abort controller when the owning injector is destroyed', () => {
+		const flow = createMockFlow<NativeFlow>();
+		vi.mocked(initFlow).mockReturnValue(flow);
+		TestBed.configureTestingModule({ providers: [{ provide: STRIVACITY_SDK, useValue: createOptions({ mode: 'native' }) }, StrivacityAuthService] });
+
+		const abortSpy = vi.spyOn(AbortController.prototype, 'abort');
+
+		// both services must live on the component's own injector for fixture.destroy() to fire their DestroyRef callbacks
+		const { destroy } = mountWithProviders([StrivacityAuthService, StrivacityNativeLoginService], () => inject(StrivacityNativeLoginService));
+
+		destroy();
+
+		expect(abortSpy).toHaveBeenCalledTimes(1);
+		abortSpy.mockRestore();
+	});
+});

package/testing/tests/server/errors.spec.ts

@@ -0,0 +1,14 @@
+import { test, expect } from 'vitest';
+import * as angularErrors from '../../../src/server/errors';
+import * as coreErrors from '@strivacity/sdk-core/utils/errors';
+
+test('re-exports error classes from the core sdk', () => {
+	const coreKeys = Object.keys(coreErrors);
+
+	expect(coreKeys.length).toBeGreaterThan(0);
+	expect(Object.keys(angularErrors).sort()).toEqual(coreKeys.sort());
+
+	for (const key of coreKeys) {
+		expect(angularErrors[key as keyof typeof angularErrors]).toBe(coreErrors[key as keyof typeof coreErrors]);
+	}
+});

package/testing/tests/server/sdk.spec.ts

@@ -0,0 +1,197 @@
+import type { Router } from 'express';
+import type { AngularServerRequest } from '../../../src/server/types';
+import { describe, test, expect, vi, beforeEach } from 'vitest';
+import { createBaseServerSDK } from '@strivacity/sdk-core/server';
+import { applyResponse } from '../../../src/server/utils';
+import { createServerSDK } from '../../../src/server/sdk';
+import { createServerOptions } from '@strivacity/testing/mocks/sdk';
+
+vi.mock('@strivacity/sdk-core/server', async (importOriginal) => ({
+	...(await importOriginal<typeof import('@strivacity/sdk-core/server')>()),
+	createBaseServerSDK: vi.fn(),
+}));
+
+vi.mock('../../../src/server/utils', async (importOriginal) => ({
+	...(await importOriginal<typeof import('../../../src/server/utils')>()),
+	applyResponse: vi.fn().mockResolvedValue(undefined),
+}));
+
+function createBase() {
+	return {
+		options: { clientId: 'client-id' },
+		getSession: vi.fn().mockResolvedValue(null),
+		updateSession: vi.fn().mockResolvedValue(undefined),
+		refreshSession: vi.fn().mockResolvedValue({ access_token: 'refreshed' }),
+		revokeSession: vi.fn().mockResolvedValue(undefined),
+		getEntrySession: vi.fn().mockResolvedValue({ sessionId: 'session-1' }),
+		completeLogin: vi.fn().mockResolvedValue({ access_token: 'access-token' }),
+		logout: vi.fn().mockResolvedValue(undefined),
+		handleLogin: vi.fn(),
+		handleRegister: vi.fn(),
+		handleCallback: vi.fn(),
+		handleRefresh: vi.fn(),
+		handleRevoke: vi.fn(),
+		handleEntry: vi.fn(),
+		handleLogout: vi.fn(),
+		handleBackChannelLogout: vi.fn(),
+		handler: vi.fn().mockResolvedValue(new Response(null)),
+	};
+}
+
+function getRouteHandler(router: Router, method: string, path: string) {
+	const layer = (
+		router.stack as Array<{ route?: { path: string; methods: Record<string, boolean>; stack: Array<{ handle: (...args: Array<unknown>) => unknown }> } }>
+	).find((candidate) => candidate.route?.path === path && candidate.route.methods[method]);
+
+	if (!layer?.route) {
+		throw new Error(`No ${method.toUpperCase()} ${path} route registered`);
+	}
+
+	return layer.route.stack[0].handle as (req: unknown, res: unknown, next: (error?: unknown) => void) => Promise<void>;
+}
+
+beforeEach(() => {
+	vi.mocked(createBaseServerSDK).mockReset();
+	vi.mocked(applyResponse).mockClear();
+});
+
+describe('createServerSDK', () => {
+	test('creates the base server sdk with a toRequest adapter that converts Express requests to standard Requests, and the given config', () => {
+		const base = createBase();
+		vi.mocked(createBaseServerSDK).mockReturnValue(base as never);
+		const initConfig = createServerOptions();
+
+		createServerSDK(initConfig);
+
+		expect(createBaseServerSDK).toHaveBeenCalledTimes(1);
+		const [adapter, forwardedConfig] = vi.mocked(createBaseServerSDK).mock.calls[0];
+
+		expect(forwardedConfig).toBe(initConfig);
+
+		const req = {
+			originalUrl: '/callback?code=abc',
+			protocol: 'https',
+			method: 'GET',
+			headers: {},
+			get: () => 'brandtegrity.io',
+		} as unknown as AngularServerRequest;
+		const webRequest = adapter.toRequest(req);
+
+		expect(webRequest.url).toBe('https://brandtegrity.io/callback?code=abc');
+	});
+
+	test('passes an already-standard Request straight through the toRequest adapter', () => {
+		const base = createBase();
+		vi.mocked(createBaseServerSDK).mockReturnValue(base as never);
+		createServerSDK(createServerOptions());
+
+		const [adapter] = vi.mocked(createBaseServerSDK).mock.calls[0];
+		const request = new Request('https://brandtegrity.io');
+
+		expect(adapter.toRequest(request)).toBe(request);
+	});
+
+	test('exposes the underlying options', () => {
+		const base = createBase();
+		vi.mocked(createBaseServerSDK).mockReturnValue(base as never);
+
+		const sdk = createServerSDK(createServerOptions());
+
+		expect(sdk.options).toBe(base.options);
+	});
+
+	test.each([
+		['getSession', [{} as never], null],
+		['updateSession', [{ access_token: 'a' } as never, {} as never], undefined],
+		['refreshSession', [{} as never], { access_token: 'refreshed' }],
+		['revokeSession', [{} as never], undefined],
+		['getEntrySession', ['https://brandtegrity.io/entry'], { sessionId: 'session-1' }],
+		['completeLogin', [{ code: 'abc' }, {} as never], { access_token: 'access-token' }],
+		['logout', ['https://brandtegrity.io', {} as never], undefined],
+		['handleLogin', [{} as never], new Response(null)],
+		['handleRegister', [{} as never], new Response(null)],
+		['handleCallback', [{} as never], new Response(null)],
+		['handleRefresh', [{} as never], new Response(null)],
+		['handleRevoke', [{} as never], new Response(null)],
+		['handleEntry', [{} as never], new Response(null)],
+		['handleLogout', [{} as never], new Response(null)],
+		['handleBackChannelLogout', [{} as never], new Response(null)],
+	] as const)('%s calls through to the base server sdk with the same arguments and return value', async (method, args) => {
+		const base = createBase();
+		vi.mocked(createBaseServerSDK).mockReturnValue(base as never);
+		const sdk = createServerSDK(createServerOptions());
+
+		const result = await (sdk[method as keyof typeof sdk] as (...a: Array<unknown>) => unknown)(...args);
+		const baseMock = base[method as keyof typeof base] as ReturnType<typeof vi.fn>;
+
+		expect(baseMock).toHaveBeenCalledWith(...args);
+		expect(result).toEqual(await baseMock.mock.results[0].value);
+	});
+
+	test('handler calls through to the base server sdk', async () => {
+		const base = createBase();
+		vi.mocked(createBaseServerSDK).mockReturnValue(base as never);
+		const sdk = createServerSDK(createServerOptions());
+		const req = {} as AngularServerRequest;
+
+		const result = await sdk.handler(req);
+
+		expect(base.handler).toHaveBeenCalledWith(req);
+		expect(result).toBe(await base.handler.mock.results[0].value);
+	});
+
+	describe('handlers router', () => {
+		test.each([
+			['GET', '/login', 'handleLogin'],
+			['GET', '/register', 'handleRegister'],
+			['GET', '/callback', 'handleCallback'],
+			['GET', '/refresh', 'handleRefresh'],
+			['GET', '/revoke', 'handleRevoke'],
+			['GET', '/entry', 'handleEntry'],
+			['GET', '/logout', 'handleLogout'],
+			['POST', '/backchannel-logout', 'handleBackChannelLogout'],
+		] as const)('%s %s calls base.%s with the request and applies the resulting response', async (method, path, baseMethod) => {
+			const base = createBase();
+			const response = new Response(null, { status: 200 });
+			vi.mocked(base[baseMethod]).mockResolvedValue(response);
+			vi.mocked(createBaseServerSDK).mockReturnValue(base as never);
+
+			const sdk = createServerSDK(createServerOptions());
+			const handler = getRouteHandler(sdk.handlers, method.toLowerCase(), path);
+			const req = { id: 'req' };
+			const res = { id: 'res' };
+			const next = vi.fn();
+
+			await handler(req, res, next);
+
+			expect(base[baseMethod]).toHaveBeenCalledWith(req);
+			expect(applyResponse).toHaveBeenCalledWith(response, res);
+			expect(next).not.toHaveBeenCalled();
+		});
+
+		test.each([
+			['GET', '/login', 'handleLogin'],
+			['GET', '/register', 'handleRegister'],
+			['GET', '/callback', 'handleCallback'],
+			['GET', '/refresh', 'handleRefresh'],
+			['GET', '/revoke', 'handleRevoke'],
+			['GET', '/entry', 'handleEntry'],
+			['GET', '/logout', 'handleLogout'],
+			['POST', '/backchannel-logout', 'handleBackChannelLogout'],
+		] as const)('%s %s forwards a rejection from base.%s to next() instead of applying a response', async (method, path, baseMethod) => {
+			const base = createBase();
+			const error = new Error('boom');
+			vi.mocked(base[baseMethod]).mockRejectedValue(error);
+			vi.mocked(createBaseServerSDK).mockReturnValue(base as never);
+
+			const sdk = createServerSDK(createServerOptions());
+			const handler = getRouteHandler(sdk.handlers, method.toLowerCase(), path);
+			const next = vi.fn();
+
+			await handler({}, {}, next);
+
+			expect(next).toHaveBeenCalledWith(error);
+			expect(applyResponse).not.toHaveBeenCalled();
+		});
+	});
+});

package/testing/tests/server/session.spec.ts

@@ -0,0 +1,52 @@
+import type { AngularServerSDK } from '../../../src/server/types';
+import { ApplicationInitStatus, REQUEST, TransferState } from '@angular/core';
+import { TestBed } from '@angular/core/testing';
+import { describe, test, expect, vi } from 'vitest';
+import { SESSION_TRANSFER_KEY, provideStrivacityServerSession } from '../../../src/server/session';
+
+function configure(request: Request | undefined, serverSdk: AngularServerSDK | undefined) {
+	TestBed.configureTestingModule({
+		providers: [{ provide: REQUEST, useValue: request }, provideStrivacityServerSession(serverSdk)],
+	});
+
+	return TestBed.inject(ApplicationInitStatus).donePromise;
+}
+
+describe('provideStrivacityServerSession', () => {
+	test('loads the session for the incoming request and hands it over via TransferState', async () => {
+		const request = new Request('https://brandtegrity.io');
+		const session = { access_token: 'access-token' };
+		const getSession = vi.fn().mockResolvedValue(session);
+
+		await configure(request, { getSession } as unknown as AngularServerSDK);
+
+		expect(getSession).toHaveBeenCalledWith(request);
+		expect(TestBed.inject(TransferState).get(SESSION_TRANSFER_KEY, undefined)).toEqual(session);
+	});
+
+	test('transfers null when the server sdk finds no session for the request', async () => {
+		const request = new Request('https://brandtegrity.io');
+		const getSession = vi.fn().mockResolvedValue(null);
+
+		await configure(request, { getSession } as unknown as AngularServerSDK);
+
+		expect(TestBed.inject(TransferState).get(SESSION_TRANSFER_KEY, undefined)).toBeNull();
+	});
+
+	test('is a no-op when there is no incoming request (e.g. not running under SSR)', async () => {
+		const getSession = vi.fn().mockResolvedValue({ access_token: 'access-token' });
+
+		await configure(undefined, { getSession } as unknown as AngularServerSDK);
+
+		expect(getSession).not.toHaveBeenCalled();
+		expect(TestBed.inject(TransferState).hasKey(SESSION_TRANSFER_KEY)).toBe(false);
+	});
+
+	test('is a no-op when no server sdk was configured (serverSessionUri unset)', async () => {
+		const request = new Request('https://brandtegrity.io');
+
+		await configure(request, undefined);
+
+		expect(TestBed.inject(TransferState).hasKey(SESSION_TRANSFER_KEY)).toBe(false);
+	});
+});

package/testing/tests/server/storages.spec.ts

@@ -0,0 +1,58 @@
+import type { Request as ExpressRequest } from 'express';
+import { describe, test, expect, vi, beforeEach } from 'vitest';
+import { createMockStorage } from '@strivacity/testing/mocks/sdk';
+import * as coreStorages from '@strivacity/sdk-core/storages';
+import { createSessionIdCookieStorage as createSessionIdCookieStorageBase } from '@strivacity/sdk-core/storages/server';
+
+vi.mock('@strivacity/sdk-core/storages/server', async (importOriginal) => ({
+	...(await importOriginal<typeof import('@strivacity/sdk-core/storages/server')>()),
+	createSessionIdCookieStorage: vi.fn(),
+}));
+
+beforeEach(() => {
+	vi.mocked(createSessionIdCookieStorageBase).mockReset();
+});
+
+describe('server storages', () => {
+	test('re-exports everything from the core storages barrel, with createSessionIdCookieStorage overridden by the local wrapper', async () => {
+		const angularStorages = await import('../../../src/server/storages');
+		const coreKeys = Object.keys(coreStorages);
+
+		expect(coreKeys.length).toBeGreaterThan(0);
+		expect(Object.keys(angularStorages).sort()).toEqual(coreKeys.sort());
+
+		for (const key of coreKeys) {
+			if (key === 'createSessionIdCookieStorage') {
+				continue;
+			}
+
+			expect(angularStorages[key as keyof typeof angularStorages]).toBe(coreStorages[key as keyof typeof coreStorages]);
+		}
+
+		expect(angularStorages.createSessionIdCookieStorage).not.toBe(coreStorages.createSessionIdCookieStorage);
+	});
+
+	test('createSessionIdCookieStorage forwards the storage and options to the core implementation, with an adapter converting Express requests to standard Requests', async () => {
+		const angularStorages = await import('../../../src/server/storages');
+		const wrapped = { get: vi.fn() };
+		vi.mocked(createSessionIdCookieStorageBase).mockReturnValue(wrapped as never);
+		const storage = createMockStorage();
+		const options = { defaultCookieOptions: { path: '/' } };
+
+		const result = angularStorages.createSessionIdCookieStorage(storage, options);
+
+		expect(result).toBe(wrapped);
+		expect(createSessionIdCookieStorageBase).toHaveBeenCalledTimes(1);
+
+		const [adapter, forwardedStorage, forwardedOptions] = vi.mocked(createSessionIdCookieStorageBase).mock.calls[0];
+
+		expect(forwardedStorage).toBe(storage);
+		expect(forwardedOptions).toBe(options);
+
+		const req = { originalUrl: '/callback', protocol: 'https', method: 'GET', headers: {}, get: () => 'brandtegrity.io' } as unknown as ExpressRequest;
+		const webRequest = adapter.toRequest(req);
+
+		expect(webRequest.url).toBe('https://brandtegrity.io/callback');
+		expect(webRequest.method).toBe('GET');
+	});
+});