siftlode/frontend/src/lib/playlistView.test.ts

import { describe, expect, it } from "vitest";
import { applyView, sameOrder } from "./playlistView";
import type { Column } from "./tableColumns";
import type { Video } from "./api";

// The playlist's view derivation. What makes it worth a test: the column sort and the
// channel grouping compose — groups are ordered by channel name in the SORT's direction, and the
// sort then applies within each group. Getting that backwards silently produces a plausible-looking
// order, and the whole "save this order" feature writes whatever this function returned.

const v = (id: string, title: string, channel: string, secs: number | null = 60): Video =>
  ({ id, title, channel_title: channel, duration_seconds: secs }) as Video;

const columns = [
  {
    key: "title",
    header: "Title",
    render: () => null,
    sortable: true,
    sortValue: (x: Video) => x.title ?? "",
  },
  {
    key: "channel",
    header: "Channel",
    render: () => null,
    sortable: true,
    sortValue: (x: Video) => x.channel_title ?? "",
  },
  {
    key: "duration",
    header: "Length",
    render: () => null,
    sortable: true,
    sortValue: (x: Video) => x.duration_seconds ?? Number.MAX_SAFE_INTEGER,
  },
] as Column<Video>[];

const titles = (rows: Video[]) => rows.map((r) => r.title);

describe("applyView", () => {
  const rows = [
    v("1", "delta", "Beta"),
    v("2", "alpha", "Alpha"),
    v("3", "charlie", "Beta"),
    v("4", "bravo", "Alpha"),
  ];

  it("returns the stored order untouched with no sort and no grouping", () => {
    expect(applyView(rows, columns, null, false, "en")).toBe(rows);
  });

  it("sorts by the named column", () => {
    expect(titles(applyView(rows, columns, { key: "title", dir: "asc" }, false, "en"))).toEqual([
      "alpha",
      "bravo",
      "charlie",
      "delta",
    ]);
    expect(titles(applyView(rows, columns, { key: "title", dir: "desc" }, false, "en"))).toEqual([
      "delta",
      "charlie",
      "bravo",
      "alpha",
    ]);
  });

  it("groups by channel, ordering the groups by name and sorting within each", () => {
    expect(titles(applyView(rows, columns, { key: "title", dir: "asc" }, true, "en"))).toEqual([
      "alpha", // Alpha
      "bravo", // Alpha
      "charlie", // Beta
      "delta", // Beta
    ]);
  });

  it("reverses the GROUP order too when the sort is descending", () => {
    expect(titles(applyView(rows, columns, { key: "title", dir: "desc" }, true, "en"))).toEqual([
      "delta", // Beta first, because the direction flips the group order as well
      "charlie",
      "bravo", // then Alpha
      "alpha",
    ]);
  });

  it("groups without a sort by keeping each group's stored order", () => {
    expect(titles(applyView(rows, columns, null, true, "en"))).toEqual([
      "alpha",
      "bravo",
      "delta",
      "charlie",
    ]);
  });

  it("parks unknown durations at the end of an ascending sort, not at zero", () => {
    const mixed = [v("1", "long", "A", 900), v("2", "live", "A", null), v("3", "short", "A", 30)];
    expect(titles(applyView(mixed, columns, { key: "duration", dir: "asc" }, false, "en"))).toEqual(
      ["short", "long", "live"],
    );
  });
});

describe("sameOrder", () => {
  const a = [v("1", "x", "A"), v("2", "y", "A")];

  it("is true for the same ids in the same positions", () => {
    expect(sameOrder(a, [v("1", "different title", "B"), v("2", "y", "A")])).toBe(true);
  });

  it("is false when the order differs", () => {
    expect(sameOrder(a, [a[1]!, a[0]!])).toBe(false);
  });

  it("is false when the length differs — a filtered view is never 'the same order'", () => {
    expect(sameOrder(a, [a[0]!])).toBe(false);
  });
});