test: add 63 new tests across utilities, composables, and stores

Add 9 new spec files and extend useSound.spec.ts to improve test
coverage from 120 to 183 tests. Covers pure utility functions
(cleanMapName, separateByCapitalLetters, uuid), composables with
state logic (useRightSidebar, useInvites), auth/login utilities
(loginLinks, setupOptions), and Pinia stores (AuthStore role
hierarchy, SearchStore player search).

Author: Flegma

composables/useInvites.spec.ts

@@ -0,0 +1,87 @@
+const matchmakingMock = {
+  matchInvites: [] as any[],
+  lobbyInvites: [] as any[],
+  friends: [] as any[],
+};
+
+const authMock = {
+  me: { steam_id: "my-steam-id" } as any,
+};
+
+vi.mock("~/stores/MatchmakingStore", () => ({
+  useMatchmakingStore: () => matchmakingMock,
+}));
+
+// useMatchmakingStore is auto-imported in Nuxt, provide global too
+(globalThis as any).useMatchmakingStore = () => matchmakingMock;
+(globalThis as any).useAuthStore = () => authMock;
+
+import { useInvites } from "./useInvites";
+
+describe("useInvites", () => {
+  beforeEach(() => {
+    matchmakingMock.matchInvites = [];
+    matchmakingMock.lobbyInvites = [];
+    matchmakingMock.friends = [];
+    authMock.me = { steam_id: "my-steam-id" };
+  });
+
+  it("returns pendingFriends sorted by name", () => {
+    matchmakingMock.friends = [
+      { name: "Charlie", status: "Pending", invited_by_steam_id: "other" },
+      { name: "Alice", status: "Pending", invited_by_steam_id: "other" },
+      { name: "Bob", status: "Pending", invited_by_steam_id: "other" },
+    ];
+
+    const { pendingFriends } = useInvites();
+    expect(pendingFriends.value.map((f: any) => f.name)).toEqual(["Alice", "Bob", "Charlie"]);
+  });
+
+  it("filters pendingFriends: status Pending AND not invited by current user", () => {
+    matchmakingMock.friends = [
+      { name: "Pending-Other", status: "Pending", invited_by_steam_id: "other-id" },
+      { name: "Pending-Me", status: "Pending", invited_by_steam_id: "my-steam-id" },
+      { name: "Accepted", status: "Accepted", invited_by_steam_id: "other-id" },
+    ];
+
+    const { pendingFriends } = useInvites();
+    expect(pendingFriends.value).toHaveLength(1);
+    expect(pendingFriends.value[0].name).toBe("Pending-Other");
+  });
+
+  it("hasInvites true when matchInvites non-empty", () => {
+    matchmakingMock.matchInvites = [{ id: "1" }];
+    const { hasInvites } = useInvites();
+    expect(hasInvites.value).toBe(true);
+  });
+
+  it("hasInvites true when lobbyInvites non-empty", () => {
+    matchmakingMock.lobbyInvites = [{ id: "1" }];
+    const { hasInvites } = useInvites();
+    expect(hasInvites.value).toBe(true);
+  });
+
+  it("hasInvites true when pendingFriends non-empty", () => {
+    matchmakingMock.friends = [
+      { name: "Pending", status: "Pending", invited_by_steam_id: "other-id" },
+    ];
+    const { hasInvites } = useInvites();
+    expect(hasInvites.value).toBe(true);
+  });
+
+  it("hasInvites false when all empty", () => {
+    const { hasInvites } = useInvites();
+    expect(hasInvites.value).toBe(false);
+  });
+
+  it("totalCount sums all three arrays", () => {
+    matchmakingMock.matchInvites = [{ id: "1" }, { id: "2" }];
+    matchmakingMock.lobbyInvites = [{ id: "3" }];
+    matchmakingMock.friends = [
+      { name: "Pending", status: "Pending", invited_by_steam_id: "other-id" },
+    ];
+
+    const { totalCount } = useInvites();
+    expect(totalCount.value).toBe(4);
+  });
+});

composables/useRightSidebar.spec.ts

@@ -0,0 +1,70 @@
+import { useRightSidebar } from "./useRightSidebar";
+
+describe("useRightSidebar", () => {
+  beforeEach(() => {
+    const { setRightSidebarOpen, isPinned, togglePin } = useRightSidebar();
+    setRightSidebarOpen(false);
+    // Reset pin state if pinned
+    if (isPinned.value) {
+      togglePin();
+    }
+    localStorage.removeItem("right-hub-pinned");
+  });
+
+  it("setRightSidebarOpen(true) opens sidebar", () => {
+    const { setRightSidebarOpen, rightSidebarOpen } = useRightSidebar();
+    setRightSidebarOpen(true);
+    expect(rightSidebarOpen.value).toBe(true);
+  });
+
+  it("toggleRightSidebar toggles open/closed", () => {
+    const { toggleRightSidebar, rightSidebarOpen, setRightSidebarOpen } = useRightSidebar();
+    setRightSidebarOpen(false);
+    toggleRightSidebar();
+    expect(rightSidebarOpen.value).toBe(true);
+    toggleRightSidebar();
+    expect(rightSidebarOpen.value).toBe(false);
+  });
+
+  it("startHoverPeek opens sidebar when closed", () => {
+    const { startHoverPeek, rightSidebarOpen } = useRightSidebar();
+    expect(rightSidebarOpen.value).toBe(false);
+    startHoverPeek();
+    expect(rightSidebarOpen.value).toBe(true);
+  });
+
+  it("startHoverPeek does nothing when already open", () => {
+    const { startHoverPeek, setRightSidebarOpen, rightSidebarOpen } = useRightSidebar();
+    setRightSidebarOpen(true);
+    startHoverPeek();
+    expect(rightSidebarOpen.value).toBe(true);
+  });
+
+  it("endHoverPeek closes sidebar when not pinned", () => {
+    const { startHoverPeek, endHoverPeek, rightSidebarOpen } = useRightSidebar();
+    startHoverPeek();
+    endHoverPeek();
+    expect(rightSidebarOpen.value).toBe(false);
+  });
+
+  it("endHoverPeek keeps sidebar open when pinned", () => {
+    const { startHoverPeek, endHoverPeek, togglePin, rightSidebarOpen } = useRightSidebar();
+    startHoverPeek();
+    togglePin();
+    endHoverPeek();
+    expect(rightSidebarOpen.value).toBe(true);
+  });
+
+  it("togglePin persists pin state to localStorage", () => {
+    const { togglePin } = useRightSidebar();
+    togglePin();
+    expect(localStorage.getItem("right-hub-pinned")).toBe("1");
+  });
+
+  it("togglePin removes localStorage key when unpinning", () => {
+    const { togglePin } = useRightSidebar();
+    togglePin(); // pin
+    togglePin(); // unpin
+    expect(localStorage.getItem("right-hub-pinned")).toBeNull();
+  });
+});

composables/useSound.spec.ts

@@ -33,4 +33,36 @@ describe("useSound", () => {
     updateSettings(true, -1.0);
     expect(volume.value).toBe(0.0);
   });
+
+  it("defaults to enabled with volume 0.7", () => {
+    const { isEnabled, volume } = useSound();
+    expect(isEnabled.value).toBe(true);
+    expect(volume.value).toBe(0.7);
+  });
+
+  it("volume and isEnabled are readonly refs", () => {
+    const { isEnabled, volume } = useSound();
+    // readonly refs still have .value but writes are no-ops in production
+    expect(typeof isEnabled.value).toBe("boolean");
+    expect(typeof volume.value).toBe("number");
+  });
+
+  it("playMatchFoundSound returns early when isEnabled is false", () => {
+    const { updateSettings, playMatchFoundSound } = useSound();
+    updateSettings(false);
+    // Guard returns early before AudioContext — should not throw
+    expect(() => playMatchFoundSound()).not.toThrow();
+  });
+
+  it("playTickSound returns early when isEnabled is false", () => {
+    const { updateSettings, playTickSound } = useSound();
+    updateSettings(false);
+    expect(() => playTickSound()).not.toThrow();
+  });
+
+  it("playCountdownSound returns early when isEnabled is false", () => {
+    const { updateSettings, playCountdownSound } = useSound();
+    updateSettings(false);
+    expect(() => playCountdownSound()).not.toThrow();
+  });
 });

stores/AuthStore.spec.ts

@@ -0,0 +1,123 @@
+import { createPinia, setActivePinia } from "pinia";
+
+vi.mock("~/stores/SearchStore", () => ({
+  useSearchStore: vi.fn(),
+}));
+vi.mock("~/stores/MatchmakingStore", () => ({
+  useMatchmakingStore: vi.fn(),
+}));
+vi.mock("~/stores/NotificationStore", () => ({
+  useNotificationStore: vi.fn(),
+}));
+vi.mock("~/stores/ApplicationSettingsStore", () => ({
+  useApplicationSettingsStore: vi.fn(),
+}));
+vi.mock("~/graphql/getGraphqlClient", () => ({
+  default: vi.fn(),
+}));
+vi.mock("~/web-sockets/Socket", () => ({
+  default: { connect: vi.fn() },
+}));
+vi.mock("~/graphql/graphqlGen", () => ({
+  generateQuery: vi.fn(),
+  generateSubscription: vi.fn(),
+}));
+vi.mock("~/graphql/meGraphql", () => ({
+  meFields: {},
+}));
+
+// Provide Nuxt auto-imports as globals
+(globalThis as any).useSearchStore = vi.fn();
+(globalThis as any).useMatchmakingStore = vi.fn();
+(globalThis as any).useNotificationStore = vi.fn();
+(globalThis as any).useApplicationSettingsStore = vi.fn();
+(globalThis as any).useMatchLobbyStore = vi.fn(() => ({
+  subscribeToMyMatches: vi.fn(),
+  subscribeToLiveMatches: vi.fn(),
+  subscribeToLiveTournaments: vi.fn(),
+  subscribeToOpenRegistrationTournaments: vi.fn(),
+  subscribeToOpenMatches: vi.fn(),
+  subscribeToChatTournaments: vi.fn(),
+  subscribeToManagingMatches: vi.fn(),
+  subscribeToManagingTournaments: vi.fn(),
+}));
+(globalThis as any).useNuxtApp = vi.fn(() => ({ $wsClient: { terminate: vi.fn(), on: vi.fn() } }));
+
+import { useAuthStore } from "./AuthStore";
+import { e_player_roles_enum } from "~/generated/zeus";
+
+describe("AuthStore", () => {
+  beforeEach(() => {
+    setActivePinia(createPinia());
+  });
+
+  describe("isRoleAbove", () => {
+    it("returns false when me is null", () => {
+      const store = useAuthStore();
+      expect(store.isRoleAbove(e_player_roles_enum.user)).toBe(false);
+    });
+
+    it("returns true when user role >= target role", () => {
+      const store = useAuthStore();
+      store.me = { role: e_player_roles_enum.administrator } as any;
+      expect(store.isRoleAbove(e_player_roles_enum.match_organizer)).toBe(true);
+    });
+
+    it("returns false when user role < target role", () => {
+      const store = useAuthStore();
+      store.me = { role: e_player_roles_enum.user } as any;
+      expect(store.isRoleAbove(e_player_roles_enum.administrator)).toBe(false);
+    });
+
+    it("returns true for same role", () => {
+      const store = useAuthStore();
+      store.me = { role: e_player_roles_enum.streamer } as any;
+      expect(store.isRoleAbove(e_player_roles_enum.streamer)).toBe(true);
+    });
+
+    it("respects full hierarchy: user < verified_user < streamer < match_organizer < tournament_organizer < administrator", () => {
+      const store = useAuthStore();
+      const hierarchy = [
+        e_player_roles_enum.user,
+        e_player_roles_enum.verified_user,
+        e_player_roles_enum.streamer,
+        e_player_roles_enum.match_organizer,
+        e_player_roles_enum.tournament_organizer,
+        e_player_roles_enum.administrator,
+      ];
+
+      for (let i = 0; i < hierarchy.length; i++) {
+        store.me = { role: hierarchy[i] } as any;
+        for (let j = 0; j < hierarchy.length; j++) {
+          expect(store.isRoleAbove(hierarchy[j])).toBe(i >= j);
+        }
+      }
+    });
+  });
+
+  describe("computed role checks", () => {
+    it("isAdmin true only for administrator", () => {
+      const store = useAuthStore();
+      store.me = { role: e_player_roles_enum.administrator } as any;
+      expect(store.isAdmin).toBe(true);
+      store.me = { role: e_player_roles_enum.user } as any;
+      expect(store.isAdmin).toBe(false);
+    });
+
+    it("isUser true only for user role", () => {
+      const store = useAuthStore();
+      store.me = { role: e_player_roles_enum.user } as any;
+      expect(store.isUser).toBe(true);
+      store.me = { role: e_player_roles_enum.administrator } as any;
+      expect(store.isUser).toBe(false);
+    });
+
+    it("isMatchOrganizer true only for match_organizer", () => {
+      const store = useAuthStore();
+      store.me = { role: e_player_roles_enum.match_organizer } as any;
+      expect(store.isMatchOrganizer).toBe(true);
+      store.me = { role: e_player_roles_enum.user } as any;
+      expect(store.isMatchOrganizer).toBe(false);
+    });
+  });
+});

stores/SearchStore.spec.ts

@@ -0,0 +1,71 @@
+import { createPinia, setActivePinia } from "pinia";
+
+const playersOnline = ref<any[]>([]);
+
+vi.mock("~/stores/MatchmakingStore", () => ({
+  useMatchmakingStore: () => ({
+    playersOnline: playersOnline.value,
+  }),
+}));
+
+import { useSearchStore } from "./SearchStore";
+
+const makePlayers = (names: string[]) =>
+  names.map((name, i) => ({
+    steam_id: `steam-${i}`,
+    name,
+    avatar_url: "",
+    country: "US",
+    is_banned: false,
+    is_muted: false,
+    is_gagged: false,
+  }));
+
+describe("SearchStore", () => {
+  beforeEach(() => {
+    setActivePinia(createPinia());
+    playersOnline.value = [];
+    localStorage.removeItem("playerSearchOnlineOnly");
+  });
+
+  it("empty query returns first 10 players from playersOnline", () => {
+    playersOnline.value = makePlayers(Array.from({ length: 15 }, (_, i) => `Player${i}`));
+    const store = useSearchStore();
+    const results = store.search("", []);
+    expect(results).toHaveLength(10);
+  });
+
+  it("empty query excludes players in exclude list", () => {
+    playersOnline.value = makePlayers(["Alice", "Bob", "Charlie"]);
+    const store = useSearchStore();
+    const results = store.search("", ["steam-1"]); // exclude Bob
+    expect(results).toHaveLength(2);
+    expect(results.find((r: any) => r.name === "Bob")).toBeUndefined();
+  });
+
+  it("search query returns fuzzy-matched results", () => {
+    playersOnline.value = makePlayers(["Alice", "Bob", "Charlie"]);
+    const store = useSearchStore();
+    const results = store.search("Alice", []);
+    expect(results.length).toBeGreaterThan(0);
+    expect(results[0].name).toBe("Alice");
+  });
+
+  it("search excludes players in exclude list", () => {
+    playersOnline.value = makePlayers(["Alice", "Alicia", "Bob"]);
+    const store = useSearchStore();
+    const results = store.search("Ali", ["steam-0"]); // exclude Alice
+    expect(results.find((r: any) => r.name === "Alice")).toBeUndefined();
+  });
+
+  it("onlineOnly defaults to true", () => {
+    const store = useSearchStore();
+    expect(store.onlineOnly).toBe(true);
+  });
+
+  it("onlineOnly reads from localStorage", () => {
+    localStorage.setItem("playerSearchOnlineOnly", "false");
+    const store = useSearchStore();
+    expect(store.onlineOnly).toBe(false);
+  });
+});