electric-cherry/tests/unit/beta-setup.test.ts

import { describe, expect, it } from 'vitest';
import { defaultPlan, betaPlanIssues, requirement } from '../../src/lib/beta-plan.js';
import {
    readBetaDraft,
    compatibleBetaServers,
    betaCandidateServers,
    betaApplicableGames,
    betaInstanceCounts,
    betaScopeMatches
} from '../../src/lib/beta-draft.js';
import { betaWaitingCondition, betaEvidenceSummary } from '../../src/lib/beta-evidence.js';

describe('beta draft and plan recovery', () => {
    it('retains exact version IDs and incomplete plan fields in a recoverable draft', () => {
        const plan = defaultPlan();
        const raw = JSON.stringify({
            version: 1,
            savedAt: new Date().toISOString(),
            step: 2,
            picks: [{ scriptId: 12, versionId: 45 }],
            servers: ['town'],
            testPlan: { ...plan, timeoutHours: null }
        });
        const draft = readBetaDraft(raw)!;
        expect(draft.picks).toEqual([{ scriptId: 12, versionId: 45 }]);
        expect(draft.selectionMode).toBe('manual');
        expect(draft.servers).toEqual(['town']);
        expect(betaPlanIssues(draft.testPlan, 1)).toContainEqual(
            expect.objectContaining({ field: 'timeoutHours' })
        );
        expect(readBetaDraft('{bad')).toBeNull();
        expect(
            readBetaDraft(
                JSON.stringify({ version: 1, picks: [{ scriptId: '12', versionId: 45 }] })
            )
        ).toBeNull();
    });
    it('restores the shared count and incomplete input without substituting manual selections', () => {
        const raw = {
            version: 1,
            savedAt: '',
            step: 1,
            picks: [{ scriptId: 12, versionId: 45 }],
            servers: ['previous-manual-choice'],
            selectionMode: 'automatic',
            instanceCount: 2,
            testPlan: defaultPlan()
        };
        expect(readBetaDraft(JSON.stringify(raw))).toMatchObject({
            selectionMode: 'automatic',
            instanceCount: 2
        });
        for (const instanceCount of [null, 1.5, -1]) {
            expect(readBetaDraft(JSON.stringify({ ...raw, instanceCount }))?.instanceCount).toBe(
                instanceCount
            );
        }
        expect(readBetaDraft(JSON.stringify({ ...raw, instanceCount: '2' }))).toBeNull();
        expect(readBetaDraft(JSON.stringify({ ...raw, selectionMode: 'unknown' }))).toBeNull();
    });
    it('migrates per-game drafts without reducing coverage and revisits unequal counts', () => {
        const raw = {
            version: 1,
            savedAt: '',
            step: 3,
            picks: [{ scriptId: 12, versionId: 45 }],
            servers: [],
            selectionMode: 'automatic',
            instancesPerGame: { t5: 2, t6: 3 },
            testPlan: defaultPlan()
        };
        expect(readBetaDraft(JSON.stringify(raw))).toMatchObject({ instanceCount: 3, step: 1 });
        expect(
            readBetaDraft(JSON.stringify({ ...raw, instancesPerGame: { t5: 2, t6: 2 } }))
        ).toMatchObject({ instanceCount: 2, step: 3 });
        expect(
            readBetaDraft(JSON.stringify({ ...raw, instancesPerGame: { t5: 2, t6: null } }))
                ?.instanceCount
        ).toBeNull();
        expect(readBetaDraft(JSON.stringify({ ...raw, instancesPerGame: {} }))?.instanceCount).toBe(
            1
        );
        expect(readBetaDraft(JSON.stringify({ ...raw, selectionMode: 'manual' }))?.step).toBe(3);
        expect(readBetaDraft(JSON.stringify({ ...raw, instancesPerGame: { t5: '2' } }))).toBeNull();
    });
    it('defaults a legacy draft with no server choices to automatic selection', () => {
        expect(
            readBetaDraft(
                JSON.stringify({
                    version: 1,
                    picks: [{ scriptId: 12, versionId: 45 }],
                    servers: [],
                    testPlan: defaultPlan()
                })
            )?.selectionMode
        ).toBe('automatic');
    });
    it('keeps compatible explicit selections without selecting newly eligible servers', () => {
        const result = compatibleBetaServers(['town1', 'town2'], ['town2', 'town3']);
        expect([...result.kept]).toEqual(['town2']);
        expect(result.removed).toEqual(['town1']);
    });
    it('identifies the precise requirement and rejects an impossible quorum before review', () => {
        const plan = {
            ...defaultPlan(),
            scope: 'quorum' as const,
            quorum: 3,
            requirements: [{ ...requirement('matches', 'matches'), target: 1.5, minPlayers: 0 }]
        };
        expect(betaPlanIssues(plan, 2).map((issue) => issue.field)).toEqual([
            'quorum',
            'matches-target',
            'matches-minPlayers'
        ]);
        expect(
            betaPlanIssues(plan, 2).find((issue) => issue.field === 'matches-target')?.requirementId
        ).toBe('matches');
    });
});
describe('multi-game beta setup', () => {
    const servers = [
        { name: 'kino', game: 't5', map: 'zombie_theater' },
        { name: 'town', game: 't6', map: 'zm_transit' },
        { name: 'origins', game: 't6', map: 'zm_tomb' }
    ];
    it('offers the union of different file scopes while keeping file-to-server matches separate', () => {
        const files = [
            { scope_type: 'game' as const, scope_value: 't5' },
            { scope_type: 'map' as const, scope_value: 'zm_transit' }
        ];
        expect(betaCandidateServers(files, servers).map((server) => server.name)).toEqual([
            'kino',
            'town'
        ]);
        expect(betaApplicableGames(files, servers)).toEqual(['t5', 't6']);
        expect(betaScopeMatches(files[0], servers[1])).toBe(false);
        expect(betaScopeMatches(files[1], servers[0])).toBe(false);
    });
    it('includes every server for an unscoped file and requires a selected file first', () => {
        expect(betaCandidateServers([{ scope_type: null, scope_value: null }], servers)).toEqual(
            servers
        );
        expect(betaCandidateServers([], servers)).toEqual([]);
        expect(betaApplicableGames([], servers)).toEqual([]);
    });
    it('uses the shared count for every applicable game, including games without fleet matches', () => {
        const files = [
            { scope_type: 'game' as const, scope_value: 't5' },
            { scope_type: 'game' as const, scope_value: 't6' }
        ];
        expect(betaApplicableGames(files, [])).toEqual(['t5', 't6']);
        expect(betaInstanceCounts(betaApplicableGames(files, []), 2)).toEqual({ t5: 2, t6: 2 });
        expect(betaInstanceCounts(betaApplicableGames([files[1]], servers), 3)).toEqual({ t6: 3 });
        for (const count of [null, 0, -1, 1.5, 1001])
            expect(betaInstanceCounts(['t5', 't6'], count)).toEqual({});
        expect(betaInstanceCounts([], 2)).toEqual({});
    });
});
describe('beta evidence explanations', () => {
    const observation = {
        lastGameplayAt: new Date().toISOString(),
        lastEvent: 'round_change',
        players: 2,
        round: 12,
        matchStarted: true,
        gameEnded: false,
        healthy: true,
        healthCheckedAt: new Date().toISOString()
    };
    it('distinguishes missing reports, insufficient population, and report-driven time', () => {
        const r = { ...requirement('populated-minutes', 'play'), minPlayers: 3 };
        expect(betaWaitingCondition(r)).toContain('No gameplay report');
        expect(betaWaitingCondition(r, observation)).toContain('latest report has 2 players');
        expect(betaWaitingCondition(r, { ...observation, players: 3 })).toContain(
            'next report arrives'
        );
    });
    it('summarizes telemetry while keeping arbitrary or legacy payloads readable', () => {
        const event = {
            id: 1,
            server: 'town',
            server_deleted_at: null,
            received_at: '',
            kind: 'game_end',
            payload: JSON.stringify({ round: 25, players: [{ name: 'A' }], map: 'zm_transit' })
        };
        expect(betaEvidenceSummary(event)).toBe(
            'Game ended at round 25 with 1 players on zm_transit.'
        );
        expect(betaEvidenceSummary({ ...event, kind: 'old-event', payload: 'invalid' })).toBe(
            'old event'
        );
    });
});