clawdie-ai/setup/freebsd-timezones.test.ts

/**
 * setup/freebsd-timezones.test.ts — pure timezone helper tests.
 *
 * No mocks needed — all functions are pure.
 *
 * Run with: npx vitest run setup/freebsd-timezones.test.ts
 */
import { describe, it, expect } from 'vitest';

import {
  getTimezoneOptions,
  formatTimezoneLabel,
  prioritizeTimezones,
  findTimezoneOption,
  isValidTimezone,
} from './freebsd-timezones.js';

// ---------------------------------------------------------------------------
// getTimezoneOptions
// ---------------------------------------------------------------------------

describe('getTimezoneOptions', () => {
  it('returns a non-empty array', () => {
    expect(getTimezoneOptions().length).toBeGreaterThan(0);
  });

  it('includes Europe/Ljubljana', () => {
    const opts = getTimezoneOptions();
    expect(opts.some((o) => o.timezone === 'Europe/Ljubljana')).toBe(true);
  });

  it('includes UTC', () => {
    const opts = getTimezoneOptions();
    expect(opts.some((o) => o.timezone === 'UTC')).toBe(true);
  });

  it('every entry has timezone, label, and region fields', () => {
    for (const opt of getTimezoneOptions()) {
      expect(typeof opt.timezone).toBe('string');
      expect(typeof opt.label).toBe('string');
      expect(typeof opt.region).toBe('string');
    }
  });

  it('returns the same reference each call (stable array)', () => {
    // Both calls should return equal content (not necessarily same reference)
    expect(getTimezoneOptions()).toEqual(getTimezoneOptions());
  });
});

// ---------------------------------------------------------------------------
// formatTimezoneLabel
// ---------------------------------------------------------------------------

describe('formatTimezoneLabel', () => {
  it('returns the label field of the option', () => {
    const opt = { timezone: 'UTC', label: 'UTC (Coordinated Universal Time)', region: 'Etc' };
    expect(formatTimezoneLabel(opt)).toBe('UTC (Coordinated Universal Time)');
  });
});

// ---------------------------------------------------------------------------
// prioritizeTimezones
// ---------------------------------------------------------------------------

describe('prioritizeTimezones', () => {
  const opts = getTimezoneOptions();

  it('returns list unchanged when preferred is null', () => {
    const result = prioritizeTimezones(opts, null);
    expect(result).toEqual(opts);
  });

  it('returns list unchanged when preferred is undefined', () => {
    const result = prioritizeTimezones(opts);
    expect(result).toEqual(opts);
  });

  it('moves preferred timezone to first position', () => {
    const result = prioritizeTimezones(opts, 'UTC');
    expect(result[0].timezone).toBe('UTC');
  });

  it('keeps preferred timezone in list (no duplication)', () => {
    const result = prioritizeTimezones(opts, 'UTC');
    const count = result.filter((o) => o.timezone === 'UTC').length;
    expect(count).toBe(1);
  });

  it('preserves total length when preferred is found', () => {
    const result = prioritizeTimezones(opts, 'America/New_York');
    expect(result).toHaveLength(opts.length);
  });

  it('preserves total length when preferred is not found', () => {
    const result = prioritizeTimezones(opts, 'Unknown/Timezone');
    expect(result).toHaveLength(opts.length);
  });

  it('returns list unchanged when preferred is not in list', () => {
    const result = prioritizeTimezones(opts, 'Unknown/Timezone');
    expect(result).toEqual(opts);
  });

  it('does not mutate the original array', () => {
    const original = [...opts];
    prioritizeTimezones(opts, 'UTC');
    expect(opts).toEqual(original);
  });

  it('places Ljubljana first when preferred', () => {
    const result = prioritizeTimezones(opts, 'Europe/Ljubljana');
    expect(result[0].timezone).toBe('Europe/Ljubljana');
  });
});

// ---------------------------------------------------------------------------
// findTimezoneOption
// ---------------------------------------------------------------------------

describe('findTimezoneOption', () => {
  it('returns the option for a known timezone', () => {
    const result = findTimezoneOption('UTC');
    expect(result).not.toBeUndefined();
    expect(result?.timezone).toBe('UTC');
  });

  it('returns undefined for an unknown timezone', () => {
    expect(findTimezoneOption('Mars/Olympus')).toBeUndefined();
  });

  it('returns the correct label for America/New_York', () => {
    const result = findTimezoneOption('America/New_York');
    expect(result?.label).toContain('New York');
  });
});

// ---------------------------------------------------------------------------
// isValidTimezone
// ---------------------------------------------------------------------------

describe('isValidTimezone', () => {
  it('returns true for UTC', () => {
    expect(isValidTimezone('UTC')).toBe(true);
  });

  it('returns true for Europe/Ljubljana', () => {
    expect(isValidTimezone('Europe/Ljubljana')).toBe(true);
  });

  it('returns false for an unknown timezone string', () => {
    expect(isValidTimezone('Fake/Zone')).toBe(false);
  });

  it('returns false for empty string', () => {
    expect(isValidTimezone('')).toBe(false);
  });

  it('is case-sensitive (lowercase fails)', () => {
    expect(isValidTimezone('utc')).toBe(false);
  });
});