@vylos/core 0.2.1 → 0.4.0

package/tests/engine/schemas.test.ts

@@ -1,250 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { baseGameStateSchema, extendGameStateSchema } from '../../src/engine/schemas/baseGameState.schema';
-import { engineStateSchema, engineSettingsSchema } from '../../src/engine/schemas/engineState.schema';
-import { checkpointSchema } from '../../src/engine/schemas/checkpoint.schema';
-import { locationSchema, locationLinkSchema } from '../../src/engine/schemas/location.schema';
-import { z } from 'zod';
-
-describe('baseGameStateSchema', () => {
-  const validState = {
-    locationId: 'bedroom',
-    gameTime: 8,
-    flags: { intro_done: true },
-    counters: { coffee_count: 2 },
-    player: { name: 'Alice' },
-  };
-
-  it('validates a correct base game state', () => {
-    const result = baseGameStateSchema.safeParse(validState);
-    expect(result.success).toBe(true);
-  });
-
-  it('rejects empty locationId', () => {
-    const result = baseGameStateSchema.safeParse({ ...validState, locationId: '' });
-    expect(result.success).toBe(false);
-  });
-
-  it('rejects negative gameTime', () => {
-    const result = baseGameStateSchema.safeParse({ ...validState, gameTime: -1 });
-    expect(result.success).toBe(false);
-  });
-
-  it('rejects empty player name', () => {
-    const result = baseGameStateSchema.safeParse({
-      ...validState,
-      player: { name: '' },
-    });
-    expect(result.success).toBe(false);
-  });
-
-  it('rejects missing fields', () => {
-    const result = baseGameStateSchema.safeParse({ locationId: 'test' });
-    expect(result.success).toBe(false);
-  });
-});
-
-describe('extendGameStateSchema', () => {
-  it('extends base schema with custom fields', () => {
-    const extended = extendGameStateSchema({
-      reputation: z.number(),
-      inventory: z.array(z.string()),
-    });
-
-    const result = extended.safeParse({
-      locationId: 'cafe',
-      gameTime: 14,
-      flags: {},
-      counters: {},
-      player: { name: 'Bob' },
-      reputation: 50,
-      inventory: ['key', 'map'],
-    });
-    expect(result.success).toBe(true);
-  });
-
-  it('rejects extended state missing custom fields', () => {
-    const extended = extendGameStateSchema({
-      reputation: z.number(),
-    });
-
-    const result = extended.safeParse({
-      locationId: 'cafe',
-      gameTime: 14,
-      flags: {},
-      counters: {},
-      player: { name: 'Bob' },
-      // missing reputation
-    });
-    expect(result.success).toBe(false);
-  });
-});
-
-describe('engineStateSchema', () => {
-  const validEngineState = {
-    phase: 'created',
-    background: null,
-    foreground: null,
-    dialogue: null,
-    choices: null,
-    currentLocationId: null,
-    availableActions: [],
-    availableLocations: [],
-    menuOpen: null,
-    skipMode: false,
-    autoMode: false,
-  };
-
-  it('validates initial engine state', () => {
-    const result = engineStateSchema.safeParse(validEngineState);
-    expect(result.success).toBe(true);
-  });
-
-  it('validates engine state with dialogue', () => {
-    const result = engineStateSchema.safeParse({
-      ...validEngineState,
-      phase: 'running',
-      dialogue: { text: 'Hello', speaker: 'Alice', isNarration: false },
-    });
-    expect(result.success).toBe(true);
-  });
-
-  it('validates engine state with choices', () => {
-    const result = engineStateSchema.safeParse({
-      ...validEngineState,
-      phase: 'running',
-      choices: {
-        prompt: null,
-        options: [
-          { text: 'Yes', value: 'yes' },
-          { text: 'No', value: 'no' },
-        ],
-      },
-    });
-    expect(result.success).toBe(true);
-  });
-
-  it('rejects invalid phase', () => {
-    const result = engineStateSchema.safeParse({
-      ...validEngineState,
-      phase: 'invalid',
-    });
-    expect(result.success).toBe(false);
-  });
-});
-
-describe('engineSettingsSchema', () => {
-  it('validates default settings', () => {
-    const result = engineSettingsSchema.safeParse({
-      textSpeed: 0.5,
-      autoSpeed: 0.5,
-      volume: { master: 1, music: 0.8, sfx: 0.8, voice: 1 },
-      language: 'en',
-      fullscreen: false,
-    });
-    expect(result.success).toBe(true);
-  });
-
-  it('rejects volume out of range', () => {
-    const result = engineSettingsSchema.safeParse({
-      textSpeed: 0.5,
-      autoSpeed: 0.5,
-      volume: { master: 1.5, music: 0.8, sfx: 0.8, voice: 1 },
-      language: 'en',
-      fullscreen: false,
-    });
-    expect(result.success).toBe(false);
-  });
-});
-
-describe('checkpointSchema', () => {
-  it('validates a say checkpoint', () => {
-    const result = checkpointSchema.safeParse({
-      step: 0,
-      gameState: {
-        locationId: 'cafe',
-        gameTime: 14,
-        flags: {},
-        counters: {},
-        player: { name: 'Alice' },
-      },
-      type: 'say',
-    });
-    expect(result.success).toBe(true);
-  });
-
-  it('validates a choice checkpoint with result', () => {
-    const result = checkpointSchema.safeParse({
-      step: 1,
-      gameState: {
-        locationId: 'cafe',
-        gameTime: 14,
-        flags: {},
-        counters: {},
-        player: { name: 'Alice' },
-      },
-      type: 'choice',
-      choiceResult: 'coffee',
-    });
-    expect(result.success).toBe(true);
-  });
-
-  it('rejects negative step number', () => {
-    const result = checkpointSchema.safeParse({
-      step: -1,
-      gameState: {
-        locationId: 'cafe',
-        gameTime: 14,
-        flags: {},
-        counters: {},
-        player: { name: 'Alice' },
-      },
-      type: 'say',
-    });
-    expect(result.success).toBe(false);
-  });
-});
-
-describe('locationSchema', () => {
-  it('validates a location with backgrounds', () => {
-    const result = locationSchema.safeParse({
-      id: 'cafe',
-      name: 'The Cafe',
-      backgrounds: [
-        { path: '/assets/cafe_day.jpg', timeRange: [6, 18] },
-        { path: '/assets/cafe_night.jpg', timeRange: [18, 6] },
-        { path: '/assets/cafe_default.jpg' },
-      ],
-    });
-    expect(result.success).toBe(true);
-  });
-
-  it('validates a location with i18n name', () => {
-    const result = locationSchema.safeParse({
-      id: 'cafe',
-      name: { en: 'The Cafe', fr: 'Le Café' },
-      backgrounds: [{ path: '/assets/cafe.jpg' }],
-    });
-    expect(result.success).toBe(true);
-  });
-
-  it('rejects empty location id', () => {
-    const result = locationSchema.safeParse({
-      id: '',
-      name: 'Test',
-      backgrounds: [],
-    });
-    expect(result.success).toBe(false);
-  });
-});
-
-describe('locationLinkSchema', () => {
-  it('validates a link', () => {
-    const result = locationLinkSchema.safeParse({ from: 'bedroom', to: 'hallway' });
-    expect(result.success).toBe(true);
-  });
-
-  it('rejects empty from', () => {
-    const result = locationLinkSchema.safeParse({ from: '', to: 'hallway' });
-    expect(result.success).toBe(false);
-  });
-});

package/tests/safety/event-validation.test.ts

@@ -1,102 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { baseGameStateSchema, extendGameStateSchema } from '../../src/engine/schemas/baseGameState.schema';
-import { StateValidationError } from '../../src/engine/errors/StateValidationError';
-import { z } from 'zod';
-
-/**
- * Tests for the Zod validation gate that runs after event execution.
- * The engine validates state after each event to prevent corruption.
- */
-describe('Event validation gate', () => {
-  function validateState(schema: z.ZodSchema, state: unknown): { valid: boolean; error?: StateValidationError } {
-    const result = schema.safeParse(state);
-    if (result.success) return { valid: true };
-    return { valid: false, error: new StateValidationError(result.error) };
-  }
-
-  it('accepts valid state after event execution', () => {
-    const state = {
-      locationId: 'cafe',
-      gameTime: 14,
-      flags: { intro_done: true },
-      counters: { coffee: 1 },
-      player: { name: 'Alice' },
-    };
-
-    const { valid } = validateState(baseGameStateSchema, state);
-    expect(valid).toBe(true);
-  });
-
-  it('rejects state with corrupted locationId', () => {
-    const state = {
-      locationId: '',
-      gameTime: 14,
-      flags: {},
-      counters: {},
-      player: { name: 'Alice' },
-    };
-
-    const { valid, error } = validateState(baseGameStateSchema, state);
-    expect(valid).toBe(false);
-    expect(error?.message).toContain('locationId');
-  });
-
-  it('rejects state with wrong type for flags', () => {
-    const state = {
-      locationId: 'cafe',
-      gameTime: 14,
-      flags: 'not-an-object',
-      counters: {},
-      player: { name: 'Alice' },
-    };
-
-    const { valid } = validateState(baseGameStateSchema, state);
-    expect(valid).toBe(false);
-  });
-
-  it('validates extended project schema', () => {
-    const projectSchema = extendGameStateSchema({
-      reputation: z.number().min(0).max(100),
-      inventory: z.array(z.string()),
-      npcRelations: z.record(z.string(), z.number().min(-100).max(100)),
-    });
-
-    // Simulates an event that correctly modified state
-    const goodState = {
-      locationId: 'cafe',
-      gameTime: 14,
-      flags: { intro_done: true },
-      counters: {},
-      player: { name: 'Alice' },
-      reputation: 50,
-      inventory: ['map', 'key'],
-      npcRelations: { barista: 10, landlord: -5 },
-    };
-    expect(validateState(projectSchema, goodState).valid).toBe(true);
-
-    // Simulates a buggy event that set reputation to 150
-    const badState = { ...goodState, reputation: 150 };
-    const result = validateState(projectSchema, badState);
-    expect(result.valid).toBe(false);
-    expect(result.error?.message).toContain('reputation');
-  });
-
-  it('rejects prototype pollution attempts', () => {
-    const state = {
-      locationId: 'cafe',
-      gameTime: 14,
-      flags: {},
-      counters: {},
-      player: { name: 'Alice' },
-      __proto__: { isAdmin: true },
-    };
-
-    // Zod parses with structuredClone behavior, __proto__ not a valid field
-    const result = baseGameStateSchema.safeParse(state);
-    // Should either succeed (ignoring __proto__) or fail — both are safe
-    // The important thing is that isAdmin is NOT in the result
-    if (result.success) {
-      expect((result.data as Record<string, unknown>)['isAdmin']).toBeUndefined();
-    }
-  });
-});

package/tests/safety/state-schema.test.ts

@@ -1,96 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { baseGameStateSchema, extendGameStateSchema } from '../../src/engine/schemas/baseGameState.schema';
-import { StateValidationError } from '../../src/engine/errors/StateValidationError';
-import { z } from 'zod';
-
-describe('State validation safety', () => {
-  it('catches type coercion attempts', () => {
-    const result = baseGameStateSchema.safeParse({
-      locationId: 123,  // should be string
-      gameTime: '8',    // should be number
-      flags: {},
-      counters: {},
-      player: { name: 'Alice' },
-    });
-    expect(result.success).toBe(false);
-  });
-
-  it('catches extra properties in strict mode', () => {
-    const strict = baseGameStateSchema.strict();
-    const result = strict.safeParse({
-      locationId: 'cafe',
-      gameTime: 8,
-      flags: {},
-      counters: {},
-      player: { name: 'Alice' },
-      hacked: true,
-    });
-    expect(result.success).toBe(false);
-  });
-
-  it('StateValidationError formats issues nicely', () => {
-    const result = baseGameStateSchema.safeParse({
-      locationId: '',
-      gameTime: -1,
-      flags: {},
-      counters: {},
-      player: { name: '' },
-    });
-
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      const error = new StateValidationError(result.error);
-      expect(error.message).toContain('State validation failed');
-      expect(error.name).toBe('StateValidationError');
-      expect(error.zodError).toBe(result.error);
-    }
-  });
-
-  it('validates extended schema rejects base-only data', () => {
-    const schema = extendGameStateSchema({
-      reputation: z.number().min(0).max(100),
-    });
-
-    const result = schema.safeParse({
-      locationId: 'cafe',
-      gameTime: 8,
-      flags: {},
-      counters: {},
-      player: { name: 'Alice' },
-      // missing reputation
-    });
-    expect(result.success).toBe(false);
-  });
-
-  it('validates extended schema accepts complete data', () => {
-    const schema = extendGameStateSchema({
-      reputation: z.number().min(0).max(100),
-    });
-
-    const result = schema.safeParse({
-      locationId: 'cafe',
-      gameTime: 8,
-      flags: {},
-      counters: {},
-      player: { name: 'Alice' },
-      reputation: 50,
-    });
-    expect(result.success).toBe(true);
-  });
-
-  it('validates extended schema rejects out-of-range custom field', () => {
-    const schema = extendGameStateSchema({
-      reputation: z.number().min(0).max(100),
-    });
-
-    const result = schema.safeParse({
-      locationId: 'cafe',
-      gameTime: 8,
-      flags: {},
-      counters: {},
-      player: { name: 'Alice' },
-      reputation: 150,
-    });
-    expect(result.success).toBe(false);
-  });
-});