@strivacity/sdk-core 4.0.0-beta.1 → 4.0.0-beta.2

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

@@ -1,195 +0,0 @@
-/* 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

@@ -1,37 +0,0 @@
-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

@@ -1,71 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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}`);
-	});
-});