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

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

import { GameStatus } from "../src/lib/game.types";
import type { Game, CreateGameDto, UpdateGameDto } from "../src/lib/game.types";

describe("game Types", () => {
  describe("gameStatus enum", () => {
    it("should have the correct values", () => {
      expect(GameStatus.playing).toBe("PLAYING");
      expect(GameStatus.completed).toBe("COMPLETED");
      expect(GameStatus.backlog).toBe("BACKLOG");
    });

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

  describe("game interface", () => {
    it("should accept valid game object with minimal fields", () => {
      const game: Game = {
        createdAt: new Date("2024-01-15"),
        dateAdded: new Date("2024-01-15"),
        id:        "game123",
        links:     [],
        status:    GameStatus.playing,
        tags:      [],
        title:     "The Legend of Zelda: Breath of the Wild",
        updatedAt: new Date("2024-01-16"),
      };

      expect(game.platform).toBeUndefined();
      expect(game.dateCompleted).toBeUndefined();
      expect(game.rating).toBeUndefined();
      expect(game.notes).toBeUndefined();
      expect(game.coverImage).toBeUndefined();
    });

    it("should accept valid game object with all fields", () => {
      const fullGame: Game = {
        coverImage:    "https://example.com/hades-cover.jpg",
        createdAt:     new Date("2024-01-01"),
        dateAdded:     new Date("2024-01-01"),
        dateCompleted: new Date("2024-01-20"),
        id:            "game456",
        links:         [
          { title: "Steam", url: "https://store.steampowered.com/app/hades" },
          { title: "Official Site", url: "https://supergiantgames.com/hades" },
        ],
        notes:     "One of the best roguelikes ever made",
        platform:  "Nintendo Switch",
        rating:    5,
        status:    GameStatus.completed,
        tags:      [ "roguelike", "indie", "action", "mythology" ],
        title:     "Hades",
        updatedAt: new Date("2024-01-20"),
      };

      expect(fullGame.platform).toBe("Nintendo Switch");
      expect(fullGame.rating).toBe(5);
      expect(fullGame.tags).toHaveLength(4);
      expect(fullGame.links).toHaveLength(2);
    });

    it("should accept games on different platforms", () => {
      const pcGame: Game = {
        createdAt: new Date("2024-02-01"),
        dateAdded: new Date("2024-02-01"),
        id:        "game789",
        links:     [],
        platform:  "PC",
        status:    GameStatus.completed,
        tags:      [ "puzzle", "first-person" ],
        title:     "Portal 2",
        updatedAt: new Date("2024-02-01"),
      };

      const ps5Game: Game = {
        createdAt: new Date("2024-02-05"),
        dateAdded: new Date("2024-02-05"),
        id:        "game999",
        links:     [],
        platform:  "PlayStation 5",
        status:    GameStatus.backlog,
        tags:      [ "action", "superhero" ],
        title:     "Spider-Man: Miles Morales",
        updatedAt: new Date("2024-02-05"),
      };

      expect(pcGame.platform).toBe("PC");
      expect(ps5Game.platform).toBe("PlayStation 5");
    });
  });

  describe("createGameDto interface", () => {
    it("should accept DTO with required fields only", () => {
      const createDto: CreateGameDto = {
        status: GameStatus.backlog,
        title:  "Elden Ring",
      };

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

    it("should accept DTO with all fields", () => {
      const fullCreateDto: CreateGameDto = {
        coverImage: "https://example.com/hollow-knight.jpg",
        links:      [ { title: "Wiki", url: "https://hollowknight.wiki" } ],
        notes:      "Beautiful metroidvania with challenging gameplay",
        platform:   "Nintendo Switch",
        rating:     4,
        status:     GameStatus.playing,
        tags:       [ "metroidvania", "indie", "platformer" ],
        title:      "Hollow Knight",
      };

      expect(fullCreateDto.platform).toBe("Nintendo Switch");
      expect(fullCreateDto.rating).toBe(4);
      expect(fullCreateDto.tags).toEqual([ "metroidvania", "indie", "platformer" ]);
      expect(fullCreateDto.links).toHaveLength(1);
    });
  });

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

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

      expect(partialUpdate.status).toBe(GameStatus.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: UpdateGameDto = {
        coverImage:    "https://example.com/new-cover.jpg",
        dateCompleted: new Date("2024-02-15"),
        links:         [ { title: "New Link", url: "https://newlink.com" } ],
        notes:         "Updated after completion",
        platform:      "Xbox Series X",
        rating:        3,
        status:        GameStatus.completed,
        tags:          [ "updated", "tags" ],
        title:         "Updated Game Title",
      };

      expect(fullUpdate.title).toBe("Updated Game Title");
      expect(fullUpdate.platform).toBe("Xbox Series X");
      expect(fullUpdate.dateCompleted).toEqual(new Date("2024-02-15"));
      expect(fullUpdate.links).toHaveLength(1);
    });
  });
});