Skip to content

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

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

import {createTestAccount, type TestAccount} from '@app/api/auth/tests/AuthTestUtils';
import {createUserID} from '@app/api/BrandedTypes';
import {fetchOne, upsertOne} from '@app/api/database/CassandraQueryExecution';
import {Db} from '@app/api/database/CassandraTypes';
import type {UserRow} from '@app/api/database/types/UserTypes';
import {getUserRepository} from '@app/api/middleware/ServiceSingletons';
import {Users} from '@app/api/Tables';
import {type ApiTestHarness, createApiTestHarness} from '@app/api/test/ApiTestHarness';
import {HTTP_STATUS} from '@app/api/test/TestConstants';
import {createBuilder} from '@app/api/test/TestRequestBuilder';
import {backfillHiddenProfileBadges} from '@app/api/worker/tasks/BackfillHiddenProfileBadges';
import {PremiumFlags, UserFlags} from '@fluxer/constants/src/UserConstants';
import type {UserPrivateResponse} from '@fluxer/schema/src/domains/user/UserResponseSchemas';
import {afterAll, beforeAll, beforeEach, describe, expect, test} from 'vitest';

const FETCH_USER_ROW = Users.select({where: Users.where.eq('user_id'), limit: 1});

const LEGACY_STAFF_HIDDEN = 1n << 57n;
const LEGACY_PREMIUM_BADGE_HIDDEN_IN_USER_FLAGS = 1n << 40n;
const LEGACY_BADGE_SEQUENCE_HIDDEN_IN_USER_FLAGS = 1n << 43n;
const LEGACY_PREMIUM_BADGE_HIDDEN = 1 << 1;
const LEGACY_BADGE_SEQUENCE_HIDDEN = 1 << 4;
const LEGACY_OPERATOR_PASS_BADGE_HIDDEN = 1 << 9;

describe('hidden profile badges migration', () => {
	let harness: ApiTestHarness;

	beforeAll(async () => {
		harness = await createApiTestHarness();
	});
	afterAll(async () => {
		await harness.shutdown();
	});
	beforeEach(async () => {
		await harness.resetData();
	});

	async function writeLegacyBits(account: TestAccount, flags: bigint, premiumFlags: number): Promise<void> {
		await upsertOne(
			Users.patchByPk(
				{user_id: createUserID(BigInt(account.userId))},
				{flags: Db.set(flags), premium_flags: Db.set(premiumFlags)},
			),
		);
	}

	async function storedRow(account: TestAccount): Promise<UserRow> {
		const row = await fetchOne<UserRow>(FETCH_USER_ROW.bind({user_id: createUserID(BigInt(account.userId))}));
		return row!;
	}

	async function hiddenList(account: TestAccount): Promise<Array<string>> {
		const me = await createBuilder<UserPrivateResponse>(harness, account.token)
			.get('/users/@me')
			.expect(HTTP_STATUS.OK)
			.execute();
		return me.hidden_profile_badges;
	}

	test('each legacy bit loads as its hidden keys and the next write clears the bits', async () => {
		const staff = await createTestAccount(harness);
		await writeLegacyBits(staff, UserFlags.STAFF | LEGACY_STAFF_HIDDEN, LEGACY_OPERATOR_PASS_BADGE_HIDDEN);
		expect(await hiddenList(staff)).toEqual(['operator_pass', 'staff']);

		const premium = await createTestAccount(harness);
		await writeLegacyBits(premium, 0n, LEGACY_PREMIUM_BADGE_HIDDEN);
		expect(await hiddenList(premium)).toEqual(['plutonium', 'premium', 'visionary']);

		const sequence = await createTestAccount(harness);
		await writeLegacyBits(sequence, 0n, LEGACY_BADGE_SEQUENCE_HIDDEN);
		expect(await hiddenList(sequence)).toEqual(['visionary_number']);

		const older = await createTestAccount(harness);
		await writeLegacyBits(
			older,
			LEGACY_PREMIUM_BADGE_HIDDEN_IN_USER_FLAGS | LEGACY_BADGE_SEQUENCE_HIDDEN_IN_USER_FLAGS,
			0,
		);
		expect(await hiddenList(older)).toEqual(['plutonium', 'premium', 'visionary', 'visionary_number']);

		await createBuilder(harness, staff.token)
			.patch('/users/@me')
			.body({bio: 'still hidden'})
			.expect(HTTP_STATUS.OK)
			.execute();
		const row = await storedRow(staff);
		expect(row.flags).toBe(UserFlags.STAFF);
		expect(row.premium_flags ?? 0).toBe(0);
		expect([...(row.hidden_profile_badges ?? [])].sort()).toEqual(['operator_pass', 'staff']);
		expect(await hiddenList(staff)).toEqual(['operator_pass', 'staff']);
	});

	test('moving the bits on a write keeps flags changed by someone else after the read', async () => {
		const account = await createTestAccount(harness);
		await writeLegacyBits(account, LEGACY_STAFF_HIDDEN, LEGACY_PREMIUM_BADGE_HIDDEN);
		const userId = createUserID(BigInt(account.userId));
		const staleRow = (await getUserRepository().findUniqueAssert(userId)).toRow();
		await getUserRepository().updateFlags(userId, (flags) => flags | UserFlags.DISABLED);
		await upsertOne(
			Users.patchByPk(
				{user_id: userId},
				{premium_flags: Db.set(LEGACY_PREMIUM_BADGE_HIDDEN | PremiumFlags.PURCHASE_DISABLED)},
			),
		);

		await getUserRepository().patchUpsert(userId, {bio: 'written from a stale read'}, staleRow);
		const row = await storedRow(account);
		expect(row.flags).toBe(UserFlags.DISABLED);
		expect(row.premium_flags).toBe(PremiumFlags.PURCHASE_DISABLED);
		expect([...(row.hidden_profile_badges ?? [])].sort()).toEqual(['plutonium', 'premium', 'staff', 'visionary']);
	});

	test('the backfill moves every legacy bit once and leaves nothing for a second run', async () => {
		const staff = await createTestAccount(harness);
		const premium = await createTestAccount(harness);
		const untouched = await createTestAccount(harness);
		await writeLegacyBits(staff, UserFlags.STAFF | LEGACY_STAFF_HIDDEN, 0);
		await writeLegacyBits(premium, 0n, LEGACY_PREMIUM_BADGE_HIDDEN | LEGACY_BADGE_SEQUENCE_HIDDEN);
		const untouchedVersion = (await storedRow(untouched)).version;

		expect(await backfillHiddenProfileBadges(getUserRepository(), 2)).toEqual({migrated: 2, failed: 0});
		const staffRow = await storedRow(staff);
		expect(staffRow.flags).toBe(UserFlags.STAFF);
		expect([...(staffRow.hidden_profile_badges ?? [])]).toEqual(['staff']);
		const premiumRow = await storedRow(premium);
		expect(premiumRow.premium_flags ?? 0).toBe(0);
		expect([...(premiumRow.hidden_profile_badges ?? [])].sort()).toEqual([
			'plutonium',
			'premium',
			'visionary',
			'visionary_number',
		]);

		const versions = [(await storedRow(staff)).version, (await storedRow(premium)).version];
		expect(await backfillHiddenProfileBadges(getUserRepository(), 2)).toEqual({migrated: 0, failed: 0});
		expect([(await storedRow(staff)).version, (await storedRow(premium)).version]).toEqual(versions);
		expect((await storedRow(untouched)).version).toBe(untouchedVersion);
	});
});