Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
9.2 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-or-later

import type {ICacheService} from '@pkgs/cache/src/ICacheService';
import {KVCacheProvider} from '@pkgs/cache/src/providers/KVCacheProvider';
import {MockKVProvider} from '@pkgs/kv_client/src/testing/MockKVProvider';
import {describe, expect, it} from 'vitest';

const INFLIGHT_OVERFLOW_ENTRIES = 10000;
const PRODUCE_TIMEOUT_MS = 50;
const PRODUCE_TIMEOUT_MESSAGE = 'Cache produce timed out';

interface Deferred<T> {
	promise: Promise<T>;
	resolve: (value: T) => void;
	reject: (error: Error) => void;
}

function deferred<T>(): Deferred<T> {
	let resolve!: (value: T) => void;
	let reject!: (error: Error) => void;
	const promise = new Promise<T>((res, rej) => {
		resolve = res;
		reject = rej;
	});
	return {promise, resolve, reject};
}

interface GatedProduce {
	started: Deferred<void>;
	result: Deferred<string>;
}

function gatedFactory(calls: number): {produces: Array<GatedProduce>; factory: () => Promise<string>} {
	const produces = Array.from({length: calls}, () => ({started: deferred<void>(), result: deferred<string>()}));
	let next = 0;
	const factory = async () => {
		const produce = produces[next++];
		produce.started.resolve();
		return await produce.result.promise;
	};
	return {produces, factory};
}

async function fillInflight(cache: ICacheService): Promise<() => Promise<void>> {
	const fillers = Array.from({length: INFLIGHT_OVERFLOW_ENTRIES}, () => gatedFactory(1));
	const filling = fillers.map((filler, index) => cache.getOrSet(`filler:${index}`, filler.factory, 30));
	await Promise.all(fillers.map((filler) => filler.produces[0].started.promise));
	return async () => {
		for (const filler of fillers) {
			filler.produces[0].result.resolve('filler');
		}
		await Promise.all(filling);
	};
}

describe('cache invalidation during an in-flight produce', () => {
	it('does not resurrect a value deleted while the factory was running', async () => {
		const cache = new KVCacheProvider({client: new MockKVProvider()});
		const gate = deferred<string>();
		const pending = cache.getOrSet('session', async () => await gate.promise, 30);
		await cache.delete('session');
		gate.resolve('revoked-session');
		await expect(pending).resolves.toBe('revoked-session');
		expect(await cache.get('session')).toBeNull();
	});

	it('does not resurrect a value another cache instance deleted while the factory was running', async () => {
		const shared = new MockKVProvider();
		const deleting = new KVCacheProvider({client: shared});
		const producing = new KVCacheProvider({client: shared});
		const {produces, factory} = gatedFactory(1);
		const pending = producing.getOrSet('session', factory, 30);
		await produces[0].started.promise;
		await deleting.delete('session');
		produces[0].result.resolve('revoked-session');
		await expect(pending).resolves.toBe('revoked-session');
		expect(await deleting.get('session')).toBeNull();
		await expect(producing.getOrSet('session', async () => 'fresh', 30)).resolves.toBe('fresh');
		expect(await deleting.get('session')).toBe('fresh');
	});

	it('still stores the value when no invalidation happens', async () => {
		const cache = new KVCacheProvider({client: new MockKVProvider()});
		const gate = deferred<string>();
		const pending = cache.getOrSet('session', async () => await gate.promise, 30);
		gate.resolve('live-session');
		await pending;
		expect(await cache.get('session')).toBe('live-session');
	});

	it('does not resurrect a value deleted while a retried produce was running', async () => {
		const cache = new KVCacheProvider({client: new MockKVProvider()});
		const {produces, factory} = gatedFactory(2);
		const producer = cache.getOrSet('session', factory, 30);
		const joiner = cache.getOrSet('session', factory, 30);
		await produces[0].started.promise;
		produces[0].result.reject(new Error('produce failed'));
		await expect(producer).rejects.toThrow('produce failed');
		await produces[1].started.promise;
		await cache.delete('session');
		produces[1].result.resolve('fresh-after-delete');
		await expect(joiner).resolves.toBe('fresh-after-delete');
		expect(await cache.get('session')).toBeNull();
	});

	it('stores the value a retried produce built when no invalidation happens', async () => {
		const cache = new KVCacheProvider({client: new MockKVProvider()});
		const {produces, factory} = gatedFactory(2);
		const producer = cache.getOrSet('session', factory, 30);
		const joiner = cache.getOrSet('session', factory, 30);
		await produces[0].started.promise;
		produces[0].result.reject(new Error('produce failed'));
		await expect(producer).rejects.toThrow('produce failed');
		await produces[1].started.promise;
		produces[1].result.resolve('retried-session');
		await expect(joiner).resolves.toBe('retried-session');
		expect(await cache.get('session')).toBe('retried-session');
	});

	it('stores the value a retried produce built after the first produce was invalidated', async () => {
		const cache = new KVCacheProvider({client: new MockKVProvider()});
		const {produces, factory} = gatedFactory(2);
		const producer = cache.getOrSet('session', factory, 30);
		const joiner = cache.getOrSet('session', factory, 30);
		await produces[0].started.promise;
		await cache.delete('session');
		produces[0].result.reject(new Error('produce failed'));
		await expect(producer).rejects.toThrow('produce failed');
		await produces[1].started.promise;
		produces[1].result.resolve('retried-session');
		await expect(joiner).resolves.toBe('retried-session');
		expect(await cache.get('session')).toBe('retried-session');
	});

	it('does not resurrect a value deleted after a concurrent caller released its produce', async () => {
		const cache = new KVCacheProvider({client: new MockKVProvider()});
		const {produces, factory} = gatedFactory(1);
		const pending = cache.getOrSet('session', factory, 30);
		await produces[0].started.promise;
		await cache.set('session', 'served-from-cache', 30);
		await expect(cache.getOrSet('session', async () => 'unused', 30)).resolves.toBe('served-from-cache');
		await cache.delete('session');
		produces[0].result.resolve('stale-produce');
		await expect(pending).resolves.toBe('stale-produce');
		expect(await cache.get('session')).toBeNull();
	});

	it('does not resurrect a value deleted while a second overflow produce was running', async () => {
		const cache = new KVCacheProvider({client: new MockKVProvider()});
		const drain = await fillInflight(cache);
		const first = deferred<string>();
		const second = deferred<string>();
		const firstProduce = cache.getOrSet('session', async () => await first.promise, 30);
		const secondProduce = cache.getOrSet('session', async () => await second.promise, 30);
		first.resolve('first-produce');
		await expect(firstProduce).resolves.toBe('first-produce');
		await cache.delete('session');
		second.resolve('second-produce');
		await expect(secondProduce).resolves.toBe('second-produce');
		expect(await cache.get('session')).toBeNull();
		await drain();
	});

	it('does not pin a key forever when the factory never settles', async () => {
		const cache = new KVCacheProvider({client: new MockKVProvider()});
		const stuck = deferred<string>();
		const pinned = cache.getOrSet('session', async () => await stuck.promise, 30, PRODUCE_TIMEOUT_MS);
		await expect(pinned).rejects.toThrow(PRODUCE_TIMEOUT_MESSAGE);
		await expect(cache.getOrSet('session', async () => 'recovered', 30, PRODUCE_TIMEOUT_MS)).resolves.toBe('recovered');
		expect(await cache.get('session')).toBe('recovered');
	});

	it('retries once for the joiners when the producer times out', async () => {
		const cache = new KVCacheProvider({client: new MockKVProvider()});
		const {produces, factory} = gatedFactory(2);
		const producer = cache.getOrSet('session', factory, 30, PRODUCE_TIMEOUT_MS);
		const joiner = cache.getOrSet('session', factory, 30, PRODUCE_TIMEOUT_MS);
		await expect(producer).rejects.toThrow(PRODUCE_TIMEOUT_MESSAGE);
		await produces[1].started.promise;
		produces[1].result.resolve('retried-session');
		await expect(joiner).resolves.toBe('retried-session');
		expect(await cache.get('session')).toBe('retried-session');
	});

	it('stores a sibling produce that succeeded after an overflow produce timed out', async () => {
		const cache = new KVCacheProvider({client: new MockKVProvider()});
		const drain = await fillInflight(cache);
		const stuck = deferred<string>();
		const sibling = deferred<string>();
		const abandoned = cache.getOrSet('session', async () => await stuck.promise, 30, PRODUCE_TIMEOUT_MS);
		const succeeding = cache.getOrSet('session', async () => await sibling.promise, 30, PRODUCE_TIMEOUT_MS * 100);
		await expect(abandoned).rejects.toThrow(PRODUCE_TIMEOUT_MESSAGE);
		sibling.resolve('sibling-produce');
		await expect(succeeding).resolves.toBe('sibling-produce');
		expect(await cache.get('session')).toBe('sibling-produce');
		await drain();
	});

	it('keeps a later produce cacheable after an earlier one was invalidated', async () => {
		const cache = new KVCacheProvider({client: new MockKVProvider()});
		const first = deferred<string>();
		const pending = cache.getOrSet('session', async () => await first.promise, 30);
		await cache.delete('session');
		first.resolve('stale');
		await pending;
		expect(await cache.get('session')).toBeNull();
		await cache.getOrSet('session', async () => 'fresh', 30);
		expect(await cache.get('session')).toBe('fresh');
	});
});