library/shared-types/test/music.types.spec.ts

/**
 * @copyright NHCarrigan
 * @license Naomi's Public License
 * @author Naomi Carrigan
 */

import { MusicStatus, MusicType } from "../src/lib/music.types";
import type { Music, CreateMusicDto, UpdateMusicDto } from "../src/lib/music.types";

describe("music Types", () => {
  describe("musicType enum", () => {
    it("should have the correct values", () => {
      expect(MusicType.album).toBe("ALBUM");
      expect(MusicType.single).toBe("SINGLE");
      expect(MusicType.ep).toBe("EP");
    });

    it("should have all expected enum values", () => {
      const values = Object.values(MusicType);
      expect(values).toHaveLength(3);
      expect(values).toContain("ALBUM");
      expect(values).toContain("SINGLE");
      expect(values).toContain("EP");
    });
  });

  describe("musicStatus enum", () => {
    it("should have the correct values", () => {
      expect(MusicStatus.listening).toBe("LISTENING");
      expect(MusicStatus.completed).toBe("COMPLETED");
      expect(MusicStatus.wantToListen).toBe("WANT_TO_LISTEN");
    });

    it("should have all expected enum values", () => {
      const values = Object.values(MusicStatus);
      expect(values).toHaveLength(4);
      expect(values).toContain("LISTENING");
      expect(values).toContain("COMPLETED");
      expect(values).toContain("WANT_TO_LISTEN");
      expect(values).toContain("RETIRED");
    });
  });

  describe("music interface", () => {
    it("should accept valid music object with minimal fields", () => {
      const music: Music = {
        artist:    "Pink Floyd",
        createdAt: new Date("2024-01-15"),
        dateAdded: new Date("2024-01-15"),
        id:        "music123",
        links:     [],
        status:    MusicStatus.listening,
        tags:      [],
        title:     "Dark Side of the Moon",
        type:      MusicType.album,
        updatedAt: new Date("2024-01-16"),
      };

      expect(music.dateCompleted).toBeUndefined();
      expect(music.rating).toBeUndefined();
      expect(music.notes).toBeUndefined();
      expect(music.coverArt).toBeUndefined();
    });

    it("should accept valid music object with all fields", () => {
      const fullMusic: Music = {
        artist:        "Pink Floyd",
        coverArt:      "https://example.com/the-wall-cover.jpg",
        createdAt:     new Date("2024-01-01"),
        dateAdded:     new Date("2024-01-01"),
        dateCompleted: new Date("2024-01-20"),
        id:            "music456",
        links:         [
          { title: "Spotify", url: "https://spotify.com/album/the-wall" },
          { title: "Apple Music", url: "https://music.apple.com/album/the-wall" },
        ],
        notes:     "A rock opera masterpiece",
        rating:    5,
        status:    MusicStatus.completed,
        tags:      [ "progressive rock", "concept album", "classic" ],
        title:     "The Wall",
        type:      MusicType.album,
        updatedAt: new Date("2024-01-20"),
      };

      expect(fullMusic.artist).toBe("Pink Floyd");
      expect(fullMusic.rating).toBe(5);
      expect(fullMusic.tags).toHaveLength(3);
      expect(fullMusic.links).toHaveLength(2);
    });

    it("should accept different music types", () => {
      const single: Music = {
        artist:    "The Weeknd",
        createdAt: new Date("2024-02-01"),
        dateAdded: new Date("2024-02-01"),
        id:        "music789",
        links:     [],
        status:    MusicStatus.completed,
        tags:      [ "pop", "synthwave" ],
        title:     "Blinding Lights",
        type:      MusicType.single,
        updatedAt: new Date("2024-02-01"),
      };

      const ep: Music = {
        artist:    "The Weeknd",
        createdAt: new Date("2024-02-05"),
        dateAdded: new Date("2024-02-05"),
        id:        "music999",
        links:     [],
        status:    MusicStatus.wantToListen,
        tags:      [ "r&b", "dark" ],
        title:     "My Dear Melancholy,",
        type:      MusicType.ep,
        updatedAt: new Date("2024-02-05"),
      };

      expect(single.type).toBe(MusicType.single);
      expect(ep.type).toBe(MusicType.ep);
    });
  });

  describe("createMusicDto interface", () => {
    it("should accept DTO with required fields only", () => {
      const createDto: CreateMusicDto = {
        artist: "Fleetwood Mac",
        status: MusicStatus.wantToListen,
        title:  "Rumours",
        type:   MusicType.album,
      };

      expect(createDto.rating).toBeUndefined();
      expect(createDto.notes).toBeUndefined();
      expect(createDto.coverArt).toBeUndefined();
      expect(createDto.tags).toBeUndefined();
      expect(createDto.links).toBeUndefined();
    });

    it("should accept DTO with all fields", () => {
      const fullCreateDto: CreateMusicDto = {
        artist:   "The Weeknd",
        coverArt: "https://example.com/after-hours.jpg",
        links:    [ { title: "YouTube", url: "https://youtube.com/album/after-hours" } ],
        notes:    "Dark synthwave vibes",
        rating:   4,
        status:   MusicStatus.listening,
        tags:     [ "synthwave", "pop", "r&b" ],
        title:    "After Hours",
        type:     MusicType.album,
      };

      expect(fullCreateDto.artist).toBe("The Weeknd");
      expect(fullCreateDto.type).toBe(MusicType.album);
      expect(fullCreateDto.rating).toBe(4);
      expect(fullCreateDto.tags).toEqual([ "synthwave", "pop", "r&b" ]);
      expect(fullCreateDto.links).toHaveLength(1);
    });
  });

  describe("updateMusicDto type", () => {
    it("should accept empty update DTO", () => {
      const emptyUpdate: UpdateMusicDto = {};
      expect(emptyUpdate).toEqual({});
    });

    it("should accept partial updates including dateCompleted", () => {
      const partialUpdate: UpdateMusicDto = {
        dateCompleted: new Date("2024-02-10"),
        rating:        5,
        status:        MusicStatus.completed,
      };

      expect(partialUpdate.status).toBe(MusicStatus.completed);
      expect(partialUpdate.dateCompleted).toEqual(new Date("2024-02-10"));
      expect(partialUpdate.rating).toBe(5);
      expect(partialUpdate.title).toBeUndefined();
    });

    it("should accept full update", () => {
      const fullUpdate: UpdateMusicDto = {
        artist:        "Different Artist",
        coverArt:      "https://example.com/new-cover.jpg",
        dateCompleted: new Date("2024-02-15"),
        links:         [ { title: "New Link", url: "https://newlink.com" } ],
        notes:         "Updated after listening",
        rating:        3,
        status:        MusicStatus.completed,
        tags:          [ "updated", "tags" ],
        title:         "Updated Album Title",
        type:          MusicType.ep,
      };

      expect(fullUpdate.title).toBe("Updated Album Title");
      expect(fullUpdate.artist).toBe("Different Artist");
      expect(fullUpdate.type).toBe(MusicType.ep);
      expect(fullUpdate.dateCompleted).toEqual(new Date("2024-02-15"));
      expect(fullUpdate.links).toHaveLength(1);
    });
  });
});