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

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

@@ -0,0 +1,15 @@
+import { test, expect } from 'vitest';
+import * as index from '../../../src/server';
+
+test('should export the correct things', () => {
+	const expectedExports = [
+		'COOKIE_CONTEXT',
+		'COOKIE_CHUNK_SIZE',
+		'DISALLOWED_PROXY_HEADERS',
+		'RETURN_TO_COOKIE',
+		'BACKCHANNEL_LOGOUT_TOKEN_MAX_AGE_SECONDS',
+		'createBaseServerSDK',
+	];
+
+	expect(Object.keys(index)).toEqual(expectedExports);
+});

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

@@ -0,0 +1,107 @@
+import { describe, beforeEach, test, expect } from 'vitest';
+import { createCacheAPIStorage } from '../../../src/storages';
+
+function toCacheKey(url: RequestInfo): string {
+	return typeof url === 'string' ? url : url.url;
+}
+
+class MockCache implements Partial<Cache> {
+	private readonly store = new Map<string, Response>();
+
+	match(url: RequestInfo): Promise<Response | undefined> {
+		const response = this.store.get(toCacheKey(url));
+
+		return Promise.resolve(response?.clone());
+	}
+
+	put(url: RequestInfo, response: Response): Promise<void> {
+		this.store.set(toCacheKey(url), response);
+
+		return Promise.resolve();
+	}
+
+	delete(url: RequestInfo): Promise<boolean> {
+		return Promise.resolve(this.store.delete(toCacheKey(url)));
+	}
+}
+
+class MockCacheStorage implements Partial<CacheStorage> {
+	private readonly caches = new Map<string, MockCache>();
+
+	open(cacheName: string): Promise<Cache> {
+		if (!this.caches.has(cacheName)) {
+			this.caches.set(cacheName, new MockCache());
+		}
+
+		return Promise.resolve(this.caches.get(cacheName) as unknown as Cache);
+	}
+
+	keys(): Promise<string[]> {
+		return Promise.resolve([...this.caches.keys()]);
+	}
+
+	has(cacheName: string): Promise<boolean> {
+		return Promise.resolve(this.caches.has(cacheName));
+	}
+}
+
+describe('createCacheAPIStorage', () => {
+	beforeEach(() => {
+		globalThis.caches = new MockCacheStorage() as unknown as CacheStorage;
+	});
+
+	test('should return null when the key does not exist', async () => {
+		const storage = createCacheAPIStorage();
+
+		await expect(storage.get('missing')).resolves.toBeNull();
+	});
+
+	test('should store and retrieve a value', async () => {
+		const storage = createCacheAPIStorage();
+
+		await storage.set('key', 'value');
+
+		await expect(storage.get('key')).resolves.toBe('value');
+	});
+
+	test('should overwrite an existing value', async () => {
+		const storage = createCacheAPIStorage();
+
+		await storage.set('key', 'value');
+		await storage.set('key', 'new-value');
+
+		await expect(storage.get('key')).resolves.toBe('new-value');
+	});
+
+	test('should delete a stored value', async () => {
+		const storage = createCacheAPIStorage();
+
+		await storage.set('key', 'value');
+		await storage.delete('key');
+
+		await expect(storage.get('key')).resolves.toBeNull();
+	});
+
+	test('should not throw when deleting a non-existent key', async () => {
+		const storage = createCacheAPIStorage();
+
+		await expect(storage.delete('missing')).resolves.toBeUndefined();
+	});
+
+	test('should use a custom cache name when provided', async () => {
+		const storage = createCacheAPIStorage('custom-cache');
+
+		await storage.set('key', 'value');
+
+		await expect(globalThis.caches.has('custom-cache')).resolves.toBe(true);
+	});
+
+	test('should isolate values stored under different cache names', async () => {
+		const storageA = createCacheAPIStorage('cache-a');
+		const storageB = createCacheAPIStorage('cache-b');
+
+		await storageA.set('key', 'value-a');
+
+		await expect(storageB.get('key')).resolves.toBeNull();
+	});
+});

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

@@ -0,0 +1,22 @@
+import { test, expect } from 'vitest';
+import * as index from '../../../src/storages';
+
+test('should export the correct things', () => {
+	const expectedExports = [
+		'createCacheAPIStorage',
+		'createIndexedDBStorage',
+		'createLocalStorage',
+		'createMemoryStorage',
+		'COOKIE_CONTEXT',
+		'COOKIE_CHUNK_SIZE',
+		'createServerStateStorage',
+		'createServerMemoryStorage',
+		'createSessionIdCookieStorage',
+		'createEncryptedCookieStorage',
+		'createSessionStorage',
+		'createWorkerStorage',
+		'handleWorkerStorageRequests',
+	];
+
+	expect(Object.keys(index)).toEqual(expectedExports);
+});

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

@@ -0,0 +1,113 @@
+import 'fake-indexeddb/auto';
+import { describe, test, expect, vi } from 'vitest';
+import { createIndexedDBStorage } from '../../../src/storages';
+
+type FakeIDBRequest = { onsuccess: ((event: unknown) => void) | null; onerror: ((event: unknown) => void) | null; error: Error };
+
+let dbIndex = 0;
+
+function uniqueDbName(): string {
+	return `test-db-${++dbIndex}`;
+}
+
+function createFailingRequest(error: Error): FakeIDBRequest {
+	const request: FakeIDBRequest = { onsuccess: null, onerror: null, error };
+
+	queueMicrotask(() => request.onerror?.({ target: request }));
+
+	return request;
+}
+
+describe('createIndexedDBStorage', () => {
+	test('should return null when the key does not exist', async () => {
+		const storage = createIndexedDBStorage(uniqueDbName());
+
+		await expect(storage.get('missing')).resolves.toBeNull();
+	});
+
+	test('should store and retrieve a value', async () => {
+		const storage = createIndexedDBStorage(uniqueDbName());
+
+		await storage.set('key', 'value');
+
+		await expect(storage.get('key')).resolves.toBe('value');
+	});
+
+	test('should overwrite an existing value', async () => {
+		const storage = createIndexedDBStorage(uniqueDbName());
+
+		await storage.set('key', 'value');
+		await storage.set('key', 'new-value');
+
+		await expect(storage.get('key')).resolves.toBe('new-value');
+	});
+
+	test('should delete a stored value', async () => {
+		const storage = createIndexedDBStorage(uniqueDbName());
+
+		await storage.set('key', 'value');
+		await storage.delete('key');
+
+		await expect(storage.get('key')).resolves.toBeNull();
+	});
+
+	test('should not throw when deleting a non-existent key', async () => {
+		const storage = createIndexedDBStorage(uniqueDbName());
+
+		await expect(storage.delete('missing')).resolves.toBeUndefined();
+	});
+
+	test('should use a custom database and store name when provided', async () => {
+		const storage = createIndexedDBStorage(uniqueDbName(), 'custom-store');
+
+		await storage.set('key', 'value');
+
+		await expect(storage.get('key')).resolves.toBe('value');
+	});
+
+	test('should reuse the same database connection across calls', async () => {
+		const storage = createIndexedDBStorage(uniqueDbName());
+
+		await storage.set('key-1', 'value-1');
+		await storage.set('key-2', 'value-2');
+
+		await expect(storage.get('key-1')).resolves.toBe('value-1');
+		await expect(storage.get('key-2')).resolves.toBe('value-2');
+	});
+
+	test('should reject when opening the database fails', async () => {
+		const error = new Error('open failed');
+		vi.spyOn(indexedDB, 'open').mockImplementation(() => createFailingRequest(error) as unknown as IDBOpenDBRequest);
+
+		const storage = createIndexedDBStorage(uniqueDbName());
+
+		await expect(storage.get('key')).rejects.toBe(error);
+	});
+
+	test('should reject when reading a value fails', async () => {
+		const storage = createIndexedDBStorage(uniqueDbName());
+		const error = new Error('get failed');
+
+		vi.spyOn(IDBObjectStore.prototype, 'get').mockImplementation(() => createFailingRequest(error) as unknown as IDBRequest);
+
+		await expect(storage.get('key')).rejects.toBe(error);
+	});
+
+	test('should reject when writing a value fails', async () => {
+		const storage = createIndexedDBStorage(uniqueDbName());
+		const error = new Error('put failed');
+
+		vi.spyOn(IDBObjectStore.prototype, 'put').mockImplementation(() => createFailingRequest(error) as unknown as IDBRequest);
+
+		await expect(storage.set('key', 'value')).rejects.toBe(error);
+	});
+
+	test('should reject when deleting a value fails', async () => {
+		const storage = createIndexedDBStorage(uniqueDbName());
+		const error = new Error('delete failed');
+
+		vi.spyOn(IDBObjectStore.prototype, 'delete').mockImplementation(() => createFailingRequest(error) as unknown as IDBRequest);
+
+		await expect(storage.delete('key')).rejects.toBe(error);
+	});
+});

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

@@ -0,0 +1,46 @@
+import { describe, beforeEach, test, expect } from 'vitest';
+import { createLocalStorage } from '../../../src/storages';
+
+describe('createLocalStorage', () => {
+	beforeEach(() => {
+		globalThis.localStorage?.clear();
+	});
+
+	test('should return null when the key does not exist', async () => {
+		const storage = createLocalStorage();
+
+		await expect(storage.get('missing')).resolves.toBeNull();
+	});
+
+	test('should store and retrieve a value', async () => {
+		const storage = createLocalStorage();
+
+		await storage.set('key', 'value');
+
+		await expect(storage.get('key')).resolves.toBe('value');
+	});
+
+	test('should overwrite an existing value', async () => {
+		const storage = createLocalStorage();
+
+		await storage.set('key', 'value');
+		await storage.set('key', 'new-value');
+
+		await expect(storage.get('key')).resolves.toBe('new-value');
+	});
+
+	test('should delete a stored value', async () => {
+		const storage = createLocalStorage();
+
+		await storage.set('key', 'value');
+		await storage.delete('key');
+
+		await expect(storage.get('key')).resolves.toBeNull();
+	});
+
+	test('should not throw when deleting a non-existent key', async () => {
+		const storage = createLocalStorage();
+
+		await expect(storage.delete('missing')).resolves.toBeUndefined();
+	});
+});

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

@@ -0,0 +1,51 @@
+import { describe, test, expect } from 'vitest';
+import { createMemoryStorage } from '../../../src/storages';
+
+describe('createMemoryStorage', () => {
+	test('should return null when the key does not exist', async () => {
+		const storage = createMemoryStorage();
+
+		await expect(storage.get('missing')).resolves.toBeNull();
+	});
+
+	test('should store and retrieve a value', async () => {
+		const storage = createMemoryStorage();
+
+		await storage.set('key', 'value');
+
+		await expect(storage.get('key')).resolves.toBe('value');
+	});
+
+	test('should overwrite an existing value', async () => {
+		const storage = createMemoryStorage();
+
+		await storage.set('key', 'value');
+		await storage.set('key', 'new-value');
+
+		await expect(storage.get('key')).resolves.toBe('new-value');
+	});
+
+	test('should delete a stored value', async () => {
+		const storage = createMemoryStorage();
+
+		await storage.set('key', 'value');
+		await storage.delete('key');
+
+		await expect(storage.get('key')).resolves.toBeNull();
+	});
+
+	test('should not throw when deleting a non-existent key', async () => {
+		const storage = createMemoryStorage();
+
+		await expect(storage.delete('missing')).resolves.toBeUndefined();
+	});
+
+	test('should isolate state between separate instances', async () => {
+		const storageA = createMemoryStorage();
+		const storageB = createMemoryStorage();
+
+		await storageA.set('key', 'value');
+
+		await expect(storageB.get('key')).resolves.toBeNull();
+	});
+});