Skip to content

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

TypeScript fluxerfluxerapp

test(api): cover community visits and visit sessions

Hampus89a4e8103c1c
diff --git a/fluxer_api/src/api/guild/tests/GuildVisitAdversarial.test.ts b/fluxer_api/src/api/guild/tests/GuildVisitAdversarial.test.ts
new file mode 100644
index 000000000..ade8528bb
--- /dev/null
+++ b/fluxer_api/src/api/guild/tests/GuildVisitAdversarial.test.ts
@@ -0,0 +1,113 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+import {createTestAccount, type TestAccount} from '@app/api/auth/tests/AuthTestUtils';
+import {sendChannelMessage} from '@app/api/channel/tests/ChannelTestUtils';
+import {getInstanceConfigRepository} from '@app/api/middleware/ServiceSingletons';
+import {type ApiTestHarness, createApiTestHarness} from '@app/api/test/ApiTestHarness';
+import {HTTP_STATUS} from '@app/api/test/TestConstants';
+import {createBuilder, createBuilderWithoutAuth} from '@app/api/test/TestRequestBuilder';
+import type {GuildResponse} from '@fluxer/schema/src/domains/guild/GuildResponseSchemas';
+import {afterAll, beforeAll, beforeEach, describe, expect, it} from 'vitest';
+
+interface Registered {
+ token: string;
+ user_id: string;
+}
+
+interface Scene {
+ owner: TestAccount;
+ guildId: string;
+ channelId: string;
+ code: string;
+}
+
+const SHARED_IP = '198.51.100.77';
+
+describe('Guild visits under adversarial use', () => {
+ let harness: ApiTestHarness;
+ beforeAll(async () => {
+ harness = await createApiTestHarness();
+ });
+ beforeEach(async () => {
+ await harness.reset();
+ await getInstanceConfigRepository().updateGuildVisitsConfig({enabled: true, user_basis_points: 10000});
+ });
+ afterAll(async () => {
+ await harness?.shutdown();
+ });
+
+ async function createScene(inviteBody: Record<string, unknown> = {}): Promise<Scene> {
+ const owner = await createTestAccount(harness);
+ const guild = await createBuilder<GuildResponse>(harness, owner.token)
+ .post('/guilds')
+ .body({name: 'Adversarial'})
+ .execute();
+ const channelId = guild.system_channel_id!;
+ await sendChannelMessage(harness, owner.token, channelId, 'members only chatter');
+ const invite = await createBuilder<{code: string}>(harness, owner.token)
+ .post(`/channels/${channelId}/invites`)
+ .body(inviteBody)
+ .execute();
+ return {owner, guildId: guild.id, channelId, code: invite.code};
+ }
+
+ async function createUnclaimed(username: string, ip?: string): Promise<Registered> {
+ const builder = createBuilderWithoutAuth<Registered>(harness)
+ .post('/auth/register')
+ .body({username, consent: true, date_of_birth: '1990-01-01'});
+ if (ip) builder.header('x-forwarded-for', ip);
+ return await builder.execute();
+ }
+
+ it('keeps a limited invite usable when one account visits and leaves in a loop', async () => {
+ const {guildId, code} = await createScene({max_uses: 3});
+ const looper = await createTestAccount(harness);
+ for (let round = 0; round < 3; round++) {
+ await createBuilder(harness, looper.token).post(`/invites/${code}/visit`).body(null).execute();
+ await createBuilder(harness, looper.token)
+ .delete(`/users/@me/guild-visits/${guildId}`)
+ .expect(HTTP_STATUS.NO_CONTENT)
+ .execute();
+ }
+ const newcomer = await createTestAccount(harness);
+ await createBuilder(harness, newcomer.token).post(`/invites/${code}`).body(null).execute();
+ });
+
+ it('refuses unclaimed accounts a full join on the enforced tier whatever the client claims', async () => {
+ await getInstanceConfigRepository().updateAccountsConfig({interaction_tier: 'enforced'});
+ const {owner, guildId, code} = await createScene();
+ const before = await createBuilder<GuildResponse>(harness, owner.token).get(`/guilds/${guildId}`).execute();
+ const unclaimed = await createUnclaimed('squatter');
+ const joined = await createBuilder(harness, unclaimed.token).post(`/invites/${code}`).body(null).executeRaw();
+ expect(joined.response.status).toBe(HTTP_STATUS.FORBIDDEN);
+ const after = await createBuilder<GuildResponse>(harness, owner.token).get(`/guilds/${guildId}`).execute();
+ expect(after.member_count).toBe(before.member_count);
+ });
+
+ it('stops REST reads by a visitor whose address was banned through another account', async () => {
+ const {owner, guildId, channelId, code} = await createScene();
+ const alt = await createUnclaimed('lurkalt', SHARED_IP);
+ await createBuilder(harness, alt.token)
+ .post(`/invites/${code}/visit`)
+ .header('x-forwarded-for', SHARED_IP)
+ .body(null)
+ .execute();
+ const main = await createUnclaimed('lurkmain', SHARED_IP);
+ await createBuilder(harness, owner.token)
+ .put(`/guilds/${guildId}/bans/${main.user_id}`)
+ .body({delete_message_days: 0})
+ .expect(HTTP_STATUS.NO_CONTENT)
+ .execute();
+ await createBuilder(harness, alt.token)
+ .post(`/invites/${code}/visit`)
+ .header('x-forwarded-for', SHARED_IP)
+ .body(null)
+ .expect(HTTP_STATUS.FORBIDDEN)
+ .execute();
+ const read = await createBuilder(harness, alt.token)
+ .get(`/channels/${channelId}/messages`)
+ .header('x-forwarded-for', SHARED_IP)
+ .executeRaw();
+ expect(read.response.status).not.toBe(HTTP_STATUS.OK);
+ });
+});
diff --git a/fluxer_api/src/api/guild/tests/GuildVisitSession.test.ts b/fluxer_api/src/api/guild/tests/GuildVisitSession.test.ts
new file mode 100644
index 000000000..d0b2b4a0e
--- /dev/null
+++ b/fluxer_api/src/api/guild/tests/GuildVisitSession.test.ts
@@ -0,0 +1,79 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+import {createTestAccount, type TestAccount} from '@app/api/auth/tests/AuthTestUtils';
+import {createGuildID, createUserID} from '@app/api/BrandedTypes';
+import {createChannelInvite, createGuild, getGuildChannels} from '@app/api/guild/tests/GuildTestUtils';
+import {bumpGuildBanGeneration} from '@app/api/guild/visits/GuildVisitLifecycle';
+import {guildVisitRepository} from '@app/api/guild/visits/GuildVisitorAccess';
+import {getGuildRepository, getInstanceConfigRepository} from '@app/api/middleware/ServiceSingletons';
+import {type ApiTestHarness, createApiTestHarness} from '@app/api/test/ApiTestHarness';
+import {createBuilder} from '@app/api/test/TestRequestBuilder';
+import {HttpStatus} from '@fluxer/constants/src/HttpConstants';
+import {afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi} from 'vitest';
+
+interface SessionData {
+ data: {visit_guild_ids: Array<string>};
+}
+
+const VISITOR_IP = '198.51.100.23';
+
+describe('Guild visit session ban checks', () => {
+ let harness: ApiTestHarness;
+
+ beforeAll(async () => {
+ harness = await createApiTestHarness();
+ });
+ beforeEach(async () => {
+ await harness.reset();
+ await getInstanceConfigRepository().updateGuildVisitsConfig({enabled: true, user_basis_points: 10000});
+ });
+ afterAll(async () => {
+ await harness.shutdown();
+ });
+
+ async function createVisit() {
+ const owner = await createTestAccount(harness);
+ const visitor = await createTestAccount(harness, {ipAddress: VISITOR_IP});
+ const guild = await createGuild(harness, owner.token, 'Session Visits');
+ const [channel] = await getGuildChannels(harness, owner.token, guild.id);
+ const invite = await createChannelInvite(harness, owner.token, channel.id);
+ await createBuilder(harness, visitor.token)
+ .post(`/invites/${invite.code}/visit`)
+ .header('x-forwarded-for', VISITOR_IP)
+ .body(null)
+ .execute();
+ const guildId = createGuildID(BigInt(guild.id));
+ await bumpGuildBanGeneration(guildId);
+ return {owner, visitor, guildId};
+ }
+
+ function restoreSession(visitor: TestAccount) {
+ return createBuilder<SessionData>(harness, '')
+ .post('/test/rpc-session-init')
+ .body({type: 'session', token: visitor.token, version: 1, ip: VISITOR_IP, guild_visits_capable: true});
+ }
+
+ it.each([
+ ['account', 'visitor', null],
+ ['IP address', 'owner', VISITOR_IP],
+ ] as const)('ends the visit when the %s is banned', async (_label, target, ip) => {
+ const {owner, visitor, guildId} = await createVisit();
+ const userId = createUserID(BigInt(visitor.userId));
+ const targets = {owner: owner.userId, visitor: visitor.userId};
+ await getGuildRepository().upsertBan({
+ guild_id: guildId,
+ user_id: createUserID(BigInt(targets[target])),
+ moderator_id: createUserID(BigInt(owner.userId)),
+ banned_at: new Date(),
+ expires_at: null,
+ reason: null,
+ ip,
+ email: null,
+ });
+
+ const session = await restoreSession(visitor).execute();
+
+ expect(session.data.visit_guild_ids).toEqual([]);
+ expect(await guildVisitRepository().get(userId, guildId)).toBeNull();
+ });
+});
diff --git a/fluxer_api/src/api/guild/tests/GuildVisits.test.ts b/fluxer_api/src/api/guild/tests/GuildVisits.test.ts
new file mode 100644
index 000000000..6d361ed0a
--- /dev/null
+++ b/fluxer_api/src/api/guild/tests/GuildVisits.test.ts
@@ -0,0 +1,420 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+import {createTestAccount, setUserACLs, type TestAccount} from '@app/api/auth/tests/AuthTestUtils';
+import {createGuildID, createUserID} from '@app/api/BrandedTypes';
+import {sendChannelMessage} from '@app/api/channel/tests/ChannelTestUtils';
+import {guildVisitRepository} from '@app/api/guild/visits/GuildVisitorAccess';
+import {getGatewayService} from '@app/api/middleware/ServiceRegistry';
+import {getInstanceConfigRepository} from '@app/api/middleware/ServiceSingletons';
+import {type ApiTestHarness, createApiTestHarness} from '@app/api/test/ApiTestHarness';
+import type {NoopGatewayService} from '@app/api/test/NoopGatewayService';
+import {HTTP_STATUS} from '@app/api/test/TestConstants';
+import {createBuilder, createBuilderWithoutAuth} from '@app/api/test/TestRequestBuilder';
+import {APIErrorCodes} from '@fluxer/constants/src/ApiErrorCodes';
+import {DiscoveryCategories} from '@fluxer/constants/src/DiscoveryConstants';
+import {GuildFeatures} from '@fluxer/constants/src/GuildConstants';
+import {GuildVisitSources} from '@fluxer/constants/src/GuildVisitConstants';
+import {Headers} from '@fluxer/constants/src/Headers';
+import type {GuildResponse} from '@fluxer/schema/src/domains/guild/GuildResponseSchemas';
+import type {GuildVisitResponse, GuildVisitStartResponse} from '@fluxer/schema/src/domains/guild/GuildVisitSchemas';
+import {afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi} from 'vitest';
+
+interface Registered {
+ token: string;
+ user_id: string;
+ entry?: {guild_id: string; mode: string} | null;
+}
+
+interface VisitGuild {
+ owner: TestAccount;
+ guildId: string;
+ channelId: string;
+ code: string;
+}
+
+function yearsAgo(years: number): string {
+ const date = new Date();
+ date.setUTCFullYear(date.getUTCFullYear() - years);
+ date.setUTCDate(date.getUTCDate() - 1);
+ return date.toISOString().slice(0, 10);
+}
+
+describe('Guild visits', () => {
+ let harness: ApiTestHarness;
+ let gateway: NoopGatewayService;
+ beforeAll(async () => {
+ harness = await createApiTestHarness();
+ });
+ beforeEach(async () => {
+ await harness.reset();
+ gateway = getGatewayService() as NoopGatewayService;
+ gateway.visitEvents.length = 0;
+ await getInstanceConfigRepository().updateGuildVisitsConfig({enabled: true, user_basis_points: 10000});
+ });
+ afterAll(async () => {
+ await harness?.shutdown();
+ });
+
+ async function createVisitGuild(name = 'Visit Guild', inviteBody: Record<string, unknown> = {}): Promise<VisitGuild> {
+ const owner = await createTestAccount(harness);
+ const guild = await createBuilder<GuildResponse>(harness, owner.token).post('/guilds').body({name}).execute();
+ const channelId = guild.system_channel_id!;
+ const invite = await createBuilder<{code: string}>(harness, owner.token)
+ .post(`/channels/${channelId}/invites`)
+ .body(inviteBody)
+ .execute();
+ return {owner, guildId: guild.id, channelId, code: invite.code};
+ }
+
+ async function createUnclaimed(dateOfBirth = yearsAgo(30)): Promise<Registered> {
+ return await createBuilderWithoutAuth<Registered>(harness)
+ .post('/auth/register')
+ .body({username: 'visitor', consent: true, date_of_birth: dateOfBirth})
+ .execute();
+ }
+
+ function startVisit(token: string, code: string) {
+ return createBuilder<GuildVisitStartResponse>(harness, token).post(`/invites/${code}/visit`).body(null);
+ }
+
+ async function setFeatures(owner: TestAccount, guildId: string, features: Array<string>): Promise<void> {
+ await createBuilder(harness, owner.token).patch(`/guilds/${guildId}`).body({features}).execute();
+ }
+
+ it('turns visits on for new guilds and lets the owner turn them off', async () => {
+ const {owner, guildId} = await createVisitGuild();
+ const guild = await createBuilder<GuildResponse>(harness, owner.token).get(`/guilds/${guildId}`).execute();
+ expect(guild.features).toContain(GuildFeatures.VISITS_ENABLED);
+ await setFeatures(owner, guildId, []);
+ const after = await createBuilder<GuildResponse>(harness, owner.token).get(`/guilds/${guildId}`).execute();
+ expect(after.features).not.toContain(GuildFeatures.VISITS_ENABLED);
+ });
+
+ it('starts a visit from an invite without making a member', async () => {
+ const {guildId, code} = await createVisitGuild();
+ const visitor = await createUnclaimed();
+ const started = await startVisit(visitor.token, code).execute();
+ expect(started).toMatchObject({guild_id: guildId, member: false, visit: {guild_id: guildId, source: 1}});
+ expect(gateway.visitEvents).toEqual([
+ {kind: 'start', userId: createUserID(BigInt(visitor.user_id)), guildId: createGuildID(BigInt(guildId))},
+ ]);
+ expect(
+ await gateway.hasGuildMember({
+ guildId: createGuildID(BigInt(guildId)),
+ userId: createUserID(BigInt(visitor.user_id)),
+ }),
+ ).toBe(false);
+ const visits = await createBuilder<Array<GuildVisitResponse>>(harness, visitor.token)
+ .get('/users/@me/guild-visits')
+ .execute();
+ expect(visits.map((visit) => visit.guild_id)).toEqual([guildId]);
+ const again = await startVisit(visitor.token, code).execute();
+ expect(again.visit?.started_at).toBe(started.visit?.started_at);
+ });
+
+ it('answers as a member when the user already joined', async () => {
+ const {owner, guildId, code} = await createVisitGuild();
+ const started = await startVisit(owner.token, code).execute();
+ expect(started).toEqual({guild_id: guildId, member: true, visit: null});
+ expect(gateway.visitEvents).toEqual([]);
+ });
+
+ it('hides the visit route while the switch or the assignment is off', async () => {
+ const {code} = await createVisitGuild();
+ const visitor = await createUnclaimed();
+ await getInstanceConfigRepository().updateGuildVisitsConfig({enabled: false});
+ await startVisit(visitor.token, code).expect(HTTP_STATUS.NOT_FOUND, APIErrorCodes.UNKNOWN_INVITE).execute();
+ await getInstanceConfigRepository().updateGuildVisitsConfig({enabled: true, user_basis_points: 0});
+ await startVisit(visitor.token, code).expect(HTTP_STATUS.NOT_FOUND, APIErrorCodes.UNKNOWN_INVITE).execute();
+ const listed = await createBuilder<Array<GuildVisitResponse>>(harness, visitor.token)
+ .get('/users/@me/guild-visits')
+ .execute();
+ expect(listed).toEqual([]);
+ });
+
+ it('refuses guilds that turned visits off or paused invites', async () => {
+ const {owner, guildId, code} = await createVisitGuild();
+ const visitor = await createUnclaimed();
+ await setFeatures(owner, guildId, []);
+ await startVisit(visitor.token, code).expect(HTTP_STATUS.FORBIDDEN, APIErrorCodes.GUILD_VISITS_DISABLED).execute();
+ await setFeatures(owner, guildId, [GuildFeatures.VISITS_ENABLED, GuildFeatures.INVITES_DISABLED]);
+ await startVisit(visitor.token, code).expect(HTTP_STATUS.FORBIDDEN, APIErrorCodes.INVITES_DISABLED).execute();
+ });
+
+ it('keeps adults-only guilds away from younger accounts', async () => {
+ const {owner, guildId, code} = await createVisitGuild();
+ await createBuilder(harness, owner.token).patch(`/guilds/${guildId}`).body({nsfw: true}).execute();
+ const teen = await createUnclaimed(yearsAgo(15));
+ await startVisit(teen.token, code)
+ .expect(HTTP_STATUS.FORBIDDEN, APIErrorCodes.GUILD_VISIT_AGE_RESTRICTED)
+ .execute();
+ const adult = await createUnclaimed(yearsAgo(30));
+ await startVisit(adult.token, code).execute();
+ });
+
+ it('asks for a date of birth before any visit', async () => {
+ const {code} = await createVisitGuild();
+ const account = await createBuilderWithoutAuth<Registered>(harness)
+ .post('/auth/register')
+ .body({username: 'birthdayless', consent: true})
+ .execute();
+ await startVisit(account.token, code).expect(HTTP_STATUS.FORBIDDEN, APIErrorCodes.DATE_OF_BIRTH_REQUIRED).execute();
+ });
+
+ it('refuses banned users and accounts that cannot start anything new', async () => {
+ const {owner, guildId, code} = await createVisitGuild();
+ const banned = await createTestAccount(harness);
+ await createBuilder(harness, owner.token)
+ .put(`/guilds/${guildId}/bans/${banned.userId}`)
+ .body({delete_message_days: 0})
+ .expect(HTTP_STATUS.NO_CONTENT)
+ .execute();
+ await startVisit(banned.token, code).expect(HTTP_STATUS.FORBIDDEN, APIErrorCodes.USER_BANNED_FROM_GUILD).execute();
+ });
+
+ it('spends a limited invite use only on joining', async () => {
+ const {guildId, code} = await createVisitGuild('Limited', {max_uses: 1});
+ const first = await createTestAccount(harness);
+ const second = await createTestAccount(harness);
+ const started = await startVisit(first.token, code).execute();
+ expect(started.visit).not.toBeNull();
+ expect((await startVisit(second.token, code).execute()).visit).not.toBeNull();
+ const joined = await createBuilder<GuildResponse>(harness, first.token)
+ .post(`/users/@me/guild-visits/${guildId}/join`)
+ .body(null)
+ .execute();
+ expect(joined.id).toBe(guildId);
+ expect(
+ await guildVisitRepository().get(createUserID(BigInt(first.userId)), createGuildID(BigInt(guildId))),
+ ).toBeNull();
+ await createBuilder(harness, second.token)
+ .post(`/invites/${code}`)
+ .body(null)
+ .expect(HTTP_STATUS.NOT_FOUND, APIErrorCodes.UNKNOWN_INVITE)
+ .execute();
+ });
+
+ it('joins from a visit through the invite accept route without a second use', async () => {
+ const {guildId, code} = await createVisitGuild('Accept', {max_uses: 1});
+ const visitor = await createTestAccount(harness);
+ await startVisit(visitor.token, code).execute();
+ await createBuilder(harness, visitor.token).post(`/invites/${code}`).body(null).execute();
+ expect(
+ await gateway.hasGuildMember({
+ guildId: createGuildID(BigInt(guildId)),
+ userId: createUserID(BigInt(visitor.userId)),
+ }),
+ ).toBe(true);
+ expect(
+ await guildVisitRepository().get(createUserID(BigInt(visitor.userId)), createGuildID(BigInt(guildId))),
+ ).toBeNull();
+ });
+
+ it('asks unclaimed visitors to finish their account before joining, and keeps the visit', async () => {
+ await getInstanceConfigRepository().updateAccountsConfig({interaction_tier: 'enforced'});
+ const {guildId, code} = await createVisitGuild();
+ const visitor = await createUnclaimed();
+ await startVisit(visitor.token, code).execute();
+ const refused = await createBuilder<{action: string}>(harness, visitor.token)
+ .post(`/users/@me/guild-visits/${guildId}/join`)
+ .header(Headers.X_FLUXER_CAPABILITIES, 'guild_visits')
+ .body(null)
+ .expect(HTTP_STATUS.FORBIDDEN, APIErrorCodes.ACCOUNT_VERIFICATION_REQUIRED)
+ .execute();
+ expect(refused.action).toBe('guild_join');
+ expect(
+ await guildVisitRepository().get(createUserID(BigInt(visitor.user_id)), createGuildID(BigInt(guildId))),
+ ).not.toBeNull();
+ });
+
+ it('joins a visited guild as a member with a member count change', async () => {
+ const {owner, guildId, code} = await createVisitGuild();
+ const visitor = await createTestAccount(harness);
+ await startVisit(visitor.token, code).execute();
+ const before = await createBuilder<GuildResponse>(harness, owner.token).get(`/guilds/${guildId}`).execute();
+ await createBuilder(harness, visitor.token).post(`/users/@me/guild-visits/${guildId}/join`).body(null).execute();
+ const after = await createBuilder<GuildResponse>(harness, owner.token).get(`/guilds/${guildId}`).execute();
+ expect(after.member_count).toBe((before.member_count ?? 0) + 1);
+ const visits = await createBuilder<Array<GuildVisitResponse>>(harness, visitor.token)
+ .get('/users/@me/guild-visits')
+ .execute();
+ expect(visits).toEqual([]);
+ await createBuilder(harness, visitor.token)
+ .post(`/users/@me/guild-visits/${guildId}/join`)
+ .body(null)
+ .expect(HTTP_STATUS.NOT_FOUND, APIErrorCodes.GUILD_VISIT_NOT_FOUND)
+ .execute();
+ });
+
+ it('ends a visit when the user leaves it', async () => {
+ const {guildId, code} = await createVisitGuild();
+ const visitor = await createUnclaimed();
+ await startVisit(visitor.token, code).execute();
+ await createBuilder(harness, visitor.token)
+ .delete(`/users/@me/guild-visits/${guildId}`)
+ .expect(HTTP_STATUS.NO_CONTENT)
+ .execute();
+ await createBuilder(harness, visitor.token)
+ .delete(`/users/@me/guild-visits/${guildId}`)
+ .expect(HTTP_STATUS.NO_CONTENT)
+ .execute();
+ expect(gateway.visitEvents.map((event) => event.kind)).toEqual(['start', 'end', 'end']);
+ expect(
+ await guildVisitRepository().get(createUserID(BigInt(visitor.user_id)), createGuildID(BigInt(guildId))),
+ ).toBeNull();
+ });
+
+ it('replaces the least recently opened visit past the cap for unclaimed accounts', async () => {
+ const visitor = await createUnclaimed();
+ const guilds: Array<VisitGuild> = [];
+ for (let index = 0; index < 6; index++) {
+ const guild = await createVisitGuild(`Cap ${index}`);
+ guilds.push(guild);
+ await startVisit(visitor.token, guild.code).execute();
+ }
+ const visits = await createBuilder<Array<GuildVisitResponse>>(harness, visitor.token)
+ .get('/users/@me/guild-visits')
+ .execute();
+ expect(visits).toHaveLength(5);
+ expect(visits.map((visit) => visit.guild_id)).not.toContain(guilds[0]!.guildId);
+ expect(
+ gateway.visitEvents.filter((event) => event.kind === 'end').map((event) => event.guildId.toString()),
+ ).toEqual([guilds[0]!.guildId]);
+ });
+
+ it('offers a visit on invite payloads only to users who can visit', async () => {
+ const {owner, guildId, code} = await createVisitGuild();
+ const visitor = await createUnclaimed();
+ const seen = await createBuilder<{guild: {visits_enabled?: boolean}}>(harness, visitor.token)
+ .get(`/invites/${code}`)
+ .execute();
+ expect(seen.guild.visits_enabled).toBe(true);
+ await setFeatures(owner, guildId, []);
+ const off = await createBuilder<{guild: {visits_enabled?: boolean}}>(harness, visitor.token)
+ .get(`/invites/${code}`)
+ .execute();
+ expect(off.guild.visits_enabled).toBe(false);
+ await getInstanceConfigRepository().updateGuildVisitsConfig({user_basis_points: 0});
+ await setFeatures(owner, guildId, [GuildFeatures.VISITS_ENABLED]);
+ const anonymous = await createBuilderWithoutAuth<{guild: {visits_enabled?: boolean}}>(harness)
+ .get(`/invites/${code}`)
+ .execute();
+ expect(anonymous.guild).not.toHaveProperty('visits_enabled');
+ });
+
+ it('turns an invite used at sign-up into a visit after the date of birth step', async () => {
+ const {guildId, code} = await createVisitGuild();
+ const account = await createBuilderWithoutAuth<Registered>(harness)
+ .post('/auth/register')
+ .header(Headers.X_FLUXER_CAPABILITIES, 'guild_visits')
+ .body({username: 'latecomer', consent: true, invite_code: code})
+ .execute();
+ expect(account.entry ?? null).toBeNull();
+ expect(await guildVisitRepository().list(createUserID(BigInt(account.user_id)))).toEqual([]);
+ const result = await createBuilder<{entry: {guild_id: string; mode: string} | null}>(harness, account.token)
+ .put('/users/@me/date-of-birth')
+ .header(Headers.X_FLUXER_CAPABILITIES, 'guild_visits')
+ .body({date_of_birth: yearsAgo(25)})
+ .execute();
+ expect(result.entry).toEqual({guild_id: guildId, mode: 'visit'});
+ const rows = await guildVisitRepository().list(createUserID(BigInt(account.user_id)));
+ expect(rows.map((row) => [row.guild_id.toString(), row.source])).toEqual([[guildId, GuildVisitSources.INVITE]]);
+ });
+
+ it('ends visits when the guild turns them off later', async () => {
+ const {owner, guildId, code, channelId} = await createVisitGuild();
+ const visitor = await createUnclaimed();
+ await startVisit(visitor.token, code).execute();
+ await sendChannelMessage(harness, owner.token, channelId, 'hello visitors');
+ await createBuilder(harness, visitor.token).get(`/channels/${channelId}/messages`).execute();
+ await setFeatures(owner, guildId, []);
+ await createBuilder(harness, visitor.token)
+ .get(`/channels/${channelId}/messages`)
+ .expect(HTTP_STATUS.FORBIDDEN, APIErrorCodes.ACCESS_DENIED)
+ .execute();
+ });
+
+ it('lets the owner turn previews off for discovery too', async () => {
+ const {owner, guildId} = await createVisitGuild('Listed Guild');
+ await createBuilder(harness, '').post(`/test/guilds/${guildId}/member-count`).body({member_count: 10}).execute();
+ const admin = await createTestAccount(harness);
+ await setUserACLs(harness, admin, ['admin:authenticate', 'discovery:review']);
+ await createBuilder(harness, owner.token)
+ .post(`/guilds/${guildId}/discovery`)
+ .body({description: 'A listed community for previews', category_type: DiscoveryCategories.GAMING})
+ .execute();
+ await createBuilder(harness, admin.token)
+ .patch(`/admin/discovery/applications/${guildId}`)
+ .body({status: 'approved'})
+ .execute();
+ const visitor = await createUnclaimed();
+ const discoveryVisit = () =>
+ createBuilder<GuildVisitStartResponse>(harness, visitor.token)
+ .post(`/discovery/guilds/${guildId}/visit`)
+ .body(null);
+ expect((await discoveryVisit().execute()).visit).not.toBeNull();
+ await createBuilder(harness, visitor.token)
+ .delete(`/users/@me/guild-visits/${guildId}`)
+ .expect(HTTP_STATUS.NO_CONTENT)
+ .execute();
+ await setFeatures(owner, guildId, []);
+ await discoveryVisit().expect(HTTP_STATUS.FORBIDDEN, APIErrorCodes.GUILD_VISITS_DISABLED).execute();
+ });
+
+ it.each([
+ {maxAge: 0, expectedWireExpiry: null, expectedStoredExpiry: null},
+ {
+ maxAge: 60,
+ expectedWireExpiry: '2026-10-23T02:21:00.000Z',
+ expectedStoredExpiry: new Date('2026-10-23T02:21:00.000Z'),
+ },
+ ])(
+ 'retains a $maxAge-second invite expiry when starting a later visit',
+ async ({maxAge, expectedWireExpiry, expectedStoredExpiry}) => {
+ vi.useFakeTimers({toFake: ['Date']});
+ vi.setSystemTime(new Date('2026-10-23T02:20:00.000Z'));
+ const {guildId, code} = await createVisitGuild('Invite expiry', {max_age: maxAge, unique: true});
+ const visitor = await createUnclaimed();
+ const invite = await createBuilderWithoutAuth<{expires_at: string | null}>(harness)
+ .get(`/invites/${code}`)
+ .execute();
+ expect(invite.expires_at).toBe(expectedWireExpiry);
+ vi.advanceTimersByTime(10000);
+ const started = await startVisit(visitor.token, code).execute();
+ expect(started).toEqual({
+ guild_id: guildId,
+ member: false,
+ visit: {
+ guild_id: guildId,
+ source: 1,
+ started_at: '2026-10-23T02:20:10.000Z',
+ opened_at: '2026-10-23T02:20:10.000Z',
+ },
+ });
+ const row = await guildVisitRepository().get(
+ createUserID(BigInt(visitor.user_id)),
+ createGuildID(BigInt(guildId)),
+ );
+ expect(row).toEqual({
+ user_id: createUserID(BigInt(visitor.user_id)),
+ guild_id: createGuildID(BigInt(guildId)),
+ source: 1,
+ invite_code: code,
+ invite_expires_at: expectedStoredExpiry,
+ started_at: new Date('2026-10-23T02:20:10.000Z'),
+ opened_at: new Date('2026-10-23T02:20:10.000Z'),
+ });
+ const visits = await createBuilder<Array<GuildVisitResponse>>(harness, visitor.token)
+ .get('/users/@me/guild-visits')
+ .execute();
+ expect(visits).toEqual([
+ {
+ guild_id: guildId,
+ source: 1,
+ started_at: '2026-10-23T02:20:10.000Z',
+ opened_at: '2026-10-23T02:20:10.000Z',
+ },
+ ]);
+ },
+ );
+});