Skip to content

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

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

import {createGuildID, createUserID, type GuildID, type UserID} from '@app/api/BrandedTypes';
import {GatewayRpcClient} from '@app/api/infrastructure/GatewayRpcClient';
import {GatewayService} from '@app/api/infrastructure/GatewayService';
import type {GatewayVoiceStateCounts} from '@app/api/infrastructure/IGatewayService';
import {NatsGatewayRpcTransport} from '@app/api/infrastructure/NatsGatewayRpcTransport';
import {FakeNatsConnectionManager} from '@app/api/test/mocks/FakeNatsConnectionManager';
import type {VoiceAccessContext} from '@app/api/voice/VoiceAvailabilityService';
import {VoiceAvailabilityService} from '@app/api/voice/VoiceAvailabilityService';
import type {VoiceRegionRecord, VoiceServerRecord} from '@app/api/voice/VoiceModel';
import {resolveVoiceRegionPreference, selectVoiceRegionId} from '@app/api/voice/VoiceRegionSelection';
import {VoiceRepository} from '@app/api/voice/VoiceRepository';
import {VoiceServerLoadTracker} from '@app/api/voice/VoiceServerLoad';
import {VoiceTopology} from '@app/api/voice/VoiceTopology';
import {GuildFeatures} from '@fluxer/constants/src/GuildConstants';
import {afterEach, describe, expect, it} from 'vitest';

function createRegion(overrides: Partial<VoiceRegionRecord> = {}): VoiceRegionRecord {
	return {
		id: 'us-default',
		name: 'US Default',
		emoji: 'flag',
		latitude: 39.8283,
		longitude: -98.5795,
		isDefault: true,
		restrictions: {
			vipOnly: false,
			requiredGuildFeatures: new Set(),
			allowedGuildIds: new Set(),
			allowedUserIds: new Set(),
		},
		createdAt: new Date(),
		updatedAt: new Date(),
		...overrides,
	};
}

function createServer(overrides: Partial<VoiceServerRecord> = {}): VoiceServerRecord {
	return {
		regionId: 'us-default',
		serverId: 'server-1',
		endpoint: 'wss://voice.example.com',
		apiKey: 'test-key',
		apiSecret: 'test-secret',
		latitude: null,
		longitude: null,
		isActive: true,
		softConnectionLimit: null,
		notes: null,
		internalEndpoint: null,
		pinnedHostname: null,
		pinnedSoftLimit: false,
		publicIpv4: null,
		publicIpv6: null,
		draining: false,
		restrictions: {
			vipOnly: false,
			requiredGuildFeatures: new Set(),
			allowedGuildIds: new Set(),
			allowedUserIds: new Set(),
		},
		createdAt: new Date(),
		updatedAt: new Date(),
		...overrides,
	};
}

const ownedTopologies: Array<VoiceTopology> = [];
const ownedManagers: Array<FakeNatsConnectionManager> = [];

afterEach(async () => {
	const topologies = ownedTopologies.splice(0);
	const managers = ownedManagers.splice(0);
	const shutdowns = topologies.map(async (topology) => topology.shutdown());
	if (managers.length > 0) {
		shutdowns.push(GatewayRpcClient.resetForTests());
	}
	const outcomes = await Promise.allSettled(shutdowns);
	for (const outcome of outcomes) {
		if (outcome.status === 'rejected') {
			throw outcome.reason;
		}
	}
	for (const manager of managers) {
		expect(manager.drained).toBe(true);
	}
});

async function createTopology(
	regions: Array<VoiceRegionRecord>,
	serversByRegion: Map<string, Array<VoiceServerRecord>>,
): Promise<VoiceTopology> {
	const repository = new VoiceRepository();
	for (const region of regions) {
		await repository.upsertRegion(region);
	}
	for (const servers of serversByRegion.values()) {
		for (const server of servers) {
			await repository.upsertServer(server);
		}
	}
	const topology = new VoiceTopology(repository, null);
	ownedTopologies.push(topology);
	await topology.initialize();
	return topology;
}

async function createLoadSource(response: GatewayVoiceStateCounts): Promise<VoiceServerLoadTracker> {
	const manager = new FakeNatsConnectionManager(() => ({ok: true, result: response}));
	ownedManagers.push(manager);
	GatewayRpcClient.createForTests(new NatsGatewayRpcTransport(manager));
	const tracker = new VoiceServerLoadTracker({gatewayService: new GatewayService(), now: () => 1000});
	await tracker.refresh();
	expect(manager.requests).toStrictEqual([
		{subject: 'rpc.gateway.process.voice_state_counts', body: {}, timeout: 5000},
	]);
	return tracker;
}

describe('VoiceAvailabilityService', () => {
	let service: VoiceAvailabilityService;
	describe('region access through getAvailableRegions', () => {
		it('returns true for unrestricted region', async () => {
			const region = createRegion();
			const topology = await createTopology([region], new Map([['us-default', [createServer()]]]));
			service = new VoiceAvailabilityService(topology);
			const context: VoiceAccessContext = {
				requestingUserId: createUserID(123n),
			};
			expect(
				service.getAvailableRegions(context).map(({id, isAccessible, serverCount, activeServerCount}) => ({
					id,
					isAccessible,
					serverCount,
					activeServerCount,
				})),
			).toStrictEqual([{id: 'us-default', isAccessible: true, serverCount: 1, activeServerCount: 1}]);
		});
		it('returns false when user is not in allowedUserIds', async () => {
			const region = createRegion({
				restrictions: {
					vipOnly: false,
					requiredGuildFeatures: new Set(),
					allowedGuildIds: new Set(),
					allowedUserIds: new Set([createUserID(456n)]),
				},
			});
			const topology = await createTopology([region], new Map([['us-default', [createServer()]]]));
			service = new VoiceAvailabilityService(topology);
			const context: VoiceAccessContext = {
				requestingUserId: createUserID(123n),
			};
			expect(
				service.getAvailableRegions(context).map(({id, isAccessible, serverCount, activeServerCount}) => ({
					id,
					isAccessible,
					serverCount,
					activeServerCount,
				})),
			).toStrictEqual([{id: 'us-default', isAccessible: false, serverCount: 1, activeServerCount: 1}]);
		});
		it('returns true when user is in allowedUserIds', async () => {
			const region = createRegion({
				restrictions: {
					vipOnly: false,
					requiredGuildFeatures: new Set(),
					allowedGuildIds: new Set(),
					allowedUserIds: new Set([createUserID(123n)]),
				},
			});
			const topology = await createTopology([region], new Map([['us-default', [createServer()]]]));
			service = new VoiceAvailabilityService(topology);
			const context: VoiceAccessContext = {
				requestingUserId: createUserID(123n),
			};
			expect(
				service.getAvailableRegions(context).map(({id, isAccessible, serverCount, activeServerCount}) => ({
					id,
					isAccessible,
					serverCount,
					activeServerCount,
				})),
			).toStrictEqual([{id: 'us-default', isAccessible: true, serverCount: 1, activeServerCount: 1}]);
		});
		it('returns false for vipOnly region without VIP_VOICE feature', async () => {
			const region = createRegion({
				restrictions: {
					vipOnly: true,
					requiredGuildFeatures: new Set(),
					allowedGuildIds: new Set(),
					allowedUserIds: new Set(),
				},
			});
			const topology = await createTopology([region], new Map([['us-default', [createServer()]]]));
			service = new VoiceAvailabilityService(topology);
			const context: VoiceAccessContext = {
				requestingUserId: createUserID(123n),
				guildId: createGuildID(456n),
				guildFeatures: new Set(),
			};
			expect(
				service.getAvailableRegions(context).map(({id, isAccessible, serverCount, activeServerCount}) => ({
					id,
					isAccessible,
					serverCount,
					activeServerCount,
				})),
			).toStrictEqual([{id: 'us-default', isAccessible: false, serverCount: 1, activeServerCount: 1}]);
		});
		it('returns true for vipOnly region with VIP_VOICE feature', async () => {
			const region = createRegion({
				restrictions: {
					vipOnly: true,
					requiredGuildFeatures: new Set(),
					allowedGuildIds: new Set(),
					allowedUserIds: new Set(),
				},
			});
			const topology = await createTopology([region], new Map([['us-default', [createServer()]]]));
			service = new VoiceAvailabilityService(topology);
			const context: VoiceAccessContext = {
				requestingUserId: createUserID(123n),
				guildId: createGuildID(456n),
				guildFeatures: new Set([GuildFeatures.VIP_VOICE]),
			};
			expect(
				service.getAvailableRegions(context).map(({id, isAccessible, serverCount, activeServerCount}) => ({
					id,
					isAccessible,
					serverCount,
					activeServerCount,
				})),
			).toStrictEqual([{id: 'us-default', isAccessible: true, serverCount: 1, activeServerCount: 1}]);
		});
		it('returns false for vipOnly region without guildId', async () => {
			const region = createRegion({
				restrictions: {
					vipOnly: true,
					requiredGuildFeatures: new Set(),
					allowedGuildIds: new Set(),
					allowedUserIds: new Set(),
				},
			});
			const topology = await createTopology([region], new Map([['us-default', [createServer()]]]));
			service = new VoiceAvailabilityService(topology);
			const context: VoiceAccessContext = {
				requestingUserId: createUserID(123n),
			};
			expect(
				service.getAvailableRegions(context).map(({id, isAccessible, serverCount, activeServerCount}) => ({
					id,
					isAccessible,
					serverCount,
					activeServerCount,
				})),
			).toStrictEqual([{id: 'us-default', isAccessible: false, serverCount: 1, activeServerCount: 1}]);
		});
		it('returns true for guild in allowedGuildIds', async () => {
			const region = createRegion({
				restrictions: {
					vipOnly: false,
					requiredGuildFeatures: new Set(),
					allowedGuildIds: new Set([createGuildID(456n)]),
					allowedUserIds: new Set(),
				},
			});
			const topology = await createTopology([region], new Map([['us-default', [createServer()]]]));
			service = new VoiceAvailabilityService(topology);
			const context: VoiceAccessContext = {
				requestingUserId: createUserID(123n),
				guildId: createGuildID(456n),
			};
			expect(
				service.getAvailableRegions(context).map(({id, isAccessible, serverCount, activeServerCount}) => ({
					id,
					isAccessible,
					serverCount,
					activeServerCount,
				})),
			).toStrictEqual([{id: 'us-default', isAccessible: true, serverCount: 1, activeServerCount: 1}]);
		});
		it('returns false for guild not in allowedGuildIds', async () => {
			const region = createRegion({
				restrictions: {
					vipOnly: false,
					requiredGuildFeatures: new Set(),
					allowedGuildIds: new Set([createGuildID(789n)]),
					allowedUserIds: new Set(),
				},
			});
			const topology = await createTopology([region], new Map([['us-default', [createServer()]]]));
			service = new VoiceAvailabilityService(topology);
			const context: VoiceAccessContext = {
				requestingUserId: createUserID(123n),
				guildId: createGuildID(456n),
			};
			expect(
				service.getAvailableRegions(context).map(({id, isAccessible, serverCount, activeServerCount}) => ({
					id,
					isAccessible,
					serverCount,
					activeServerCount,
				})),
			).toStrictEqual([{id: 'us-default', isAccessible: false, serverCount: 1, activeServerCount: 1}]);
		});
		it('returns true for guild with required feature', async () => {
			const region = createRegion({
				restrictions: {
					vipOnly: false,
					requiredGuildFeatures: new Set(['PREMIUM']),
					allowedGuildIds: new Set(),
					allowedUserIds: new Set(),
				},
			});
			const topology = await createTopology([region], new Map([['us-default', [createServer()]]]));
			service = new VoiceAvailabilityService(topology);
			const context: VoiceAccessContext = {
				requestingUserId: createUserID(123n),
				guildId: createGuildID(456n),
				guildFeatures: new Set(['PREMIUM']),
			};
			expect(
				service.getAvailableRegions(context).map(({id, isAccessible, serverCount, activeServerCount}) => ({
					id,
					isAccessible,
					serverCount,
					activeServerCount,
				})),
			).toStrictEqual([{id: 'us-default', isAccessible: true, serverCount: 1, activeServerCount: 1}]);
		});
		it('returns false for guild without required feature', async () => {
			const region = createRegion({
				restrictions: {
					vipOnly: false,
					requiredGuildFeatures: new Set(['PREMIUM']),
					allowedGuildIds: new Set(),
					allowedUserIds: new Set(),
				},
			});
			const topology = await createTopology([region], new Map([['us-default', [createServer()]]]));
			service = new VoiceAvailabilityService(topology);
			const context: VoiceAccessContext = {
				requestingUserId: createUserID(123n),
				guildId: createGuildID(456n),
				guildFeatures: new Set(),
			};
			expect(
				service.getAvailableRegions(context).map(({id, isAccessible, serverCount, activeServerCount}) => ({
					id,
					isAccessible,
					serverCount,
					activeServerCount,
				})),
			).toStrictEqual([{id: 'us-default', isAccessible: false, serverCount: 1, activeServerCount: 1}]);
		});
	});
	describe('server access through getAccessibleServersForRegion', () => {
		it('returns false for inactive server', async () => {
			const region = createRegion();
			const server = createServer({isActive: false});
			const topology = await createTopology([region], new Map([['us-default', [server]]]));
			service = new VoiceAvailabilityService(topology);
			const context: VoiceAccessContext = {
				requestingUserId: createUserID(123n),
			};
			expect(service.getAccessibleServersForRegion('us-default', context).map(({serverId}) => serverId)).toStrictEqual(
				[],
			);
		});
		it('returns true for active unrestricted server', async () => {
			const region = createRegion();
			const server = createServer();
			const topology = await createTopology([region], new Map([['us-default', [server]]]));
			service = new VoiceAvailabilityService(topology);
			const context: VoiceAccessContext = {
				requestingUserId: createUserID(123n),
			};
			expect(service.getAccessibleServersForRegion('us-default', context).map(({serverId}) => serverId)).toStrictEqual([
				'server-1',
			]);
		});
		it('returns false when user is not in server allowedUserIds', async () => {
			const region = createRegion();
			const server = createServer({
				restrictions: {
					vipOnly: false,
					requiredGuildFeatures: new Set(),
					allowedGuildIds: new Set(),
					allowedUserIds: new Set([createUserID(456n)]),
				},
			});
			const topology = await createTopology([region], new Map([['us-default', [server]]]));
			service = new VoiceAvailabilityService(topology);
			const context: VoiceAccessContext = {
				requestingUserId: createUserID(123n),
			};
			expect(service.getAccessibleServersForRegion('us-default', context).map(({serverId}) => serverId)).toStrictEqual(
				[],
			);
		});
	});
	describe('getAvailableRegions', () => {
		it('returns regions with accessibility status', async () => {
			const region1 = createRegion({id: 'us-default', isDefault: true});
			const region2 = createRegion({
				id: 'eu-vip',
				isDefault: false,
				restrictions: {
					vipOnly: true,
					requiredGuildFeatures: new Set(),
					allowedGuildIds: new Set(),
					allowedUserIds: new Set(),
				},
			});
			const server1 = createServer({regionId: 'us-default'});
			const topology = await createTopology(
				[region1, region2],
				new Map([
					['us-default', [server1]],
					['eu-vip', []],
				]),
			);
			service = new VoiceAvailabilityService(topology);
			const context: VoiceAccessContext = {
				requestingUserId: createUserID(123n),
			};
			const regions = service.getAvailableRegions(context);
			expect(regions).toHaveLength(2);
			expect(regions.find(({id}) => id === 'us-default')?.isAccessible).toBe(true);
			expect(regions.find(({id}) => id === 'eu-vip')?.isAccessible).toBe(false);
		});
		it('marks region as not accessible if no servers are available', async () => {
			const region = createRegion();
			const topology = await createTopology([region], new Map([['us-default', []]]));
			service = new VoiceAvailabilityService(topology);
			const context: VoiceAccessContext = {
				requestingUserId: createUserID(123n),
			};
			const regions = service.getAvailableRegions(context);
			expect(regions).toHaveLength(1);
			expect(regions[0].isAccessible).toBe(false);
			expect(regions[0].serverCount).toBe(0);
		});
	});
	describe('selectServer', () => {
		it('returns server from specified region', async () => {
			const region = createRegion();
			const server = createServer();
			const topology = await createTopology([region], new Map([['us-default', [server]]]));
			service = new VoiceAvailabilityService(topology);
			const context: VoiceAccessContext = {
				requestingUserId: createUserID(123n),
			};
			const selected = service.selectServer('us-default', context);
			expect(selected).not.toBeNull();
			expect(selected?.serverId).toBe('server-1');
		});
		it('returns null for region with no servers', async () => {
			const region = createRegion();
			const topology = await createTopology([region], new Map([['us-default', []]]));
			service = new VoiceAvailabilityService(topology);
			const context: VoiceAccessContext = {
				requestingUserId: createUserID(123n),
			};
			const selected = service.selectServer('us-default', context);
			expect(selected).toBeNull();
		});
		it('returns null for non-existent region', async () => {
			const topology = await createTopology([], new Map());
			service = new VoiceAvailabilityService(topology);
			const context: VoiceAccessContext = {
				requestingUserId: createUserID(123n),
			};
			const selected = service.selectServer('non-existent', context);
			expect(selected).toBeNull();
		});
		it('rotates between accessible servers', async () => {
			const region = createRegion();
			const server1 = createServer({serverId: 'server-1'});
			const server2 = createServer({serverId: 'server-2'});
			const topology = await createTopology([region], new Map([['us-default', [server1, server2]]]));
			service = new VoiceAvailabilityService(topology);
			const context: VoiceAccessContext = {
				requestingUserId: createUserID(123n),
			};
			const first = service.selectServer('us-default', context);
			const second = service.selectServer('us-default', context);
			const third = service.selectServer('us-default', context);
			expect(first?.serverId).toBe('server-1');
			expect(second?.serverId).toBe('server-2');
			expect(third?.serverId).toBe('server-1');
		});
		it('rotates only between servers below their soft connection limit', async () => {
			const region = createRegion();
			const server1 = createServer({serverId: 'server-1', softConnectionLimit: 50});
			const server2 = createServer({serverId: 'server-2'});
			const topology = await createTopology([region], new Map([['us-default', [server1, server2]]]));
			service = new VoiceAvailabilityService(
				topology,
				await createLoadSource({
					total_voice_states: 50,
					regions: [],
					servers: [{server_id: 'server-1', voice_state_count: 50}],
				}),
			);
			const context: VoiceAccessContext = {
				requestingUserId: createUserID(123n),
			};
			expect(service.selectServer('us-default', context)?.serverId).toBe('server-2');
			expect(service.selectServer('us-default', context)?.serverId).toBe('server-2');
		});
		it('rotates across every server when all of them are at their soft connection limit', async () => {
			const region = createRegion();
			const server1 = createServer({serverId: 'server-1', softConnectionLimit: 50});
			const server2 = createServer({serverId: 'server-2', softConnectionLimit: 50});
			const topology = await createTopology([region], new Map([['us-default', [server1, server2]]]));
			service = new VoiceAvailabilityService(
				topology,
				await createLoadSource({
					total_voice_states: 180,
					regions: [],
					servers: [
						{server_id: 'server-1', voice_state_count: 90},
						{server_id: 'server-2', voice_state_count: 90},
					],
				}),
			);
			const context: VoiceAccessContext = {
				requestingUserId: createUserID(123n),
			};
			expect(service.selectServer('us-default', context)?.serverId).toBe('server-1');
			expect(service.selectServer('us-default', context)?.serverId).toBe('server-2');
		});
	});
	describe('region placement for users outside region restrictions', () => {
		const vipOnlyRestrictions = {
			vipOnly: true,
			requiredGuildFeatures: new Set<string>(),
			allowedGuildIds: new Set<GuildID>(),
			allowedUserIds: new Set<UserID>(),
		};
		const context: VoiceAccessContext = {
			requestingUserId: createUserID(123n),
			guildId: createGuildID(456n),
			guildFeatures: new Set(),
		};
		function placeWithoutCoordinates(): {regionId: string; server: VoiceServerRecord} | null {
			const accessibleRegions = service.getAvailableRegions(context).filter((region) => region.isAccessible);
			const preference = resolveVoiceRegionPreference({
				preferredRegionId: null,
				accessibleRegions,
				defaultRegionId: null,
			});
			const regionId = selectVoiceRegionId({
				preferredRegionId: preference.regionId,
				mode: preference.mode,
				accessibleRegions,
				selectionKey: 'guild:456:channel:1',
			});
			if (regionId === null) {
				return null;
			}
			return service.selectServerOrFallback(regionId, context, accessibleRegions);
		}
		it('places the user in an open region instead of the VIP-only default region', async () => {
			const vipRegion = createRegion({id: 'vip', isDefault: true, restrictions: vipOnlyRestrictions});
			const openRegion = createRegion({id: 'open', isDefault: false});
			const topology = await createTopology(
				[vipRegion, openRegion],
				new Map([
					['vip', [createServer({regionId: 'vip', serverId: 'vip-1'})]],
					['open', [createServer({regionId: 'open', serverId: 'open-1'})]],
				]),
			);
			service = new VoiceAvailabilityService(topology);
			const placement = placeWithoutCoordinates();
			expect(placement?.regionId).toBe('open');
			expect(placement?.server.serverId).toBe('open-1');
			expect(service.selectServerOrFallback('vip', context, [])).toBeNull();
		});
		it('places nobody when every region is restricted', async () => {
			const vipRegion = createRegion({id: 'vip', isDefault: true, restrictions: vipOnlyRestrictions});
			const topology = await createTopology(
				[vipRegion],
				new Map([['vip', [createServer({regionId: 'vip', serverId: 'vip-1'})]]]),
			);
			service = new VoiceAvailabilityService(topology);
			expect(placeWithoutCoordinates()).toBeNull();
		});
	});
});