pepepper/fluxer
1
0 Fork 0
mirror of https://github.com/fluxerapp/fluxer synced 2026-10-18 05:25:40 +09:00
Code Issues Packages Projects Releases Wiki Activity

feat(experiments): ship seven treatments to everyone (#2798)

Browse Source
This commit is contained in:
Hampus authored and GitHub committed 2026-09-15 18:03:35 +02:00
1 parent 9e614026d7
commit 910db6734b
167 files changed
+4608 -58147
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

fluxer_api/src/api/admin/controllers/InstanceConfigAdminController.ts
-113
View File
@@ -31,14 +31,7 @@ import {
import {GatewayRolloutConfigSchema} from '@fluxer/schema/src/domains/admin/GatewayRolloutSchemas';
import {VoiceNoiseSuppressionConfigSchema} from '@fluxer/schema/src/domains/admin/VoiceNoiseSuppressionSchemas';
import {UserIdParam} from '@fluxer/schema/src/domains/common/CommonParamSchemas';
import {BlockedMessageGroupsConfigSchema} from '@fluxer/schema/src/domains/experiment/BlockedMessageGroupsSchemas';
import {ExperimentDeliveryConfigSchema} from '@fluxer/schema/src/domains/experiment/ExperimentSchemas';
import {ExpressionInfoCardConfigSchema} from '@fluxer/schema/src/domains/experiment/ExpressionInfoCardSchemas';
import {GuildActivityLogPresentationConfigSchema} from '@fluxer/schema/src/domains/experiment/GuildActivityLogPresentationSchemas';
import {GuildHeaderCollapseConfigSchema} from '@fluxer/schema/src/domains/experiment/GuildHeaderCollapseSchemas';
import {MessageHoverTrackingConfigSchema} from '@fluxer/schema/src/domains/experiment/MessageHoverTrackingSchemas';
import {MessageKeyboardFocusConfigSchema} from '@fluxer/schema/src/domains/experiment/MessageKeyboardFocusSchemas';
import {TypingIndicatorReworkConfigSchema} from '@fluxer/schema/src/domains/experiment/TypingIndicatorReworkSchemas';
import type {InstanceBranding} from '@fluxer/schema/src/domains/instance/InstanceSchemas';
import {SmtpEmailProvider} from '@pkgs/email/src/SmtpEmailProvider';
import type {Context} from 'hono';
@@ -64,14 +57,7 @@ async function buildInstanceConfigResponse(): Promise<InstanceConfigResponse> {
ssoConfig,
gatewayRollout,
voiceNoiseSuppression,
guildActivityLogPresentation,
experimentDelivery,
messageHoverTracking,
messageKeyboardFocus,
blockedMessageGroups,
expressionInfoCard,
guildHeaderCollapse,
typingIndicatorRework,
registrationConfig,
registrationUrls,
pendingRegistrations,
@@ -79,14 +65,7 @@ async function buildInstanceConfigResponse(): Promise<InstanceConfigResponse> {
instanceConfigRepository.getSsoConfig(),
instanceConfigRepository.getGatewayRolloutConfig(),
instanceConfigRepository.getVoiceNoiseSuppressionConfig(),
instanceConfigRepository.getGuildActivityLogPresentationConfig(),
instanceConfigRepository.getExperimentDeliveryConfig(),
instanceConfigRepository.getMessageHoverTrackingConfig(),
instanceConfigRepository.getMessageKeyboardFocusConfig(),
instanceConfigRepository.getBlockedMessageGroupsConfig(),
instanceConfigRepository.getExpressionInfoCardConfig(),
instanceConfigRepository.getGuildHeaderCollapseConfig(),
instanceConfigRepository.getTypingIndicatorReworkConfig(),
instanceConfigRepository.getRegistrationConfig(),
instanceConfigRepository.getRegistrationUrlsForAdmin(),
instanceConfigRepository.getPendingRegistrations(),
@@ -117,14 +96,7 @@ async function buildInstanceConfigResponse(): Promise<InstanceConfigResponse> {
},
gateway_rollout: gatewayRollout,
voice_noise_suppression: voiceNoiseSuppression,
guild_activity_log_presentation: guildActivityLogPresentation,
experiment_delivery: experimentDelivery,
message_hover_tracking: messageHoverTracking,
message_keyboard_focus: messageKeyboardFocus,
blocked_message_groups: blockedMessageGroups,
expression_info_card: expressionInfoCard,
guild_header_collapse: guildHeaderCollapse,
typing_indicator_rework: typingIndicatorRework,
registration: {
...registrationConfig,
urls: registrationUrls,
@@ -268,91 +240,6 @@ export function InstanceConfigAdminController(app: HonoApp) {
await instanceConfigRepository.setVoiceNoiseSuppressionConfig(validated);
}
}
if (data.guild_activity_log_presentation) {
const patch = omitUndefinedFields(data.guild_activity_log_presentation);
if (Object.keys(patch).length > 0) {
const currentGuildActivityLogPresentation =
await instanceConfigRepository.getGuildActivityLogPresentationConfig();
const validated = GuildActivityLogPresentationConfigSchema.parse({
...currentGuildActivityLogPresentation,
...patch,
config_version: currentGuildActivityLogPresentation.config_version + 1,
});
await instanceConfigRepository.setGuildActivityLogPresentationConfig(validated);
}
}
if (data.message_hover_tracking) {
const patch = omitUndefinedFields(data.message_hover_tracking);
if (Object.keys(patch).length > 0) {
const currentMessageHoverTracking = await instanceConfigRepository.getMessageHoverTrackingConfig();
const validated = MessageHoverTrackingConfigSchema.parse({
...currentMessageHoverTracking,
...patch,
config_version: currentMessageHoverTracking.config_version + 1,
});
await instanceConfigRepository.setMessageHoverTrackingConfig(validated);
}
}
if (data.message_keyboard_focus) {
const patch = omitUndefinedFields(data.message_keyboard_focus);
if (Object.keys(patch).length > 0) {
const currentMessageKeyboardFocus = await instanceConfigRepository.getMessageKeyboardFocusConfig();
const validated = MessageKeyboardFocusConfigSchema.parse({
...currentMessageKeyboardFocus,
...patch,
config_version: currentMessageKeyboardFocus.config_version + 1,
});
await instanceConfigRepository.setMessageKeyboardFocusConfig(validated);
}
}
if (data.blocked_message_groups) {
const patch = omitUndefinedFields(data.blocked_message_groups);
if (Object.keys(patch).length > 0) {
const currentBlockedMessageGroups = await instanceConfigRepository.getBlockedMessageGroupsConfig();
const validated = BlockedMessageGroupsConfigSchema.parse({
...currentBlockedMessageGroups,
...patch,
config_version: currentBlockedMessageGroups.config_version + 1,
});
await instanceConfigRepository.setBlockedMessageGroupsConfig(validated);
}
}
if (data.expression_info_card) {
const patch = omitUndefinedFields(data.expression_info_card);
if (Object.keys(patch).length > 0) {
const currentExpressionInfoCard = await instanceConfigRepository.getExpressionInfoCardConfig();
const validated = ExpressionInfoCardConfigSchema.parse({
...currentExpressionInfoCard,
...patch,
config_version: currentExpressionInfoCard.config_version + 1,
});
await instanceConfigRepository.setExpressionInfoCardConfig(validated);
}
}
if (data.guild_header_collapse) {
const patch = omitUndefinedFields(data.guild_header_collapse);
if (Object.keys(patch).length > 0) {
const currentGuildHeaderCollapse = await instanceConfigRepository.getGuildHeaderCollapseConfig();
const validated = GuildHeaderCollapseConfigSchema.parse({
...currentGuildHeaderCollapse,
...patch,
config_version: currentGuildHeaderCollapse.config_version + 1,
});
await instanceConfigRepository.setGuildHeaderCollapseConfig(validated);
}
}
if (data.typing_indicator_rework) {
const patch = omitUndefinedFields(data.typing_indicator_rework);
if (Object.keys(patch).length > 0) {
const currentTypingIndicatorRework = await instanceConfigRepository.getTypingIndicatorReworkConfig();
const validated = TypingIndicatorReworkConfigSchema.parse({
...currentTypingIndicatorRework,
...patch,
config_version: currentTypingIndicatorRework.config_version + 1,
});
await instanceConfigRepository.setTypingIndicatorReworkConfig(validated);
}
}
if (data.experiment_delivery) {
const currentExperimentDelivery = await instanceConfigRepository.getExperimentDeliveryConfig();
const validated = ExperimentDeliveryConfigSchema.parse({
fluxer_api/src/api/experiment/ExperimentController.ts
+2 -37
View File
@@ -9,14 +9,7 @@ import type {HonoApp} from '@app/api/types/HonoEnv';
import {entityTagMatches} from '@app/api/utils/EntityTag';
import {Headers as HttpHeaders} from '@fluxer/constants/src/Headers';
import {resolveVoiceNoiseSuppressionAssignment} from '@fluxer/schema/src/domains/admin/VoiceNoiseSuppressionSchemas';
import {resolveBlockedMessageGroupsAssignment} from '@fluxer/schema/src/domains/experiment/BlockedMessageGroupsSchemas';
import {ExperimentAssignmentsResponse} from '@fluxer/schema/src/domains/experiment/ExperimentSchemas';
import {resolveExpressionInfoCardAssignment} from '@fluxer/schema/src/domains/experiment/ExpressionInfoCardSchemas';
import {resolveGuildActivityLogPresentationAssignment} from '@fluxer/schema/src/domains/experiment/GuildActivityLogPresentationSchemas';
import {resolveGuildHeaderCollapseAssignment} from '@fluxer/schema/src/domains/experiment/GuildHeaderCollapseSchemas';
import {resolveMessageHoverTrackingAssignment} from '@fluxer/schema/src/domains/experiment/MessageHoverTrackingSchemas';
import {resolveMessageKeyboardFocusAssignment} from '@fluxer/schema/src/domains/experiment/MessageKeyboardFocusSchemas';
import {resolveTypingIndicatorReworkAssignment} from '@fluxer/schema/src/domains/experiment/TypingIndicatorReworkSchemas';
export function ExperimentController(app: HonoApp) {
app.get(
@@ -35,43 +28,15 @@ export function ExperimentController(app: HonoApp) {
}),
async (ctx) => {
const instanceConfigRepository = ctx.get('instanceConfigRepository');
const [
delivery,
voiceConfig,
messageHoverTrackingConfig,
messageKeyboardFocusConfig,
blockedMessageGroupsConfig,
guildActivityLogPresentationConfig,
expressionInfoCardConfig,
guildHeaderCollapseConfig,
typingIndicatorReworkConfig,
] = await Promise.all([
const [delivery, voiceConfig] = await Promise.all([
instanceConfigRepository.getExperimentDeliveryConfig(),
instanceConfigRepository.getVoiceNoiseSuppressionConfig(),
instanceConfigRepository.getMessageHoverTrackingConfig(),
instanceConfigRepository.getMessageKeyboardFocusConfig(),
instanceConfigRepository.getBlockedMessageGroupsConfig(),
instanceConfigRepository.getGuildActivityLogPresentationConfig(),
instanceConfigRepository.getExpressionInfoCardConfig(),
instanceConfigRepository.getGuildHeaderCollapseConfig(),
instanceConfigRepository.getTypingIndicatorReworkConfig(),
]);
const userId = ctx.get('user').id.toString();
const body: ExperimentAssignmentsResponse = {
poll_interval_seconds: delivery.poll_interval_seconds,
poll_jitter_percent: delivery.poll_jitter_percent,
assignments: {
voice_noise_suppression: resolveVoiceNoiseSuppressionAssignment(voiceConfig, userId),
message_hover_tracking: resolveMessageHoverTrackingAssignment(messageHoverTrackingConfig, userId),
message_keyboard_focus: resolveMessageKeyboardFocusAssignment(messageKeyboardFocusConfig, userId),
blocked_message_groups: resolveBlockedMessageGroupsAssignment(blockedMessageGroupsConfig, userId),
guild_activity_log_presentation: resolveGuildActivityLogPresentationAssignment(
guildActivityLogPresentationConfig,
userId,
),
expression_info_card: resolveExpressionInfoCardAssignment(expressionInfoCardConfig, userId),
guild_header_collapse: resolveGuildHeaderCollapseAssignment(guildHeaderCollapseConfig, userId),
typing_indicator_rework: resolveTypingIndicatorReworkAssignment(typingIndicatorReworkConfig, userId),
voice_noise_suppression: resolveVoiceNoiseSuppressionAssignment(voiceConfig, ctx.get('user').id.toString()),
},
};
const etag = `"${createHash('sha256').update(JSON.stringify(body)).digest('hex')}"`;
fluxer_api/src/api/experiment/tests/ExperimentController.test.ts
+1 -467
View File
@@ -10,48 +10,13 @@ import {
DEFAULT_VOICE_NOISE_SUPPRESSION_CONFIG,
INERT_VOICE_NOISE_SUPPRESSION_ASSIGNMENT,
} from '@fluxer/schema/src/domains/admin/VoiceNoiseSuppressionSchemas';
import {
DEFAULT_BLOCKED_MESSAGE_GROUPS_CONFIG,
INERT_BLOCKED_MESSAGE_GROUPS_ASSIGNMENT,
} from '@fluxer/schema/src/domains/experiment/BlockedMessageGroupsSchemas';
import {
DEFAULT_EXPERIMENT_POLL_INTERVAL_SECONDS,
DEFAULT_EXPERIMENT_POLL_JITTER_PERCENT,
type ExperimentAssignmentsResponse,
type ExperimentDeliveryConfigResponse,
readBlockedMessageGroupsAssignment,
readExpressionInfoCardAssignment,
readGuildActivityLogPresentationAssignment,
readGuildHeaderCollapseAssignment,
readMessageHoverTrackingAssignment,
readMessageKeyboardFocusAssignment,
readTypingIndicatorReworkAssignment,
readVoiceNoiseSuppressionAssignment,
} from '@fluxer/schema/src/domains/experiment/ExperimentSchemas';
import {
DEFAULT_EXPRESSION_INFO_CARD_CONFIG,
INERT_EXPRESSION_INFO_CARD_ASSIGNMENT,
} from '@fluxer/schema/src/domains/experiment/ExpressionInfoCardSchemas';
import {
DEFAULT_GUILD_ACTIVITY_LOG_PRESENTATION_CONFIG,
INERT_GUILD_ACTIVITY_LOG_PRESENTATION_ASSIGNMENT,
} from '@fluxer/schema/src/domains/experiment/GuildActivityLogPresentationSchemas';
import {
DEFAULT_GUILD_HEADER_COLLAPSE_CONFIG,
INERT_GUILD_HEADER_COLLAPSE_ASSIGNMENT,
} from '@fluxer/schema/src/domains/experiment/GuildHeaderCollapseSchemas';
import {
DEFAULT_MESSAGE_HOVER_TRACKING_CONFIG,
INERT_MESSAGE_HOVER_TRACKING_ASSIGNMENT,
} from '@fluxer/schema/src/domains/experiment/MessageHoverTrackingSchemas';
import {
DEFAULT_MESSAGE_KEYBOARD_FOCUS_CONFIG,
INERT_MESSAGE_KEYBOARD_FOCUS_ASSIGNMENT,
} from '@fluxer/schema/src/domains/experiment/MessageKeyboardFocusSchemas';
import {
DEFAULT_TYPING_INDICATOR_REWORK_CONFIG,
INERT_TYPING_INDICATOR_REWORK_ASSIGNMENT,
} from '@fluxer/schema/src/domains/experiment/TypingIndicatorReworkSchemas';
import {afterAll, beforeAll, beforeEach, describe, expect, it} from 'vitest';
const NOT_MODIFIED = 304;
@@ -84,16 +49,7 @@ describe('GET /experiments', () => {
expect(body).toEqual({
poll_interval_seconds: DEFAULT_EXPERIMENT_POLL_INTERVAL_SECONDS,
poll_jitter_percent: DEFAULT_EXPERIMENT_POLL_JITTER_PERCENT,
assignments: {
voice_noise_suppression: INERT_VOICE_NOISE_SUPPRESSION_ASSIGNMENT,
message_hover_tracking: INERT_MESSAGE_HOVER_TRACKING_ASSIGNMENT,
message_keyboard_focus: INERT_MESSAGE_KEYBOARD_FOCUS_ASSIGNMENT,
blocked_message_groups: INERT_BLOCKED_MESSAGE_GROUPS_ASSIGNMENT,
guild_activity_log_presentation: INERT_GUILD_ACTIVITY_LOG_PRESENTATION_ASSIGNMENT,
expression_info_card: INERT_EXPRESSION_INFO_CARD_ASSIGNMENT,
guild_header_collapse: INERT_GUILD_HEADER_COLLAPSE_ASSIGNMENT,
typing_indicator_rework: INERT_TYPING_INDICATOR_REWORK_ASSIGNMENT,
},
assignments: {voice_noise_suppression: INERT_VOICE_NOISE_SUPPRESSION_ASSIGNMENT},
});
});
@@ -124,428 +80,6 @@ describe('GET /experiments', () => {
expect(readVoiceNoiseSuppressionAssignment(body).enabled).toBe(false);
});
it('populates the message hover tracking key even when the rollout is disabled', async () => {
const account = await createTestAccount(harness);
const body = await createBuilder<ExperimentAssignmentsResponse>(harness, account.token).get(ENDPOINT).execute();
expect(Object.hasOwn(body.assignments, 'message_hover_tracking')).toBe(true);
expect(readMessageHoverTrackingAssignment(body)).toEqual(INERT_MESSAGE_HOVER_TRACKING_ASSIGNMENT);
});
it('targets an allowlisted account for message hover tracking', async () => {
const account = await createTestAccount(harness);
await getInstanceConfigRepository().setMessageHoverTrackingConfig({
...DEFAULT_MESSAGE_HOVER_TRACKING_CONFIG,
enabled: true,
config_version: 4,
included_user_ids: [account.userId],
});
const body = await createBuilder<ExperimentAssignmentsResponse>(harness, account.token).get(ENDPOINT).execute();
expect(readMessageHoverTrackingAssignment(body)).toEqual({
enabled: true,
config_version: 4,
user_targeted: true,
source: 'user_rule',
});
});
it('leaves an account outside a zero-width message hover tracking rollout', async () => {
const account = await createTestAccount(harness);
await getInstanceConfigRepository().setMessageHoverTrackingConfig({
...DEFAULT_MESSAGE_HOVER_TRACKING_CONFIG,
enabled: true,
config_version: 2,
});
const body = await createBuilder<ExperimentAssignmentsResponse>(harness, account.token).get(ENDPOINT).execute();
expect(readMessageHoverTrackingAssignment(body)).toEqual({
enabled: true,
config_version: 2,
user_targeted: false,
source: null,
});
});
it('populates the message keyboard focus key even when the rollout is disabled', async () => {
const account = await createTestAccount(harness);
const body = await createBuilder<ExperimentAssignmentsResponse>(harness, account.token).get(ENDPOINT).execute();
expect(Object.hasOwn(body.assignments, 'message_keyboard_focus')).toBe(true);
expect(readMessageKeyboardFocusAssignment(body)).toEqual(INERT_MESSAGE_KEYBOARD_FOCUS_ASSIGNMENT);
});
it('targets an allowlisted account for message keyboard focus', async () => {
const account = await createTestAccount(harness);
await getInstanceConfigRepository().setMessageKeyboardFocusConfig({
...DEFAULT_MESSAGE_KEYBOARD_FOCUS_CONFIG,
enabled: true,
config_version: 4,
included_user_ids: [account.userId],
});
const body = await createBuilder<ExperimentAssignmentsResponse>(harness, account.token).get(ENDPOINT).execute();
expect(readMessageKeyboardFocusAssignment(body)).toEqual({
enabled: true,
config_version: 4,
user_targeted: true,
source: 'user_rule',
});
});
it('leaves an account outside a zero-width message keyboard focus rollout', async () => {
const account = await createTestAccount(harness);
await getInstanceConfigRepository().setMessageKeyboardFocusConfig({
...DEFAULT_MESSAGE_KEYBOARD_FOCUS_CONFIG,
enabled: true,
config_version: 2,
});
const body = await createBuilder<ExperimentAssignmentsResponse>(harness, account.token).get(ENDPOINT).execute();
expect(readMessageKeyboardFocusAssignment(body)).toEqual({
enabled: true,
config_version: 2,
user_targeted: false,
source: null,
});
});
it('populates the blocked message groups key even when the rollout is disabled', async () => {
const account = await createTestAccount(harness);
const body = await createBuilder<ExperimentAssignmentsResponse>(harness, account.token).get(ENDPOINT).execute();
expect(Object.hasOwn(body.assignments, 'blocked_message_groups')).toBe(true);
expect(readBlockedMessageGroupsAssignment(body)).toEqual(INERT_BLOCKED_MESSAGE_GROUPS_ASSIGNMENT);
});
it('targets an allowlisted account for blocked message groups', async () => {
const account = await createTestAccount(harness);
await getInstanceConfigRepository().setBlockedMessageGroupsConfig({
...DEFAULT_BLOCKED_MESSAGE_GROUPS_CONFIG,
enabled: true,
config_version: 4,
included_user_ids: [account.userId],
});
const body = await createBuilder<ExperimentAssignmentsResponse>(harness, account.token).get(ENDPOINT).execute();
expect(readBlockedMessageGroupsAssignment(body)).toEqual({
enabled: true,
config_version: 4,
user_targeted: true,
source: 'user_rule',
});
});
it('leaves an account outside a zero-width blocked message groups rollout', async () => {
const account = await createTestAccount(harness);
await getInstanceConfigRepository().setBlockedMessageGroupsConfig({
...DEFAULT_BLOCKED_MESSAGE_GROUPS_CONFIG,
enabled: true,
config_version: 2,
});
const body = await createBuilder<ExperimentAssignmentsResponse>(harness, account.token).get(ENDPOINT).execute();
expect(readBlockedMessageGroupsAssignment(body)).toEqual({
enabled: true,
config_version: 2,
user_targeted: false,
source: null,
});
});
it('populates the guild activity log presentation key even when the rollout is disabled', async () => {
const account = await createTestAccount(harness);
const body = await createBuilder<ExperimentAssignmentsResponse>(harness, account.token).get(ENDPOINT).execute();
expect(Object.hasOwn(body.assignments, 'guild_activity_log_presentation')).toBe(true);
expect(readGuildActivityLogPresentationAssignment(body)).toEqual(INERT_GUILD_ACTIVITY_LOG_PRESENTATION_ASSIGNMENT);
});
it('targets an allowlisted account for guild activity log presentation', async () => {
const targeted = await createTestAccount(harness);
const untargeted = await createTestAccount(harness);
await getInstanceConfigRepository().setGuildActivityLogPresentationConfig({
...DEFAULT_GUILD_ACTIVITY_LOG_PRESENTATION_CONFIG,
enabled: true,
config_version: 6,
included_user_ids: [targeted.userId],
});
const targetedBody = await createBuilder<ExperimentAssignmentsResponse>(harness, targeted.token)
.get(ENDPOINT)
.execute();
expect(readGuildActivityLogPresentationAssignment(targetedBody)).toEqual({
enabled: true,
config_version: 6,
user_targeted: true,
source: 'user_rule',
});
const untargetedBody = await createBuilder<ExperimentAssignmentsResponse>(harness, untargeted.token)
.get(ENDPOINT)
.execute();
expect(readGuildActivityLogPresentationAssignment(untargetedBody)).toEqual({
enabled: true,
config_version: 6,
user_targeted: false,
source: null,
});
});
it('bumps the guild activity log presentation config version on every admin update', async () => {
const admin = await setUserACLs(harness, await createTestAccount(harness), [
AdminACLs.AUTHENTICATE,
AdminACLs.INSTANCE_CONFIG_VIEW,
AdminACLs.INSTANCE_CONFIG_UPDATE,
]);
const updated = await createBuilder<{
guild_activity_log_presentation: {config_version: number; enabled: boolean; rollout_basis_points: number};
}>(harness, admin.token)
.patch('/admin/instance/config')
.body({guild_activity_log_presentation: {enabled: true, rollout_basis_points: 10000}})
.execute();
expect(updated.guild_activity_log_presentation).toMatchObject({
config_version: 1,
enabled: true,
rollout_basis_points: 10000,
});
const body = await createBuilder<ExperimentAssignmentsResponse>(harness, admin.token).get(ENDPOINT).execute();
expect(readGuildActivityLogPresentationAssignment(body)).toEqual({
enabled: true,
config_version: 1,
user_targeted: true,
source: 'canary',
});
});
it('populates the expression info card key even when the rollout is disabled', async () => {
const account = await createTestAccount(harness);
const body = await createBuilder<ExperimentAssignmentsResponse>(harness, account.token).get(ENDPOINT).execute();
expect(Object.hasOwn(body.assignments, 'expression_info_card')).toBe(true);
expect(readExpressionInfoCardAssignment(body)).toEqual(INERT_EXPRESSION_INFO_CARD_ASSIGNMENT);
});
it('targets an allowlisted account for the expression info card', async () => {
const account = await createTestAccount(harness);
await getInstanceConfigRepository().setExpressionInfoCardConfig({
...DEFAULT_EXPRESSION_INFO_CARD_CONFIG,
enabled: true,
config_version: 4,
included_user_ids: [account.userId],
});
const body = await createBuilder<ExperimentAssignmentsResponse>(harness, account.token).get(ENDPOINT).execute();
expect(readExpressionInfoCardAssignment(body)).toEqual({
enabled: true,
config_version: 4,
user_targeted: true,
source: 'user_rule',
});
});
it('leaves an account outside a zero-width expression info card rollout', async () => {
const account = await createTestAccount(harness);
await getInstanceConfigRepository().setExpressionInfoCardConfig({
...DEFAULT_EXPRESSION_INFO_CARD_CONFIG,
enabled: true,
config_version: 2,
});
const body = await createBuilder<ExperimentAssignmentsResponse>(harness, account.token).get(ENDPOINT).execute();
expect(readExpressionInfoCardAssignment(body)).toEqual({
enabled: true,
config_version: 2,
user_targeted: false,
source: null,
});
});
it('populates the guild header collapse key even when the rollout is disabled', async () => {
const account = await createTestAccount(harness);
const body = await createBuilder<ExperimentAssignmentsResponse>(harness, account.token).get(ENDPOINT).execute();
expect(Object.hasOwn(body.assignments, 'guild_header_collapse')).toBe(true);
expect(readGuildHeaderCollapseAssignment(body)).toEqual(INERT_GUILD_HEADER_COLLAPSE_ASSIGNMENT);
});
it('targets an allowlisted account for guild header collapse', async () => {
const account = await createTestAccount(harness);
await getInstanceConfigRepository().setGuildHeaderCollapseConfig({
...DEFAULT_GUILD_HEADER_COLLAPSE_CONFIG,
enabled: true,
config_version: 4,
included_user_ids: [account.userId],
});
const body = await createBuilder<ExperimentAssignmentsResponse>(harness, account.token).get(ENDPOINT).execute();
expect(readGuildHeaderCollapseAssignment(body)).toEqual({
enabled: true,
config_version: 4,
user_targeted: true,
source: 'user_rule',
});
});
it('leaves an account outside a zero-width guild header collapse rollout', async () => {
const account = await createTestAccount(harness);
await getInstanceConfigRepository().setGuildHeaderCollapseConfig({
...DEFAULT_GUILD_HEADER_COLLAPSE_CONFIG,
enabled: true,
config_version: 2,
});
const body = await createBuilder<ExperimentAssignmentsResponse>(harness, account.token).get(ENDPOINT).execute();
expect(readGuildHeaderCollapseAssignment(body)).toEqual({
enabled: true,
config_version: 2,
user_targeted: false,
source: null,
});
});
it('populates the typing indicator rework key even when the rollout is disabled', async () => {
const account = await createTestAccount(harness);
const body = await createBuilder<ExperimentAssignmentsResponse>(harness, account.token).get(ENDPOINT).execute();
expect(Object.hasOwn(body.assignments, 'typing_indicator_rework')).toBe(true);
expect(readTypingIndicatorReworkAssignment(body)).toEqual(INERT_TYPING_INDICATOR_REWORK_ASSIGNMENT);
});
it('targets an allowlisted account for typing indicator rework', async () => {
const account = await createTestAccount(harness);
await getInstanceConfigRepository().setTypingIndicatorReworkConfig({
...DEFAULT_TYPING_INDICATOR_REWORK_CONFIG,
enabled: true,
config_version: 6,
included_user_ids: [account.userId],
});
const body = await createBuilder<ExperimentAssignmentsResponse>(harness, account.token).get(ENDPOINT).execute();
expect(readTypingIndicatorReworkAssignment(body)).toEqual({
enabled: true,
config_version: 6,
user_targeted: true,
source: 'user_rule',
});
});
it('leaves an account outside a zero-width typing indicator rework rollout', async () => {
const account = await createTestAccount(harness);
await getInstanceConfigRepository().setTypingIndicatorReworkConfig({
...DEFAULT_TYPING_INDICATOR_REWORK_CONFIG,
enabled: true,
config_version: 2,
});
const body = await createBuilder<ExperimentAssignmentsResponse>(harness, account.token).get(ENDPOINT).execute();
expect(readTypingIndicatorReworkAssignment(body)).toEqual({
enabled: true,
config_version: 2,
user_targeted: false,
source: null,
});
});
it('serves a fresh body once the typing indicator rework config changes', async () => {
const account = await createTestAccount(harness);
const first = await createBuilder<ExperimentAssignmentsResponse>(harness, account.token)
.get(ENDPOINT)
.executeWithResponse();
const staleEtag = first.response.headers.get('etag') as string;
await getInstanceConfigRepository().setTypingIndicatorReworkConfig({
...DEFAULT_TYPING_INDICATOR_REWORK_CONFIG,
enabled: true,
config_version: 1,
rollout_basis_points: 10000,
});
const refreshed = await createBuilder<ExperimentAssignmentsResponse>(harness, account.token)
.get(ENDPOINT)
.header('If-None-Match', staleEtag)
.executeWithResponse();
expect(refreshed.response.status).toBe(HTTP_STATUS.OK);
expect(refreshed.response.headers.get('etag')).not.toBe(staleEtag);
expect(refreshed.json?.assignments.typing_indicator_rework).toMatchObject({
enabled: true,
config_version: 1,
user_targeted: true,
});
});
it('resolves all eight experiments independently', async () => {
const account = await createTestAccount(harness);
await getInstanceConfigRepository().setMessageHoverTrackingConfig({
...DEFAULT_MESSAGE_HOVER_TRACKING_CONFIG,
enabled: true,
rollout_basis_points: 10000,
});
await getInstanceConfigRepository().setMessageKeyboardFocusConfig({
...DEFAULT_MESSAGE_KEYBOARD_FOCUS_CONFIG,
enabled: true,
rollout_basis_points: 10000,
});
await getInstanceConfigRepository().setBlockedMessageGroupsConfig({
...DEFAULT_BLOCKED_MESSAGE_GROUPS_CONFIG,
enabled: true,
rollout_basis_points: 10000,
});
await getInstanceConfigRepository().setGuildActivityLogPresentationConfig({
...DEFAULT_GUILD_ACTIVITY_LOG_PRESENTATION_CONFIG,
enabled: true,
rollout_basis_points: 10000,
});
await getInstanceConfigRepository().setExpressionInfoCardConfig({
...DEFAULT_EXPRESSION_INFO_CARD_CONFIG,
enabled: true,
rollout_basis_points: 10000,
});
await getInstanceConfigRepository().setGuildHeaderCollapseConfig({
...DEFAULT_GUILD_HEADER_COLLAPSE_CONFIG,
enabled: true,
rollout_basis_points: 10000,
});
await getInstanceConfigRepository().setTypingIndicatorReworkConfig({
...DEFAULT_TYPING_INDICATOR_REWORK_CONFIG,
enabled: true,
rollout_basis_points: 10000,
});
const body = await createBuilder<ExperimentAssignmentsResponse>(harness, account.token).get(ENDPOINT).execute();
expect(readMessageHoverTrackingAssignment(body).user_targeted).toBe(true);
expect(readMessageKeyboardFocusAssignment(body).user_targeted).toBe(true);
expect(readBlockedMessageGroupsAssignment(body).user_targeted).toBe(true);
expect(readGuildActivityLogPresentationAssignment(body).user_targeted).toBe(true);
expect(readExpressionInfoCardAssignment(body).user_targeted).toBe(true);
expect(readGuildHeaderCollapseAssignment(body).user_targeted).toBe(true);
expect(readTypingIndicatorReworkAssignment(body).user_targeted).toBe(true);
expect(readVoiceNoiseSuppressionAssignment(body).enabled).toBe(false);
});
it('serves the delivery cadence from the delivery config and not from the voice config', async () => {
const account = await createTestAccount(harness);
await getInstanceConfigRepository().setExperimentDeliveryConfig({
fluxer_api/src/api/instance/InstanceConfigRepository.test.ts
-392
View File
@@ -13,48 +13,13 @@ import {
DEFAULT_VOICE_NOISE_SUPPRESSION_CONFIG,
type VoiceNoiseSuppressionConfig,
} from '@fluxer/schema/src/domains/admin/VoiceNoiseSuppressionSchemas';
import {
type BlockedMessageGroupsConfig,
DEFAULT_BLOCKED_MESSAGE_GROUPS_CONFIG,
} from '@fluxer/schema/src/domains/experiment/BlockedMessageGroupsSchemas';
import {
DEFAULT_EXPERIMENT_DELIVERY_CONFIG,
type ExperimentDeliveryConfig,
} from '@fluxer/schema/src/domains/experiment/ExperimentSchemas';
import {
DEFAULT_EXPRESSION_INFO_CARD_CONFIG,
type ExpressionInfoCardConfig,
} from '@fluxer/schema/src/domains/experiment/ExpressionInfoCardSchemas';
import {
DEFAULT_GUILD_ACTIVITY_LOG_PRESENTATION_CONFIG,
type GuildActivityLogPresentationConfig,
} from '@fluxer/schema/src/domains/experiment/GuildActivityLogPresentationSchemas';
import {
DEFAULT_GUILD_HEADER_COLLAPSE_CONFIG,
type GuildHeaderCollapseConfig,
} from '@fluxer/schema/src/domains/experiment/GuildHeaderCollapseSchemas';
import {
DEFAULT_MESSAGE_HOVER_TRACKING_CONFIG,
type MessageHoverTrackingConfig,
} from '@fluxer/schema/src/domains/experiment/MessageHoverTrackingSchemas';
import {
DEFAULT_MESSAGE_KEYBOARD_FOCUS_CONFIG,
type MessageKeyboardFocusConfig,
} from '@fluxer/schema/src/domains/experiment/MessageKeyboardFocusSchemas';
import {
DEFAULT_TYPING_INDICATOR_REWORK_CONFIG,
type TypingIndicatorReworkConfig,
} from '@fluxer/schema/src/domains/experiment/TypingIndicatorReworkSchemas';
import {afterEach, describe, expect, it, vi} from 'vitest';
const VOICE_NOISE_SUPPRESSION_CONFIG_KEY = 'voice_noise_suppression_config';
const MESSAGE_HOVER_TRACKING_CONFIG_KEY = 'message_hover_tracking_config';
const MESSAGE_KEYBOARD_FOCUS_CONFIG_KEY = 'message_keyboard_focus_config';
const BLOCKED_MESSAGE_GROUPS_CONFIG_KEY = 'blocked_message_groups_config';
const GUILD_ACTIVITY_LOG_PRESENTATION_CONFIG_KEY = 'guild_activity_log_presentation_config';
const EXPRESSION_INFO_CARD_CONFIG_KEY = 'expression_info_card_config';
const GUILD_HEADER_COLLAPSE_CONFIG_KEY = 'guild_header_collapse_config';
const TYPING_INDICATOR_REWORK_CONFIG_KEY = 'typing_indicator_rework_config';
const EXPERIMENT_DELIVERY_CONFIG_KEY = 'experiment_delivery_config';
const APP_PUBLIC_CONFIG_KEY = 'app_public_config';
const INSTANCE_POLICY_CONFIG_KEY = 'instance_policy_config';
@@ -347,363 +312,6 @@ describe('InstanceConfigRepository', () => {
await expect(repository.getVoiceNoiseSuppressionConfig()).resolves.toEqual(config);
});
it('returns the default message hover tracking config when the key is absent', async () => {
const executor = new CountingInMemoryCassandraQueryExecutor();
setCassandraQueryExecutorForTesting(executor);
const kvProvider = new MockKVProvider();
const repository = createRepository(kvProvider);
await expect(repository.getMessageHoverTrackingConfig()).resolves.toEqual(DEFAULT_MESSAGE_HOVER_TRACKING_CONFIG);
});
it.each([
{name: 'unparseable text', stored: 'not-json'},
{name: 'a json array', stored: '[]'},
{name: 'out-of-range values', stored: '{"rollout_basis_points":99999}'},
{name: 'a target that is not a snowflake', stored: '{"included_user_ids":["nope"]}'},
])('falls back to the default message hover tracking config for $name', async ({stored}) => {
const executor = new CountingInMemoryCassandraQueryExecutor();
setCassandraQueryExecutorForTesting(executor);
const kvProvider = new MockKVProvider();
const repository = createRepository(kvProvider);
await repository.setConfig(MESSAGE_HOVER_TRACKING_CONFIG_KEY, stored);
await expect(repository.getMessageHoverTrackingConfig()).resolves.toEqual(DEFAULT_MESSAGE_HOVER_TRACKING_CONFIG);
});
it('round-trips a stored message hover tracking config', async () => {
const executor = new CountingInMemoryCassandraQueryExecutor();
setCassandraQueryExecutorForTesting(executor);
const kvProvider = new MockKVProvider();
const repository = createRepository(kvProvider);
const config: MessageHoverTrackingConfig = {
...DEFAULT_MESSAGE_HOVER_TRACKING_CONFIG,
enabled: true,
config_version: 5,
rollout_basis_points: 2500,
rollout_salt: 'message-hover-tracking-v2',
included_user_ids: ['1400000000000000001'],
excluded_user_ids: ['1400000000000000002'],
};
await repository.setMessageHoverTrackingConfig(config);
await expect(repository.getMessageHoverTrackingConfig()).resolves.toEqual(config);
});
it('returns the default message keyboard focus config when the key is absent', async () => {
const executor = new CountingInMemoryCassandraQueryExecutor();
setCassandraQueryExecutorForTesting(executor);
const kvProvider = new MockKVProvider();
const repository = createRepository(kvProvider);
await expect(repository.getMessageKeyboardFocusConfig()).resolves.toEqual(DEFAULT_MESSAGE_KEYBOARD_FOCUS_CONFIG);
});
it.each([
{name: 'unparseable text', stored: 'not-json'},
{name: 'a json array', stored: '[]'},
{name: 'out-of-range values', stored: '{"rollout_basis_points":99999}'},
{name: 'a target that is not a snowflake', stored: '{"included_user_ids":["nope"]}'},
])('falls back to the default message keyboard focus config for $name', async ({stored}) => {
const executor = new CountingInMemoryCassandraQueryExecutor();
setCassandraQueryExecutorForTesting(executor);
const kvProvider = new MockKVProvider();
const repository = createRepository(kvProvider);
await repository.setConfig(MESSAGE_KEYBOARD_FOCUS_CONFIG_KEY, stored);
await expect(repository.getMessageKeyboardFocusConfig()).resolves.toEqual(DEFAULT_MESSAGE_KEYBOARD_FOCUS_CONFIG);
});
it('round-trips a stored message keyboard focus config', async () => {
const executor = new CountingInMemoryCassandraQueryExecutor();
setCassandraQueryExecutorForTesting(executor);
const kvProvider = new MockKVProvider();
const repository = createRepository(kvProvider);
const config: MessageKeyboardFocusConfig = {
...DEFAULT_MESSAGE_KEYBOARD_FOCUS_CONFIG,
enabled: true,
config_version: 5,
rollout_basis_points: 2500,
rollout_salt: 'message-keyboard-focus-v2',
included_user_ids: ['1400000000000000001'],
excluded_user_ids: ['1400000000000000002'],
};
await repository.setMessageKeyboardFocusConfig(config);
await expect(repository.getMessageKeyboardFocusConfig()).resolves.toEqual(config);
});
it('returns the default blocked message groups config when the key is absent', async () => {
const executor = new CountingInMemoryCassandraQueryExecutor();
setCassandraQueryExecutorForTesting(executor);
const kvProvider = new MockKVProvider();
const repository = createRepository(kvProvider);
await expect(repository.getBlockedMessageGroupsConfig()).resolves.toEqual(DEFAULT_BLOCKED_MESSAGE_GROUPS_CONFIG);
});
it.each([
{name: 'unparseable text', stored: 'not-json'},
{name: 'a json array', stored: '[]'},
{name: 'out-of-range values', stored: '{"rollout_basis_points":99999}'},
{name: 'a target that is not a snowflake', stored: '{"included_user_ids":["nope"]}'},
])('falls back to the default blocked message groups config for $name', async ({stored}) => {
const executor = new CountingInMemoryCassandraQueryExecutor();
setCassandraQueryExecutorForTesting(executor);
const kvProvider = new MockKVProvider();
const repository = createRepository(kvProvider);
await repository.setConfig(BLOCKED_MESSAGE_GROUPS_CONFIG_KEY, stored);
await expect(repository.getBlockedMessageGroupsConfig()).resolves.toEqual(DEFAULT_BLOCKED_MESSAGE_GROUPS_CONFIG);
});
it('round-trips a stored blocked message groups config', async () => {
const executor = new CountingInMemoryCassandraQueryExecutor();
setCassandraQueryExecutorForTesting(executor);
const kvProvider = new MockKVProvider();
const repository = createRepository(kvProvider);
const config: BlockedMessageGroupsConfig = {
...DEFAULT_BLOCKED_MESSAGE_GROUPS_CONFIG,
enabled: true,
config_version: 5,
rollout_basis_points: 2500,
rollout_salt: 'blocked-message-groups-v2',
included_user_ids: ['1400000000000000001'],
excluded_user_ids: ['1400000000000000002'],
};
await repository.setBlockedMessageGroupsConfig(config);
await expect(repository.getBlockedMessageGroupsConfig()).resolves.toEqual(config);
});
it('returns the default guild activity log presentation config when the key is absent', async () => {
const executor = new CountingInMemoryCassandraQueryExecutor();
setCassandraQueryExecutorForTesting(executor);
const kvProvider = new MockKVProvider();
const repository = createRepository(kvProvider);
await expect(repository.getGuildActivityLogPresentationConfig()).resolves.toEqual(
DEFAULT_GUILD_ACTIVITY_LOG_PRESENTATION_CONFIG,
);
});
it.each([
{name: 'unparseable text', stored: 'not-json'},
{name: 'a json array', stored: '[]'},
{name: 'out-of-range values', stored: '{"rollout_basis_points":99999}'},
{name: 'a target that is not a snowflake', stored: '{"included_user_ids":["nope"]}'},
])('falls back to the default guild activity log presentation config for $name', async ({stored}) => {
const executor = new CountingInMemoryCassandraQueryExecutor();
setCassandraQueryExecutorForTesting(executor);
const kvProvider = new MockKVProvider();
const repository = createRepository(kvProvider);
await repository.setConfig(GUILD_ACTIVITY_LOG_PRESENTATION_CONFIG_KEY, stored);
await expect(repository.getGuildActivityLogPresentationConfig()).resolves.toEqual(
DEFAULT_GUILD_ACTIVITY_LOG_PRESENTATION_CONFIG,
);
});
it('round-trips a stored guild activity log presentation config', async () => {
const executor = new CountingInMemoryCassandraQueryExecutor();
setCassandraQueryExecutorForTesting(executor);
const kvProvider = new MockKVProvider();
const repository = createRepository(kvProvider);
const config: GuildActivityLogPresentationConfig = {
...DEFAULT_GUILD_ACTIVITY_LOG_PRESENTATION_CONFIG,
enabled: true,
config_version: 5,
rollout_basis_points: 2500,
rollout_salt: 'guild-activity-log-presentation-v2',
included_user_ids: ['1400000000000000001'],
excluded_user_ids: ['1400000000000000002'],
};
await repository.setGuildActivityLogPresentationConfig(config);
await expect(repository.getGuildActivityLogPresentationConfig()).resolves.toEqual(config);
});
it('returns the default expression info card config when the key is absent', async () => {
const executor = new CountingInMemoryCassandraQueryExecutor();
setCassandraQueryExecutorForTesting(executor);
const kvProvider = new MockKVProvider();
const repository = createRepository(kvProvider);
await expect(repository.getExpressionInfoCardConfig()).resolves.toEqual(DEFAULT_EXPRESSION_INFO_CARD_CONFIG);
});
it.each([
{name: 'unparseable text', stored: 'not-json'},
{name: 'a json array', stored: '[]'},
{name: 'out-of-range values', stored: '{"rollout_basis_points":99999}'},
{name: 'a target that is not a snowflake', stored: '{"included_user_ids":["nope"]}'},
])('falls back to the default expression info card config for $name', async ({stored}) => {
const executor = new CountingInMemoryCassandraQueryExecutor();
setCassandraQueryExecutorForTesting(executor);
const kvProvider = new MockKVProvider();
const repository = createRepository(kvProvider);
await repository.setConfig(EXPRESSION_INFO_CARD_CONFIG_KEY, stored);
await expect(repository.getExpressionInfoCardConfig()).resolves.toEqual(DEFAULT_EXPRESSION_INFO_CARD_CONFIG);
});
it('round-trips a stored expression info card config', async () => {
const executor = new CountingInMemoryCassandraQueryExecutor();
setCassandraQueryExecutorForTesting(executor);
const kvProvider = new MockKVProvider();
const repository = createRepository(kvProvider);
const config: ExpressionInfoCardConfig = {
...DEFAULT_EXPRESSION_INFO_CARD_CONFIG,
enabled: true,
config_version: 5,
rollout_basis_points: 2500,
rollout_salt: 'expression-info-card-v2',
included_user_ids: ['1400000000000000001'],
excluded_user_ids: ['1400000000000000002'],
};
await repository.setExpressionInfoCardConfig(config);
await expect(repository.getExpressionInfoCardConfig()).resolves.toEqual(config);
});
it('returns the default guild header collapse config when the key is absent', async () => {
const executor = new CountingInMemoryCassandraQueryExecutor();
setCassandraQueryExecutorForTesting(executor);
const kvProvider = new MockKVProvider();
const repository = createRepository(kvProvider);
await expect(repository.getGuildHeaderCollapseConfig()).resolves.toEqual(DEFAULT_GUILD_HEADER_COLLAPSE_CONFIG);
});
it.each([
{name: 'unparseable text', stored: 'not-json'},
{name: 'a json array', stored: '[]'},
{name: 'out-of-range values', stored: '{"rollout_basis_points":99999}'},
{name: 'a target that is not a snowflake', stored: '{"included_user_ids":["nope"]}'},
])('falls back to the default guild header collapse config for $name', async ({stored}) => {
const executor = new CountingInMemoryCassandraQueryExecutor();
setCassandraQueryExecutorForTesting(executor);
const kvProvider = new MockKVProvider();
const repository = createRepository(kvProvider);
await repository.setConfig(GUILD_HEADER_COLLAPSE_CONFIG_KEY, stored);
await expect(repository.getGuildHeaderCollapseConfig()).resolves.toEqual(DEFAULT_GUILD_HEADER_COLLAPSE_CONFIG);
});
it('round-trips a stored guild header collapse config', async () => {
const executor = new CountingInMemoryCassandraQueryExecutor();
setCassandraQueryExecutorForTesting(executor);
const kvProvider = new MockKVProvider();
const repository = createRepository(kvProvider);
const config: GuildHeaderCollapseConfig = {
...DEFAULT_GUILD_HEADER_COLLAPSE_CONFIG,
enabled: true,
config_version: 5,
rollout_basis_points: 1500,
rollout_salt: 'guild-header-collapse-v2',
included_user_ids: ['1400000000000000001'],
excluded_user_ids: ['1400000000000000002'],
};
await repository.setGuildHeaderCollapseConfig(config);
await expect(repository.getGuildHeaderCollapseConfig()).resolves.toEqual(config);
});
it('fills newly added guild header collapse fields from the schema defaults', async () => {
const executor = new CountingInMemoryCassandraQueryExecutor();
setCassandraQueryExecutorForTesting(executor);
const kvProvider = new MockKVProvider();
const repository = createRepository(kvProvider);
await repository.setConfig(
GUILD_HEADER_COLLAPSE_CONFIG_KEY,
JSON.stringify({enabled: true, config_version: 2, rollout_basis_points: 1000}),
);
await expect(repository.getGuildHeaderCollapseConfig()).resolves.toEqual({
...DEFAULT_GUILD_HEADER_COLLAPSE_CONFIG,
enabled: true,
config_version: 2,
rollout_basis_points: 1000,
});
});
it('returns the default typing indicator rework config when the key is absent', async () => {
const executor = new CountingInMemoryCassandraQueryExecutor();
setCassandraQueryExecutorForTesting(executor);
const kvProvider = new MockKVProvider();
const repository = createRepository(kvProvider);
await expect(repository.getTypingIndicatorReworkConfig()).resolves.toEqual(DEFAULT_TYPING_INDICATOR_REWORK_CONFIG);
});
it.each([
{name: 'unparseable text', stored: 'not-json'},
{name: 'a json array', stored: '[]'},
{name: 'out-of-range values', stored: '{"rollout_basis_points":99999}'},
{name: 'a target that is not a snowflake', stored: '{"included_user_ids":["nope"]}'},
])('falls back to the default typing indicator rework config for $name', async ({stored}) => {
const executor = new CountingInMemoryCassandraQueryExecutor();
setCassandraQueryExecutorForTesting(executor);
const kvProvider = new MockKVProvider();
const repository = createRepository(kvProvider);
await repository.setConfig(TYPING_INDICATOR_REWORK_CONFIG_KEY, stored);
await expect(repository.getTypingIndicatorReworkConfig()).resolves.toEqual(DEFAULT_TYPING_INDICATOR_REWORK_CONFIG);
});
it('round-trips a stored typing indicator rework config', async () => {
const executor = new CountingInMemoryCassandraQueryExecutor();
setCassandraQueryExecutorForTesting(executor);
const kvProvider = new MockKVProvider();
const repository = createRepository(kvProvider);
const config: TypingIndicatorReworkConfig = {
...DEFAULT_TYPING_INDICATOR_REWORK_CONFIG,
enabled: true,
config_version: 5,
rollout_basis_points: 1500,
rollout_salt: 'typing-indicator-rework-v2',
included_user_ids: ['1400000000000000001'],
excluded_user_ids: ['1400000000000000002'],
};
await repository.setTypingIndicatorReworkConfig(config);
await expect(repository.getTypingIndicatorReworkConfig()).resolves.toEqual(config);
});
it('fills newly added typing indicator rework fields from the schema defaults', async () => {
const executor = new CountingInMemoryCassandraQueryExecutor();
setCassandraQueryExecutorForTesting(executor);
const kvProvider = new MockKVProvider();
const repository = createRepository(kvProvider);
await repository.setConfig(
TYPING_INDICATOR_REWORK_CONFIG_KEY,
JSON.stringify({enabled: true, config_version: 2, rollout_basis_points: 1000}),
);
await expect(repository.getTypingIndicatorReworkConfig()).resolves.toEqual({
...DEFAULT_TYPING_INDICATOR_REWORK_CONFIG,
enabled: true,
config_version: 2,
rollout_basis_points: 1000,
});
});
it('fills newly added voice noise suppression fields from the schema defaults', async () => {
const executor = new CountingInMemoryCassandraQueryExecutor();
setCassandraQueryExecutorForTesting(executor);
fluxer_api/src/api/instance/InstanceConfigRepository.ts
-151
View File
@@ -32,38 +32,10 @@ import {
type VoiceNoiseSuppressionConfig,
VoiceNoiseSuppressionConfigSchema,
} from '@fluxer/schema/src/domains/admin/VoiceNoiseSuppressionSchemas';
import {
type BlockedMessageGroupsConfig,
BlockedMessageGroupsConfigSchema,
} from '@fluxer/schema/src/domains/experiment/BlockedMessageGroupsSchemas';
import {
type ExperimentDeliveryConfig,
ExperimentDeliveryConfigSchema,
} from '@fluxer/schema/src/domains/experiment/ExperimentSchemas';
import {
type ExpressionInfoCardConfig,
ExpressionInfoCardConfigSchema,
} from '@fluxer/schema/src/domains/experiment/ExpressionInfoCardSchemas';
import {
type GuildActivityLogPresentationConfig,
GuildActivityLogPresentationConfigSchema,
} from '@fluxer/schema/src/domains/experiment/GuildActivityLogPresentationSchemas';
import {
type GuildHeaderCollapseConfig,
GuildHeaderCollapseConfigSchema,
} from '@fluxer/schema/src/domains/experiment/GuildHeaderCollapseSchemas';
import {
type MessageHoverTrackingConfig,
MessageHoverTrackingConfigSchema,
} from '@fluxer/schema/src/domains/experiment/MessageHoverTrackingSchemas';
import {
type MessageKeyboardFocusConfig,
MessageKeyboardFocusConfigSchema,
} from '@fluxer/schema/src/domains/experiment/MessageKeyboardFocusSchemas';
import {
type TypingIndicatorReworkConfig,
TypingIndicatorReworkConfigSchema,
} from '@fluxer/schema/src/domains/experiment/TypingIndicatorReworkSchemas';
import {
type InstanceAppPublic,
InstanceAppPublicSchema,
@@ -82,14 +54,7 @@ import {z} from 'zod';
const GATEWAY_ROLLOUT_CONFIG_KEY = 'gateway_rollout_config';
const VOICE_NOISE_SUPPRESSION_CONFIG_KEY = 'voice_noise_suppression_config';
const GUILD_ACTIVITY_LOG_PRESENTATION_CONFIG_KEY = 'guild_activity_log_presentation_config';
const EXPERIMENT_DELIVERY_CONFIG_KEY = 'experiment_delivery_config';
const MESSAGE_HOVER_TRACKING_CONFIG_KEY = 'message_hover_tracking_config';
const MESSAGE_KEYBOARD_FOCUS_CONFIG_KEY = 'message_keyboard_focus_config';
const BLOCKED_MESSAGE_GROUPS_CONFIG_KEY = 'blocked_message_groups_config';
const EXPRESSION_INFO_CARD_CONFIG_KEY = 'expression_info_card_config';
const GUILD_HEADER_COLLAPSE_CONFIG_KEY = 'guild_header_collapse_config';
const TYPING_INDICATOR_REWORK_CONFIG_KEY = 'typing_indicator_rework_config';
const REGISTRATION_CONFIG_KEY = 'registration_config';
const REGISTRATION_URLS_KEY = 'registration_urls';
const REGISTRATION_PENDING_APPROVALS_KEY = 'registration_pending_approvals';
@@ -372,14 +337,7 @@ type StoredConfigSection =
| 'app public'
| 'gateway rollout'
| 'voice noise suppression'
| 'guild activity log presentation'
| 'experiment delivery'
| 'message hover tracking'
| 'message keyboard focus'
| 'blocked message groups'
| 'expression info card'
| 'guild header collapse'
| 'typing indicator rework'
| 'instance policy'
| 'integrations'
| 'media'
@@ -517,38 +475,10 @@ function parseStoredVoiceNoiseSuppressionConfig(raw: string | null): VoiceNoiseS
return parseStoredConfigOrDefault(VoiceNoiseSuppressionConfigSchema, raw, 'voice noise suppression');
}
function parseStoredGuildActivityLogPresentationConfig(raw: string | null): GuildActivityLogPresentationConfig {
return parseStoredConfigOrDefault(GuildActivityLogPresentationConfigSchema, raw, 'guild activity log presentation');
}
function parseStoredExperimentDeliveryConfig(raw: string | null): ExperimentDeliveryConfig {
return parseStoredConfigOrDefault(ExperimentDeliveryConfigSchema, raw, 'experiment delivery');
}
function parseStoredMessageHoverTrackingConfig(raw: string | null): MessageHoverTrackingConfig {
return parseStoredConfigOrDefault(MessageHoverTrackingConfigSchema, raw, 'message hover tracking');
}
function parseStoredMessageKeyboardFocusConfig(raw: string | null): MessageKeyboardFocusConfig {
return parseStoredConfigOrDefault(MessageKeyboardFocusConfigSchema, raw, 'message keyboard focus');
}
function parseStoredBlockedMessageGroupsConfig(raw: string | null): BlockedMessageGroupsConfig {
return parseStoredConfigOrDefault(BlockedMessageGroupsConfigSchema, raw, 'blocked message groups');
}
function parseStoredExpressionInfoCardConfig(raw: string | null): ExpressionInfoCardConfig {
return parseStoredConfigOrDefault(ExpressionInfoCardConfigSchema, raw, 'expression info card');
}
function parseStoredGuildHeaderCollapseConfig(raw: string | null): GuildHeaderCollapseConfig {
return parseStoredConfigOrDefault(GuildHeaderCollapseConfigSchema, raw, 'guild header collapse');
}
function parseStoredTypingIndicatorReworkConfig(raw: string | null): TypingIndicatorReworkConfig {
return parseStoredConfigOrDefault(TypingIndicatorReworkConfigSchema, raw, 'typing indicator rework');
}
function validateStoredCollection<T>(schema: z.ZodType<T>, value: unknown, section: StoredConfigSection): Array<T> {
if (!Array.isArray(value)) {
throw new Error(`Stored ${section} configuration must be an array`);
@@ -1067,14 +997,7 @@ export class InstanceConfigRepository {
parseStoredGatewayRolloutConfig(snapshot.get(GATEWAY_ROLLOUT_CONFIG_KEY) ?? null),
);
parseStoredVoiceNoiseSuppressionConfig(snapshot.get(VOICE_NOISE_SUPPRESSION_CONFIG_KEY) ?? null);
parseStoredGuildActivityLogPresentationConfig(snapshot.get(GUILD_ACTIVITY_LOG_PRESENTATION_CONFIG_KEY) ?? null);
parseStoredExperimentDeliveryConfig(snapshot.get(EXPERIMENT_DELIVERY_CONFIG_KEY) ?? null);
parseStoredMessageHoverTrackingConfig(snapshot.get(MESSAGE_HOVER_TRACKING_CONFIG_KEY) ?? null);
parseStoredMessageKeyboardFocusConfig(snapshot.get(MESSAGE_KEYBOARD_FOCUS_CONFIG_KEY) ?? null);
parseStoredBlockedMessageGroupsConfig(snapshot.get(BLOCKED_MESSAGE_GROUPS_CONFIG_KEY) ?? null);
parseStoredExpressionInfoCardConfig(snapshot.get(EXPRESSION_INFO_CARD_CONFIG_KEY) ?? null);
parseStoredGuildHeaderCollapseConfig(snapshot.get(GUILD_HEADER_COLLAPSE_CONFIG_KEY) ?? null);
parseStoredTypingIndicatorReworkConfig(snapshot.get(TYPING_INDICATOR_REWORK_CONFIG_KEY) ?? null);
const policy = parseStoredInstancePolicyConfig(snapshot.get(INSTANCE_POLICY_CONFIG_KEY) ?? null);
checkStoredConfig('registration', () =>
parseStoredRegistrationConfig(snapshot.get(REGISTRATION_CONFIG_KEY) ?? null),
@@ -1155,85 +1078,11 @@ export class InstanceConfigRepository {
await this.setConfig(VOICE_NOISE_SUPPRESSION_CONFIG_KEY, JSON.stringify(validated));
}
async getGuildActivityLogPresentationConfig(): Promise<GuildActivityLogPresentationConfig> {
const raw = await this.getConfig(GUILD_ACTIVITY_LOG_PRESENTATION_CONFIG_KEY);
return parseStoredGuildActivityLogPresentationConfig(raw);
}
async setGuildActivityLogPresentationConfig(config: GuildActivityLogPresentationConfig): Promise<void> {
const validated = validateStoredConfig(
GuildActivityLogPresentationConfigSchema,
config,
'guild activity log presentation',
);
await this.setConfig(GUILD_ACTIVITY_LOG_PRESENTATION_CONFIG_KEY, JSON.stringify(validated));
}
async getExperimentDeliveryConfig(): Promise<ExperimentDeliveryConfig> {
const raw = await this.getConfig(EXPERIMENT_DELIVERY_CONFIG_KEY);
return parseStoredExperimentDeliveryConfig(raw);
}
async getMessageHoverTrackingConfig(): Promise<MessageHoverTrackingConfig> {
const raw = await this.getConfig(MESSAGE_HOVER_TRACKING_CONFIG_KEY);
return parseStoredMessageHoverTrackingConfig(raw);
}
async setMessageHoverTrackingConfig(config: MessageHoverTrackingConfig): Promise<void> {
const validated = validateStoredConfig(MessageHoverTrackingConfigSchema, config, 'message hover tracking');
await this.setConfig(MESSAGE_HOVER_TRACKING_CONFIG_KEY, JSON.stringify(validated));
}
async getMessageKeyboardFocusConfig(): Promise<MessageKeyboardFocusConfig> {
const raw = await this.getConfig(MESSAGE_KEYBOARD_FOCUS_CONFIG_KEY);
return parseStoredMessageKeyboardFocusConfig(raw);
}
async setMessageKeyboardFocusConfig(config: MessageKeyboardFocusConfig): Promise<void> {
const validated = validateStoredConfig(MessageKeyboardFocusConfigSchema, config, 'message keyboard focus');
await this.setConfig(MESSAGE_KEYBOARD_FOCUS_CONFIG_KEY, JSON.stringify(validated));
}
async getBlockedMessageGroupsConfig(): Promise<BlockedMessageGroupsConfig> {
const raw = await this.getConfig(BLOCKED_MESSAGE_GROUPS_CONFIG_KEY);
return parseStoredBlockedMessageGroupsConfig(raw);
}
async setBlockedMessageGroupsConfig(config: BlockedMessageGroupsConfig): Promise<void> {
const validated = validateStoredConfig(BlockedMessageGroupsConfigSchema, config, 'blocked message groups');
await this.setConfig(BLOCKED_MESSAGE_GROUPS_CONFIG_KEY, JSON.stringify(validated));
}
async getExpressionInfoCardConfig(): Promise<ExpressionInfoCardConfig> {
const raw = await this.getConfig(EXPRESSION_INFO_CARD_CONFIG_KEY);
return parseStoredExpressionInfoCardConfig(raw);
}
async setExpressionInfoCardConfig(config: ExpressionInfoCardConfig): Promise<void> {
const validated = validateStoredConfig(ExpressionInfoCardConfigSchema, config, 'expression info card');
await this.setConfig(EXPRESSION_INFO_CARD_CONFIG_KEY, JSON.stringify(validated));
}
async getGuildHeaderCollapseConfig(): Promise<GuildHeaderCollapseConfig> {
const raw = await this.getConfig(GUILD_HEADER_COLLAPSE_CONFIG_KEY);
return parseStoredGuildHeaderCollapseConfig(raw);
}
async setGuildHeaderCollapseConfig(config: GuildHeaderCollapseConfig): Promise<void> {
const validated = validateStoredConfig(GuildHeaderCollapseConfigSchema, config, 'guild header collapse');
await this.setConfig(GUILD_HEADER_COLLAPSE_CONFIG_KEY, JSON.stringify(validated));
}
async getTypingIndicatorReworkConfig(): Promise<TypingIndicatorReworkConfig> {
const raw = await this.getConfig(TYPING_INDICATOR_REWORK_CONFIG_KEY);
return parseStoredTypingIndicatorReworkConfig(raw);
}
async setTypingIndicatorReworkConfig(config: TypingIndicatorReworkConfig): Promise<void> {
const validated = validateStoredConfig(TypingIndicatorReworkConfigSchema, config, 'typing indicator rework');
await this.setConfig(TYPING_INDICATOR_REWORK_CONFIG_KEY, JSON.stringify(validated));
}
async setExperimentDeliveryConfig(config: ExperimentDeliveryConfig): Promise<void> {
const validated = validateStoredConfig(ExperimentDeliveryConfigSchema, config, 'experiment delivery');
await this.setConfig(EXPERIMENT_DELIVERY_CONFIG_KEY, JSON.stringify(validated));
fluxer_api/src/api/openapi/openapi.json
+1 -87
View File
@@ -27595,16 +27595,7 @@
"assignments": {
"type": "object",
"properties": {
"voice_noise_suppression": {"$ref": "#/components/schemas/VoiceNoiseSuppressionAssignmentResponse"},
"message_hover_tracking": {"$ref": "#/components/schemas/MessageHoverTrackingAssignmentResponse"},
"message_keyboard_focus": {"$ref": "#/components/schemas/MessageKeyboardFocusAssignmentResponse"},
"blocked_message_groups": {"$ref": "#/components/schemas/BlockedMessageGroupsAssignmentResponse"},
"guild_activity_log_presentation": {
"$ref": "#/components/schemas/GuildActivityLogPresentationAssignmentResponse"
},
"expression_info_card": {"$ref": "#/components/schemas/ExpressionInfoCardAssignmentResponse"},
"guild_header_collapse": {"$ref": "#/components/schemas/GuildHeaderCollapseAssignmentResponse"},
"typing_indicator_rework": {"$ref": "#/components/schemas/TypingIndicatorReworkAssignmentResponse"}
"voice_noise_suppression": {"$ref": "#/components/schemas/VoiceNoiseSuppressionAssignmentResponse"}
},
"additionalProperties": false
}
@@ -31344,83 +31335,6 @@
"additionalProperties": false
},
"DonationCurrency": {"type": "string", "enum": ["usd", "eur", "brl", "inr", "pln", "try", "sek", "dkk", "nok"]},
"TypingIndicatorReworkAssignmentResponse": {
"type": "object",
"properties": {
"enabled": {"type": "boolean"},
"config_version": {"type": "integer", "minimum": -9007199254740991, "maximum": 9007199254740991},
"user_targeted": {"type": "boolean"},
"source": {"anyOf": [{"type": "string", "enum": ["user_rule", "canary"]}, {"type": "null"}]}
},
"required": ["enabled", "config_version", "user_targeted", "source"],
"additionalProperties": false
},
"GuildHeaderCollapseAssignmentResponse": {
"type": "object",
"properties": {
"enabled": {"type": "boolean"},
"config_version": {"type": "integer", "minimum": -9007199254740991, "maximum": 9007199254740991},
"user_targeted": {"type": "boolean"},
"source": {"anyOf": [{"type": "string", "enum": ["user_rule", "canary"]}, {"type": "null"}]}
},
"required": ["enabled", "config_version", "user_targeted", "source"],
"additionalProperties": false
},
"ExpressionInfoCardAssignmentResponse": {
"type": "object",
"properties": {
"enabled": {"type": "boolean"},
"config_version": {"type": "integer", "minimum": -9007199254740991, "maximum": 9007199254740991},
"user_targeted": {"type": "boolean"},
"source": {"anyOf": [{"type": "string", "enum": ["user_rule", "canary"]}, {"type": "null"}]}
},
"required": ["enabled", "config_version", "user_targeted", "source"],
"additionalProperties": false
},
"GuildActivityLogPresentationAssignmentResponse": {
"type": "object",
"properties": {
"enabled": {"type": "boolean"},
"config_version": {"type": "integer", "minimum": -9007199254740991, "maximum": 9007199254740991},
"user_targeted": {"type": "boolean"},
"source": {"anyOf": [{"type": "string", "enum": ["user_rule", "canary"]}, {"type": "null"}]}
},
"required": ["enabled", "config_version", "user_targeted", "source"],
"additionalProperties": false
},
"BlockedMessageGroupsAssignmentResponse": {
"type": "object",
"properties": {
"enabled": {"type": "boolean"},
"config_version": {"type": "integer", "minimum": -9007199254740991, "maximum": 9007199254740991},
"user_targeted": {"type": "boolean"},
"source": {"anyOf": [{"type": "string", "enum": ["user_rule", "canary"]}, {"type": "null"}]}
},
"required": ["enabled", "config_version", "user_targeted", "source"],
"additionalProperties": false
},
"MessageKeyboardFocusAssignmentResponse": {
"type": "object",
"properties": {
"enabled": {"type": "boolean"},
"config_version": {"type": "integer", "minimum": -9007199254740991, "maximum": 9007199254740991},
"user_targeted": {"type": "boolean"},
"source": {"anyOf": [{"type": "string", "enum": ["user_rule", "canary"]}, {"type": "null"}]}
},
"required": ["enabled", "config_version", "user_targeted", "source"],
"additionalProperties": false
},
"MessageHoverTrackingAssignmentResponse": {
"type": "object",
"properties": {
"enabled": {"type": "boolean"},
"config_version": {"type": "integer", "minimum": -9007199254740991, "maximum": 9007199254740991},
"user_targeted": {"type": "boolean"},
"source": {"anyOf": [{"type": "string", "enum": ["user_rule", "canary"]}, {"type": "null"}]}
},
"required": ["enabled", "config_version", "user_targeted", "source"],
"additionalProperties": false
},
"VoiceNoiseSuppressionAssignmentResponse": {
"type": "object",
"properties": {