Simplify collection launch review

2026-10-07 14:55:24 -04:00
parent 2e1e5ea35f
commit 7fd59d32b4
9 changed files with 993 additions and 163 deletions
@@ -0,0 +1,129 @@
+import { describe, expect, it } from 'vitest';
+import type { CollectionPreview, LaunchAvailability } from '../../src/lib/deployment-plan.js';
+import { zombieMapBySlug, type ZombieGame } from '../../src/lib/map-aliases.js';
+import { collectionCapacitySummary, collectionKeyCoverage, collectionMapGroups } from '../../src/lib/ui/collection-summary.js';
+
+function entry(game: ZombieGame, mapSlug: string, count: number, existingServers: string[] = []): CollectionPreview['entries'][number] {
+    const map = zombieMapBySlug(game, mapSlug)!;
+    return { count, existing: existingServers.length, missing: Math.max(0, count - existingServers.length), existingServers,
+        coverage: existingServers.map(name => ({ name, health: 'stopped', href: `/servers/${name}` })),
+        recipe: { game, mapSlug, mapName: map.friendly, expectedMap: map.canonical, capturedAt: '', image: 'runtime:latest',
+            configFile: 'server.cfg', configSource: 'Current setup', files: [], fingerprint: '' } };
+}
+
+function preview(overrides: Partial<CollectionPreview> = {}): CollectionPreview {
+    return { id: 'preview', expiresAt: '2030-01-01T00:00:00Z', blueprintName: 'Collection', launchConcurrency: 1,
+        mode: 'fill', retainedServers: [], removals: [], entries: [], servers: [], blockers: [], ready: true, ...overrides };
+}
+
+function capacity(overrides: Partial<LaunchAvailability> = {}): LaunchAvailability {
+    return { requested: 5, estimatedAvailable: null, updatedAt: null, portsAvailable: null, cpuCoresAvailable: null,
+        memoryBytesAvailable: null, startupSlots: null, startupLimit: null, queued: null, ...overrides };
+}
+
+describe('collection key coverage', () => {
+    it('counts coverage separately by game without treating removals as available keys', () => {
+        const plan = preview({ mode: 'exact', entries: [entry('t5', 'theater', 2), entry('t6', 'town', 1)],
+            removals: [{ name: 't5_zombie_moon_1', reason: 'Outside collection' }], servers: [
+                { entryIndex: 0, name: 't5_zombie_theater_1', hasSavedKey: true, port: null },
+                { entryIndex: 0, name: 't5_zombie_theater_2', hasSavedKey: false, port: null },
+                { entryIndex: 1, name: 't6_zombie_town_1', hasSavedKey: true, port: null },
+            ] });
+        expect(collectionKeyCoverage(plan)).toEqual([
+            { game: 't5', label: 'Black Ops I', required: 2, available: 1, unassigned: 0 },
+            { game: 't6', label: 'Black Ops II', required: 1, available: 1, unassigned: 0 },
+        ]);
+    });
+
+    it('counts an unavailable lobby as required but never covered, and omits games without creations', () => {
+        expect(collectionKeyCoverage(preview({ entries: [entry('t5', 'theater', 1), entry('t6', 'town', 1)],
+            servers: [{ entryIndex: 1, name: null, hasSavedKey: true, port: null }] }))).toEqual([
+            { game: 't6', label: 'Black Ops II', required: 1, available: 0, unassigned: 1 },
+        ]);
+        expect(collectionKeyCoverage(preview({ mode: 'exact', removals: [{ name: 't5_zombie_theater_1', reason: 'Remove' }] }))).toEqual([]);
+    });
+
+    it('distinguishes known key shortages from creations waiting for a lobby', () => {
+        const [pool] = collectionKeyCoverage(preview({ entries: [entry('t5', 'theater', 3)], servers: [
+            { entryIndex: 0, name: 't5_zombie_theater_19', hasSavedKey: true, port: null },
+            { entryIndex: 0, name: 't5_zombie_theater_20', hasSavedKey: false, port: null },
+            { entryIndex: 0, name: null, hasSavedKey: false, port: null },
+        ] }));
+        expect(pool).toMatchObject({ required: 3, available: 1, unassigned: 1 });
+        expect(pool.required - pool.unassigned - pool.available).toBe(1);
+    });
+});
+
+describe('collection map summaries', () => {
+    it('preserves full existing counts in fill mode, including stopped inventory and excess lobbies', () => {
+        const plan = preview({ entries: [entry('t5', 'theater', 1, ['t5_zombie_theater_1', 't5_zombie_theater_2']), entry('t5', 'moon', 2)] });
+        expect(collectionMapGroups(plan)).toEqual([{ game: 't5', label: 'Black Ops I', rows: [
+            { key: 't5:theater', mapName: 'Kino Der Toten', target: 1, existing: 2, create: 0, remove: 0 },
+            { key: 't5:moon', mapName: 'Moon', target: 2, existing: 0, create: 2, remove: 0 },
+        ] }]);
+    });
+
+    it('counts ordinary excess once and adds already-pending removals missing from backend coverage', () => {
+        const plan = preview({ mode: 'exact', entries: [entry('t5', 'theater', 1, ['t5_zombie_theater_1', 't5_zombie_theater_2'])],
+            retainedServers: ['t5_zombie_theater_1'], removals: [
+                { name: 't5_zombie_theater_2', reason: 'Excess' },
+                { name: 't5_zombie_theater_3', reason: 'Already awaiting removal' },
+            ] });
+        expect(collectionMapGroups(plan)[0].rows).toEqual([
+            { key: 't5:theater', mapName: 'Kino Der Toten', target: 1, existing: 3, create: 0, remove: 2 },
+        ]);
+    });
+
+    it('shows outside maps with target zero across both games without combining T6 variants', () => {
+        const plan = preview({ mode: 'exact', entries: [entry('t6', 'town', 1, ['t6_zombie_town_1'])],
+            retainedServers: ['t6_zombie_town_1'], removals: [
+                { name: 't5_zombie_moon_1', reason: 'Outside collection' },
+                { name: 't6_zombie_farm_1', reason: 'Outside collection' },
+                { name: 't6_zombie_town_grief_1', reason: 'Outside collection' },
+            ] });
+        expect(collectionMapGroups(plan)).toEqual([
+            { game: 't5', label: 'Black Ops I', rows: [{ key: 't5:moon', mapName: 'Moon', target: 0, existing: 1, create: 0, remove: 1 }] },
+            { game: 't6', label: 'Black Ops II', rows: [
+                { key: 't6:town', mapName: 'Town Survival', target: 1, existing: 1, create: 0, remove: 0 },
+                { key: 't6:farm', mapName: 'Farm Survival', target: 0, existing: 1, create: 0, remove: 1 },
+                { key: 't6:towngrief', mapName: 'Town Grief', target: 0, existing: 1, create: 0, remove: 1 },
+            ] },
+        ]);
+    });
+
+    it('uses authoritative coverage before names and resolves friendly legacy aliases', () => {
+        const plan = preview({ mode: 'exact', entries: [entry('t6', 'town', 1, ['custom-town', 't6_zombie_town_1']), entry('t5', 'theater', 1, ['t5_zombie_theater_1'])],
+            removals: [{ name: 'custom-town', reason: 'Excess' }, { name: 'T5_ZOMBIE_KINO_DER_TOTEN_2', reason: 'Awaiting removal' }] });
+        expect(collectionMapGroups(plan).map(group => group.rows)).toEqual([
+            [{ key: 't5:theater', mapName: 'Kino Der Toten', target: 1, existing: 2, create: 0, remove: 1 }],
+            [{ key: 't6:town', mapName: 'Town Survival', target: 1, existing: 2, create: 0, remove: 1 }],
+        ]);
+    });
+
+    it('keeps unknown removals visible without guessing a shared engine-map variant', () => {
+        const plan = preview({ mode: 'exact', removals: [
+            { name: 't6_zombie_zm_transit_1', reason: 'Unknown variant' },
+            { name: 'custom-instance', reason: 'Outside collection' },
+        ] });
+        expect(collectionMapGroups(plan)).toEqual([
+            { game: 't6', label: 'Black Ops II', rows: [{ key: 't6:server:t6_zombie_zm_transit_1', mapName: 't6_zombie_zm_transit_1', target: 0, existing: 1, create: 0, remove: 1 }] },
+            { game: null, label: 'Other servers', rows: [{ key: 'other:server:custom-instance', mapName: 'custom-instance', target: 0, existing: 1, create: 0, remove: 1 }] },
+        ]);
+    });
+});
+
+describe('collection capacity summary', () => {
+    it('keeps unknown and insufficient capacity queueable', () => {
+        expect(collectionCapacitySummary()).toBe('Capacity estimate unavailable; launches can wait for capacity.');
+        expect(collectionCapacitySummary(capacity())).toBe('Capacity estimate unavailable; launches can wait for capacity.');
+        expect(collectionCapacitySummary(capacity({ estimatedAvailable: 0 }))).toBe('Estimated capacity for 0 of 5 servers; launches can wait for capacity.');
+        expect(collectionCapacitySummary(capacity({ estimatedAvailable: 2 }))).toBe('Estimated capacity for 2 of 5 servers; launches can wait for capacity.');
+        expect(collectionCapacitySummary(capacity({ requested: 1, estimatedAvailable: 0 }))).toBe('Estimated capacity for 0 of 1 server; launches can wait for capacity.');
+    });
+
+    it('uses requested counts when enough capacity exists and handles plans without creations', () => {
+        expect(collectionCapacitySummary(capacity({ estimatedAvailable: 20 }))).toBe('Estimated capacity for all 5 servers.');
+        expect(collectionCapacitySummary(capacity({ requested: 1, estimatedAvailable: 1 }))).toBe('Estimated capacity for 1 server.');
+        expect(collectionCapacitySummary(capacity({ requested: 0 }))).toBe('No new server capacity needed.');
+    });
+});