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

package/testing/tests/utils/credentials.spec.ts

@@ -0,0 +1,195 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { describe, test, expect, afterEach } from 'vitest';
+import { createWebAuthnCredential, assertWebAuthnCredential } from '../../../src/utils/credentials';
+import { ProtocolError } from '../../../src/utils/errors';
+import { encodeBase64URL } from '../../../src/utils/base64url';
+import { creationOptions, fromBuffer, mockCredentials, requestOptions, toBuffer } from '@strivacity/testing/mocks/credentials';
+
+describe('createWebAuthnCredential', () => {
+	afterEach(() => {
+		delete (navigator as any).credentials;
+	});
+
+	test('decodes the challenge, user id and excludeCredentials ids, and returns the formatted registration response', async () => {
+		let capturedPublicKey: any;
+
+		mockCredentials({
+			create: (options) => {
+				capturedPublicKey = options.publicKey;
+				return Promise.resolve({
+					id: 'credential-id',
+					rawId: toBuffer('raw-id'),
+					type: 'public-key',
+					authenticatorAttachment: 'platform',
+					response: {
+						clientDataJSON: toBuffer('client-data'),
+						attestationObject: toBuffer('attestation'),
+						getTransports: () => ['internal'],
+					},
+					getClientExtensionResults: () => ({ foo: 'bar' }),
+				});
+			},
+		});
+
+		const result = await createWebAuthnCredential(
+			creationOptions({ excludeCredentials: [{ id: encodeBase64URL(toBuffer('exclude-1')), type: 'public-key' }] }),
+		);
+
+		expect(fromBuffer(capturedPublicKey.challenge)).toBe('challenge');
+		expect(fromBuffer(capturedPublicKey.user.id)).toBe('user-1');
+		expect(fromBuffer(capturedPublicKey.excludeCredentials[0].id)).toBe('exclude-1');
+
+		expect(result).toEqual({
+			id: 'credential-id',
+			rawId: encodeBase64URL(toBuffer('raw-id')),
+			response: {
+				clientDataJSON: encodeBase64URL(toBuffer('client-data')),
+				attestationObject: encodeBase64URL(toBuffer('attestation')),
+				transports: ['internal'],
+			},
+			authenticatorAttachment: 'platform',
+			clientExtensionResults: { foo: 'bar' },
+			type: 'public-key',
+		});
+	});
+
+	test('defaults excludeCredentials to an empty array when not provided', async () => {
+		let capturedPublicKey: any;
+
+		mockCredentials({
+			create: (options) => {
+				capturedPublicKey = options.publicKey;
+				return Promise.resolve({
+					type: 'public-key',
+					rawId: toBuffer('raw-id'),
+					response: { clientDataJSON: toBuffer(''), attestationObject: toBuffer('') },
+					getClientExtensionResults: () => ({}),
+				});
+			},
+		});
+
+		await createWebAuthnCredential(creationOptions());
+
+		expect(capturedPublicKey.excludeCredentials).toEqual([]);
+	});
+
+	test('defaults transports to an empty array when the response has no getTransports', async () => {
+		mockCredentials({
+			create: () =>
+				Promise.resolve({
+					type: 'public-key',
+					rawId: toBuffer('raw-id'),
+					response: { clientDataJSON: toBuffer(''), attestationObject: toBuffer('') },
+					getClientExtensionResults: () => ({}),
+				}),
+		});
+
+		const result = await createWebAuthnCredential(creationOptions());
+
+		expect(result.response.transports).toEqual([]);
+	});
+
+	test('forwards the provided AbortController signal to navigator.credentials.create', async () => {
+		let capturedSignal: AbortSignal | undefined;
+		const abortController = new AbortController();
+
+		mockCredentials({
+			create: (options) => {
+				capturedSignal = options.signal;
+				return Promise.resolve({
+					type: 'public-key',
+					rawId: toBuffer('raw-id'),
+					response: { clientDataJSON: toBuffer(''), attestationObject: toBuffer('') },
+					getClientExtensionResults: () => ({}),
+				});
+			},
+		});
+
+		await createWebAuthnCredential(creationOptions(), abortController);
+
+		expect(capturedSignal).toBe(abortController.signal);
+	});
+
+	test('throws a ProtocolError when the created credential is not a public-key credential', async () => {
+		mockCredentials({ create: () => Promise.resolve({ type: 'other', response: {} }) });
+
+		await expect(createWebAuthnCredential(creationOptions())).rejects.toThrow(new ProtocolError('Not a public key'));
+	});
+});
+
+describe('assertWebAuthnCredential', () => {
+	afterEach(() => {
+		delete (navigator as any).credentials;
+	});
+
+	test('decodes the challenge and allowCredentials ids, and returns credential.toJSON()', async () => {
+		let capturedPublicKey: any;
+		const toJSONResult = { id: 'credential-id' };
+
+		mockCredentials({
+			get: (options) => {
+				capturedPublicKey = options.publicKey;
+				return Promise.resolve({ type: 'public-key', toJSON: () => toJSONResult });
+			},
+		});
+
+		const result = await assertWebAuthnCredential(requestOptions({ allowCredentials: [{ id: encodeBase64URL(toBuffer('allow-1')), type: 'public-key' }] }));
+
+		expect(fromBuffer(capturedPublicKey.challenge)).toBe('challenge');
+		expect(fromBuffer(capturedPublicKey.allowCredentials[0].id)).toBe('allow-1');
+		expect(result).toBe(toJSONResult);
+	});
+
+	test('defaults allowCredentials to an empty array when not provided', async () => {
+		let capturedPublicKey: any;
+
+		mockCredentials({
+			get: (options) => {
+				capturedPublicKey = options.publicKey;
+				return Promise.resolve({ type: 'public-key', toJSON: () => ({}) });
+			},
+		});
+
+		await assertWebAuthnCredential(requestOptions());
+
+		expect(capturedPublicKey.allowCredentials).toEqual([]);
+	});
+
+	test('defaults the mediation requirement to "optional"', async () => {
+		let capturedMediation;
+
+		mockCredentials({
+			get: (options) => {
+				capturedMediation = options.mediation;
+				return Promise.resolve({ type: 'public-key', toJSON: () => ({}) });
+			},
+		});
+
+		await assertWebAuthnCredential(requestOptions());
+
+		expect(capturedMediation).toBe('optional');
+	});
+
+	test('uses the provided mediation requirement', async () => {
+		let capturedMediation;
+
+		mockCredentials({
+			get: (options) => {
+				capturedMediation = options.mediation;
+
+				return Promise.resolve({ type: 'public-key', toJSON: () => ({}) });
+			},
+		});
+
+		await assertWebAuthnCredential(requestOptions(), 'conditional');
+
+		expect(capturedMediation).toBe('conditional');
+	});
+
+	test('throws a ProtocolError when the retrieved credential is not a public-key credential', async () => {
+		mockCredentials({ get: () => Promise.resolve({ type: 'other', toJSON: () => ({}) }) });
+
+		await expect(assertWebAuthnCredential(requestOptions())).rejects.toThrow(new ProtocolError('Not a public key'));
+	});
+});

package/testing/tests/utils/dom.spec.ts

@@ -0,0 +1,37 @@
+import { describe, test, expect, vi, afterEach } from 'vitest';
+import { injectScript } from '../../../src/utils/dom';
+
+describe('injectScript', () => {
+	afterEach(() => {
+		vi.unstubAllGlobals();
+		document.getElementById('script-id')?.remove();
+	});
+
+	test('appends a script element with the given id, src, async and module type', () => {
+		injectScript('script-id', 'https://brandtegrity.io/script.js');
+
+		const script = document.getElementById('script-id') as HTMLScriptElement;
+
+		expect(script).not.toBeNull();
+		expect(script.src).toBe('https://brandtegrity.io/script.js');
+		expect(script.async).toBe(true);
+		expect(script.type).toBe('module');
+		expect(script.parentElement).toBe(document.body);
+	});
+
+	test('does not inject a second script when an element with the same id already exists', () => {
+		injectScript('script-id', 'https://brandtegrity.io/first.js');
+		injectScript('script-id', 'https://brandtegrity.io/second.js');
+
+		const script = document.getElementById('script-id') as HTMLScriptElement;
+
+		expect(script.src).toBe('https://brandtegrity.io/first.js');
+		expect(document.querySelectorAll('#script-id').length).toBe(1);
+	});
+
+	test('is a no-op when document is unavailable', () => {
+		vi.stubGlobal('document', undefined);
+
+		expect(() => injectScript('script-id', 'https://brandtegrity.io/script.js')).not.toThrow();
+	});
+});

package/testing/tests/utils/index.spec.ts

@@ -0,0 +1,71 @@
+import { test, expect } from 'vitest';
+import * as index from '../../../src/utils';
+
+test('should export the correct things', () => {
+	const expectedExports = [
+		'encodeBase64URL',
+		'decodeBase64URL',
+		'timestamp',
+		'unflattenObject',
+		'buildCookieString',
+		'createWebAuthnCredential',
+		'assertWebAuthnCredential',
+		'encryptString',
+		'decryptString',
+		'injectScript',
+		'FallbackError',
+		'PopupBlockedError',
+		'PopupClosedError',
+		'UnsupportedFlowError',
+		'SessionExpiredError',
+		'NetworkError',
+		'ServerError',
+		'OidcError',
+		'ProtocolError',
+		'ConfigurationError',
+		'InternalError',
+		'throwTokenEndpointError',
+		'throwHttpError',
+		'createHttpClient',
+		'createDefaultLogging',
+		'getDefaultFlowState',
+		'defaultOptions',
+		'getDiscoveryDocument',
+		'getSDKOptions',
+		'generateCodeVerifier',
+		'generateCodeChallenge',
+		'generateRandomHex',
+		'decodeJwt',
+		'verifyJwt',
+		'generateJwt',
+		'verifyIdToken',
+		'buildAuthorizationUrl',
+		'buildEndSessionUrl',
+		'exchangeCode',
+		'refreshToken',
+		'revokeToken',
+		'fetchFlowEntry',
+		'finalizeLoginSession',
+		'submitLoginForm',
+		'DISALLOWED_PROXY_HEADERS',
+		'RETURN_TO_COOKIE',
+		'BACKCHANNEL_LOGOUT_EVENT',
+		'DEFAULT_COOKIE_MAX_AGE',
+		'getServerSDKOptions',
+		'parseCookieHeader',
+		'serializeCookie',
+		'pushSetCookie',
+		'flushSetCookies',
+		'proxyResponse',
+		'toSafeRedirect',
+		'createSession',
+		'loadSession',
+		'serializeSession',
+		'isSessionExpired',
+		'createState',
+		'parseState',
+		'serializeState',
+	];
+
+	expect(Object.keys(index)).toEqual(expectedExports);
+});

package/testing/tests/utils/logging.spec.ts

@@ -0,0 +1,82 @@
+import { describe, test, expect, vi } from 'vitest';
+import { createDefaultLogging } from '../../../src/utils/logging';
+
+describe('createDefaultLogging', () => {
+	test('logs debug messages via console.log without an xEventId prefix', () => {
+		const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+		const logging = createDefaultLogging();
+
+		logging.debug('hello');
+
+		expect(logSpy).toHaveBeenCalledWith('hello');
+	});
+
+	test('prefixes debug messages with the xEventId when set', () => {
+		const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+		const logging = createDefaultLogging();
+		logging.xEventId = 'event-1';
+
+		logging.debug('hello');
+
+		expect(logSpy).toHaveBeenCalledWith('(event-1) hello');
+	});
+
+	test('logs info messages via console.info', () => {
+		const infoSpy = vi.spyOn(console, 'info').mockImplementation(() => {});
+		const logging = createDefaultLogging();
+
+		logging.info('hello');
+
+		expect(infoSpy).toHaveBeenCalledWith('hello');
+	});
+
+	test('prefixes info messages with the xEventId when set', () => {
+		const infoSpy = vi.spyOn(console, 'info').mockImplementation(() => {});
+		const logging = createDefaultLogging();
+		logging.xEventId = 'event-1';
+
+		logging.info('hello');
+
+		expect(infoSpy).toHaveBeenCalledWith('(event-1) hello');
+	});
+
+	test('logs warn messages via console.warn', () => {
+		const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+		const logging = createDefaultLogging();
+
+		logging.warn('hello');
+
+		expect(warnSpy).toHaveBeenCalledWith('hello');
+	});
+
+	test('prefixes warn messages with the xEventId when set', () => {
+		const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+		const logging = createDefaultLogging();
+		logging.xEventId = 'event-1';
+
+		logging.warn('hello');
+
+		expect(warnSpy).toHaveBeenCalledWith('(event-1) hello');
+	});
+
+	test('logs error messages via console.error including the error', () => {
+		const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+		const logging = createDefaultLogging();
+		const error = new Error('boom');
+
+		logging.error('hello', error);
+
+		expect(errorSpy).toHaveBeenCalledWith(`hello - ${error}`);
+	});
+
+	test('prefixes error messages with the xEventId when set', () => {
+		const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+		const logging = createDefaultLogging();
+		logging.xEventId = 'event-1';
+		const error = new Error('boom');
+
+		logging.error('hello', error);
+
+		expect(errorSpy).toHaveBeenCalledWith(`(event-1) hello - ${error}`);
+	});
+});