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 type {
AdminAuditCoverageCase,
AdminAuditCoverageContext,
} from '@app/api/admin/tests/audit_coverage/AdminAuditCoverage';
import {
createTestAccount,
createTotpSecret,
createUniqueEmail,
createUniqueUsername,
generateTotpCode,
setUserACLs,
type TestAccount,
} from '@app/api/auth/tests/AuthTestUtils';
import {
createRegistrationResponse,
createWebAuthnDevice,
type WebAuthnCredentialMetadata,
type WebAuthnRegistrationOptions,
} from '@app/api/auth/tests/WebAuthnTestUtils';
import {createUserID} from '@app/api/BrandedTypes';
import {Config} from '@app/api/Config';
import {createFriendship} from '@app/api/channel/tests/ChannelTestUtils';
import {getInstanceConfigRepository, getUserRepository} from '@app/api/middleware/ServiceSingletons';
import type {User} from '@app/api/models/User';
import {createBuilder} from '@app/api/test/TestRequestBuilder';
import {AccountIdentityModes} from '@fluxer/constants/src/AccountIdentityConstants';
import {AdminACLs} from '@fluxer/constants/src/AdminACLs';
import {DeletionReasons} from '@fluxer/constants/src/Core';
import {PremiumFlags, UserFlags, UserPremiumTypes} from '@fluxer/constants/src/UserConstants';
import {expect, onTestFinished} from 'vitest';
async function loadUser(account: TestAccount): Promise<User> {
const user = await getUserRepository().findUnique(createUserID(BigInt(account.userId)));
if (!user) {
throw new Error(`User ${account.userId} not found`);
}
return user;
}
function adminBuilder({harness, admin}: AdminAuditCoverageContext) {
return createBuilder(harness, admin.token);
}
async function enableTotp(context: AdminAuditCoverageContext, account: TestAccount): Promise<string> {
const secret = createTotpSecret();
await createBuilder(context.harness, account.token)
.post('/users/@me/mfa/totp/enable')
.body({secret, code: generateTotpCode(secret), password: account.password})
.execute();
return secret;
}
const COVERAGE_DECISION = {
reason_code: DeletionReasons.SPAM,
source: 'own_review',
automation: 'none',
statement: 'Coverage decision',
};
export const UserWriteAdminAuditCases: ReadonlyArray<AdminAuditCoverageCase> = [
{
method: 'DELETE',
route: '/admin/users/:user_id/relationships',
async prepare({harness}) {
const target = await createTestAccount(harness);
const friend = await createTestAccount(harness);
await createFriendship(harness, target, friend);
return {
request: {path: `/admin/users/${target.userId}/relationships?category=friend`},
expected: {
action: 'remove_relationships_by_category',
targetType: 'user',
targetId: target.userId,
metadata: {category: 'friend', removed_count: '1'},
},
};
},
},
{
method: 'DELETE',
route: '/admin/users/:user_id/relationships/:target_user_id',
async prepare({harness}) {
const target = await createTestAccount(harness);
const friend = await createTestAccount(harness);
await createFriendship(harness, target, friend);
return {
request: {
path: `/admin/users/${target.userId}/relationships/${friend.userId}?category=friend`,
expectStatus: 204,
},
expected: {
action: 'remove_relationship',
targetType: 'user',
targetId: target.userId,
metadata: {target_user_id: friend.userId, category: 'friend'},
},
};
},
},
{
method: 'DELETE',
route: '/admin/users/:user_id/sessions',
async prepare({harness}) {
const target = await createTestAccount(harness);
return {
request: {path: `/admin/users/${target.userId}/sessions`},
expected: {
action: 'terminate_sessions',
targetType: 'user',
targetId: target.userId,
metadata: {},
},
};
},
},
{
method: 'DELETE',
route: '/admin/users/:user_id/webauthn-credentials/:credential_id',
async prepare(context) {
const {harness} = context;
const target = await createTestAccount(harness);
const secret = await enableTotp(context, target);
const device = createWebAuthnDevice();
const registrationOptions = await createBuilder<WebAuthnRegistrationOptions>(harness, target.token)
.post('/users/@me/mfa/webauthn/credentials/registration-options')
.body({mfa_method: 'totp', mfa_code: generateTotpCode(secret)})
.execute();
if (registrationOptions.rp.id) {
device.rpId = registrationOptions.rp.id;
}
await createBuilder(harness, target.token)
.post('/users/@me/mfa/webauthn/credentials')
.body({
response: createRegistrationResponse(device, registrationOptions, 'Coverage Passkey'),
challenge: registrationOptions.challenge,
name: 'Coverage Passkey',
mfa_method: 'totp',
mfa_code: generateTotpCode(secret),
})
.expect(204)
.execute();
const credentials = await createBuilder<Array<WebAuthnCredentialMetadata>>(harness, target.token)
.get('/users/@me/mfa/webauthn/credentials')
.execute();
const credentialId = credentials[0]!.id;
return {
request: {
path: `/admin/users/${target.userId}/webauthn-credentials/${credentialId}`,
expectStatus: 204,
},
expected: {
action: 'delete_webauthn_credential',
targetType: 'user',
targetId: target.userId,
metadata: {credential_id: credentialId},
},
};
},
},
{
method: 'DELETE',
route: '/admin/users/:user_id/mfa',
async prepare(context) {
const target = await createTestAccount(context.harness);
await enableTotp(context, target);
return {
request: {path: `/admin/users/${target.userId}/mfa`, expectStatus: 204},
expected: {
action: 'disable_mfa',
targetType: 'user',
targetId: target.userId,
metadata: {},
},
};
},
},
{
method: 'DELETE',
route: '/admin/users/:user_id/profile-fields',
async prepare({harness}) {
const target = await createTestAccount(harness);
return {
request: {
path: `/admin/users/${target.userId}/profile-fields`,
body: {fields: ['bio', 'pronouns', 'global_name'], basis: {type: 'holder_request'}},
},
expected: {
action: 'clear_fields',
targetType: 'user',
targetId: target.userId,
metadata: {fields: 'bio,pronouns,global_name', basis: 'holder_request'},
},
};
},
},
{
method: 'DELETE',
route: '/admin/users/:user_id/profile-fields',
name: 'enforcement',
async prepare({harness}) {
const target = await createTestAccount(harness);
return {
request: {
path: `/admin/users/${target.userId}/profile-fields`,
body: {fields: ['global_name'], basis: {type: 'enforcement', decision: COVERAGE_DECISION}},
},
expected: {
action: 'clear_fields',
targetType: 'user',
targetId: target.userId,
metadata: {
fields: 'global_name',
basis: 'enforcement',
decision_id: expect.any(String),
reason_code: DeletionReasons.SPAM.toString(),
kind: 'profile_reset',
notice_status: 'sent',
},
},
};
},
},
{
method: 'PUT',
route: '/admin/users/:user_id/bot-status',
async prepare({harness}) {
const target = await createTestAccount(harness);
return {
request: {path: `/admin/users/${target.userId}/bot-status`, body: {bot: true}},
expected: {
action: 'set_bot_status',
targetType: 'user',
targetId: target.userId,
metadata: {bot: 'true'},
},
};
},
},
{
method: 'PUT',
route: '/admin/users/:user_id/system-status',
async prepare(context) {
const target = await createTestAccount(context.harness);
await adminBuilder(context).put(`/admin/users/${target.userId}/bot-status`).body({bot: true}).execute();
return {
request: {path: `/admin/users/${target.userId}/system-status`, body: {system: true}},
expected: {
action: 'set_system_status',
targetType: 'user',
targetId: target.userId,
metadata: {system: 'true'},
},
};
},
},
{
method: 'PATCH',
route: '/admin/users/:user_id/username',
async prepare({harness}) {
const target = await createTestAccount(harness);
const username = createUniqueUsername('renamed');
return {
request: {path: `/admin/users/${target.userId}/username`, body: {username}},
expected: {
action: 'change_username',
targetType: 'user',
targetId: target.userId,
metadata: {
old_username: (await loadUser(target)).username,
new_username: username,
discriminator: expect.any(String),
},
},
};
},
},
{
method: 'PATCH',
route: '/admin/users/:user_id/email',
async prepare({harness}) {
const target = await createTestAccount(harness);
const email = createUniqueEmail('changed');
return {
request: {path: `/admin/users/${target.userId}/email`, body: {email}},
expected: {
action: 'change_email',
targetType: 'user',
targetId: target.userId,
metadata: {old_email: (await loadUser(target)).email!, new_email: email},
},
};
},
},
{
method: 'PUT',
route: '/admin/users/:user_id/email-verification',
async prepare({harness}) {
const target = await createTestAccount(harness, {skipEmailVerification: true});
return {
request: {path: `/admin/users/${target.userId}/email-verification`},
expected: {
action: 'verify_email',
targetType: 'user',
targetId: target.userId,
metadata: {email: (await loadUser(target)).email!},
},
};
},
},
{
method: 'POST',
route: '/admin/users/:user_id/verification-email',
async prepare({harness}) {
const target = await createTestAccount(harness, {skipEmailVerification: true});
return {
request: {path: `/admin/users/${target.userId}/verification-email`, expectStatus: 204},
expected: {
action: 'resend_verification_email',
targetType: 'user',
targetId: target.userId,
metadata: {email: (await loadUser(target)).email!},
},
};
},
},
{
method: 'POST',
route: '/admin/users/:user_id/password-reset',
async prepare({harness}) {
const target = await createTestAccount(harness);
return {
request: {path: `/admin/users/${target.userId}/password-reset`, expectStatus: 204},
expected: {
action: 'send_password_reset',
targetType: 'user',
targetId: target.userId,
metadata: {email: (await loadUser(target)).email!},
},
};
},
},
{
method: 'POST',
route: '/admin/users',
async prepare() {
const username = createUniqueUsername('created');
return {
request: {path: '/admin/users', body: {username, email: createUniqueEmail('created')}},
expected: {
action: 'create_user',
targetType: 'user',
targetId: expect.any(String),
metadata: {username, admin: 'false'},
},
};
},
},
{
method: 'POST',
route: '/admin/users/:user_id/password-reset-link',
async prepare({harness}) {
const target = await createTestAccount(harness);
const originalSelfHosted = Config.instance.selfHosted;
onTestFinished(() => {
Config.instance.selfHosted = originalSelfHosted;
});
Config.instance.selfHosted = true;
await getInstanceConfigRepository().setAccountIdentityMode(AccountIdentityModes.USERNAME, 'setup');
return {
request: {path: `/admin/users/${target.userId}/password-reset-link`},
expected: {
action: 'create_password_reset_link',
targetType: 'user',
targetId: target.userId,
metadata: {},
},
};
},
},
{
method: 'POST',
route: '/admin/users/:user_id/sign-in-link',
async prepare({harness}) {
const target = await setUserACLs(harness, await createTestAccount(harness), [AdminACLs.WILDCARD]);
return {
request: {path: `/admin/users/${target.userId}/sign-in-link`, operator: true},
expected: {
action: 'create_sign_in_link',
targetType: 'user',
targetId: target.userId,
metadata: {via: 'rexctl'},
},
};
},
},
{
method: 'DELETE',
route: '/admin/users/:user_id/recovery-kit',
async prepare({harness}) {
const target = await createTestAccount(harness);
const originalSelfHosted = Config.instance.selfHosted;
onTestFinished(() => {
Config.instance.selfHosted = originalSelfHosted;
});
Config.instance.selfHosted = true;
await getInstanceConfigRepository().setAccountIdentityMode(AccountIdentityModes.USERNAME, 'setup');
return {
request: {path: `/admin/users/${target.userId}/recovery-kit`, expectStatus: 204},
expected: {
action: 'revoke_recovery_kit',
targetType: 'user',
targetId: target.userId,
metadata: {},
},
};
},
},
{
method: 'PUT',
route: '/admin/users/:user_id/ban',
async prepare({harness}) {
const target = await createTestAccount(harness);
return {
request: {
path: `/admin/users/${target.userId}/ban`,
body: {duration_hours: 24, decision: COVERAGE_DECISION},
},
expected: {
action: 'temp_ban',
targetType: 'user',
targetId: target.userId,
metadata: {
duration_hours: '24',
banned_until: expect.any(String),
decision_id: expect.any(String),
reason_code: DeletionReasons.SPAM.toString(),
kind: 'suspension',
notice_status: 'sent',
},
},
};
},
},
{
method: 'DELETE',
route: '/admin/users/:user_id/ban',
async prepare(context) {
const target = await createTestAccount(context.harness);
const users = getUserRepository();
const user = await loadUser(target);
await users.patchUpsert(user.id, {temp_banned_until: new Date(Date.now() + 86_400_000)}, user.toRow());
await users.updateFlags(user.id, (flags) => flags | UserFlags.DISABLED);
return {
request: {path: `/admin/users/${target.userId}/ban`},
expected: {
action: 'unban',
targetType: 'user',
targetId: target.userId,
metadata: {ended_notice: 'true'},
},
};
},
},
{
method: 'POST',
route: '/admin/users/:user_id/warnings',
async prepare({harness}) {
const target = await createTestAccount(harness);
return {
request: {path: `/admin/users/${target.userId}/warnings`, body: {decision: COVERAGE_DECISION}},
expected: {
action: 'warn_user',
targetType: 'user',
targetId: target.userId,
metadata: {
decision_id: expect.any(String),
reason_code: DeletionReasons.SPAM.toString(),
kind: 'warning',
notice_status: 'sent',
},
},
};
},
},
{
method: 'PUT',
route: '/admin/users/:user_id/feature-limits',
async prepare({harness}) {
const target = await createTestAccount(harness);
return {
request: {
path: `/admin/users/${target.userId}/feature-limits`,
body: {limit: 'direct_messages', decision: COVERAGE_DECISION},
},
expected: {
action: 'limit_features',
targetType: 'user',
targetId: target.userId,
metadata: {
limit: 'direct_messages',
decision_id: expect.any(String),
reason_code: DeletionReasons.SPAM.toString(),
kind: 'feature_limit',
notice_status: 'sent',
},
},
};
},
},
{
method: 'PUT',
route: '/admin/users/:user_id/deletion',
async prepare({harness}) {
const target = await createTestAccount(harness);
return {
request: {
path: `/admin/users/${target.userId}/deletion`,
body: {days_until_deletion: 30, basis: {type: 'holder_request'}},
},
expected: {
action: 'schedule_deletion',
targetType: 'user',
targetId: target.userId,
metadata: {
basis: 'holder_request',
days: '30',
reason_code: DeletionReasons.USER_REQUESTED.toString(),
pending_deletion_at: expect.any(String),
notification_sent: 'true',
},
},
};
},
},
{
method: 'DELETE',
route: '/admin/users/:user_id/deletion',
async prepare(context) {
const target = await createTestAccount(context.harness);
await adminBuilder(context)
.put(`/admin/users/${target.userId}/deletion`)
.body({days_until_deletion: 30, basis: {type: 'holder_request'}})
.execute();
const pendingDeletionAt = (await loadUser(target)).pendingDeletionAt!.toISOString();
return {
request: {
path: `/admin/users/${target.userId}/deletion`,
body: {expected_pending_deletion_at: pendingDeletionAt},
},
expected: {
action: 'cancel_deletion',
targetType: 'user',
targetId: target.userId,
metadata: {
cancelled_pending_deletion_at: pendingDeletionAt,
cancelled_scheduled_by: context.admin.userId,
cancelled_scheduled_at: expect.any(String),
cancelled_reason_code: DeletionReasons.USER_REQUESTED.toString(),
notice: 'account_deletion_cancelled',
},
},
};
},
},
{
method: 'DELETE',
route: '/admin/users/:user_id/message-deletion',
async prepare({harness}) {
const target = await createTestAccount(harness);
await createBuilder(harness, target.token)
.post('/users/@me/messages/delete')
.body({password: target.password})
.expect(204)
.execute();
return {
request: {path: `/admin/users/${target.userId}/message-deletion`},
expected: {
action: 'cancel_bulk_message_deletion',
targetType: 'user',
targetId: target.userId,
metadata: {},
},
};
},
},
{
method: 'PUT',
route: '/admin/users/:user_id/acls',
async prepare({harness}) {
const target = await createTestAccount(harness);
const acls = [AdminACLs.AUTHENTICATE, AdminACLs.USER_LOOKUP];
return {
request: {path: `/admin/users/${target.userId}/acls`, body: {acls}},
expected: {
action: 'set_acls',
targetType: 'user',
targetId: target.userId,
metadata: {acls: acls.join(',')},
},
};
},
},
{
method: 'PUT',
route: '/admin/users/:user_id/traits',
async prepare({harness}) {
const target = await createTestAccount(harness);
return {
request: {path: `/admin/users/${target.userId}/traits`, body: {traits: ['coverage_trait']}},
expected: {
action: 'set_traits',
targetType: 'user',
targetId: target.userId,
metadata: {traits: 'coverage_trait'},
},
};
},
},
{
method: 'PATCH',
route: '/admin/users/:user_id/flags',
async prepare({harness}) {
const target = await createTestAccount(harness);
const {flags} = await loadUser(target);
return {
request: {
path: `/admin/users/${target.userId}/flags`,
body: {add_flags: [UserFlags.PARTNER.toString()], remove_flags: [UserFlags.SPAMMER.toString()]},
},
expected: {
action: 'update_flags',
targetType: 'user',
targetId: target.userId,
metadata: {
add_flags: UserFlags.PARTNER.toString(),
remove_flags: UserFlags.SPAMMER.toString(),
new_flags: ((flags | UserFlags.PARTNER) & ~UserFlags.SPAMMER).toString(),
},
},
};
},
},
{
method: 'PATCH',
route: '/admin/users/:user_id/premium-flags',
async prepare({harness}) {
const target = await createTestAccount(harness);
const {premiumFlags} = await loadUser(target);
return {
request: {
path: `/admin/users/${target.userId}/premium-flags`,
body: {add_flags: [PremiumFlags.BADGE_MASKED], remove_flags: [PremiumFlags.PURCHASE_DISABLED]},
},
expected: {
action: 'update_premium_flags',
targetType: 'user',
targetId: target.userId,
metadata: {
add_flags: PremiumFlags.BADGE_MASKED.toString(),
remove_flags: PremiumFlags.PURCHASE_DISABLED.toString(),
new_flags: ((premiumFlags | PremiumFlags.BADGE_MASKED) & ~PremiumFlags.PURCHASE_DISABLED).toString(),
},
},
};
},
},
{
method: 'DELETE',
route: '/admin/users/:user_id/premium',
async prepare({harness}) {
const target = await createTestAccount(harness);
const user = await loadUser(target);
const giftEnd = new Date(Date.now() + 30 * 86_400_000);
await getUserRepository().patchUpsert(
user.id,
{
premium_type: UserPremiumTypes.SUBSCRIPTION,
premium_since: new Date(),
premium_gift_extension_ends_at: giftEnd,
},
user.toRow(),
);
return {
request: {path: `/admin/users/${target.userId}/premium`},
expected: {
action: 'remove_premium',
targetType: 'user',
targetId: target.userId,
metadata: {
previous_premium_type: UserPremiumTypes.SUBSCRIPTION.toString(),
previous_premium_until: giftEnd.toISOString(),
removed_enabled_override: 'false',
},
},
};
},
},
{
method: 'PATCH',
route: '/admin/users/:user_id/date-of-birth',
async prepare({harness}) {
const target = await createTestAccount(harness);
return {
request: {path: `/admin/users/${target.userId}/date-of-birth`, body: {date_of_birth: '1995-06-15'}},
expected: {
action: 'change_dob',
targetType: 'user',
targetId: target.userId,
metadata: {
old_dob: (await loadUser(target)).dateOfBirth!,
new_dob: '1995-06-15',
cleared_below_minimum_age: 'false',
outside_plausible_range: 'false',
},
},
};
},
},
];