Files

233 lines
8.4 KiB
TypeScript

import { beforeEach, describe, expect, it, vi } from "vitest";
const mocks = vi.hoisted(() => ({
featureFlagFindFirst: vi.fn(),
tenantFindMany: vi.fn(),
tenantUserCount: vi.fn(),
tenantSubscriptionFindUnique: vi.fn(),
overrideUpsert: vi.fn(),
featureFlagAuditCreate: vi.fn(),
recordAdminAction: vi.fn(),
runWithRlsContext: vi.fn(),
}));
vi.mock("~/utils/db.server", () => ({
db: {
featureFlag: { findFirst: mocks.featureFlagFindFirst },
tenant: { findMany: mocks.tenantFindMany },
tenantUser: { count: mocks.tenantUserCount },
tenantSubscription: { findUnique: mocks.tenantSubscriptionFindUnique },
$transaction: vi.fn(async (operation: (transaction: unknown) => unknown) =>
operation({
featureFlag: { findFirst: mocks.featureFlagFindFirst },
tenant: { findMany: mocks.tenantFindMany },
adminFeatureFlagOverride: { upsert: mocks.overrideUpsert },
featureFlagAudit: { create: mocks.featureFlagAuditCreate },
})
),
},
}));
vi.mock("@hivegrid/db/rls-context.server", () => ({
runWithRlsContext: (context: unknown, callback: () => unknown) => mocks.runWithRlsContext(context, callback),
}));
vi.mock("~/services/admin/admin-action-audit.server", () => ({
assertAdminActionReason: (reason: string) => {
const normalized = reason.trim();
if (normalized.length < 5) throw new Error("reason");
return normalized;
},
recordAdminAction: mocks.recordAdminAction,
}));
import {
AdminFeatureFlagRolloutError,
applyAdminFeatureFlagBulkOverride,
getAdminFeatureFlagRolloutView,
normalizeTenantIds,
} from "./feature-flag-rollout.server";
beforeEach(() => {
vi.clearAllMocks();
mocks.runWithRlsContext.mockImplementation((_context: unknown, callback: () => unknown) => callback());
});
describe("admin feature flag rollout preview", () => {
it("bounds tenant hydration concurrency while preserving full deterministic output", async () => {
const tenantIds = Array.from({ length: 6 }, (_, index) => `tenant-${index + 1}`);
const gates = new Map(tenantIds.map((tenantId) => [tenantId, createDeferred()]));
const started: string[] = [];
const completed: string[] = [];
let active = 0;
let maxActive = 0;
mocks.featureFlagFindFirst.mockResolvedValue({
id: "flag-1",
key: "sales_workspace",
name: "Sales Workspace",
description: "Sales Workspace",
defaultValue: false,
enabled: false,
lifecycleStage: "rollout",
filters: [
{
id: "filter-pilot",
name: "Pilot tenants",
priority: 10,
resultValue: true,
active: true,
createdAt: new Date("2026-07-01T00:00:00.000Z"),
criteria: { tenantIdIn: ["tenant-1", "tenant-3", "tenant-6"] },
},
],
tenantOverrides: [{ tenantId: "tenant-2", value: true, expiresAt: null }],
});
mocks.tenantFindMany.mockResolvedValue(
tenantIds.map((id, index) => ({
id,
name: `Tenant ${index + 1}`,
slug: id,
createdAt: new Date(`2026-06-0${index + 1}T00:00:00.000Z`),
active: id !== "tenant-4",
}))
);
mocks.tenantUserCount.mockImplementation(
async (input: { where: { tenantId: string } }) =>
({ "tenant-1": 1, "tenant-2": 11, "tenant-3": 26, "tenant-4": 51, "tenant-5": 101, "tenant-6": 0 })[input.where.tenantId]
);
mocks.tenantSubscriptionFindUnique.mockImplementation(async (input: { where: { tenantId: string } }) => {
await gates.get(input.where.tenantId)!.promise;
return input.where.tenantId === "tenant-1" ? { status: "trialing", products: [{ subscriptionProductId: "product-pro" }] } : null;
});
mocks.runWithRlsContext.mockImplementation(async (context: { tenantId: string }, callback: () => Promise<unknown>) => {
active += 1;
maxActive = Math.max(maxActive, active);
started.push(context.tenantId);
try {
return await callback();
} finally {
active -= 1;
completed.push(context.tenantId);
}
});
const viewPromise = getAdminFeatureFlagRolloutView("sales_workspace", new Date("2026-07-29T00:00:00.000Z"));
await vi.waitFor(() => expect(started).toEqual(["tenant-1", "tenant-2", "tenant-3", "tenant-4"]));
expect(maxActive).toBe(4);
gates.get("tenant-4")!.resolve();
await vi.waitFor(() => expect(started).toEqual(["tenant-1", "tenant-2", "tenant-3", "tenant-4", "tenant-5"]));
gates.get("tenant-2")!.resolve();
await vi.waitFor(() => expect(started).toEqual(["tenant-1", "tenant-2", "tenant-3", "tenant-4", "tenant-5", "tenant-6"]));
for (const gate of gates.values()) gate.resolve();
const view = await viewPromise;
expect(maxActive).toBe(4);
expect(completed.slice(0, 2)).toEqual(["tenant-4", "tenant-2"]);
expect(view?.tenants.map((tenant) => tenant.id)).toEqual(tenantIds);
expect(view?.tenants.map((tenant) => tenant.size)).toEqual(["1-10", "11-25", "26-50", "51-100", "100+", "1-10"]);
expect(view?.tenants[0]).toMatchObject({
status: "trialing",
subscriptionProductIds: ["product-pro"],
});
expect(view?.tenants[3]).toMatchObject({ status: "inactive", subscriptionProductIds: [] });
expect(view?.preview).toEqual({
enabled: 4,
disabled: 2,
overrides: 1,
filtered: 3,
defaulted: 2,
rows: [
{ tenantId: "tenant-1", decision: { value: true, source: "filter", filterId: "filter-pilot" } },
{ tenantId: "tenant-2", decision: { value: true, source: "override", filterId: null } },
{ tenantId: "tenant-3", decision: { value: true, source: "filter", filterId: "filter-pilot" } },
{ tenantId: "tenant-4", decision: { value: false, source: "default", filterId: null } },
{ tenantId: "tenant-5", decision: { value: false, source: "default", filterId: null } },
{ tenantId: "tenant-6", decision: { value: true, source: "filter", filterId: "filter-pilot" } },
],
});
});
});
describe("admin feature flag bulk override input", () => {
it("normalizes, deduplicates and sorts tenant identifiers", () => {
expect(normalizeTenantIds([" tenant-b ", "tenant-a", "tenant-b"])).toEqual(["tenant-a", "tenant-b"]);
});
it("rejects an empty selection and oversized batches", () => {
expect(() => normalizeTenantIds([])).toThrow(AdminFeatureFlagRolloutError);
expect(() => normalizeTenantIds(Array.from({ length: 501 }, (_, index) => `tenant-${index}`))).toThrow(
AdminFeatureFlagRolloutError
);
});
it("persists every override and both append-only audit contracts in one transaction", async () => {
mocks.featureFlagFindFirst.mockResolvedValue({
id: "flag-1",
key: "sales_workspace",
name: "Sales Workspace",
});
mocks.tenantFindMany.mockResolvedValue([{ id: "tenant-a" }, { id: "tenant-b" }]);
await expect(
applyAdminFeatureFlagBulkOverride({
flagKey: "sales_workspace",
tenantIds: ["tenant-b", "tenant-a"],
value: true,
actorAdminUserId: "admin-raffael",
reason: "Pilotgruppe freigeben",
note: "Vertriebspilot",
})
).resolves.toEqual({ updated: 2 });
expect(mocks.overrideUpsert).toHaveBeenCalledTimes(2);
expect(mocks.overrideUpsert.mock.calls.map(([input]) => input.where)).toEqual([
{
admin_feature_flag_override_flag_tenant_key: {
featureFlagId: "flag-1",
tenantId: "tenant-a",
},
},
{
admin_feature_flag_override_flag_tenant_key: {
featureFlagId: "flag-1",
tenantId: "tenant-b",
},
},
]);
expect(mocks.featureFlagAuditCreate).toHaveBeenCalledWith({
data: expect.objectContaining({
flagId: "flag-1",
actorUserId: "admin-raffael",
actorType: "admin",
action: "bulk_override",
metadata: {
reason: "Pilotgruppe freigeben",
tenantIds: ["tenant-a", "tenant-b"],
},
}),
});
expect(mocks.recordAdminAction).toHaveBeenCalledWith(
expect.objectContaining({
action: "featureFlag.bulkOverride",
actorUserId: "admin-raffael",
targetKind: "FeatureFlag",
targetId: "flag-1",
reason: "Pilotgruppe freigeben",
}),
expect.any(Object)
);
});
});
function createDeferred(): { readonly promise: Promise<void>; readonly resolve: () => void } {
let resolve!: () => void;
const promise = new Promise<void>((resolvePromise) => {
resolve = resolvePromise;
});
return { promise, resolve };
}