boardgame-core/tests/core/part-factory.test.ts

import { describe, it, expect } from 'vitest';
import { createParts, createPartsFromTable } from '@/core/part-factory';

describe('createParts', () => {
  it('should create multiple parts with auto-generated IDs', () => {
    const parts = createParts(
      { regionId: 'deck', position: [] },
      (i) => `card-${i + 1}`,
      3
    );
    expect(Object.keys(parts).length).toBe(3);
    expect(parts['card-1']).toBeDefined();
    expect(parts['card-2']).toBeDefined();
    expect(parts['card-3']).toBeDefined();
  });

  it('should create parts with identical properties', () => {
    const parts = createParts(
      { regionId: 'deck', position: [], type: 'token' as string },
      (i) => `token-${i + 1}`,
      2
    );
    expect(parts['token-1'].regionId).toBe('deck');
    expect(parts['token-2'].regionId).toBe('deck');
    expect(parts['token-1'].type).toBe('token');
    expect(parts['token-2'].type).toBe('token');
  });

  it('should create one part when count is not provided', () => {
    const parts = createParts({}, (i) => `item-${i}`);
    expect(Object.keys(parts).length).toBe(1);
    expect(parts['item-0']).toBeDefined();
  });
});

describe('createPartsFromTable', () => {
  it('should create parts from table entries', () => {
    const items = [
      { type: 'kitten', count: 13 },
      { type: 'cat', count: 6 },
    ];
    const parts = createPartsFromTable(
      items,
      (item, index) => `${item.type}-${index + 1}`,
      (item) => item.count
    );
    expect(Object.keys(parts).length).toBe(19);
  });

  it('should create one part per item when count is not specified', () => {
    const items = [{ name: 'A' }, { name: 'B' }];
    const parts = createPartsFromTable(
      items,
      (item, index) => `${item.name}-${index}`
    );
    expect(Object.keys(parts).length).toBe(2);
    // index is 0 for each item since count defaults to 1
    expect(parts['A-0']).toBeDefined();
    expect(parts['B-0']).toBeDefined();
  });

  it('should use fixed count when provided as number', () => {
    const items = [{ name: 'A' }, { name: 'B' }];
    const parts = createPartsFromTable(
      items,
      (item, index) => `${item.name}-${index}`,
      2
    );
    expect(Object.keys(parts).length).toBe(4);
  });
});