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

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

@@ -0,0 +1,435 @@
+import type { ServerAdapter, ServerStorage, LogoutTokenClaims } from '../../../src/types';
+import { describe, test, expect, beforeEach, vi } from 'vitest';
+import { createServerStateStorage, createServerMemoryStorage, createSessionIdCookieStorage, createEncryptedCookieStorage } from '../../../src/storages';
+import { flushSetCookies } from '../../../src/utils';
+
+type MockEvent = { request: Request };
+
+const adapter: ServerAdapter<MockEvent> = {
+	toRequest: (event) => event.request,
+};
+
+function createMockEvent(cookies: Record<string, string> = {}): MockEvent {
+	const cookieHeader = Object.entries(cookies)
+		.map(([name, value]) => `${name}=${encodeURIComponent(value)}`)
+		.join('; ');
+	const request = new Request('https://example.com');
+
+	if (cookieHeader) {
+		// `Request`'s constructor strips forbidden headers like `cookie`, so it must be set directly on the built request instead.
+		request.headers.set('cookie', cookieHeader);
+	}
+
+	return { request };
+}
+
+// Reads the `Set-Cookie` headers accumulated for an event back into a plain name/value map.
+function getSetCookies(event: MockEvent): Record<string, string> {
+	const response = flushSetCookies(event, new Response());
+	const cookies: Record<string, string> = {};
+
+	for (const header of response.headers.getSetCookie()) {
+		const [pair] = header.split(';');
+		const index = pair.indexOf('=');
+
+		cookies[pair.slice(0, index)] = decodeURIComponent(pair.slice(index + 1));
+	}
+
+	return cookies;
+}
+
+describe('createServerStateStorage', () => {
+	test('should return null when the key does not exist', async () => {
+		const storage = createServerStateStorage();
+
+		await expect(storage.get('missing')).resolves.toBeNull();
+	});
+
+	test('should store and retrieve a value', async () => {
+		const storage = createServerStateStorage();
+
+		await storage.set('key', 'value');
+
+		await expect(storage.get('key')).resolves.toBe('value');
+	});
+
+	test('should overwrite an existing value', async () => {
+		const storage = createServerStateStorage();
+
+		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 = createServerStateStorage();
+
+		await storage.set('key', 'value');
+		await storage.delete('key');
+
+		await expect(storage.get('key')).resolves.toBeNull();
+	});
+
+	test('should share state across separate instances', async () => {
+		const storageA = createServerStateStorage();
+		const storageB = createServerStateStorage();
+
+		await storageA.set('key', 'value');
+
+		await expect(storageB.get('key')).resolves.toBe('value');
+	});
+});
+
+describe('createServerMemoryStorage', () => {
+	beforeEach(() => {
+		delete (globalThis as { sty?: unknown }).sty;
+	});
+
+	test('should return null when the key does not exist', async () => {
+		const storage = createServerMemoryStorage();
+
+		await expect(storage.get('missing')).resolves.toBeNull();
+	});
+
+	test('should store and retrieve a value', async () => {
+		const storage = createServerMemoryStorage();
+
+		await storage.set('key', 'value');
+
+		await expect(storage.get('key')).resolves.toBe('value');
+	});
+
+	test('should overwrite an existing value', async () => {
+		const storage = createServerMemoryStorage();
+
+		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 = createServerMemoryStorage();
+
+		await storage.set('key', 'value');
+		await storage.delete('key');
+
+		await expect(storage.get('key')).resolves.toBeNull();
+	});
+
+	test('should reset the shared state whenever a new instance is created', async () => {
+		const storageA = createServerMemoryStorage();
+
+		await storageA.set('key', 'value');
+
+		createServerMemoryStorage();
+
+		await expect(storageA.get('key')).resolves.toBeNull();
+	});
+
+	test('should delete sessions matching the logout token sid', async () => {
+		const storage = createServerMemoryStorage();
+
+		await storage.set('session-a', JSON.stringify({ claims: { sid: 'sid-a' } }));
+		await storage.set('session-b', JSON.stringify({ claims: { sid: 'sid-b' } }));
+
+		await storage.deleteByLogoutToken!({ sid: 'sid-a' } as LogoutTokenClaims);
+
+		await expect(storage.get('session-a')).resolves.toBeNull();
+		await expect(storage.get('session-b')).resolves.not.toBeNull();
+	});
+
+	test('should delete sessions matching the logout token sub', async () => {
+		const storage = createServerMemoryStorage();
+
+		await storage.set('session-a', JSON.stringify({ claims: { sub: 'sub-a' } }));
+		await storage.set('session-b', JSON.stringify({ claims: { sub: 'sub-b' } }));
+
+		await storage.deleteByLogoutToken!({ sub: 'sub-a' } as LogoutTokenClaims);
+
+		await expect(storage.get('session-a')).resolves.toBeNull();
+		await expect(storage.get('session-b')).resolves.not.toBeNull();
+	});
+
+	test('should not delete sessions when the logout token matches nothing', async () => {
+		const storage = createServerMemoryStorage();
+
+		await storage.set('session-a', JSON.stringify({ claims: { sid: 'sid-a' } }));
+
+		await storage.deleteByLogoutToken!({ sid: 'other-sid' } as LogoutTokenClaims);
+
+		await expect(storage.get('session-a')).resolves.not.toBeNull();
+	});
+});
+
+describe('createSessionIdCookieStorage', () => {
+	type MockEvent = { request: Request };
+
+	function createSessionAdapter(): ServerAdapter<MockEvent> {
+		return { toRequest: (event) => event.request };
+	}
+
+	function createUnderlyingStorage(): ServerStorage<MockEvent> {
+		return {
+			get: vi.fn().mockResolvedValue(null),
+			set: vi.fn().mockResolvedValue(undefined),
+			delete: vi.fn().mockResolvedValue(undefined),
+			deleteByLogoutToken: vi.fn().mockResolvedValue(undefined),
+		};
+	}
+
+	test('should return null and skip the underlying storage when no session id cookie exists', async () => {
+		const underlying = createUnderlyingStorage();
+		const storage = createSessionIdCookieStorage(createSessionAdapter(), underlying);
+
+		await expect(storage.get('key', createMockEvent())).resolves.toBeNull();
+		expect(underlying.get).not.toHaveBeenCalled();
+	});
+
+	test('should generate a new session id and set a cookie on first set', async () => {
+		const underlying = createUnderlyingStorage();
+		const storage = createSessionIdCookieStorage(createSessionAdapter(), underlying);
+		const outgoingEvent = createMockEvent();
+
+		await storage.set('key', 'value', outgoingEvent);
+
+		const cookies = getSetCookies(outgoingEvent);
+
+		expect(cookies.key).toBeTruthy();
+		expect(underlying.set).toHaveBeenCalledWith(cookies.key, 'value');
+	});
+
+	test('should use the custom uuidGenerator when generating a session id', async () => {
+		const underlying = createUnderlyingStorage();
+		const uuidGenerator = vi.fn().mockReturnValue('custom-uuid');
+		const randomUUID = vi.spyOn(globalThis.crypto, 'randomUUID');
+		const storage = createSessionIdCookieStorage(createSessionAdapter(), underlying, { uuidGenerator });
+		const outgoingEvent = createMockEvent();
+
+		await storage.set('key', 'value', outgoingEvent);
+
+		expect(uuidGenerator).toHaveBeenCalledTimes(1);
+		expect(randomUUID).not.toHaveBeenCalled();
+		expect(getSetCookies(outgoingEvent).key).toBe('custom-uuid');
+		expect(underlying.set).toHaveBeenCalledWith('custom-uuid', 'value');
+
+		randomUUID.mockRestore();
+	});
+
+	test('should reuse the existing session id on subsequent set calls', async () => {
+		const underlying = createUnderlyingStorage();
+		const storage = createSessionIdCookieStorage(createSessionAdapter(), underlying);
+		const outgoingEvent = createMockEvent();
+
+		await storage.set('key', 'value', outgoingEvent);
+		const sessionId = getSetCookies(outgoingEvent).key;
+
+		const incomingEvent = createMockEvent({ key: sessionId });
+		await storage.set('key', 'other-value', incomingEvent);
+
+		expect(getSetCookies(incomingEvent).key).toBeUndefined();
+		expect(underlying.set).toHaveBeenLastCalledWith(sessionId, 'other-value');
+	});
+
+	test('should retrieve the value from the underlying storage via the session id cookie', async () => {
+		const underlying = createServerMemoryStorage();
+		const storage = createSessionIdCookieStorage(createSessionAdapter(), underlying);
+		const outgoingEvent = createMockEvent();
+
+		await storage.set('key', 'value', outgoingEvent);
+		const incomingEvent = createMockEvent(getSetCookies(outgoingEvent));
+
+		await expect(storage.get('key', incomingEvent)).resolves.toBe('value');
+	});
+
+	test('should delete the session from the underlying storage and expire the cookie', async () => {
+		const underlying = createUnderlyingStorage();
+		const storage = createSessionIdCookieStorage(createSessionAdapter(), underlying);
+		const outgoingEvent = createMockEvent();
+
+		await storage.set('key', 'value', outgoingEvent);
+		const sessionId = getSetCookies(outgoingEvent).key;
+
+		const incomingEvent = createMockEvent({ key: sessionId });
+		await storage.delete('key', incomingEvent);
+
+		expect(underlying.delete).toHaveBeenCalledWith(sessionId);
+		const [header] = flushSetCookies(incomingEvent, new Response()).headers.getSetCookie();
+
+		expect(header).toContain('key=');
+		expect(header).toContain('Expires=Thu, 01 Jan 1970');
+	});
+
+	test('should still expire the cookie when no session id exists on delete', async () => {
+		const underlying = createUnderlyingStorage();
+		const storage = createSessionIdCookieStorage(createSessionAdapter(), underlying);
+		const event = createMockEvent();
+
+		await storage.delete('key', event);
+
+		expect(underlying.delete).not.toHaveBeenCalled();
+		const [header] = flushSetCookies(event, new Response()).headers.getSetCookie();
+
+		expect(header).toContain('Expires=Thu, 01 Jan 1970');
+	});
+
+	test('should apply the default and custom cookie attributes', async () => {
+		const storage = createSessionIdCookieStorage(createSessionAdapter(), createUnderlyingStorage(), {
+			defaultCookieOptions: { sameSite: 'strict', path: '/custom' },
+		});
+		const outgoingEvent = createMockEvent();
+
+		await storage.set('key', 'value', outgoingEvent);
+
+		const [header] = flushSetCookies(outgoingEvent, new Response()).headers.getSetCookie();
+
+		expect(header).toContain('Path=/custom');
+		expect(header).toContain('SameSite=Strict');
+		expect(header).toContain('HttpOnly');
+		expect(header).toContain('Secure');
+	});
+
+	test('should delegate deleteByLogoutToken to the underlying storage', async () => {
+		const underlying = createUnderlyingStorage();
+		const storage = createSessionIdCookieStorage(createSessionAdapter(), underlying);
+		const token = { sid: 'session-id' } as LogoutTokenClaims;
+
+		await storage.deleteByLogoutToken!(token);
+
+		expect(underlying.deleteByLogoutToken).toHaveBeenCalledWith(token);
+	});
+
+	test('should use a pre-existing adapter.getSessionId instead of the cookie-based default', async () => {
+		const underlying = createUnderlyingStorage();
+		const adapter = createSessionAdapter();
+		adapter.getSessionId = vi.fn().mockResolvedValue('custom-session-id');
+
+		const storage = createSessionIdCookieStorage(adapter, underlying);
+
+		await expect(storage.get('key', createMockEvent())).resolves.toBeNull();
+		expect(underlying.get).toHaveBeenCalledWith('custom-session-id');
+	});
+});
+
+describe('createEncryptedCookieStorage', () => {
+	const secret = 'test-secret';
+
+	test('should return null when no event is provided', async () => {
+		const storage = createEncryptedCookieStorage(secret, adapter);
+
+		await expect(storage.get('key')).resolves.toBeNull();
+	});
+
+	test('should return null when the cookie is not present', async () => {
+		const storage = createEncryptedCookieStorage(secret, adapter);
+
+		await expect(storage.get('key', createMockEvent())).resolves.toBeNull();
+	});
+
+	test('should store and retrieve a value via cookies', async () => {
+		const storage = createEncryptedCookieStorage(secret, adapter);
+		const outgoingEvent = createMockEvent();
+
+		await storage.set('key', 'value', outgoingEvent);
+
+		const incomingEvent = createMockEvent(getSetCookies(outgoingEvent));
+
+		await expect(storage.get('key', incomingEvent)).resolves.toBe('value');
+	});
+
+	test('should encrypt the cookie value', async () => {
+		const storage = createEncryptedCookieStorage(secret, adapter);
+		const outgoingEvent = createMockEvent();
+
+		await storage.set('key', 'sensitive-value', outgoingEvent);
+
+		expect(getSetCookies(outgoingEvent).key).not.toContain('sensitive-value');
+	});
+
+	test('should apply the default cookie attributes', async () => {
+		const storage = createEncryptedCookieStorage(secret, adapter);
+		const outgoingEvent = createMockEvent();
+
+		await storage.set('key', 'value', outgoingEvent);
+
+		const [header] = flushSetCookies(outgoingEvent, new Response()).headers.getSetCookie();
+
+		expect(header).toContain('Path=/');
+		expect(header).toContain('HttpOnly');
+		expect(header).toContain('Secure');
+		expect(header).toContain('SameSite=Lax');
+	});
+
+	test('should accept custom cookie options', async () => {
+		const storage = createEncryptedCookieStorage(secret, adapter, {
+			defaultCookieOptions: { httpOnly: false, secure: false, sameSite: 'strict', path: '/custom' },
+		});
+		const outgoingEvent = createMockEvent();
+
+		await storage.set('key', 'value', outgoingEvent);
+
+		const [header] = flushSetCookies(outgoingEvent, new Response()).headers.getSetCookie();
+
+		expect(header).toContain('Path=/custom');
+		expect(header).toContain('SameSite=Strict');
+		expect(header).not.toContain('HttpOnly');
+		expect(header).not.toContain('Secure');
+	});
+
+	test('should chunk values larger than the cookie size limit', async () => {
+		const storage = createEncryptedCookieStorage(secret, adapter);
+		const outgoingEvent = createMockEvent();
+		const largeValue = 'a'.repeat(3000);
+
+		await storage.set('key', largeValue, outgoingEvent);
+
+		const cookies = getSetCookies(outgoingEvent);
+
+		expect(cookies.key).toBe('');
+		expect(cookies['key.0']).toBeDefined();
+		expect(cookies['key.1']).toBeDefined();
+
+		await expect(storage.get('key', createMockEvent(cookies))).resolves.toBe(largeValue);
+	});
+
+	test('should remove existing chunks when overwriting with a smaller value', async () => {
+		const storage = createEncryptedCookieStorage(secret, adapter);
+		const outgoingEvent = createMockEvent();
+		const largeValue = 'a'.repeat(3000);
+
+		await storage.set('key', largeValue, outgoingEvent);
+		const incomingEvent = createMockEvent(getSetCookies(outgoingEvent));
+
+		await storage.set('key', 'small-value', incomingEvent);
+		const cookies = getSetCookies(incomingEvent);
+
+		expect(cookies.key).toBeDefined();
+		expect(cookies['key.0']).toBe('');
+		expect(cookies['key.1']).toBe('');
+	});
+
+	test('should delete a stored cookie', async () => {
+		const storage = createEncryptedCookieStorage(secret, adapter);
+		const outgoingEvent = createMockEvent();
+
+		await storage.delete('key', outgoingEvent);
+
+		const [header] = flushSetCookies(outgoingEvent, new Response()).headers.getSetCookie();
+
+		expect(header).toContain('key=');
+		expect(header).toContain('Expires=Thu, 01 Jan 1970');
+	});
+
+	test('should return null after decrypting with a different secret', async () => {
+		const storage = createEncryptedCookieStorage(secret, adapter);
+		const outgoingEvent = createMockEvent();
+
+		await storage.set('key', 'value', outgoingEvent);
+
+		const otherStorage = createEncryptedCookieStorage('other-secret', adapter);
+		const incomingEvent = createMockEvent(getSetCookies(outgoingEvent));
+
+		await expect(otherStorage.get('key', incomingEvent)).resolves.toBeNull();
+	});
+});

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

@@ -0,0 +1,46 @@
+import { describe, beforeEach, test, expect } from 'vitest';
+import { createSessionStorage } from '../../../src/storages';
+
+describe('createSessionStorage', () => {
+	beforeEach(() => {
+		globalThis.sessionStorage?.clear();
+	});
+
+	test('should return null when the key does not exist', async () => {
+		const storage = createSessionStorage();
+
+		await expect(storage.get('missing')).resolves.toBeNull();
+	});
+
+	test('should store and retrieve a value', async () => {
+		const storage = createSessionStorage();
+
+		await storage.set('key', 'value');
+
+		await expect(storage.get('key')).resolves.toBe('value');
+	});
+
+	test('should overwrite an existing value', async () => {
+		const storage = createSessionStorage();
+
+		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 = createSessionStorage();
+
+		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 = createSessionStorage();
+
+		await expect(storage.delete('missing')).resolves.toBeUndefined();
+	});
+});

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

@@ -0,0 +1,106 @@
+import type { SDKStorage } from '../../../src/types';
+import type { WorkerStorageRequest, WorkerStorageResponse } from '../../../src/storages/worker';
+import { describe, test, expect, beforeEach, afterEach, vi } from 'vitest';
+import { createWorkerStorage, handleWorkerStorageRequests } from '../../../src/storages';
+
+// Simulates a Worker in the same thread: messages posted to one side are dispatched as `message` events on the other.
+class MockWorker extends EventTarget implements Partial<Worker> {
+	public other!: MockWorker;
+
+	postMessage(message: unknown): void {
+		this.other.dispatchEvent(new MessageEvent('message', { data: message }));
+	}
+}
+
+function createLinkedWorkers(): [mainSide: MockWorker, workerSide: MockWorker] {
+	const workerSide = new MockWorker();
+	const mainSide = new MockWorker();
+
+	workerSide.other = mainSide;
+	mainSide.other = workerSide;
+
+	return [mainSide, workerSide];
+}
+
+function createMemoryLikeStorage(): SDKStorage {
+	const store = new Map<string, string>();
+
+	return {
+		get: (key) => {
+			return Promise.resolve(store.get(key) ?? null);
+		},
+		set: (key, value) => {
+			store.set(key, value);
+			return Promise.resolve();
+		},
+		delete: (key) => {
+			store.delete(key);
+			return Promise.resolve();
+		},
+	};
+}
+
+afterEach(() => {
+	vi.unstubAllGlobals();
+});
+
+describe('createWorkerStorage / handleWorkerStorageRequests', () => {
+	let mainSide: MockWorker;
+	let workerSide: MockWorker;
+
+	beforeEach(() => {
+		[mainSide, workerSide] = createLinkedWorkers();
+		vi.stubGlobal('self', workerSide);
+	});
+
+	test('should return null when the key does not exist', async () => {
+		handleWorkerStorageRequests(createMemoryLikeStorage());
+		const storage = createWorkerStorage(mainSide);
+
+		await expect(storage.get('missing')).resolves.toBeNull();
+	});
+
+	test('should store and retrieve a value', async () => {
+		handleWorkerStorageRequests(createMemoryLikeStorage());
+		const storage = createWorkerStorage(mainSide);
+
+		await storage.set('key', 'value');
+
+		await expect(storage.get('key')).resolves.toBe('value');
+	});
+
+	test('should delete a stored value', async () => {
+		handleWorkerStorageRequests(createMemoryLikeStorage());
+		const storage = createWorkerStorage(mainSide);
+
+		await storage.set('key', 'value');
+		await storage.delete('key');
+
+		await expect(storage.get('key')).resolves.toBeNull();
+	});
+
+	test('should reject the pending call when the underlying storage throws', async () => {
+		handleWorkerStorageRequests({
+			get: () => Promise.reject(new Error('boom')),
+			set: () => Promise.resolve(),
+			delete: () => Promise.resolve(),
+		});
+		const storage = createWorkerStorage(mainSide);
+
+		await expect(storage.get('key')).rejects.toThrow('boom');
+	});
+
+	test('should ignore incoming messages without a matching pending request', () => {
+		createWorkerStorage(mainSide);
+
+		expect(() =>
+			mainSide.dispatchEvent(new MessageEvent('message', { data: { requestId: 'unknown', result: 'value' } satisfies WorkerStorageResponse })),
+		).not.toThrow();
+	});
+
+	test('should ignore malformed requests inside the worker', () => {
+		handleWorkerStorageRequests(createMemoryLikeStorage());
+
+		expect(() => workerSide.dispatchEvent(new MessageEvent('message', { data: {} as WorkerStorageRequest }))).not.toThrow();
+	});
+});

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

@@ -0,0 +1,77 @@
+import { describe, test, expect, vi, afterEach } from 'vitest';
+import { timestamp, unflattenObject, buildCookieString } from '../../../src/utils/common';
+
+describe('timestamp', () => {
+	afterEach(() => {
+		vi.useRealTimers();
+	});
+
+	test('returns the current time in whole seconds', () => {
+		vi.useFakeTimers();
+		vi.setSystemTime(new Date('2030-01-01T00:00:00.000Z'));
+
+		expect(timestamp()).toBe(Math.floor(new Date('2030-01-01T00:00:00.000Z').getTime() / 1000));
+	});
+});
+
+describe('unflattenObject', () => {
+	test('returns an empty object for an empty input', () => {
+		expect(unflattenObject({})).toEqual({});
+	});
+
+	test('unflattens a single-level dot-separated key', () => {
+		expect(unflattenObject({ 'a.b': 1 })).toEqual({ a: { b: 1 } });
+	});
+
+	test('unflattens multiple nested levels', () => {
+		expect(unflattenObject({ 'a.b.c': 1 })).toEqual({ a: { b: { c: 1 } } });
+	});
+
+	test('merges sibling keys under the same parent', () => {
+		expect(unflattenObject({ 'a.b': 1, 'a.c': 2 })).toEqual({ a: { b: 1, c: 2 } });
+	});
+
+	test('keeps keys without dots at the top level', () => {
+		expect(unflattenObject({ foo: 'bar' })).toEqual({ foo: 'bar' });
+	});
+});
+
+describe('buildCookieString', () => {
+	test('includes HttpOnly and Secure by default', () => {
+		expect(buildCookieString('foo', 'bar', {})).toBe('foo=bar; HttpOnly; Secure; Path=/');
+	});
+
+	test('URI-encodes the cookie value', () => {
+		expect(buildCookieString('foo', 'hello world', {})).toBe('foo=hello%20world; HttpOnly; Secure; Path=/');
+	});
+
+	test('omits HttpOnly when explicitly false', () => {
+		expect(buildCookieString('foo', 'bar', { httpOnly: false })).toBe('foo=bar; Secure; Path=/');
+	});
+
+	test('omits Secure when explicitly false', () => {
+		expect(buildCookieString('foo', 'bar', { secure: false })).toBe('foo=bar; HttpOnly; Path=/');
+	});
+
+	test('uses a custom path', () => {
+		expect(buildCookieString('foo', 'bar', { path: '/auth' })).toBe('foo=bar; HttpOnly; Secure; Path=/auth');
+	});
+
+	test('includes SameSite when provided', () => {
+		expect(buildCookieString('foo', 'bar', { sameSite: 'lax' })).toBe('foo=bar; HttpOnly; Secure; Path=/; SameSite=lax');
+	});
+
+	test('includes Max-Age when provided', () => {
+		expect(buildCookieString('foo', 'bar', { maxAge: 3600 })).toBe('foo=bar; HttpOnly; Secure; Path=/; Max-Age=3600');
+	});
+
+	test('includes Domain when provided', () => {
+		expect(buildCookieString('foo', 'bar', { domain: 'brandtegrity.io' })).toBe('foo=bar; HttpOnly; Secure; Path=/; Domain=brandtegrity.io');
+	});
+
+	test('combines all attributes', () => {
+		expect(buildCookieString('foo', 'bar', { path: '/auth', sameSite: 'strict', maxAge: 60, domain: 'brandtegrity.io' })).toBe(
+			'foo=bar; HttpOnly; Secure; Path=/auth; SameSite=strict; Max-Age=60; Domain=brandtegrity.io',
+		);
+	});
+});