Files
clean-architecture-frontend…/tests/platform/cardinality/extreme-scale-registry.test.ts
T

113 lines
4.2 KiB
TypeScript

import { performance } from "node:perf_hooks";
import { describe, expect, it } from "vitest";
import {
resolveProductFeatures,
selectCompiledProductFeatures,
} from "../../../src/contracts/product-features.ts";
import { composeUniqueRecord } from "../../../src/platform/cardinality/compose-unique-record.ts";
const SMALL_REGISTRY_SIZE = 10_000;
const LARGE_REGISTRY_SIZE = 100_000;
const FEATURE_SCALE_SIZE = 100_000;
const LOOKUP_OPERATIONS = 1_000_000;
const MEASUREMENT_RUNS = 3;
const MAX_COMPOSE_GROWTH_RATIO = 30;
const MAX_LARGE_COMPOSE_MS = 3_000;
const MAX_MEMBERSHIP_MS = 3_000;
const MAX_LOOKUP_MS = 1_500;
function syntheticRecords(count: number): readonly Readonly<Record<string, number>>[] {
return Array.from({ length: count }, (_, index) => ({ [`key-${index}`]: index }));
}
function median(values: readonly number[]): number {
const sorted = [...values].sort((left, right) => left - right);
return sorted[Math.floor(sorted.length / 2)] ?? Number.POSITIVE_INFINITY;
}
function measureMedianElapsedMs(action: () => void): number {
action();
const samples = Array.from({ length: MEASUREMENT_RUNS }, () => {
const startedAt = performance.now();
action();
return performance.now() - startedAt;
});
return median(samples);
}
function measureCompose(records: readonly Readonly<Record<string, number>>[]): Readonly<{
elapsedMs: number;
registry: Readonly<Record<string, number>>;
}> {
let registry: Readonly<Record<string, number>> = {};
const elapsedMs = measureMedianElapsedMs(() => {
registry = composeUniqueRecord(records, () => "synthetic registry");
});
return Object.freeze({ elapsedMs, registry });
}
describe("extreme-scale registry composition", () => {
it("keeps 10k -> 100k composition growth below a quadratic regression budget", () => {
const smallRecords = syntheticRecords(SMALL_REGISTRY_SIZE);
const largeRecords = syntheticRecords(LARGE_REGISTRY_SIZE);
const small = measureCompose(smallRecords);
const large = measureCompose(largeRecords);
const growthRatio = large.elapsedMs / Math.max(small.elapsedMs, 1);
expect(Object.keys(small.registry)).toHaveLength(SMALL_REGISTRY_SIZE);
expect(Object.keys(large.registry)).toHaveLength(LARGE_REGISTRY_SIZE);
expect(large.elapsedMs).toBeLessThan(MAX_LARGE_COMPOSE_MS);
expect(growthRatio).toBeLessThan(MAX_COMPOSE_GROWTH_RATIO);
});
it("keeps one million lookups bounded on a 100k-entry runtime registry", () => {
const { registry } = measureCompose(syntheticRecords(LARGE_REGISTRY_SIZE));
let checksum = 0;
const elapsedMs = measureMedianElapsedMs(() => {
let currentChecksum = 0;
for (let index = 0; index < LOOKUP_OPERATIONS; index += 1) {
currentChecksum += registry[`key-${index % LARGE_REGISTRY_SIZE}`] ?? -1;
}
checksum = currentChecksum;
});
expect(checksum).toBeGreaterThan(0);
expect(elapsedMs).toBeLessThan(MAX_LOOKUP_MS);
});
});
describe("extreme-scale product feature membership", () => {
it("selects and resolves 100k feature ids within the membership budget", () => {
const compiled = Array.from({ length: FEATURE_SCALE_SIZE }, (_, index) =>
Object.freeze({ featureId: `feature-${index.toString().padStart(6, "0")}` }),
);
const requestedIds = compiled
.filter((_, index) => index % 10 === 0)
.map((feature) => feature.featureId);
const declared = requestedIds.join(",");
let selected = compiled.slice(0, 0);
const selectionElapsedMs = measureMedianElapsedMs(() => {
selected = [...selectCompiledProductFeatures(compiled, declared)];
});
let statuses = resolveProductFeatures([], []);
const installedIds = selected.map((feature) => feature.featureId);
const compiledIds = compiled.map((feature) => feature.featureId);
const resolveElapsedMs = measureMedianElapsedMs(() => {
statuses = resolveProductFeatures(compiledIds, installedIds);
});
expect(selected).toHaveLength(FEATURE_SCALE_SIZE / 10);
expect(statuses).toHaveLength(FEATURE_SCALE_SIZE);
expect(statuses.filter((status) => status.state === "ACTIVE")).toHaveLength(
FEATURE_SCALE_SIZE / 10,
);
expect(selectionElapsedMs).toBeLessThan(MAX_MEMBERSHIP_MS);
expect(resolveElapsedMs).toBeLessThan(MAX_MEMBERSHIP_MS);
});
});