gridstamp 1.0.0

package/tests/stress/load.test.ts

@@ -0,0 +1,499 @@
+/**
+ * Production Stress Tests — Load, concurrency, edge cases, overflow
+ *
+ * These simulate real fleet operations:
+ * - 1000 robots registering and operating simultaneously
+ * - Rapid-fire verification cycles
+ * - Memory pressure under sustained load
+ * - Boundary conditions that break naive implementations
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  TrustTierSystem,
+  TrustTier,
+  TIER_CONFIGS,
+  BadgeSystem,
+  StreakSystem,
+  ZoneMasterySystem,
+  FleetLeaderboard,
+  LeaderboardMetric,
+  type RobotMetrics,
+  type RobotStats,
+} from '../../src/gamification/index.js';
+import {
+  computeSSIM,
+  rgbToGrayscale,
+  approximateLPIPS,
+  generateSpatialProof,
+  verifySpatialProofIntegrity,
+  createSettlement,
+} from '../../src/verification/spatial-proof.js';
+import {
+  ReplayDetector,
+  FrameIntegrityChecker,
+  CanarySystem,
+} from '../../src/antispoofing/detector.js';
+import { signFrame, generateNonce, hmacSign, deriveKey } from '../../src/utils/crypto.js';
+import { PlaceCellPopulation, GridCellSystem, computeSpatialCode } from '../../src/memory/place-cells.js';
+import { ShortTermMemory } from '../../src/memory/spatial-memory.js';
+import type { CameraFrame, Pose, RenderedView } from '../../src/types/index.js';
+
+const SECRET = 'a]9#kL2$mP7xQ4vB8nR1wF5yH3jT6dG0'.slice(0, 32);
+
+function makeTestPose(x: number, y: number): Pose {
+  return {
+    position: { x, y, z: 0 },
+    orientation: { w: 1, x: 0, y: 0, z: 0 },
+    timestamp: Date.now(),
+  };
+}
+
+function makeTestFrame(w: number, h: number, seed: number, seq: number): CameraFrame {
+  const rgb = new Uint8Array(w * h * 3);
+  for (let i = 0; i < rgb.length; i++) rgb[i] = (i * 17 + seed * 31) % 256;
+  const depth = new Float32Array(w * h);
+  for (let i = 0; i < depth.length; i++) depth[i] = 1 + (seed % 5);
+  const ts = Date.now();
+  return {
+    id: generateNonce(8),
+    timestamp: ts,
+    rgb, width: w, height: h, depth,
+    pose: makeTestPose(seed, seed),
+    hmac: signFrame(rgb, ts, seq, SECRET),
+    sequenceNumber: seq,
+  };
+}
+
+function makeRender(w: number, h: number, seed: number): RenderedView {
+  const rgb = new Uint8Array(w * h * 3);
+  for (let i = 0; i < rgb.length; i++) rgb[i] = (i * 17 + seed * 31) % 256;
+  const depth = new Float32Array(w * h);
+  for (let i = 0; i < depth.length; i++) depth[i] = 1 + (seed % 5);
+  return { rgb, depth, width: w, height: h, pose: makeTestPose(seed, seed), renderTimeMs: 1 };
+}
+
+// ============================================================
+// LOAD TESTS
+// ============================================================
+
+describe('Load: Trust Tier System', () => {
+  it('handles 1000 robot registrations', () => {
+    const system = new TrustTierSystem(SECRET);
+    const start = performance.now();
+    for (let i = 0; i < 1000; i++) {
+      system.register(`robot-${i}`);
+    }
+    const elapsed = performance.now() - start;
+    expect(system.robotCount).toBe(1000);
+    expect(elapsed).toBeLessThan(1000); // under 1 second
+  });
+
+  it('handles 10,000 success recordings across 100 robots', () => {
+    const system = new TrustTierSystem(SECRET);
+    for (let i = 0; i < 100; i++) system.register(`r-${i}`);
+    const start = performance.now();
+    for (let round = 0; round < 100; round++) {
+      for (let i = 0; i < 100; i++) {
+        system.recordSuccess(`r-${i}`, 10);
+      }
+    }
+    const elapsed = performance.now() - start;
+    expect(elapsed).toBeLessThan(5000); // under 5 seconds for 10K ops
+    // All robots should have progressed past Untrusted
+    for (let i = 0; i < 100; i++) {
+      const profile = system.getProfile(`r-${i}`)!;
+      expect(profile.points).toBe(1000);
+      expect(profile.currentTier).toBeGreaterThan(TrustTier.UNTRUSTED);
+    }
+  });
+
+  it('history chain integrity holds under volume', () => {
+    const system = new TrustTierSystem(SECRET);
+    system.register('heavy-robot');
+    // Generate enough activity to trigger multiple promotions
+    for (let i = 0; i < 500; i++) system.recordSuccess('heavy-robot', 20);
+    const result = system.verifyHistory('heavy-robot');
+    expect(result.valid).toBe(true);
+    const profile = system.getProfile('heavy-robot')!;
+    expect(profile.history.length).toBeGreaterThan(0);
+    // Every single event in history must be signed
+    for (const event of profile.history) {
+      expect(event.signature).toHaveLength(64);
+    }
+  });
+
+  it('tier progression is monotonically correct under load', () => {
+    const system = new TrustTierSystem(SECRET);
+    system.register('climber');
+    let lastTier = TrustTier.UNTRUSTED;
+    for (let i = 0; i < 1000; i++) {
+      system.recordSuccess('climber', 10);
+      const profile = system.getProfile('climber')!;
+      // Tier should never decrease during pure success run
+      expect(profile.currentTier).toBeGreaterThanOrEqual(lastTier);
+      lastTier = profile.currentTier;
+    }
+    expect(lastTier).toBeGreaterThanOrEqual(TrustTier.ELITE);
+  });
+});
+
+describe('Load: Badge System', () => {
+  it('evaluates badges for 500 robots efficiently', () => {
+    const system = new BadgeSystem(SECRET);
+    const start = performance.now();
+    for (let i = 0; i < 500; i++) {
+      const metrics: RobotMetrics = {
+        successful_verifications: 100 + i,
+        spoofing_incidents: 0,
+        threats_detected: i % 20,
+        zones_mapped: 5 + (i % 30),
+        max_zone_mastery: 0.3 + (i % 70) / 100,
+        unique_routes: 10 + i,
+        consecutive_days: 7 + (i % 60),
+        night_operations: i % 80,
+        total_verifications: 110 + i,
+        success_rate: 90 + (i % 10),
+        max_ssim: 0.85 + (i % 15) / 100,
+        max_zones_per_trip: 1 + (i % 5),
+        fast_operations: i % 20,
+      };
+      system.evaluate(`robot-${i}`, metrics);
+    }
+    const elapsed = performance.now() - start;
+    expect(elapsed).toBeLessThan(3000);
+    // Spot check: first robot should have multiple badges
+    expect(system.getBadgeCount('robot-0')).toBeGreaterThan(3);
+    // All badges should be signed
+    const badges = system.getBadges('robot-0');
+    for (const badge of badges) {
+      expect(badge.signature).toHaveLength(64);
+    }
+  });
+});
+
+describe('Load: Streak System', () => {
+  it('simulates 365-day streak for 100 robots', () => {
+    const system = new StreakSystem(SECRET);
+    for (let i = 0; i < 100; i++) system.register(`r-${i}`);
+    const baseDate = new Date('2025-01-01T12:00:00Z').getTime();
+    const start = performance.now();
+    for (let day = 0; day < 365; day++) {
+      const ts = baseDate + day * 86400000;
+      for (let i = 0; i < 100; i++) {
+        system.recordActivity(`r-${i}`, 100, ts);
+      }
+    }
+    const elapsed = performance.now() - start;
+    expect(elapsed).toBeLessThan(5000); // 36,500 operations under 5s
+    // Every robot should have 365-day streak
+    for (let i = 0; i < 100; i++) {
+      const record = system.getRecord(`r-${i}`)!;
+      expect(record.currentStreak).toBe(365);
+      expect(record.longestStreak).toBe(365);
+    }
+  });
+
+  it('multiplier stays bounded even at extreme streaks', () => {
+    const system = new StreakSystem(SECRET);
+    expect(system.calculateMultiplier(0)).toBe(1.0);
+    expect(system.calculateMultiplier(10)).toBe(2.0); // capped
+    expect(system.calculateMultiplier(100)).toBe(2.0);
+    expect(system.calculateMultiplier(10000)).toBe(2.0);
+    expect(system.calculateMultiplier(Number.MAX_SAFE_INTEGER)).toBe(2.0);
+  });
+});
+
+describe('Load: Zone Mastery', () => {
+  it('handles 50 zones with 200 robots visiting', () => {
+    const system = new ZoneMasterySystem(SECRET, 2.0);
+    // Create 50 zones
+    const zoneIds: string[] = [];
+    for (let z = 0; z < 50; z++) {
+      const zone = system.defineZone(`Zone-${z}`, {
+        min: { x: z * 100, y: 0, z: 0 },
+        max: { x: z * 100 + 50, y: 50, z: 5 },
+      });
+      zoneIds.push(zone.id);
+    }
+    expect(system.totalZones).toBe(50);
+
+    // 200 robots each visit 5 random zones
+    const start = performance.now();
+    for (let r = 0; r < 200; r++) {
+      for (let v = 0; v < 5; v++) {
+        const z = (r + v) % 50;
+        system.recordVisit(
+          `robot-${r}`,
+          { x: z * 100 + 25, y: 25, z: 2 },
+          Math.random() > 0.1, // 90% success
+          50,
+        );
+      }
+    }
+    const elapsed = performance.now() - start;
+    expect(elapsed).toBeLessThan(3000); // 1000 visits under 3s
+
+    // Spot check mastery
+    const scores = system.getAllMastery('robot-0');
+    expect(scores.length).toBeGreaterThan(0);
+    for (const score of scores) {
+      expect(score.composite).toBeGreaterThanOrEqual(0);
+      expect(score.composite).toBeLessThanOrEqual(1);
+      expect(score.coverage).toBeGreaterThanOrEqual(0);
+      expect(score.successRate).toBeGreaterThanOrEqual(0);
+    }
+  });
+});
+
+describe('Load: Fleet Leaderboard', () => {
+  it('ranks 500 robots across 10 fleets', () => {
+    const lb = new FleetLeaderboard(SECRET);
+    for (let i = 0; i < 500; i++) {
+      lb.updateStats({
+        robotId: `robot-${i}`,
+        fleetId: `fleet-${i % 10}`,
+        trustTier: (i % 6) as TrustTier,
+        points: Math.floor(Math.random() * 10000),
+        totalVerifications: 50 + Math.floor(Math.random() * 500),
+        successfulVerifications: 45 + Math.floor(Math.random() * 450),
+        zonesExplored: Math.floor(Math.random() * 50),
+        badgeCount: Math.floor(Math.random() * 20),
+        streakDays: Math.floor(Math.random() * 100),
+        maxZoneMastery: Math.random(),
+        spoofingIncidents: Math.floor(Math.random() * 3),
+      });
+    }
+    expect(lb.totalRobots).toBe(500);
+
+    const start = performance.now();
+    // Generate leaderboards for all 10 fleets
+    for (let f = 0; f < 10; f++) {
+      const board = lb.getFleetLeaderboard(`fleet-${f}`, LeaderboardMetric.COMPOSITE, 50);
+      expect(board.length).toBeLessThanOrEqual(50);
+      // Verify descending order
+      for (let j = 1; j < board.length; j++) {
+        expect(board[j]!.score).toBeLessThanOrEqual(board[j - 1]!.score);
+      }
+      // Verify ranks are sequential
+      for (let j = 0; j < board.length; j++) {
+        expect(board[j]!.rank).toBe(j + 1);
+      }
+    }
+    // Global leaderboard
+    const global = lb.getGlobalLeaderboard(LeaderboardMetric.COMPOSITE, 100);
+    expect(global.length).toBe(100);
+    const elapsed = performance.now() - start;
+    expect(elapsed).toBeLessThan(2000);
+  });
+
+  it('fleet summary aggregates correctly under load', () => {
+    const lb = new FleetLeaderboard(SECRET);
+    let totalSuccess = 0;
+    let totalVerify = 0;
+    for (let i = 0; i < 100; i++) {
+      const sv = 80 + (i % 20);
+      const tv = 100;
+      totalSuccess += sv;
+      totalVerify += tv;
+      lb.updateStats({
+        robotId: `r-${i}`,
+        fleetId: 'mega-fleet',
+        trustTier: TrustTier.VERIFIED,
+        points: 500,
+        totalVerifications: tv,
+        successfulVerifications: sv,
+        zonesExplored: 5,
+        badgeCount: 3,
+        streakDays: 10,
+        maxZoneMastery: 0.5,
+        spoofingIncidents: 0,
+      });
+    }
+    const summary = lb.getFleetSummary('mega-fleet');
+    expect(summary.robotCount).toBe(100);
+    expect(summary.totalDeliveries).toBe(totalSuccess);
+    expect(summary.averageSuccessRate).toBeCloseTo(totalSuccess / totalVerify, 2);
+  });
+});
+
+// ============================================================
+// VERIFICATION STRESS
+// ============================================================
+
+describe('Load: Spatial Verification', () => {
+  it('100 rapid spatial proofs maintain integrity', () => {
+    const proofs = [];
+    for (let i = 0; i < 100; i++) {
+      const frame = makeTestFrame(32, 32, i, i + 1);
+      const render = makeRender(32, 32, i);
+      const proof = generateSpatialProof(
+        `robot-${i}`, makeTestPose(i, i), frame, render,
+        `merkle-${i}`, [], SECRET,
+      );
+      proofs.push(proof);
+    }
+    // Every proof should have valid signature
+    for (const proof of proofs) {
+      const result = verifySpatialProofIntegrity(proof, SECRET);
+      expect(result.valid).toBe(true);
+    }
+    // Every proof with wrong secret should fail
+    for (const proof of proofs) {
+      const result = verifySpatialProofIntegrity(proof, 'b'.repeat(32));
+      expect(result.valid).toBe(false);
+    }
+  });
+
+  it('SSIM computation handles large images', () => {
+    const size = 256;
+    const img = new Uint8Array(size * size);
+    for (let i = 0; i < img.length; i++) img[i] = (i * 7) % 256;
+    const start = performance.now();
+    const ssim = computeSSIM(img, img, size, size);
+    const elapsed = performance.now() - start;
+    expect(ssim).toBeCloseTo(1.0, 2);
+    expect(elapsed).toBeLessThan(1000); // 256x256 SSIM under 1s
+  });
+
+  it('settlement atomic verify-then-pay under rapid fire', () => {
+    const settlements = [];
+    for (let i = 0; i < 50; i++) {
+      const frame = makeTestFrame(32, 32, 42, i + 1);
+      const identicalRender: RenderedView = {
+        rgb: frame.rgb, depth: frame.depth!, width: 32, height: 32,
+        pose: makeTestPose(42, 42), renderTimeMs: 1,
+      };
+      const proof = generateSpatialProof(
+        'robot-1', makeTestPose(42, 42), frame, identicalRender,
+        'merkle-root', [], SECRET,
+      );
+      if (proof.passed) {
+        const settlement = createSettlement(proof, 10.00, 'USD', `merchant-${i}`, SECRET);
+        settlements.push(settlement);
+      }
+    }
+    expect(settlements.length).toBeGreaterThan(0);
+    for (const s of settlements) {
+      expect(s.status).toBe('verified');
+      expect(s.amount).toBe(10.00);
+    }
+  });
+});
+
+// ============================================================
+// ANTI-SPOOFING STRESS
+// ============================================================
+
+describe('Load: Anti-Spoofing', () => {
+  it('replay detector handles 1000 sequential frames', () => {
+    const detector = new ReplayDetector(30);
+    const now = Date.now();
+    let criticalCount = 0;
+    for (let i = 0; i < 1000; i++) {
+      // Embed frame index as raw bytes to guarantee unique content hashes
+      const rgb = new Uint8Array(32 * 32 * 3);
+      rgb[0] = (i >> 24) & 0xFF;
+      rgb[1] = (i >> 16) & 0xFF;
+      rgb[2] = (i >> 8) & 0xFF;
+      rgb[3] = i & 0xFF;
+      for (let j = 4; j < rgb.length; j++) rgb[j] = (j + i) & 0xFF;
+      const ts = now + i * 33;
+      const frame: CameraFrame = {
+        id: `frame-${i}`,
+        timestamp: ts,
+        rgb, width: 32, height: 32,
+        sequenceNumber: i + 1,
+        hmac: signFrame(rgb, ts, i + 1, SECRET),
+      };
+      const threats = detector.check(frame);
+      const critical = threats.filter(t => t.severity === 'critical');
+      criticalCount += critical.length;
+    }
+    // Across 1000 sequential frames, no critical replay threats
+    expect(criticalCount).toBe(0);
+  });
+
+  it('canary system scales to 100 canaries', () => {
+    const canaries = new CanarySystem(SECRET);
+    for (let i = 0; i < 100; i++) {
+      canaries.plant(`canary-${i}`, { x: i * 100, y: i * 100, z: 0 });
+    }
+    expect(canaries.count).toBe(100);
+
+    // Check activation at a canary position (within 0.5m tolerance)
+    const threats = canaries.checkForCanaryActivation([
+      { x: 0.3, y: 0.3, z: 0 }, // within 0.5m of canary-0 at (0,0,0)
+    ]);
+    expect(threats.length).toBe(1);
+
+    // Check at a position far from all canaries (canaries are at i*100, i*100)
+    // Use a position that doesn't match any canary: x=50.5 * 100 = midpoint
+    const safe = canaries.checkForCanaryActivation([
+      { x: 99999, y: 99999, z: 0 },
+    ]);
+    expect(safe).toHaveLength(0);
+  });
+});
+
+// ============================================================
+// SPATIAL MEMORY STRESS
+// ============================================================
+
+describe('Load: Place Cell Population', () => {
+  it('covers large region with place cells', () => {
+    const pop = new PlaceCellPopulation(2.0);
+    const count = pop.coverRegion(
+      { x: 0, y: 0, z: 0 },
+      { x: 100, y: 100, z: 0 },
+      3.0,
+    );
+    expect(count).toBeGreaterThan(100);
+
+    // Activations should work at any point
+    const start = performance.now();
+    for (let i = 0; i < 1000; i++) {
+      const activations = pop.getActivations({
+        x: Math.random() * 100,
+        y: Math.random() * 100,
+        z: 0,
+      });
+      expect(activations.size).toBeGreaterThan(0);
+    }
+    const elapsed = performance.now() - start;
+    expect(elapsed).toBeLessThan(5000); // 1000 queries under 5s
+  });
+
+  it('grid cell system handles multi-scale queries', () => {
+    const system = new GridCellSystem(0.5, Math.SQRT2, 6, 32);
+    expect(system.totalCells).toBe(192); // 6 * 32
+    const start = performance.now();
+    for (let i = 0; i < 500; i++) {
+      const activations = system.getActivations({
+        x: Math.random() * 50,
+        y: Math.random() * 50,
+        z: 0,
+      });
+      expect(activations.size).toBe(192);
+    }
+    const elapsed = performance.now() - start;
+    expect(elapsed).toBeLessThan(3000);
+  });
+});
+
+describe('Load: Short-Term Memory', () => {
+  it('handles rapid frame insertion at 30fps', () => {
+    const stm = new ShortTermMemory(900, 30000); // 30s buffer
+    const start = performance.now();
+    for (let i = 0; i < 900; i++) {
+      const frame = makeTestFrame(32, 32, i, i + 1);
+      stm.add(frame, []);
+    }
+    const elapsed = performance.now() - start;
+    expect(stm.count).toBe(900);
+    expect(elapsed).toBeLessThan(2000);
+    // Verify FIFO eviction
+    stm.add(makeTestFrame(32, 32, 901, 901), []);
+    expect(stm.count).toBe(900); // oldest evicted
+  });
+});