Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

10.5 KB
Raw Blame
import { strict as assert } from "node:assert";
import { test } from "vitest";
import {
  buildTransposeRows,
  buildVisibleTransposeRows,
  transposeRecordIndexesForMode,
  nextContextTransposeState,
  nextAppendedTransposeState,
  nextKeyboardTransposeState,
  nextTransposeState,
  nextTransposeStateForRecordCount,
  transposeAnchorRowIndex,
  transposeEndAlignmentSpacerWidth,
  transposeFieldWidth,
  transposeScrollLeftForRecord,
  transposeScrollTopForField,
  visibleTransposeRecordWindow,
} from "../../apps/desktop/src/lib/dataGrid/dataGridTranspose.ts";

test("row number double click opens transpose for a row", () => {
  assert.deepEqual(nextTransposeState(false, null, 2), {
    showTranspose: true,
    transposeRowIndex: 2,
  });
});

test("row number double click switches transpose to another row", () => {
  assert.deepEqual(nextTransposeState(true, 2, 4), {
    showTranspose: true,
    transposeRowIndex: 4,
  });
});

test("row number double click closes transpose for the same row", () => {
  assert.deepEqual(nextTransposeState(true, 2, 2), {
    showTranspose: false,
    transposeRowIndex: null,
  });
});

test("context menu transpose keeps the requested row when multiple rows are selected", () => {
  assert.deepEqual(
    nextContextTransposeState({
      showTranspose: true,
      transposeRowIndex: 2,
      requestedRowIndex: 3,
      rowIds: [10, 11, 12, 13, 14],
      selectedRowIds: new Set([12, 13]),
      selectedRange: null,
    }),
    {
      showTranspose: true,
      transposeRowIndex: 3,
    },
  );
});

test("builds one virtualizable transpose row per field with all record values", () => {
  const rows = buildTransposeRows({
    columns: ["id", "name", "notes"],
    records: [
      [1, "Ada", null],
      [2, "Grace", "compiler"],
    ],
    typeByColumn: new Map([
      ["id", "int"],
      ["name", "varchar"],
    ]),
    displayValue: (value) => (value === null ? "NULL" : String(value)),
  });

  assert.deepEqual(rows, [
    {
      id: "0:id",
      column: "id",
      type: "int",
      values: [
        { value: 1, display: "1", isNull: false },
        { value: 2, display: "2", isNull: false },
      ],
    },
    {
      id: "1:name",
      column: "name",
      type: "varchar",
      values: [
        { value: "Ada", display: "Ada", isNull: false },
        { value: "Grace", display: "Grace", isNull: false },
      ],
    },
    {
      id: "2:notes",
      column: "notes",
      type: "",
      values: [
        { value: null, display: "NULL", isNull: true },
        { value: "compiler", display: "compiler", isNull: false },
      ],
    },
  ]);
});

test("builds transpose rows for only the visible record window", () => {
  const formatted: string[] = [];
  const rows = buildVisibleTransposeRows({
    columns: ["id", "name"],
    records: [
      [1, "Ada"],
      [2, "Grace"],
      [3, "Linus"],
    ],
    recordIndexes: [1, 2],
    displayValue: (value, column, _columnIndex, recordIndex) => {
      formatted.push(`${recordIndex}:${column}`);
      return String(value);
    },
  });

  assert.deepEqual(
    rows.map((row) => ({
      column: row.column,
      values: row.values.map((cell) => ({ recordIndex: cell.recordIndex, display: cell.display })),
    })),
    [
      {
        column: "id",
        values: [
          { recordIndex: 1, display: "2" },
          { recordIndex: 2, display: "3" },
        ],
      },
      {
        column: "name",
        values: [
          { recordIndex: 1, display: "Grace" },
          { recordIndex: 2, display: "Linus" },
        ],
      },
    ],
  );
  assert.deepEqual(formatted, ["1:id", "2:id", "1:name", "2:name"]);
});

test("builds visible transpose rows from mapped source column indexes", () => {
  const rows = buildVisibleTransposeRows({
    columns: ["name"],
    records: [
      [1, "Ada"],
      [2, "Grace"],
    ],
    recordIndexes: [0],
    valueIndexes: [1],
    displayValue: (value) => String(value),
  });

  assert.equal(rows[0].values[0].display, "Ada");
  assert.equal(rows[0].values[0].valueIndex, 1);
});

test("single-row transpose only includes the active record", () => {
  assert.deepEqual(
    transposeRecordIndexesForMode({
      multiRow: false,
      activeRecordIndex: 3,
      totalRecords: 10,
      visibleRecordIndexes: [1, 2, 3, 4],
    }),
    [3],
  );
});

test("single-row transpose clamps the active record into range", () => {
  assert.deepEqual(
    transposeRecordIndexesForMode({
      multiRow: false,
      activeRecordIndex: 12,
      totalRecords: 10,
      visibleRecordIndexes: [7, 8, 9],
    }),
    [9],
  );
});

test("multi-row transpose keeps the visible record window", () => {
  assert.deepEqual(
    transposeRecordIndexesForMode({
      multiRow: true,
      activeRecordIndex: 3,
      totalRecords: 10,
      visibleRecordIndexes: [1, 2, 3, 4],
    }),
    [1, 2, 3, 4],
  );
});

test("keyboard transpose opens from the selected cell row and closes when active", () => {
  assert.deepEqual(
    nextKeyboardTransposeState({
      showTranspose: false,
      transposeRowIndex: null,
      requestedRowIndex: 3,
      rowIds: [10, 11, 12, 13, 14],
      selectedRowIds: new Set(),
      selectedRange: null,
    }),
    {
      showTranspose: true,
      transposeRowIndex: 3,
    },
  );

  assert.deepEqual(
    nextKeyboardTransposeState({
      showTranspose: true,
      transposeRowIndex: 3,
      requestedRowIndex: 3,
      rowIds: [10, 11, 12, 13, 14],
      selectedRowIds: new Set(),
      selectedRange: null,
    }),
    {
      showTranspose: false,
      transposeRowIndex: null,
    },
  );
});

test("transpose follows appended rows when already open", () => {
  assert.deepEqual(nextAppendedTransposeState(true, 4), {
    showTranspose: true,
    transposeRowIndex: 3,
  });
  assert.deepEqual(nextAppendedTransposeState(false, 4), {
    showTranspose: false,
    transposeRowIndex: null,
  });
});

test("transpose state is preserved and clamped after record refresh", () => {
  assert.deepEqual(nextTransposeStateForRecordCount(true, 4, 3), {
    showTranspose: true,
    transposeRowIndex: 2,
  });
  assert.deepEqual(nextTransposeStateForRecordCount(true, 1, 4), {
    showTranspose: true,
    transposeRowIndex: 1,
  });
  assert.deepEqual(nextTransposeStateForRecordCount(true, 1, 0), {
    showTranspose: false,
    transposeRowIndex: null,
  });
});

test("calculates a horizontal record window with spacer widths", () => {
  assert.deepEqual(
    visibleTransposeRecordWindow({
      totalRecords: 100,
      scrollLeft: 680,
      viewportWidth: 720,
      pinnedWidth: 320,
      recordWidth: 160,
      overscan: 1,
    }),
    {
      start: 3,
      end: 9,
      beforeWidth: 480,
      afterWidth: 14560,
    },
  );
});

test("keeps the requested row as the transpose anchor when context row is inside row selection", () => {
  assert.equal(
    transposeAnchorRowIndex({
      requestedRowIndex: 3,
      rowIds: [10, 11, 12, 13, 14, 15],
      selectedRowIds: new Set([12, 13, 14]),
      selectedRange: null,
    }),
    3,
  );
});

test("keeps the requested row as the transpose anchor when context row is inside range", () => {
  assert.equal(
    transposeAnchorRowIndex({
      requestedRowIndex: 5,
      rowIds: [10, 11, 12, 13, 14, 15],
      selectedRowIds: new Set(),
      selectedRange: { startRow: 2, endRow: 5, startCol: 0, endCol: 2 },
    }),
    5,
  );
});

test("sizes the transpose field column from visible field names", () => {
  assert.equal(transposeFieldWidth(["id", "iso3", "year"]), 104);
  assert.equal(transposeFieldWidth(["country_name"]), 124);
});

test("caps the transpose field column width for long field names", () => {
  assert.equal(transposeFieldWidth(["a_very_long_metric_column_name"]), 220);
});

test("start alignment places the selected transpose record at its exact offset", () => {
  assert.equal(
    transposeScrollLeftForRecord({
      recordIndex: 55,
      totalRecords: 100,
      viewportWidth: 1200,
      pinnedWidth: 104,
      recordWidth: 168,
      currentScrollLeft: 0,
      alignment: "start",
    }),
    9240,
  );
});

test("start alignment uses trailing space to place the final variable-width record at the left edge", () => {
  const recordOffsets = [0, 500, 596, 692];
  const endSpacerWidth = transposeEndAlignmentSpacerWidth({
    viewportWidth: 300,
    pinnedWidth: 100,
    lastRecordWidth: 96,
  });

  assert.equal(endSpacerWidth, 104);
  assert.equal(
    transposeScrollLeftForRecord({
      recordIndex: 2,
      totalRecords: 3,
      viewportWidth: 300,
      pinnedWidth: 100,
      recordWidth: 230,
      recordOffsets,
      currentScrollLeft: 0,
      alignment: "start",
      endSpacerWidth,
    }),
    596,
  );
});

test("nearest alignment keeps an already visible transpose field in place", () => {
  assert.equal(
    transposeScrollTopForField({
      fieldIndex: 4,
      totalFields: 20,
      rowHeight: 30,
      viewportHeight: 300,
      currentScrollTop: 90,
      alignment: "nearest",
    }),
    90,
  );
});

test("nearest alignment scrolls a field above the viewport back to its start", () => {
  assert.equal(
    transposeScrollTopForField({
      fieldIndex: 1,
      totalFields: 20,
      rowHeight: 30,
      viewportHeight: 300,
      currentScrollTop: 900,
      alignment: "nearest",
    }),
    30,
  );
});

test("nearest alignment scrolls a field below the viewport just into view", () => {
  assert.equal(
    transposeScrollTopForField({
      fieldIndex: 15,
      totalFields: 20,
      rowHeight: 30,
      viewportHeight: 300,
      currentScrollTop: 90,
      alignment: "nearest",
    }),
    180,
  );
});

test("start alignment places the transpose field at the top of the viewport", () => {
  assert.equal(
    transposeScrollTopForField({
      fieldIndex: 7,
      totalFields: 20,
      rowHeight: 30,
      viewportHeight: 300,
      currentScrollTop: 0,
      alignment: "start",
    }),
    210,
  );
});

test("clamps the transpose field scroll to the end of the field list", () => {
  assert.equal(
    transposeScrollTopForField({
      fieldIndex: 19,
      totalFields: 20,
      rowHeight: 30,
      viewportHeight: 300,
      currentScrollTop: 0,
      alignment: "start",
    }),
    300,
  );
});

test("ignores transpose field scrolling when there is nothing to scroll", () => {
  assert.equal(
    transposeScrollTopForField({
      fieldIndex: 0,
      totalFields: 0,
      rowHeight: 30,
      viewportHeight: 300,
      currentScrollTop: 0,
    }),
    0,
  );
  assert.equal(
    transposeScrollTopForField({
      fieldIndex: 0,
      totalFields: 20,
      rowHeight: 0,
      viewportHeight: 300,
      currentScrollTop: 0,
    }),
    0,
  );
});