plex-playlist/frontend/src/validation.test.ts

import { describe, it, expect } from 'vitest';
import { PlaylistSchema, UserSchema, type Playlist, type User } from './validation';

describe('PlaylistSchema', () => {
  it('should validate a valid playlist', () => {
    const validPlaylist = {
      id: '123e4567-e89b-12d3-a456-426614174000',
      name: 'My Playlist',
      description: 'A great playlist',
      tracks: ['track1', 'track2'],
    };

    const result = PlaylistSchema.parse(validPlaylist);
    expect(result).toEqual(validPlaylist);
  });

  it('should validate playlist with minimal required fields', () => {
    const minimalPlaylist = {
      id: '123e4567-e89b-12d3-a456-426614174000',
      name: 'My Playlist',
    };

    const result = PlaylistSchema.parse(minimalPlaylist);
    expect(result).toEqual({
      id: '123e4567-e89b-12d3-a456-426614174000',
      name: 'My Playlist',
      description: undefined,
      tracks: [],
    });
  });

  it('should reject playlist with invalid UUID', () => {
    const invalidPlaylist = {
      id: 'invalid-uuid',
      name: 'My Playlist',
    };

    expect(() => PlaylistSchema.parse(invalidPlaylist)).toThrow();
  });

  it('should reject playlist with empty name', () => {
    const invalidPlaylist = {
      id: '123e4567-e89b-12d3-a456-426614174000',
      name: '',
    };

    expect(() => PlaylistSchema.parse(invalidPlaylist)).toThrow();
  });
});

describe('UserSchema', () => {
  it('should validate a valid user', () => {
    const validUser = {
      id: 123,
      username: 'testuser',
      email: 'test@example.com',
      preferences: {
        theme: 'dark' as const,
        notifications: false,
      },
    };

    const result = UserSchema.parse(validUser);
    expect(result).toEqual(validUser);
  });

  it('should validate user with default preferences', () => {
    const minimalUser = {
      id: 123,
      username: 'testuser',
      email: 'test@example.com',
    };

    const result = UserSchema.parse(minimalUser);
    expect(result).toEqual({
      id: 123,
      username: 'testuser',
      email: 'test@example.com',
      preferences: {
        theme: 'light',
        notifications: true,
      },
    });
  });

  it('should reject user with invalid email', () => {
    const invalidUser = {
      id: 123,
      username: 'testuser',
      email: 'invalid-email',
    };

    expect(() => UserSchema.parse(invalidUser)).toThrow();
  });

  it('should reject user with empty username', () => {
    const invalidUser = {
      id: 123,
      username: '',
      email: 'test@example.com',
    };

    expect(() => UserSchema.parse(invalidUser)).toThrow();
  });

  it('should reject user with invalid theme', () => {
    const invalidUser = {
      id: 123,
      username: 'testuser',
      email: 'test@example.com',
      preferences: {
        theme: 'invalid' as any,
        notifications: true,
      },
    };

    expect(() => UserSchema.parse(invalidUser)).toThrow();
  });
});

describe('Type exports', () => {
  it('should export correct TypeScript types', () => {
    // Type-only test - compilation is the validation
    const playlist: Playlist = {
      id: '123e4567-e89b-12d3-a456-426614174000',
      name: 'Test',
      description: 'Test description',
      tracks: ['track1'],
    };

    const user: User = {
      id: 1,
      username: 'test',
      email: 'test@example.com',
      preferences: {
        theme: 'light',
        notifications: true,
      },
    };

    expect(playlist.id).toBeDefined();
    expect(user.username).toBeDefined();
  });
});