Skip to content

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

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

import {
	collectsDateOfBirth,
	DateOfBirthPolicies,
	dateOfBirthPolicyFromLegacy,
	InstantAccountAvailability,
	InteractionTierModes,
	LegacyDateOfBirthEnforcements,
	RegistrationModes,
	VerificationBases,
} from '@fluxer/constants/src/AccountConfigConstants';
import {
	AccountIdentityModes,
	normalizeAccountIdentity,
	TagStyles,
} from '@fluxer/constants/src/AccountIdentityConstants';
import {
	AccountTiers,
	AccountVerificationNeeds,
	LocalCredentialKinds,
	localCredentialKindOf,
	type TierDenialError,
	TierDenialErrors,
	TierExemptions,
	type TierGatedAction,
	TierGatedActions,
} from '@fluxer/constants/src/AccountTierConstants';
import {
	type AccountTierInput,
	evaluateTierGate,
	requiresLocalCredential,
	resolveAccountTier,
	resolveEffectiveVerificationBasis,
	resolveEmailCodeAvailability,
	resolveEmailDeliveryState,
	resolveIdentifierFirst,
	resolveInstantAccountAvailability,
	resolveVerificationNeed,
	type TierGateInput,
} from '@fluxer/constants/src/AccountTierRules';
import {CaptchaProviders} from '@fluxer/constants/src/CaptchaConstants';
import {UserTraits} from '@fluxer/constants/src/UserTraitConstants';
import {describe, expect, it} from 'vitest';

const ALL_ACTIONS = Object.values(TierGatedActions);
const ALL_IDENTITY_MODES = Object.values(AccountIdentityModes);

const E = TierDenialErrors;

type Row = [
	action: TierGatedAction,
	unclaimed: TierDenialError | null,
	needsPassword: TierDenialError | null,
	unverified: TierDenialError | null,
];

const LEGACY_EXPECTED: Array<Row> = [
	[TierGatedActions.MESSAGE, E.UNCLAIMED_ACCOUNT_CANNOT_SEND_MESSAGES, E.ACCOUNT_VERIFICATION_REQUIRED, null],
	[TierGatedActions.TYPING, null, null, null],
	[
		TierGatedActions.REACTION,
		E.UNCLAIMED_ACCOUNT_CANNOT_ADD_REACTIONS,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.REACTION_EMAIL_VERIFICATION_REQUIRED,
	],
	[
		TierGatedActions.DIRECT_MESSAGE,
		E.UNCLAIMED_ACCOUNT_CANNOT_SEND_DIRECT_MESSAGES,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		null,
	],
	[
		TierGatedActions.DIRECT_MESSAGE_OPEN,
		E.UNCLAIMED_ACCOUNT_CANNOT_SEND_DIRECT_MESSAGES,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.DIRECT_MESSAGE_EMAIL_VERIFICATION_REQUIRED,
	],
	[TierGatedActions.GROUP_DM, E.UNCLAIMED_ACCOUNT_CANNOT_JOIN_GROUP_DMS, E.ACCOUNT_VERIFICATION_REQUIRED, null],
	[
		TierGatedActions.FRIEND_REQUEST,
		E.UNCLAIMED_ACCOUNT_CANNOT_SEND_FRIEND_REQUESTS,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.FRIEND_REQUEST_EMAIL_VERIFICATION_REQUIRED,
	],
	[
		TierGatedActions.FRIEND_ACCEPT,
		E.UNCLAIMED_ACCOUNT_CANNOT_ACCEPT_FRIEND_REQUESTS,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		null,
	],
	[TierGatedActions.INVITE_CREATE, null, null, null],
	[TierGatedActions.GUILD_JOIN, null, null, null],
	[
		TierGatedActions.GUILD_CREATE,
		E.UNCLAIMED_ACCOUNT_CANNOT_CREATE_GUILDS,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.GUILD_CREATION_EMAIL_VERIFICATION_REQUIRED,
	],
	[TierGatedActions.VOICE, E.UNCLAIMED_ACCOUNT_CANNOT_JOIN_VOICE_CHANNELS, E.ACCOUNT_VERIFICATION_REQUIRED, null],
	[
		TierGatedActions.CALL,
		E.UNCLAIMED_ACCOUNT_CANNOT_JOIN_ONE_ON_ONE_VOICE_CALLS,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		null,
	],
	[TierGatedActions.GROUP_CALL, null, null, null],
	[TierGatedActions.THREAD_JOIN, null, null, null],
	[TierGatedActions.CHANNEL_FOLLOW, null, null, null],
	[TierGatedActions.OWNERSHIP_TRANSFER, null, null, null],
	[
		TierGatedActions.APPLICATION_CREATE,
		E.UNCLAIMED_ACCOUNT_CANNOT_CREATE_APPLICATIONS,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		null,
	],
	[TierGatedActions.GIFT_REDEEM, E.ACCOUNT_VERIFICATION_REQUIRED, E.ACCOUNT_VERIFICATION_REQUIRED, null],
	[
		TierGatedActions.PROFILE_CUSTOMIZE,
		E.UNCLAIMED_ACCOUNTS_CAN_ONLY_SET_EMAIL_VIA_TOKEN,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.PROFILE_EMAIL_VERIFICATION_REQUIRED,
	],
	[
		TierGatedActions.REPORT,
		E.UNCLAIMED_ACCOUNT_CANNOT_SUBMIT_REPORTS,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.REPORT_EMAIL_VERIFICATION_REQUIRED,
	],
	[
		TierGatedActions.MFA,
		E.MFA_EMAIL_VERIFICATION_REQUIRED,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.MFA_EMAIL_VERIFICATION_REQUIRED,
	],
	[
		TierGatedActions.GUILD_VERIFICATION,
		E.GUILD_VERIFICATION_REQUIRED,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.GUILD_EMAIL_VERIFICATION_REQUIRED,
	],
];

const ENFORCED_EXPECTED: Array<Row> = [
	[
		TierGatedActions.MESSAGE,
		E.UNCLAIMED_ACCOUNT_CANNOT_SEND_MESSAGES,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.EMAIL_VERIFICATION_REQUIRED,
	],
	[
		TierGatedActions.TYPING,
		E.UNCLAIMED_ACCOUNT_CANNOT_SEND_MESSAGES,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.EMAIL_VERIFICATION_REQUIRED,
	],
	[
		TierGatedActions.REACTION,
		E.UNCLAIMED_ACCOUNT_CANNOT_ADD_REACTIONS,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.REACTION_EMAIL_VERIFICATION_REQUIRED,
	],
	[
		TierGatedActions.DIRECT_MESSAGE,
		E.UNCLAIMED_ACCOUNT_CANNOT_SEND_DIRECT_MESSAGES,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.DIRECT_MESSAGE_EMAIL_VERIFICATION_REQUIRED,
	],
	[
		TierGatedActions.DIRECT_MESSAGE_OPEN,
		E.UNCLAIMED_ACCOUNT_CANNOT_SEND_DIRECT_MESSAGES,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.DIRECT_MESSAGE_EMAIL_VERIFICATION_REQUIRED,
	],
	[
		TierGatedActions.GROUP_DM,
		E.UNCLAIMED_ACCOUNT_CANNOT_JOIN_GROUP_DMS,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.DIRECT_MESSAGE_EMAIL_VERIFICATION_REQUIRED,
	],
	[
		TierGatedActions.FRIEND_REQUEST,
		E.UNCLAIMED_ACCOUNT_CANNOT_SEND_FRIEND_REQUESTS,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.FRIEND_REQUEST_EMAIL_VERIFICATION_REQUIRED,
	],
	[
		TierGatedActions.FRIEND_ACCEPT,
		E.UNCLAIMED_ACCOUNT_CANNOT_ACCEPT_FRIEND_REQUESTS,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.FRIEND_REQUEST_EMAIL_VERIFICATION_REQUIRED,
	],
	[
		TierGatedActions.INVITE_CREATE,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.ACCOUNT_VERIFICATION_REQUIRED,
	],
	[
		TierGatedActions.GUILD_JOIN,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.ACCOUNT_VERIFICATION_REQUIRED,
	],
	[
		TierGatedActions.GUILD_CREATE,
		E.UNCLAIMED_ACCOUNT_CANNOT_CREATE_GUILDS,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.GUILD_CREATION_EMAIL_VERIFICATION_REQUIRED,
	],
	[
		TierGatedActions.VOICE,
		E.UNCLAIMED_ACCOUNT_CANNOT_JOIN_VOICE_CHANNELS,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.ACCOUNT_VERIFICATION_REQUIRED,
	],
	[
		TierGatedActions.CALL,
		E.UNCLAIMED_ACCOUNT_CANNOT_JOIN_ONE_ON_ONE_VOICE_CALLS,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.ACCOUNT_VERIFICATION_REQUIRED,
	],
	[
		TierGatedActions.GROUP_CALL,
		E.UNCLAIMED_ACCOUNT_CANNOT_JOIN_ONE_ON_ONE_VOICE_CALLS,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.ACCOUNT_VERIFICATION_REQUIRED,
	],
	[
		TierGatedActions.THREAD_JOIN,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.ACCOUNT_VERIFICATION_REQUIRED,
	],
	[
		TierGatedActions.CHANNEL_FOLLOW,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.ACCOUNT_VERIFICATION_REQUIRED,
	],
	[
		TierGatedActions.OWNERSHIP_TRANSFER,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.ACCOUNT_VERIFICATION_REQUIRED,
	],
	[
		TierGatedActions.APPLICATION_CREATE,
		E.UNCLAIMED_ACCOUNT_CANNOT_CREATE_APPLICATIONS,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.ACCOUNT_VERIFICATION_REQUIRED,
	],
	[TierGatedActions.GIFT_REDEEM, E.ACCOUNT_VERIFICATION_REQUIRED, E.ACCOUNT_VERIFICATION_REQUIRED, null],
	[TierGatedActions.PROFILE_CUSTOMIZE, null, null, null],
	[
		TierGatedActions.REPORT,
		E.UNCLAIMED_ACCOUNT_CANNOT_SUBMIT_REPORTS,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.REPORT_EMAIL_VERIFICATION_REQUIRED,
	],
	[
		TierGatedActions.MFA,
		E.MFA_EMAIL_VERIFICATION_REQUIRED,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.MFA_EMAIL_VERIFICATION_REQUIRED,
	],
	[
		TierGatedActions.GUILD_VERIFICATION,
		E.GUILD_VERIFICATION_REQUIRED,
		E.ACCOUNT_VERIFICATION_REQUIRED,
		E.GUILD_EMAIL_VERIFICATION_REQUIRED,
	],
];

function gate(overrides: Partial<TierGateInput>) {
	return evaluateTierGate({
		tier: AccountTiers.UNCLAIMED,
		mode: InteractionTierModes.LEGACY,
		action: TierGatedActions.MESSAGE,
		identityMode: AccountIdentityModes.EMAIL,
		hasEmail: false,
		guildJoinGateApplies: true,
		exemptions: [],
		...overrides,
	});
}

function codeOf(result: ReturnType<typeof evaluateTierGate>): TierDenialError | null {
	return result.allowed ? null : result.errorCode;
}

describe('evaluateTierGate matrix', () => {
	const accounts = [
		['unclaimed', 'email', false, 'add_email', 0],
		['unclaimed', 'email', true, 'password', 1],
		['unclaimed', 'username', false, 'password', 1],
		['unclaimed', 'username', true, 'password', 1],
		['unverified', 'email', false, 'confirm_email', 2],
		['unverified', 'email', true, 'confirm_email', 2],
		['unverified', 'username', false, 'confirm_email', 2],
		['unverified', 'username', true, 'confirm_email', 2],
		['verified', 'email', false, null, 3],
		['verified', 'email', true, null, 3],
		['verified', 'username', false, null, 3],
		['verified', 'username', true, null, 3],
	] as const;
	const cases = [
		{mode: InteractionTierModes.LEGACY, rows: LEGACY_EXPECTED},
		{mode: InteractionTierModes.ENFORCED, rows: ENFORCED_EXPECTED},
	].flatMap(({mode, rows}) =>
		rows.flatMap(([action, unclaimed, needsPassword, unverified]) => {
			const denials = [unclaimed, needsPassword, unverified, null];
			return accounts.map(([tier, identityMode, hasEmail, need, denialColumn]) => {
				const errorCode = denials[denialColumn];
				const expected = errorCode === null ? {allowed: true} : {allowed: false, action, tier, need, errorCode};
				return {mode, action, tier, identityMode, hasEmail, expected};
			});
		}),
	);

	it('has an expectation row for every action', () => {
		expect(LEGACY_EXPECTED.map(([action]) => action).sort()).toEqual([...ALL_ACTIONS].sort());
		expect(ENFORCED_EXPECTED.map(([action]) => action).sort()).toEqual([...ALL_ACTIONS].sort());
	});

	it.each(cases)('$mode $tier $action $identityMode email=$hasEmail', ({expected, ...input}) => {
		expect(gate(input)).toEqual(expected);
	});
});

describe('evaluateTierGate rewrites and conditions', () => {
	it('tells unclaimed accounts on username instances to set a password', () => {
		const result = gate({
			identityMode: AccountIdentityModes.USERNAME,
			action: TierGatedActions.REPORT,
		});
		expect(result).toEqual({
			allowed: false,
			action: TierGatedActions.REPORT,
			tier: AccountTiers.UNCLAIMED,
			need: AccountVerificationNeeds.SET_PASSWORD,
			errorCode: E.ACCOUNT_VERIFICATION_REQUIRED,
		});
		expect(
			codeOf(gate({identityMode: AccountIdentityModes.USERNAME, action: TierGatedActions.GUILD_VERIFICATION})),
		).toBe(E.ACCOUNT_VERIFICATION_REQUIRED);
	});

	it('tells unclaimed email accounts that have an email to set a password', () => {
		const result = gate({hasEmail: true, action: TierGatedActions.MESSAGE});
		expect(result).toMatchObject({
			need: AccountVerificationNeeds.SET_PASSWORD,
			errorCode: E.ACCOUNT_VERIFICATION_REQUIRED,
		});
	});

	it('keeps the specific error for unclaimed email accounts with no email', () => {
		expect(gate({action: TierGatedActions.MESSAGE})).toMatchObject({
			need: AccountVerificationNeeds.ADD_EMAIL,
			errorCode: E.UNCLAIMED_ACCOUNT_CANNOT_SEND_MESSAGES,
		});
	});

	it('applies the enforced join gate only when it applies to the person', () => {
		const join = {mode: InteractionTierModes.ENFORCED, action: TierGatedActions.GUILD_JOIN};
		expect(gate({...join, guildJoinGateApplies: false}).allowed).toBe(true);
		expect(codeOf(gate({...join, guildJoinGateApplies: true}))).toBe(E.ACCOUNT_VERIFICATION_REQUIRED);
	});

	it('lets community owners into voice under legacy, never under enforced', () => {
		const owner = {action: TierGatedActions.VOICE, exemptions: [TierExemptions.GUILD_OWNER]};
		expect(gate({...owner, mode: InteractionTierModes.LEGACY}).allowed).toBe(true);
		expect(codeOf(gate({...owner, mode: InteractionTierModes.ENFORCED}))).toBe(
			E.UNCLAIMED_ACCOUNT_CANNOT_JOIN_VOICE_CHANNELS,
		);
		expect(codeOf(gate({action: TierGatedActions.VOICE, mode: InteractionTierModes.LEGACY}))).toBe(
			E.UNCLAIMED_ACCOUNT_CANNOT_JOIN_VOICE_CHANNELS,
		);
	});
});

describe('resolveVerificationNeed', () => {
	it.each([
		[AccountTiers.VERIFIED, AccountIdentityModes.EMAIL, true, null],
		[AccountTiers.VERIFIED, AccountIdentityModes.USERNAME, false, null],
		[AccountTiers.UNVERIFIED, AccountIdentityModes.EMAIL, true, AccountVerificationNeeds.CONFIRM_EMAIL],
		[AccountTiers.UNCLAIMED, AccountIdentityModes.EMAIL, false, AccountVerificationNeeds.ADD_EMAIL],
		[AccountTiers.UNCLAIMED, AccountIdentityModes.EMAIL, true, AccountVerificationNeeds.SET_PASSWORD],
		[AccountTiers.UNCLAIMED, AccountIdentityModes.USERNAME, false, AccountVerificationNeeds.SET_PASSWORD],
		[AccountTiers.UNCLAIMED, AccountIdentityModes.USERNAME, true, AccountVerificationNeeds.SET_PASSWORD],
	] as const)('%s on %s with email=%s needs %s', (tier, identityMode, hasEmail, need) => {
		expect(resolveVerificationNeed({tier, identityMode, hasEmail})).toBe(need);
	});
});

describe('resolveEffectiveVerificationBasis', () => {
	it.each([
		['email', 'auto', 'on', 'confirmed_email'],
		['email', 'auto', 'off_username_mode', 'local_credential'],
		['email', 'auto', 'off_disabled', 'local_credential'],
		['email', 'auto', 'off_incomplete', 'local_credential'],
		['email', 'confirmed_email', 'on', 'confirmed_email'],
		['email', 'confirmed_email', 'off_username_mode', 'local_credential'],
		['email', 'confirmed_email', 'off_disabled', 'local_credential'],
		['email', 'confirmed_email', 'off_incomplete', 'local_credential'],
		['email', 'local_credential', 'on', 'local_credential'],
		['email', 'local_credential', 'off_username_mode', 'local_credential'],
		['email', 'local_credential', 'off_disabled', 'local_credential'],
		['email', 'local_credential', 'off_incomplete', 'local_credential'],
		['username', 'auto', 'on', 'local_credential'],
		['username', 'auto', 'off_username_mode', 'local_credential'],
		['username', 'auto', 'off_disabled', 'local_credential'],
		['username', 'auto', 'off_incomplete', 'local_credential'],
		['username', 'confirmed_email', 'on', 'local_credential'],
		['username', 'confirmed_email', 'off_username_mode', 'local_credential'],
		['username', 'confirmed_email', 'off_disabled', 'local_credential'],
		['username', 'confirmed_email', 'off_incomplete', 'local_credential'],
		['username', 'local_credential', 'on', 'local_credential'],
		['username', 'local_credential', 'off_username_mode', 'local_credential'],
		['username', 'local_credential', 'off_disabled', 'local_credential'],
		['username', 'local_credential', 'off_incomplete', 'local_credential'],
	] as const)('%s %s %s uses %s', (identityMode, basis, deliveryState, expected) => {
		expect(resolveEffectiveVerificationBasis({identityMode, basis, deliveryState})).toBe(expected);
	});
});

describe('resolveAccountTier', () => {
	const base: AccountTierInput = {
		isBot: false,
		isSystem: false,
		traits: new Set<string>(),
		identityMode: AccountIdentityModes.EMAIL,
		effectiveBasis: VerificationBases.CONFIRMED_EMAIL,
		hasEmail: true,
		emailVerified: true,
		localCredential: LocalCredentialKinds.NONE,
	};

	it('treats bots, system accounts and SSO accounts as verified everywhere', () => {
		for (const identityMode of ALL_IDENTITY_MODES) {
			const anon = {...base, identityMode, hasEmail: false, emailVerified: false};
			expect(resolveAccountTier({...anon, isBot: true})).toBe(AccountTiers.VERIFIED);
			expect(resolveAccountTier({...anon, isSystem: true})).toBe(AccountTiers.VERIFIED);
			expect(resolveAccountTier({...anon, traits: new Set([UserTraits.SSO])})).toBe(AccountTiers.VERIFIED);
			expect(resolveAccountTier({...anon, traits: [UserTraits.SSO]})).toBe(AccountTiers.VERIFIED);
		}
	});

	const credentials = ['none', 'password', 'passkey', 'password_and_passkey'] as const;
	const cases = [
		['email', 'confirmed_email', false, false, ['unclaimed', 'unclaimed', 'unclaimed', 'unclaimed']],
		['email', 'confirmed_email', false, true, ['unclaimed', 'unclaimed', 'unclaimed', 'unclaimed']],
		['email', 'confirmed_email', true, false, ['unverified', 'unverified', 'unverified', 'unverified']],
		['email', 'confirmed_email', true, true, ['verified', 'verified', 'verified', 'verified']],
		['email', 'local_credential', false, false, ['unclaimed', 'unclaimed', 'unclaimed', 'unclaimed']],
		['email', 'local_credential', false, true, ['unclaimed', 'unclaimed', 'unclaimed', 'unclaimed']],
		['email', 'local_credential', true, false, ['unclaimed', 'verified', 'verified', 'verified']],
		['email', 'local_credential', true, true, ['unclaimed', 'verified', 'verified', 'verified']],
		['username', 'confirmed_email', false, false, ['unclaimed', 'verified', 'verified', 'verified']],
		['username', 'confirmed_email', false, true, ['unclaimed', 'verified', 'verified', 'verified']],
		['username', 'confirmed_email', true, false, ['unclaimed', 'verified', 'verified', 'verified']],
		['username', 'confirmed_email', true, true, ['unclaimed', 'verified', 'verified', 'verified']],
		['username', 'local_credential', false, false, ['unclaimed', 'verified', 'verified', 'verified']],
		['username', 'local_credential', false, true, ['unclaimed', 'verified', 'verified', 'verified']],
		['username', 'local_credential', true, false, ['unclaimed', 'verified', 'verified', 'verified']],
		['username', 'local_credential', true, true, ['unclaimed', 'verified', 'verified', 'verified']],
	] as const;
	const credentialCases = cases.flatMap(([identityMode, effectiveBasis, hasEmail, emailVerified, expectedTiers]) =>
		credentials.map((localCredential, index) => ({
			identityMode,
			effectiveBasis,
			hasEmail,
			emailVerified,
			localCredential,
			expected: expectedTiers[index],
		})),
	);

	it.each(credentialCases)(
		'$identityMode $effectiveBasis email=$hasEmail verified=$emailVerified $localCredential',
		({expected, ...input}) => {
			expect(resolveAccountTier({...base, ...input})).toBe(expected);
		},
	);
});

describe('localCredentialKindOf', () => {
	it('combines a password and a passkey', () => {
		expect(localCredentialKindOf({hasPassword: false, hasPasskey: false})).toBe(LocalCredentialKinds.NONE);
		expect(localCredentialKindOf({hasPassword: true, hasPasskey: false})).toBe(LocalCredentialKinds.PASSWORD);
		expect(localCredentialKindOf({hasPassword: false, hasPasskey: true})).toBe(LocalCredentialKinds.PASSKEY);
		expect(localCredentialKindOf({hasPassword: true, hasPasskey: true})).toBe(
			LocalCredentialKinds.PASSWORD_AND_PASSKEY,
		);
	});
});

describe('resolveEmailDeliveryState', () => {
	it.each([
		['email', 'off', false, null, 'off_disabled'],
		['email', 'off', false, '', 'off_disabled'],
		['email', 'off', false, ' ', 'off_disabled'],
		['email', 'off', false, '[email protected]', 'off_disabled'],
		['email', 'off', true, null, 'off_disabled'],
		['email', 'off', true, '', 'off_disabled'],
		['email', 'off', true, ' ', 'off_disabled'],
		['email', 'off', true, '[email protected]', 'off_disabled'],
		['email', 'smtp', false, null, 'off_incomplete'],
		['email', 'smtp', false, '', 'off_incomplete'],
		['email', 'smtp', false, ' ', 'off_incomplete'],
		['email', 'smtp', false, '[email protected]', 'off_incomplete'],
		['email', 'smtp', true, null, 'off_incomplete'],
		['email', 'smtp', true, '', 'off_incomplete'],
		['email', 'smtp', true, ' ', 'off_incomplete'],
		['email', 'smtp', true, '[email protected]', 'on'],
		['username', 'off', false, null, 'off_username_mode'],
		['username', 'off', false, '', 'off_username_mode'],
		['username', 'off', false, ' ', 'off_username_mode'],
		['username', 'off', false, '[email protected]', 'off_username_mode'],
		['username', 'off', true, null, 'off_username_mode'],
		['username', 'off', true, '', 'off_username_mode'],
		['username', 'off', true, ' ', 'off_username_mode'],
		['username', 'off', true, '[email protected]', 'off_username_mode'],
		['username', 'smtp', false, null, 'off_username_mode'],
		['username', 'smtp', false, '', 'off_username_mode'],
		['username', 'smtp', false, ' ', 'off_username_mode'],
		['username', 'smtp', false, '[email protected]', 'off_username_mode'],
		['username', 'smtp', true, null, 'off_username_mode'],
		['username', 'smtp', true, '', 'off_username_mode'],
		['username', 'smtp', true, ' ', 'off_username_mode'],
		['username', 'smtp', true, '[email protected]', 'off_username_mode'],
	] as const)('%s %s complete=%s from=%s is %s', (identityMode, delivery, smtpComplete, fromAddress, expected) => {
		expect(resolveEmailDeliveryState({identityMode, delivery, smtpComplete, fromAddress})).toBe(expected);
	});
});

describe('resolveEmailCodeAvailability', () => {
	it.each([
		['email', 'on', false, false, 'no_owned_email'],
		['email', 'on', false, true, 'no_owned_email'],
		['email', 'on', true, false, 'no_owned_email'],
		['email', 'on', true, true, 'available'],
		['email', 'off_username_mode', false, false, 'delivery_off'],
		['email', 'off_username_mode', false, true, 'delivery_off'],
		['email', 'off_username_mode', true, false, 'delivery_off'],
		['email', 'off_username_mode', true, true, 'delivery_off'],
		['email', 'off_disabled', false, false, 'delivery_off'],
		['email', 'off_disabled', false, true, 'delivery_off'],
		['email', 'off_disabled', true, false, 'delivery_off'],
		['email', 'off_disabled', true, true, 'delivery_off'],
		['email', 'off_incomplete', false, false, 'delivery_off'],
		['email', 'off_incomplete', false, true, 'delivery_off'],
		['email', 'off_incomplete', true, false, 'delivery_off'],
		['email', 'off_incomplete', true, true, 'delivery_off'],
		['username', 'on', false, false, 'identity_mode_username'],
		['username', 'on', false, true, 'identity_mode_username'],
		['username', 'on', true, false, 'identity_mode_username'],
		['username', 'on', true, true, 'identity_mode_username'],
		['username', 'off_username_mode', false, false, 'identity_mode_username'],
		['username', 'off_username_mode', false, true, 'identity_mode_username'],
		['username', 'off_username_mode', true, false, 'identity_mode_username'],
		['username', 'off_username_mode', true, true, 'identity_mode_username'],
		['username', 'off_disabled', false, false, 'identity_mode_username'],
		['username', 'off_disabled', false, true, 'identity_mode_username'],
		['username', 'off_disabled', true, false, 'identity_mode_username'],
		['username', 'off_disabled', true, true, 'identity_mode_username'],
		['username', 'off_incomplete', false, false, 'identity_mode_username'],
		['username', 'off_incomplete', false, true, 'identity_mode_username'],
		['username', 'off_incomplete', true, false, 'identity_mode_username'],
		['username', 'off_incomplete', true, true, 'identity_mode_username'],
	] as const)('%s %s email=%s verified=%s is %s', (identityMode, deliveryState, hasEmail, emailVerified, expected) => {
		expect(resolveEmailCodeAvailability({identityMode, deliveryState, hasEmail, emailVerified})).toBe(expected);
	});
});

describe('resolveIdentifierFirst', () => {
	it.each([
		['auto', 'email', 'on', true, true],
		['auto', 'email', 'off_username_mode', false, false],
		['auto', 'email', 'off_disabled', false, false],
		['auto', 'email', 'off_incomplete', false, false],
		['auto', 'username', 'on', false, false],
		['auto', 'username', 'off_username_mode', false, false],
		['auto', 'username', 'off_disabled', false, false],
		['auto', 'username', 'off_incomplete', false, false],
		['on', 'email', 'on', true, true],
		['on', 'email', 'off_username_mode', true, false],
		['on', 'email', 'off_disabled', true, false],
		['on', 'email', 'off_incomplete', true, false],
		['on', 'username', 'on', false, false],
		['on', 'username', 'off_username_mode', false, false],
		['on', 'username', 'off_disabled', false, false],
		['on', 'username', 'off_incomplete', false, false],
		['off', 'email', 'on', false, false],
		['off', 'email', 'off_username_mode', false, false],
		['off', 'email', 'off_disabled', false, false],
		['off', 'email', 'off_incomplete', false, false],
		['off', 'username', 'on', false, false],
		['off', 'username', 'off_username_mode', false, false],
		['off', 'username', 'off_disabled', false, false],
		['off', 'username', 'off_incomplete', false, false],
	] as const)('%s %s %s resolves to %s %s', (mode, identityMode, deliveryState, identifierFirst, emailCodes) => {
		expect(resolveIdentifierFirst({mode, identityMode, deliveryState})).toEqual({identifierFirst, emailCodes});
	});
});

describe('resolveInstantAccountAvailability', () => {
	const open = {
		enabled: true,
		captchaProvider: CaptchaProviders.ALTCHA,
		registrationMode: RegistrationModes.OPEN,
		registrationUrl: null,
		emailDomainsRestricted: false,
	};

	it('is available while enabled, with a captcha and open sign-ups', () => {
		expect(resolveInstantAccountAvailability(open)).toBe(InstantAccountAvailability.AVAILABLE);
	});

	it('reports why it is unavailable, in order', () => {
		expect(resolveInstantAccountAvailability({...open, enabled: false, captchaProvider: CaptchaProviders.NONE})).toBe(
			InstantAccountAvailability.DISABLED,
		);
		expect(resolveInstantAccountAvailability({...open, captchaProvider: CaptchaProviders.NONE})).toBe(
			InstantAccountAvailability.CAPTCHA_OFF,
		);
		expect(resolveInstantAccountAvailability({...open, registrationMode: RegistrationModes.APPROVAL})).toBe(
			InstantAccountAvailability.APPROVAL_REQUIRED,
		);
		expect(resolveInstantAccountAvailability({...open, registrationMode: RegistrationModes.CLOSED})).toBe(
			InstantAccountAvailability.REGISTRATION_CLOSED,
		);
	});

	it('needs an email for public sign-ups while allowed email domains are set', () => {
		expect(resolveInstantAccountAvailability({...open, emailDomainsRestricted: true})).toBe(
			InstantAccountAvailability.EMAIL_DOMAINS_RESTRICTED,
		);
		expect(
			resolveInstantAccountAvailability({
				...open,
				emailDomainsRestricted: true,
				registrationUrl: {approvalRequired: false},
			}),
		).toBe(InstantAccountAvailability.AVAILABLE);
	});

	it('follows a registration URL over the registration mode', () => {
		for (const registrationMode of Object.values(RegistrationModes)) {
			expect(
				resolveInstantAccountAvailability({...open, registrationMode, registrationUrl: {approvalRequired: false}}),
			).toBe(InstantAccountAvailability.AVAILABLE);
			expect(
				resolveInstantAccountAvailability({...open, registrationMode, registrationUrl: {approvalRequired: true}}),
			).toBe(InstantAccountAvailability.APPROVAL_REQUIRED);
		}
	});
});

describe('requiresLocalCredential', () => {
	it.each([
		['email', 'on', false, false],
		['email', 'on', true, false],
		['email', 'off_username_mode', false, true],
		['email', 'off_username_mode', true, false],
		['email', 'off_disabled', false, true],
		['email', 'off_disabled', true, false],
		['email', 'off_incomplete', false, true],
		['email', 'off_incomplete', true, false],
		['username', 'on', false, true],
		['username', 'on', true, true],
		['username', 'off_username_mode', false, true],
		['username', 'off_username_mode', true, true],
		['username', 'off_disabled', false, true],
		['username', 'off_disabled', true, true],
		['username', 'off_incomplete', false, true],
		['username', 'off_incomplete', true, true],
	] as const)('%s %s proven=%s needs credentials: %s', (identityMode, deliveryState, emailProven, expected) => {
		expect(requiresLocalCredential({identityMode, deliveryState, emailProven})).toBe(expected);
	});
});

describe('normalizeAccountIdentity', () => {
	it('drops the tag on username instances and keeps it on email instances', () => {
		for (const tagStyle of Object.values(TagStyles)) {
			expect(normalizeAccountIdentity(AccountIdentityModes.USERNAME, tagStyle)).toEqual({
				mode: AccountIdentityModes.USERNAME,
				tagStyle: TagStyles.NONE,
			});
			expect(normalizeAccountIdentity(AccountIdentityModes.EMAIL, tagStyle)).toEqual({
				mode: AccountIdentityModes.EMAIL,
				tagStyle,
			});
		}
	});
});

describe('dateOfBirthPolicyFromLegacy', () => {
	it.each([
		[false, LegacyDateOfBirthEnforcements.OFF, DateOfBirthPolicies.OFF],
		[false, LegacyDateOfBirthEnforcements.NEW_ACCOUNTS, DateOfBirthPolicies.OFF],
		[false, LegacyDateOfBirthEnforcements.ALL, DateOfBirthPolicies.OFF],
		[true, LegacyDateOfBirthEnforcements.OFF, DateOfBirthPolicies.ASK],
		[true, LegacyDateOfBirthEnforcements.NEW_ACCOUNTS, DateOfBirthPolicies.REQUIRE_NEW_ACCOUNTS],
		[true, LegacyDateOfBirthEnforcements.ALL, DateOfBirthPolicies.REQUIRE_ALL],
	] as const)('collect=%s enforcement=%s gives %s', (collect, enforcement, policy) => {
		expect(dateOfBirthPolicyFromLegacy({collect, enforcement})).toBe(policy);
		expect(collectsDateOfBirth(policy)).toBe(collect);
	});
});