A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
// SPDX-License-Identifier: AGPL-3.0-or-later
import {createGuildID, createUserID, type GuildID} from '@app/api/BrandedTypes';
import {SYSTEM_USER_ID} from '@app/api/constants/Core';
import type {GuildRow} from '@app/api/database/types/GuildTypes';
import {GuildAuditLogService} from '@app/api/guild/GuildAuditLogService';
import {
applyPauseGuildInvites,
GUILD_INVITE_PAUSE_SCHEDULE_KEY,
type GuildInvitePauseDeps,
liftExpiredGuildInvitePauses,
} from '@app/api/guild/services/GuildInvitePauseApplier';
import {resetActivityEventsForTests, startActivityEvents} from '@app/api/infrastructure/activity/ActivityEvents';
import type {ActivityPublisher} from '@app/api/infrastructure/activity/ActivitySpool';
import type {ActionEnvelope, Event} from '@app/api/infrastructure/activity/Contract.generated';
import {Guild} from '@app/api/models/Guild';
import {applyAction} from '@app/api/worker/AccountActionConsumer';
import {AuditLogActionType} from '@fluxer/constants/src/AuditLogActionType';
import {GuildFeatures} from '@fluxer/constants/src/GuildConstants';
import {MockKVProvider} from '@pkgs/kv_client/src/testing/MockKVProvider';
import {afterEach, beforeEach, describe, expect, it} from 'vitest';
const GUILD_ID = '1472623911696138261';
const NOW = 1_760_000_000_000;
const HOUR_MS = 3_600_000;
const BASE_FEATURES = [GuildFeatures.BANNER];
type PauseEnvelope = Extract<ActionEnvelope, {type: 'pause_guild_invites'}>;
function pauseEnvelope(overrides: Partial<PauseEnvelope> = {}): PauseEnvelope {
return {
v: 1,
id: 'a:11:guild:0',
key: `guild:${GUILD_ID}`,
issued_at_ms: NOW,
expires_at_ms: NOW + 60_000,
type: 'pause_guild_invites',
guild_id: GUILD_ID,
on: true,
until_ms: NOW + 2 * HOUR_MS,
...overrides,
};
}
function guildRow(features: Iterable<string>, pausedUntil: Date | null = null): GuildRow {
return {
guild_id: createGuildID(BigInt(GUILD_ID)),
owner_id: createUserID(1472623911696138262n),
name: 'Paused',
vanity_url_code: null,
icon_hash: null,
banner_hash: null,
banner_width: null,
banner_height: null,
splash_hash: null,
splash_width: null,
splash_height: null,
splash_card_alignment: null,
embed_splash_hash: null,
embed_splash_width: null,
embed_splash_height: null,
features: new Set(features),
verification_level: 0,
mfa_level: 0,
nsfw_level: 0,
explicit_content_filter: 0,
default_message_notifications: 0,
system_channel_id: null,
system_channel_flags: 0,
rules_channel_id: null,
afk_channel_id: null,
afk_timeout: 0,
disabled_operations: 0,
member_count: 12,
audit_logs_indexed_at: null,
members_indexed_at: null,
message_history_cutoff: null,
invites_paused_until: pausedUntil,
version: 1,
};
}
class FakeGuilds {
row: GuildRow | null = null;
writes = 0;
current(): Guild {
return new Guild(this.row!);
}
async findUnique(_guildId: GuildID): Promise<Guild | null> {
return this.row ? new Guild(this.row) : null;
}
async upsertPartial(_guildId: GuildID, patch: Partial<GuildRow>): Promise<Guild> {
this.writes++;
this.row = {...this.row!, ...patch, version: this.row!.version + 1};
return new Guild(this.row);
}
}
class CapturingPublisher implements ActivityPublisher {
readonly events: Array<Event> = [];
async publish(_subject: string, payload: string): Promise<void> {
this.events.push(JSON.parse(payload) as Event);
}
featureChanges() {
return this.events.flatMap((event) => (event.kind === 'guild_features_changed' ? [event] : []));
}
}
interface Harness {
guilds: FakeGuilds;
schedule: MockKVProvider;
dispatched: Array<unknown>;
audits: Array<{userId: bigint; action: number; changes: unknown}>;
clock: {now: number};
deps: GuildInvitePauseDeps;
}
function harness(): Harness {
const guilds = new FakeGuilds();
const schedule = new MockKVProvider();
const h: Harness = {guilds, schedule, dispatched: [], audits: [], clock: {now: NOW}, deps: null as never};
const auditService = new GuildAuditLogService(null as never, null as never, null as never, null as never);
h.deps = {
guilds,
locks: {acquireLock: async () => 'token', releaseLock: async () => true},
schedule,
gateway: {
dispatchGuild: async (params) => {
h.dispatched.push(params.data);
},
},
auditLog: {
computeChanges: (previous, next) => auditService.computeChanges(previous, next),
record: async (params) => {
h.audits.push({userId: params.userId, action: params.action, changes: params.changes});
},
},
now: () => h.clock.now,
};
return h;
}
async function scheduled(h: Harness): Promise<Array<string>> {
return h.schedule.zrangebyscore(GUILD_INVITE_PAUSE_SCHEDULE_KEY, '-inf', '+inf');
}
describe('guild invite pause', () => {
let h: Harness;
let publisher: CapturingPublisher;
beforeEach(async () => {
h = harness();
publisher = new CapturingPublisher();
await startActivityEvents({publisher, kv: new MockKVProvider()});
});
afterEach(() => {
resetActivityEventsForTests();
});
it('leaves a pause the guild set itself alone and reports it as already paused', async () => {
h.guilds.row = guildRow([...BASE_FEATURES, GuildFeatures.INVITES_DISABLED]);
const outcome = await applyPauseGuildInvites(h.deps, pauseEnvelope());
expect(outcome).toEqual({
action_id: 'a:11:guild:0',
action_type: 'pause_guild_invites',
status: 'noop',
detail: 'already_paused',
observed: null,
guild_id: GUILD_ID,
});
expect(h.guilds.writes).toBe(0);
expect(await scheduled(h)).toEqual([]);
expect(publisher.events).toEqual([]);
const lifted = await applyPauseGuildInvites(h.deps, pauseEnvelope({on: false}));
expect(lifted.status).toBe('noop');
expect(h.guilds.current().features.has(GuildFeatures.INVITES_DISABLED)).toBe(true);
});
it('pauses invites, records it as the system user and schedules the lift', async () => {
h.guilds.row = guildRow(BASE_FEATURES);
const outcome = await applyPauseGuildInvites(h.deps, pauseEnvelope());
expect(outcome).toMatchObject({status: 'applied', detail: `until_ms=${NOW + 2 * HOUR_MS}`, guild_id: GUILD_ID});
const guild = h.guilds.current();
expect([...guild.features].sort()).toEqual(
[...BASE_FEATURES, GuildFeatures.INVITES_DISABLED, GuildFeatures.RAID_DETECTED].sort(),
);
expect(guild.invitesPausedUntil?.getTime()).toBe(NOW + 2 * HOUR_MS);
expect(h.dispatched).toHaveLength(1);
expect(h.audits).toEqual([
{
userId: SYSTEM_USER_ID,
action: AuditLogActionType.GUILD_UPDATE,
changes: [
{
key: 'features',
old_value: [...BASE_FEATURES],
new_value: [...BASE_FEATURES, GuildFeatures.INVITES_DISABLED, GuildFeatures.RAID_DETECTED].sort(),
},
],
},
]);
expect(await scheduled(h)).toEqual([GUILD_ID]);
const [event] = publisher.featureChanges();
expect(event?.key).toBe(`guild:${GUILD_ID}`);
expect(event?.meta.channel).toBe('worker');
expect(event?.data).toEqual({
guild_id: GUILD_ID,
actor_id: null,
source: 'action',
added: [GuildFeatures.INVITES_DISABLED, GuildFeatures.RAID_DETECTED],
removed: [],
invites_paused_until_ms: NOW + 2 * HOUR_MS,
});
});
it('extends its own pause but never shortens it', async () => {
h.guilds.row = guildRow(BASE_FEATURES);
await applyPauseGuildInvites(h.deps, pauseEnvelope());
const extended = await applyPauseGuildInvites(
h.deps,
pauseEnvelope({id: 'a:11:guild:1', until_ms: NOW + 3 * HOUR_MS}),
);
expect(extended.status).toBe('applied');
expect(h.guilds.current().invitesPausedUntil?.getTime()).toBe(NOW + 3 * HOUR_MS);
expect(
await h.schedule.zrangebyscore(GUILD_INVITE_PAUSE_SCHEDULE_KEY, NOW + 3 * HOUR_MS, NOW + 3 * HOUR_MS),
).toEqual([GUILD_ID]);
const shorter = await applyPauseGuildInvites(h.deps, pauseEnvelope({id: 'a:11:guild:2', until_ms: NOW + HOUR_MS}));
expect(shorter).toMatchObject({status: 'noop', detail: `until_ms=${NOW + 3 * HOUR_MS}`});
expect(h.guilds.current().invitesPausedUntil?.getTime()).toBe(NOW + 3 * HOUR_MS);
expect(publisher.featureChanges().map((event) => event.data.invites_paused_until_ms)).toEqual([
NOW + 2 * HOUR_MS,
NOW + 3 * HOUR_MS,
]);
});
it('lifts only its own pause and removes both features', async () => {
h.guilds.row = guildRow(BASE_FEATURES);
await applyPauseGuildInvites(h.deps, pauseEnvelope());
const outcome = await applyAction(
{js: {} as never, state: {} as never, guildInvites: h.deps, now: () => NOW},
pauseEnvelope({id: 'a:11:guild:3', on: false}),
);
expect(outcome).toMatchObject({status: 'applied', guild_id: GUILD_ID});
const guild = h.guilds.current();
expect([...guild.features]).toEqual(BASE_FEATURES);
expect(guild.invitesPausedUntil).toBeNull();
expect(await scheduled(h)).toEqual([]);
expect(publisher.featureChanges().at(-1)?.data).toMatchObject({
source: 'action',
removed: [GuildFeatures.INVITES_DISABLED, GuildFeatures.RAID_DETECTED],
invites_paused_until_ms: null,
});
const again = await applyPauseGuildInvites(h.deps, pauseEnvelope({id: 'a:11:guild:4', on: false}));
expect(again.status).toBe('noop');
});
it('ignores a late lift for an earlier window once the pause was extended', async () => {
h.guilds.row = guildRow(BASE_FEATURES);
await applyPauseGuildInvites(h.deps, pauseEnvelope());
await applyPauseGuildInvites(h.deps, pauseEnvelope({id: 'a:11:guild:5', until_ms: NOW + 3 * HOUR_MS}));
const late = await applyPauseGuildInvites(
h.deps,
pauseEnvelope({id: 'a:11:guild:6', on: false, until_ms: NOW + 2 * HOUR_MS}),
);
expect(late).toMatchObject({status: 'noop', detail: `until_ms=${NOW + 3 * HOUR_MS}`});
expect(h.guilds.current().features.has(GuildFeatures.INVITES_DISABLED)).toBe(true);
expect(h.guilds.current().invitesPausedUntil?.getTime()).toBe(NOW + 3 * HOUR_MS);
const current = await applyPauseGuildInvites(
h.deps,
pauseEnvelope({id: 'a:11:guild:7', on: false, until_ms: NOW + 3 * HOUR_MS}),
);
expect(current.status).toBe('applied');
expect(h.guilds.current().invitesPausedUntil).toBeNull();
});
it('keeps the lift scheduled when the gateway fails after the write and a redelivery changes nothing', async () => {
h.guilds.row = guildRow(BASE_FEATURES);
const dispatch = h.deps.gateway.dispatchGuild;
let failures = 1;
h.deps.gateway = {
dispatchGuild: async (params) => {
if (failures-- > 0) throw new Error('gateway timeout');
await dispatch(params);
},
};
const first = await applyPauseGuildInvites(h.deps, pauseEnvelope());
expect(first).toMatchObject({status: 'applied', guild_id: GUILD_ID});
expect(h.audits).toHaveLength(1);
expect(publisher.featureChanges()).toHaveLength(1);
const redelivered = await applyPauseGuildInvites(h.deps, pauseEnvelope());
expect(redelivered).toMatchObject({status: 'noop', detail: `until_ms=${NOW + 2 * HOUR_MS}`});
expect(h.guilds.writes).toBe(1);
expect(await scheduled(h)).toEqual([GUILD_ID]);
h.clock.now = NOW + 2 * HOUR_MS;
expect(await liftExpiredGuildInvitePauses(h.deps, 100)).toBe(1);
expect([...h.guilds.current().features]).toEqual(BASE_FEATURES);
});
it('restores a lost schedule entry when the same pause is redelivered', async () => {
h.guilds.row = guildRow(
[...BASE_FEATURES, GuildFeatures.INVITES_DISABLED, GuildFeatures.RAID_DETECTED],
new Date(NOW + 2 * HOUR_MS),
);
const outcome = await applyPauseGuildInvites(h.deps, pauseEnvelope());
expect(outcome.status).toBe('noop');
expect(h.guilds.writes).toBe(0);
expect(await scheduled(h)).toEqual([GUILD_ID]);
});
it('writes nothing when scheduling fails so the retry applies the pause', async () => {
h.guilds.row = guildRow(BASE_FEATURES);
const zadd = h.schedule.zadd.bind(h.schedule);
let failures = 1;
h.deps.schedule = {
zadd: async (...args: Parameters<typeof zadd>) => {
if (failures-- > 0) throw new Error('kv unavailable');
return zadd(...args);
},
zrem: h.schedule.zrem.bind(h.schedule),
zrangebyscore: h.schedule.zrangebyscore.bind(h.schedule),
};
await expect(applyPauseGuildInvites(h.deps, pauseEnvelope())).rejects.toThrow('kv unavailable');
expect(h.guilds.writes).toBe(0);
expect((await applyPauseGuildInvites(h.deps, pauseEnvelope())).status).toBe('applied');
expect(await scheduled(h)).toEqual([GUILD_ID]);
});
it('routes the action through the consumer and answers every outcome with the guild', async () => {
h.guilds.row = guildRow(BASE_FEATURES);
const consumer = {js: {} as never, state: {} as never, guildInvites: h.deps, now: () => NOW};
expect(await applyAction(consumer, pauseEnvelope())).toMatchObject({status: 'applied', guild_id: GUILD_ID});
expect(await applyAction(consumer, pauseEnvelope({expires_at_ms: NOW}))).toMatchObject({
status: 'expired',
guild_id: GUILD_ID,
});
expect(await applyAction(consumer, {...pauseEnvelope(), v: 2})).toMatchObject({
status: 'unsupported',
guild_id: GUILD_ID,
});
h.guilds.row = guildRow([...BASE_FEATURES, GuildFeatures.INVITES_DISABLED]);
expect(await applyAction(consumer, pauseEnvelope({id: 'a:11:guild:5'}))).toMatchObject({
status: 'noop',
detail: 'already_paused',
guild_id: GUILD_ID,
});
expect(h.guilds.writes).toBe(1);
});
it('removes a notice staff set before the pause when the pause ends', async () => {
h.guilds.row = guildRow([...BASE_FEATURES, GuildFeatures.RAID_DETECTED]);
expect((await applyPauseGuildInvites(h.deps, pauseEnvelope())).status).toBe('applied');
h.clock.now = NOW + 2 * HOUR_MS;
expect(await liftExpiredGuildInvitePauses(h.deps, 100)).toBe(1);
expect([...h.guilds.current().features]).toEqual(BASE_FEATURES);
});
it('reports a missing guild as ineligible', async () => {
expect((await applyPauseGuildInvites(h.deps, pauseEnvelope())).status).toBe('ineligible');
});
it('lifts an expired pause on the sweep without any action', async () => {
h.guilds.row = guildRow(BASE_FEATURES);
await applyPauseGuildInvites(h.deps, pauseEnvelope());
expect(await liftExpiredGuildInvitePauses(h.deps, 100)).toBe(0);
expect(h.guilds.current().features.has(GuildFeatures.INVITES_DISABLED)).toBe(true);
h.clock.now = NOW + 2 * HOUR_MS;
expect(await liftExpiredGuildInvitePauses(h.deps, 100)).toBe(1);
const guild = h.guilds.current();
expect([...guild.features]).toEqual(BASE_FEATURES);
expect(guild.invitesPausedUntil).toBeNull();
expect(await scheduled(h)).toEqual([]);
expect(publisher.featureChanges().at(-1)?.data).toMatchObject({
source: 'system',
actor_id: null,
removed: [GuildFeatures.INVITES_DISABLED, GuildFeatures.RAID_DETECTED],
});
});
it('drops a sweep entry once the pause is no longer ours and reschedules an extended one', async () => {
h.guilds.row = guildRow([...BASE_FEATURES, GuildFeatures.INVITES_DISABLED]);
await h.schedule.zadd(GUILD_INVITE_PAUSE_SCHEDULE_KEY, NOW - 1, GUILD_ID);
expect(await liftExpiredGuildInvitePauses(h.deps, 100)).toBe(0);
expect(await scheduled(h)).toEqual([]);
expect(h.guilds.current().features.has(GuildFeatures.INVITES_DISABLED)).toBe(true);
h.guilds.row = guildRow(
[...BASE_FEATURES, GuildFeatures.INVITES_DISABLED, GuildFeatures.RAID_DETECTED],
new Date(NOW + HOUR_MS),
);
await h.schedule.zadd(GUILD_INVITE_PAUSE_SCHEDULE_KEY, NOW - 1, GUILD_ID);
expect(await liftExpiredGuildInvitePauses(h.deps, 100)).toBe(0);
expect(await h.schedule.zrangebyscore(GUILD_INVITE_PAUSE_SCHEDULE_KEY, NOW + HOUR_MS, NOW + HOUR_MS)).toEqual([
GUILD_ID,
]);
expect(h.guilds.writes).toBe(0);
});
});