113 lines
4.2 KiB
TypeScript
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);
|
|
});
|
|
});
|