boardgame-core/tests/core/game.test.ts

import { describe, it, expect } from 'vitest';
import { createGameContext, createGameCommandRegistry, IGameContext } from '@/core/game';
import type { PromptEvent, Command } from '@/utils/command';

type MyState = {
    score: number;
    round: number;
};

describe('createGameContext', () => {
    it('should create a game context with state', () => {
        const registry = createGameCommandRegistry();
        const ctx = createGameContext(registry);

        expect(ctx._state).not.toBeNull();
        expect(ctx._state.value).toBeDefined();
    });

    it('should wire commands to the context', () => {
        const registry = createGameCommandRegistry();
        const ctx = createGameContext(registry);

        expect(ctx._commands).not.toBeNull();
        expect(ctx._commands.registry).toBe(registry);
    });

    it('should accept initial state as an object', () => {
        const registry = createGameCommandRegistry<MyState>();
        const ctx = createGameContext<MyState>(registry, {
            score: 0,
            round: 1,
        });

        expect(ctx._state.value.score).toBe(0);
        expect(ctx._state.value.round).toBe(1);
    });

    it('should accept initial state as a factory function', () => {
        const registry = createGameCommandRegistry<MyState>();
        const ctx = createGameContext<MyState>(registry, () => ({
            score: 10,
            round: 3,
        }));

        expect(ctx._state.value.score).toBe(10);
        expect(ctx._state.value.round).toBe(3);
    });

    it('should forward prompt events via listener', async () => {
        const registry = createGameCommandRegistry();
        const ctx = createGameContext(registry);

        registry.register('test <value>', async function (_ctx, value) {
            return this.prompt<string>('prompt <answer>', () => 'ok');
        });

        const promptPromise = new Promise<PromptEvent>(resolve => {
            ctx._commands.on('prompt', resolve);
        });
        const runPromise = ctx.run('test hello');

        const promptEvent = await promptPromise;
        expect(promptEvent).not.toBeNull();
        expect(promptEvent.schema.name).toBe('prompt');

        const error = promptEvent.tryCommit({ name: 'prompt', params: ['yes'], options: {}, flags: {} });
        expect(error).toBeNull();

        const result = await runPromise;
        expect(result.success).toBe(true);
    });
});

describe('createGameCommand', () => {
    it('should run a command with access to game context', async () => {
        const registry = createGameCommandRegistry<{ marker: string }>();
        
        registry.register('set-marker <id>', async function (ctx, id) {
            ctx.produce(state => {
                state.marker = id;
            });
            return id;
        });

        const ctx = createGameContext(registry, { marker: '' });

        const result = await ctx.run('set-marker board');
        if (!result.success) {
            console.error('Error:', result.error);
        }
        expect(result.success).toBe(true);
        if (result.success) {
            expect(result.result).toBe('board');
        }
        expect(ctx._state.value.marker).toBe('board');
    });

    it('should run a typed command with extended context', async () => {
        const registry = createGameCommandRegistry<MyState>();

        registry.register(
            'add-score <amount:number>',
            async function (ctx, amount) {
                ctx.produce(state => {
                    state.score += amount;
                });
                return ctx.value.score;
            }
        );

        const ctx = createGameContext<MyState>(registry, () => ({
            score: 0,
            round: 1,
        }));

        const result = await ctx.run('add-score 5');
        expect(result.success).toBe(true);
        if (result.success) {
            expect(result.result).toBe(5);
        }
        expect(ctx._state.value.score).toBe(5);
    });

    it('should return error for unknown command', async () => {
        const registry = createGameCommandRegistry();
        const ctx = createGameContext(registry);

        const result = await ctx.run('nonexistent');
        expect(result.success).toBe(false);
        if (!result.success) {
            expect(result.error).toContain('nonexistent');
        }
    });
});