Skip to content

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

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

import {createTestAccount, type TestAccount} from '@app/api/auth/tests/AuthTestUtils';
import {createGuildID, createUserID, type UserID} from '@app/api/BrandedTypes';
import {Config} from '@app/api/Config';
import {createTestGuildStack} from '@app/api/channel/tests/CrosspostTestUtils';
import {
	acceptInvite,
	createChannel,
	createChannelInvite,
	createGuild,
	createRole,
	getMember,
	leaveGuild,
} from '@app/api/guild/tests/GuildTestUtils';
import {getMessages} from '@app/api/message/tests/MessageTestUtils';
import {getSnowflakeService, getWorkerService, setInjectedWorkerService} from '@app/api/middleware/ServiceRegistry';
import {
	getCacheService,
	getChannelRepository,
	getGuildRepository,
	getOperatorPassWallService,
	getUserRepository,
} from '@app/api/middleware/ServiceSingletons';
import {OperatorPassHoldingService} from '@app/api/operator_pass/OperatorPassHoldingService';
import {
	type OperatorPassLabsGreetingDeps,
	runOperatorPassLabsGreeting,
} from '@app/api/operator_pass/OperatorPassLabsGreeting';
import {
	type LabsDeliveryJob,
	OPERATOR_PASS_LABS_DELIVERY_TASK,
	OperatorPassLabsRoleService,
} from '@app/api/operator_pass/OperatorPassLabsRole';
import {OperatorPassRepository} from '@app/api/operator_pass/OperatorPassRepository';
import {type ApiTestHarness, createApiTestHarness} from '@app/api/test/ApiTestHarness';
import {RecordingWorkerService} from '@app/api/test/RecordingWorkerService';
import {HTTP_STATUS} from '@app/api/test/TestConstants';
import {createBuilder} from '@app/api/test/TestRequestBuilder';
import {UserNotificationSettings} from '@fluxer/constants/src/UserConstants';
import {TestEmailService} from '@pkgs/email/src/TestEmailService';
import type {WorkerJobPayload} from '@pkgs/worker/src/contracts/WorkerTypes';
import {afterAll, afterEach, beforeAll, expect, test, vi} from 'vitest';

const DELIVERED_AT = new Date('2026-11-01T16:05:00.000Z');

let harness: ApiTestHarness;
const originalOperatorPass = {...Config.operatorPass};
const originalSelfHosted = Config.instance.selfHosted;

beforeAll(async () => {
	harness = await createApiTestHarness();
});

afterEach(() => {
	Object.assign(Config.operatorPass, originalOperatorPass);
	Config.instance.selfHosted = originalSelfHosted;
});

afterAll(async () => {
	await harness.shutdown();
});

async function setUpLabs() {
	const owner = await createTestAccount(harness);
	const labs = await createGuild(harness, owner.token, 'Labs');
	const operatorRole = await createRole(harness, owner.token, labs.id, {name: 'Operator'});
	const visionaryRole = await createRole(harness, owner.token, labs.id, {name: 'Visionary'});
	const operators = await createChannel(harness, owner.token, labs.id, 'operators');
	Config.instance.selfHosted = false;
	Config.operatorPass.labsGuildId = BigInt(labs.id);
	Config.operatorPass.labsOperatorRoleId = BigInt(operatorRole.id);
	Config.operatorPass.labsVisionaryRoleId = BigInt(visionaryRole.id);
	Config.operatorPass.labsOperatorsChannelId = BigInt(operators.id);
	const stack = createTestGuildStack();
	const repository = new OperatorPassRepository();
	const roles = new OperatorPassLabsRoleService(getGuildRepository(), stack.guildService);
	const greetingDeps: OperatorPassLabsGreetingDeps = {
		repository,
		userRepository: getUserRepository(),
		guildRepository: getGuildRepository(),
		channelRepository: getChannelRepository(),
		messages: stack.channelService.messages.send,
		snowflakeService: getSnowflakeService(),
		cacheService: getCacheService(),
	};
	return {owner, labs, operatorRole, operators, repository, roles, greetingDeps};
}

async function createOperator(repository: OperatorPassRepository): Promise<{account: TestAccount; userId: UserID}> {
	const account = await createTestAccount(harness);
	const userId = createUserID(BigInt(account.userId));
	await repository.createUnit({
		pass_id: `labs-test:${userId}:1`,
		purchase_id: null,
		buyer_id: userId,
		holder_id: userId,
		source: 'purchase',
		status: 'held',
		transferable: false,
		delivered_at: DELIVERED_AT,
		first_delivered_at: DELIVERED_AT,
		paused_at: null,
		ended_at: null,
		end_reason: null,
		withdrawal_country: null,
		withdrawal_days: null,
		version: 1,
	});
	await repository.saveOperatorPass({
		user_id: userId,
		granted_at: DELIVERED_AT,
		source: 'purchase',
		pass_count: 1,
		checkout_session_id: null,
		payment_intent_id: null,
		amount_minor: null,
		currency: null,
		paused_at: null,
		terms_version: null,
		terms_accepted_at: null,
		waiver_consent_at: null,
		waiver_consent_version: null,
		waiver_consent_ip: null,
		waiver_consent_user_agent: null,
		version: 1,
	});
	return {account, userId};
}

async function deliver(roles: OperatorPassLabsRoleService, userId: UserID, greeting: boolean | null) {
	await roles.deliver(await getUserRepository().findUniqueAssert(userId), greeting);
}

test('delivery adds Operators to Labs, never adds back someone who left, and one message welcomes the window once', async () => {
	const {owner, labs, operatorRole, operators, repository, roles, greetingDeps} = await setUpLabs();
	const first = await createOperator(repository);
	const second = await createOperator(repository);
	const leaver = await createOperator(repository);
	const quiet = await createOperator(repository);
	const invite = await createChannelInvite(harness, owner.token, labs.system_channel_id!);
	await acceptInvite(harness, leaver.account.token, invite.code);
	await leaveGuild(harness, leaver.account.token, labs.id);

	await deliver(roles, first.userId, null);
	await deliver(roles, second.userId, true);
	await deliver(roles, leaver.userId, true);
	await deliver(roles, quiet.userId, false);

	for (const operator of [first, second, quiet]) {
		const member = await getMember(harness, owner.token, labs.id, operator.account.userId);
		expect(member.roles).toContain(operatorRole.id);
		const settings = await getUserRepository().findGuildSettings(operator.userId, createGuildID(BigInt(labs.id)));
		expect(settings?.messageNotifications).toBe(UserNotificationSettings.ONLY_MENTIONS);
	}
	expect(await getGuildRepository().getMember(createGuildID(BigInt(labs.id)), leaver.userId)).toBeNull();
	expect((await repository.findLabsMember(leaver.userId))?.left_reason).toBe('left');

	expect(await runOperatorPassLabsGreeting(greetingDeps)).toEqual({greeted: 2, messages: 1, dropped: 0});
	await deliver(roles, first.userId, null);
	expect(await runOperatorPassLabsGreeting(greetingDeps)).toEqual({greeted: 0, messages: 0, dropped: 0});

	const messages = await getMessages(harness, owner.token, operators.id);
	expect(messages).toHaveLength(1);
	expect(messages[0]?.content).toContain(`<@${first.userId}>`);
	expect(messages[0]?.content).toContain(`<@${second.userId}>`);
	expect(messages[0]?.content).not.toContain(`<@${quiet.userId}>`);
	expect(messages[0]?.mentions?.map((user) => user.id).sort()).toEqual(
		[first.account.userId, second.account.userId].map(String).sort(),
	);
});

test('a run that sent the welcome but stopped before recording it does not send it again', async () => {
	const {owner, operators, repository, roles, greetingDeps} = await setUpLabs();
	const operator = await createOperator(repository);
	await deliver(roles, operator.userId, true);
	const failing = Object.create(repository) as OperatorPassRepository;
	failing.recordLabsGreeted = async () => {
		throw new Error('lost the connection');
	};

	await expect(runOperatorPassLabsGreeting({...greetingDeps, repository: failing})).rejects.toThrow(
		'lost the connection',
	);
	expect(await runOperatorPassLabsGreeting(greetingDeps)).toEqual({greeted: 1, messages: 0, dropped: 0});

	expect(await getMessages(harness, owner.token, operators.id)).toHaveLength(1);
	expect((await repository.findLabsMember(operator.userId))?.greeted_at).not.toBeNull();
});

test('turning the welcome off before the window ends means no welcome', async () => {
	const {owner, operators, repository, roles, greetingDeps} = await setUpLabs();
	const operator = await createOperator(repository);
	await deliver(roles, operator.userId, true);
	await repository.setLabsGreeting(operator.userId, false);

	expect(await runOperatorPassLabsGreeting(greetingDeps)).toEqual({greeted: 0, messages: 0, dropped: 1});
	expect(await getMessages(harness, owner.token, operators.id)).toHaveLength(0);
});

test('turning the welcome on in settings after a delivery with it off still welcomes the person once', async () => {
	const {owner, operators, repository, roles, greetingDeps} = await setUpLabs();
	const operator = await createOperator(repository);
	await deliver(roles, operator.userId, false);
	expect(await runOperatorPassLabsGreeting(greetingDeps)).toEqual({greeted: 0, messages: 0, dropped: 0});

	await repository.setLabsGreeting(operator.userId, true);
	expect(await roles.queueGreetingIfDue(await getUserRepository().findUniqueAssert(operator.userId))).toBe(true);

	expect(await runOperatorPassLabsGreeting(greetingDeps)).toEqual({greeted: 1, messages: 1, dropped: 0});
	expect(await roles.queueGreetingIfDue(await getUserRepository().findUniqueAssert(operator.userId))).toBe(false);
	expect(await getMessages(harness, owner.token, operators.id)).toHaveLength(1);
});

test('joining from checkout adds an Operator once, keeps members as they are and never adds back someone who left or was banned', async () => {
	const {owner, labs, operatorRole, repository, roles} = await setUpLabs();
	const joiner = await createOperator(repository);
	const leaver = await createOperator(repository);
	const banned = await createOperator(repository);
	const noPass = await createTestAccount(harness);
	const invite = await createChannelInvite(harness, owner.token, labs.system_channel_id!);
	await acceptInvite(harness, leaver.account.token, invite.code);
	await leaveGuild(harness, leaver.account.token, labs.id);
	await acceptInvite(harness, banned.account.token, invite.code);
	const join = async (userId: UserID) => roles.joinFromCheckout(await getUserRepository().findUniqueAssert(userId));

	expect(await join(joiner.userId)).toBe('joined');
	expect(await join(joiner.userId)).toBe('joined');
	expect((await getMember(harness, owner.token, labs.id, joiner.account.userId)).roles).toContain(operatorRole.id);
	expect(await join(leaver.userId)).toBe('left');
	await createBuilder(harness, owner.token)
		.put(`/guilds/${labs.id}/bans/${banned.account.userId}`)
		.body({})
		.expect(HTTP_STATUS.NO_CONTENT)
		.execute();
	expect(await join(banned.userId)).toBe('banned');
	expect(await join(createUserID(BigInt(noPass.userId)))).toBe('not_held');
	expect(await getGuildRepository().getMember(createGuildID(BigInt(labs.id)), leaver.userId)).toBeNull();
});

function retryJob(userId: UserID, payload: WorkerJobPayload): LabsDeliveryJob {
	return {
		userId,
		greeting: payload.greeting as boolean | null,
		origin: String(payload.origin),
		retry: Number(payload.retry),
	};
}

test('a failed add to Labs is queued again with backoff and the retry adds the person with the checkout welcome choice', async () => {
	const {owner, labs, operatorRole, repository, roles, greetingDeps} = await setUpLabs();
	const operator = await createOperator(repository);
	const stack = createTestGuildStack();
	const members = Object.create(stack.guildService.members) as typeof stack.guildService.members;
	members.addUserToGuild = async () => {
		throw new Error('gateway timed out');
	};
	const failing = new OperatorPassLabsRoleService(getGuildRepository(), {members} as typeof stack.guildService);
	const previousWorker = getWorkerService();
	const worker = new RecordingWorkerService();
	setInjectedWorkerService(worker);
	try {
		const before = Date.now();
		await failing.deliver(await getUserRepository().findUniqueAssert(operator.userId), false);
		expect(await getGuildRepository().getMember(createGuildID(BigInt(labs.id)), operator.userId)).toBeNull();
		const [queued] = worker.byTask(OPERATOR_PASS_LABS_DELIVERY_TASK);
		expect(queued?.payload).toMatchObject({user_id: operator.userId.toString(), greeting: false, retry: 1});
		expect(queued?.options?.runAt?.getTime()).toBeGreaterThanOrEqual(before + 60_000);

		await failing.retryDelivery(retryJob(operator.userId, queued!.payload), getUserRepository());
		const [, second] = worker.byTask(OPERATOR_PASS_LABS_DELIVERY_TASK);
		expect(second?.payload.retry).toBe(2);
		expect(second?.options?.jobKey).not.toBe(queued?.options?.jobKey);

		await roles.retryDelivery(retryJob(operator.userId, second!.payload), getUserRepository());
		const member = await getMember(harness, owner.token, labs.id, operator.account.userId);
		expect(member.roles).toContain(operatorRole.id);
		expect(worker.byTask(OPERATOR_PASS_LABS_DELIVERY_TASK)).toHaveLength(2);
		expect(await runOperatorPassLabsGreeting(greetingDeps)).toEqual({greeted: 0, messages: 0, dropped: 0});
	} finally {
		setInjectedWorkerService(previousWorker);
	}
});

test('a run welcomes everyone queued in that window, fifty people per message', async () => {
	const {owner, operators, repository, roles, greetingDeps} = await setUpLabs();
	const operatorIds: Array<UserID> = [];
	for (let index = 0; index < 101; index++) {
		const operator = await createOperator(repository);
		await deliver(roles, operator.userId, true);
		operatorIds.push(operator.userId);
	}

	expect(await runOperatorPassLabsGreeting(greetingDeps)).toEqual({greeted: 101, messages: 3, dropped: 0});

	const messages = await getMessages(harness, owner.token, operators.id);
	expect(messages).toHaveLength(3);
	expect(messages.map((message) => message.mentions?.length).sort()).toEqual([1, 50, 50]);
	expect(messages.flatMap((message) => message.mentions?.map((user) => user.id) ?? []).sort()).toEqual(
		operatorIds.map(String).sort(),
	);
	expect(await repository.listLabsGreetings()).toHaveLength(0);
});

test('turning #operators off keeps the Operator role away through every sync, and turning it on gives it back', async () => {
	const {owner, labs, operatorRole, repository, roles} = await setUpLabs();
	const operator = await createOperator(repository);
	const holding = new OperatorPassHoldingService({
		repository,
		userRepository: getUserRepository(),
		roleService: roles,
		gatewayService: {dispatchPresence: vi.fn()} as unknown as ConstructorParameters<
			typeof OperatorPassHoldingService
		>[0]['gatewayService'],
		emailService: new TestEmailService(),
		wallService: getOperatorPassWallService(),
		findPurchase: (purchaseId) => repository.findPurchase(purchaseId),
	});
	const roleIds = async () => (await getMember(harness, owner.token, labs.id, operator.account.userId)).roles;
	await deliver(roles, operator.userId, null);
	expect(await roleIds()).toContain(operatorRole.id);

	const hidden = await holding.updateLabsOperatorsChannel(
		await getUserRepository().findUniqueAssert(operator.userId),
		false,
	);
	expect(await roleIds()).not.toContain(operatorRole.id);
	expect((await holding.queries.describePasses(hidden)).labs.show_operators).toBe(false);

	await roles.syncLabsRolesForMembers(getUserRepository(), 100);
	await deliver(roles, operator.userId, null);
	expect(await roles.joinFromCheckout(await getUserRepository().findUniqueAssert(operator.userId))).toBe('joined');
	expect(await roleIds()).not.toContain(operatorRole.id);

	const shown = await holding.updateLabsOperatorsChannel(hidden, true);
	expect(await roleIds()).toContain(operatorRole.id);
	expect((await holding.queries.describePasses(shown)).labs.show_operators).toBe(true);
});