matterviz 0.3.4 → 0.3.6

package/tests/detect.test.ts

@@ -0,0 +1,604 @@
+// Tests for data type detection used by JsonBrowser and main.ts
+import { readFileSync } from 'node:fs'
+import { gunzipSync } from 'node:zlib'
+import { describe, expect, test } from 'vitest'
+import {
+  detect_view_type,
+  is_plottable_data,
+  scan_renderable_paths,
+} from '../src/webview/detect'
+
+const fixture = JSON.parse(
+  gunzipSync(
+    readFileSync(`${import.meta.dirname}/../test-fixtures/all-viz-types.json.gz`),
+  ).toString(),
+)
+
+describe(`detect_view_type`, () => {
+  // === Positive detections from the test fixture ===
+
+  test.each([
+    [`structures.Cu_FCC`, `structure`],
+    [`structures.Bi2Zr2O8_fluorite`, `structure`],
+    [`fermi_surface`, `fermi_surface`],
+    [`phase_diagram`, `phase_diagram`],
+    [`band_structure`, `band_structure`],
+    [`dos`, `dos`],
+    [`convex_hull_Li_Fe`, `convex_hull`],
+    [`convex_hull_Li_Fe_O`, `convex_hull`],
+    [`convex_hull_Li_Fe_P_O`, `convex_hull`],
+  ] as const)(`detects %s as %s`, (path, expected) => {
+    expect(detect_view_type(resolve(fixture, path))).toBe(expected)
+  })
+
+  // === Null / non-renderable inputs ===
+
+  test.each([
+    [null, `null`],
+    [undefined, `undefined`],
+    [42, `number`],
+    [`hello`, `string`],
+    [true, `boolean`],
+    [[], `empty array`],
+    [{}, `empty object`],
+    [{ foo: `bar` }, `arbitrary object`],
+    [{ sites: [] }, `structure with empty sites`],
+    [{ sites: [{}] }, `structure site missing species`],
+    [{ energies: [1], k_grid: [1, 2, 3] }, `partial band_grid`],
+  ] as [unknown, string][])(`returns null for %s (%s)`, (val) => {
+    expect(detect_view_type(val)).toBeNull()
+  })
+
+  // === Minimal valid shapes ===
+
+  // Reusable test data fragments
+  const k_lattice_3x3 = [
+    [1, 0, 0],
+    [0, 1, 0],
+    [0, 0, 1],
+  ]
+  const labels_dict = { G: [0, 0, 0] }
+  const pymatgen_bands = {
+    kpoints: [[0, 0, 0]],
+    branches: [{ start_index: 0, end_index: 1, name: `G-X` }],
+    bands: { '1': [[1, 2, 3]] },
+    labels_dict,
+    efermi: 5.0,
+  }
+  const norm_dos = {
+    type: `electronic`,
+    energies: [0, 1, 2],
+    densities: [[0.1, 0.2, 0.3]],
+  }
+
+  test.each([
+    [
+      `structure (abc)`,
+      `structure`,
+      {
+        sites: [{ species: [{ element: `Si` }], abc: [0, 0, 0] }],
+      },
+    ],
+    [
+      `structure (xyz)`,
+      `structure`,
+      {
+        sites: [{ species: [{ element: `Si` }], xyz: [0, 0, 0] }],
+      },
+    ],
+    [
+      `convex_hull (energy)`,
+      `convex_hull`,
+      [
+        { composition: { Li: 1 }, energy: -1.5 },
+        {
+          composition: { Fe: 1 },
+          energy: -2.0,
+        },
+      ],
+    ],
+    [
+      `convex_hull (e_form_per_atom)`,
+      `convex_hull`,
+      [
+        { composition: { Li: 1 }, e_form_per_atom: 0.0 },
+        { composition: { Fe: 1 }, e_form_per_atom: 0.0 },
+      ],
+    ],
+    [
+      `band_grid`,
+      `band_grid`,
+      {
+        energies: [[[1, 2]]],
+        k_grid: [2, 2, 2],
+        k_lattice: k_lattice_3x3,
+        fermi_energy: 5.0,
+        n_bands: 1,
+        n_spins: 1,
+      },
+    ],
+    [
+      `fermi_surface`,
+      `fermi_surface`,
+      {
+        isosurfaces: [],
+        k_lattice: k_lattice_3x3,
+        fermi_energy: 5.0,
+        reciprocal_cell: `wigner_seitz`,
+        metadata: { source: `test` },
+      },
+    ],
+    [`dos (electronic)`, `dos`, norm_dos],
+    [
+      `dos (phonon)`,
+      `dos`,
+      {
+        type: `phonon`,
+        frequencies: [0, 100, 200],
+        densities: [[0.1, 0.2, 0.3]],
+      },
+    ],
+    [`band_structure (pymatgen)`, `band_structure`, pymatgen_bands],
+    [
+      `band_structure (normalized)`,
+      `band_structure`,
+      {
+        qpoints: [[0, 0, 0]],
+        branches: [{ start_index: 0, end_index: 1 }],
+        bands: [[1, 2, 3]],
+        labels_dict,
+        nb_bands: 1,
+      },
+    ],
+    [
+      `phase_diagram`,
+      `phase_diagram`,
+      {
+        components: [`A`, `B`],
+        regions: [],
+        boundaries: [],
+        temperature_range: [300, 1500],
+      },
+    ],
+    [
+      `volumetric`,
+      `volumetric`,
+      {
+        grid: [
+          [
+            [1, 2],
+            [3, 4],
+          ],
+          [
+            [5, 6],
+            [7, 8],
+          ],
+        ],
+        grid_dims: [2, 2, 2],
+        lattice: k_lattice_3x3,
+        origin: [0, 0, 0],
+        data_range: { min: 0, max: 1 },
+        periodic: true,
+      },
+    ],
+    [
+      `xrd (hkls)`,
+      `xrd`,
+      {
+        x: [10, 20, 30],
+        y: [100, 50, 75],
+        hkls: [[[1, 0, 0]], [[1, 1, 0]], [[1, 1, 1]]],
+      },
+    ],
+    [`xrd (wavelength)`, `xrd`, { x: [10, 20], y: [100, 50], wavelength: 1.5406 }],
+    [
+      `brillouin_zone`,
+      `brillouin_zone`,
+      {
+        k_lattice: k_lattice_3x3,
+        k_path: [
+          [0, 0, 0],
+          [0.5, 0, 0],
+        ],
+      },
+    ],
+    [`bands_and_dos`, `bands_and_dos`, { band_structure: pymatgen_bands, dos: norm_dos }],
+    [
+      `table (row-based)`,
+      `table`,
+      [
+        { name: `Si`, energy: -5.4, volume: 20.5 },
+        { name: `Ge`, energy: -4.6, volume: 22.7 },
+        { name: `C`, energy: -7.4, volume: 11.2 },
+      ],
+    ],
+    [
+      `table (column-based)`,
+      `table`,
+      {
+        element: [`Si`, `Ge`, `C`],
+        energy: [-5.4, -4.6, -7.4],
+        volume: [20.5, 22.7, 11.2],
+      },
+    ],
+    // Alternative format variants (testing all code branches)
+    [
+      `convex_hull (energy_per_atom)`,
+      `convex_hull`,
+      [
+        { composition: { Li: 1 }, energy_per_atom: -1.5 },
+        { composition: { Fe: 1 }, energy_per_atom: -2.0 },
+      ],
+    ],
+    [
+      `dos (pymatgen @class)`,
+      `dos`,
+      {
+        '@class': `CompleteDos`,
+        '@module': `pymatgen.electronic_structure.dos`,
+        energies: [-5, 0, 5],
+        densities: { '1': [0.1, 0.5, 0.1] },
+        efermi: 0.0,
+      },
+    ],
+    [`xrd (d_hkls)`, `xrd`, { x: [20, 40], y: [100, 50], d_hkls: [2.0, 1.5] }],
+    [`xrd (@class)`, `xrd`, { x: [20, 40], y: [100, 50], '@class': `XrdPattern` }],
+    [
+      `brillouin_zone (reciprocal_lattice)`,
+      `brillouin_zone`,
+      {
+        reciprocal_lattice: k_lattice_3x3,
+        k_path: [[0, 0, 0]],
+      },
+    ],
+    [
+      `brillouin_zone (bz_order)`,
+      `brillouin_zone`,
+      {
+        k_lattice: k_lattice_3x3,
+        bz_order: 1,
+      },
+    ],
+    [
+      `bands_and_dos (combined fields)`,
+      `bands_and_dos`,
+      {
+        branches: [{ start_index: 0, end_index: 1 }],
+        labels_dict,
+        energies: [0, 1, 2],
+        densities: [[0.1, 0.2, 0.3]],
+        atom_dos: {},
+        kpoints: [[0, 0, 0]],
+        bands: { '1': [[1, 2]] },
+        efermi: 5.0,
+      },
+    ],
+  ] as [string, string, unknown][])(`detects %s`, (_, expected, val) => {
+    expect(detect_view_type(val)).toBe(expected)
+  })
+
+  // === Negative / boundary cases ===
+
+  test.each([
+    [`pure-string columns`, null, { names: [`Si`, `Ge`], symbols: [`Si`, `Ge`] }],
+    [
+      `x/y without hkls -> table not xrd`,
+      `table`,
+      {
+        x: [1, 2, 3],
+        y: [4, 5, 6],
+        z: [7, 8, 9],
+      },
+    ],
+    [`single convex hull entry`, null, [{ composition: { Li: 1 }, energy: -1.5 }]],
+    [
+      `2-row table too small`,
+      null,
+      [
+        { a: 1, b: 2 },
+        { a: 3, b: 4 },
+      ],
+    ],
+    [
+      `BZ with isosurfaces -> fermi_surface`,
+      `fermi_surface`,
+      {
+        k_lattice: k_lattice_3x3,
+        isosurfaces: [],
+        fermi_energy: 5.0,
+        reciprocal_cell: `wigner_seitz`,
+        metadata: {},
+      },
+    ],
+    [
+      `combined fields without atom_dos/spd_dos -> band_structure`,
+      `band_structure`,
+      {
+        branches: [{ start_index: 0, end_index: 1 }],
+        labels_dict,
+        energies: [0, 1],
+        densities: [[0.1, 0.2]],
+        kpoints: [[0, 0, 0]],
+        bands: { '1': [[1, 2]] },
+        efermi: 5.0,
+      },
+    ],
+    [
+      `bands_and_dos wrapper with too many keys`,
+      null,
+      {
+        band_structure: pymatgen_bands,
+        dos: norm_dos,
+        extra_1: 1,
+        extra_2: 2,
+        extra_3: 3,
+        extra_4: 4,
+      },
+    ],
+    [
+      `band_structure with empty branches`,
+      null,
+      {
+        branches: [],
+        labels_dict,
+        kpoints: [[0, 0, 0]],
+        bands: { '1': [[1]] },
+        efermi: 5.0,
+      },
+    ],
+    [
+      `phase_diagram with 3 components (not binary)`,
+      null,
+      {
+        components: [`A`, `B`, `C`],
+        regions: [],
+        boundaries: [],
+        temperature_range: [300, 1500],
+      },
+    ],
+    [
+      `column table with unequal lengths`,
+      null,
+      {
+        col_a: [1, 2, 3],
+        col_b: [4, 5],
+      },
+    ],
+    [
+      `row table with inconsistent keys`,
+      null,
+      [
+        { a: 1, b: 2 },
+        { x: 3, y: 4 },
+        { z: 5, w: 6 },
+      ],
+    ],
+  ] as [string, string | null, unknown][])(`%s -> %s`, (_, expected, val) => {
+    if (expected === null) expect(detect_view_type(val)).toBeNull()
+    else expect(detect_view_type(val)).toBe(expected)
+  })
+})
+
+describe(`scan_renderable_paths`, () => {
+  // Scan fixture once and reuse across related assertions
+  const fixture_paths = scan_renderable_paths(fixture)
+
+  test(`finds all expected types in test fixture`, () => {
+    expect(fixture_paths.size).toBeGreaterThanOrEqual(9)
+    const types = new Set([...fixture_paths.values()].map((info) => info.type))
+    for (const expected of [
+      `structure`,
+      `fermi_surface`,
+      `phase_diagram`,
+      `band_structure`,
+      `dos`,
+      `convex_hull`,
+    ]) {
+      expect(types, `missing type: ${expected}`).toContain(expected)
+    }
+  })
+
+  test(`finds nested structures at correct paths without recursing into them`, () => {
+    expect(fixture_paths.get(`structures.Cu_FCC`)?.type).toBe(`structure`)
+    // Should NOT find children like structures.Cu_FCC.sites
+    expect([...fixture_paths.keys()].some((key) => key.startsWith(`structures.Cu_FCC.`))).toBe(
+      false,
+    )
+  })
+
+  test.each([
+    [{ foo: `bar`, n: 42 }, `non-renderable object`],
+    [null, `null`],
+    [undefined, `undefined`],
+    [`hello`, `string primitive`],
+  ] as [unknown, string][])(`returns empty map for %s`, (val) => {
+    expect(scan_renderable_paths(val).size).toBe(0)
+  })
+
+  test(`respects max_depth`, () => {
+    const deep = {
+      a: { b: { c: { sites: [{ species: [{ element: `Si` }], abc: [0, 0, 0] }] } } },
+    }
+    expect(scan_renderable_paths(deep, ``, 2).size).toBe(0)
+    expect(scan_renderable_paths(deep, ``, 4).size).toBe(1)
+  })
+
+  test(`scans array elements`, () => {
+    const data = {
+      items: [
+        { composition: { Li: 1 }, energy: -1.5 },
+        { sites: [{ species: [{ element: `Si` }], abc: [0, 0, 0] }] },
+      ],
+    }
+    expect(scan_renderable_paths(data).get(`items[1]`)?.type).toBe(`structure`)
+  })
+
+  test.each([
+    [
+      `root-level dotted key`,
+      {
+        'mp-1234.structure': {
+          sites: [{ species: [{ element: `Si` }], abc: [0, 0, 0] }],
+        },
+      },
+      `["mp-1234.structure"]`,
+    ],
+    [
+      `nested dotted key`,
+      {
+        results: {
+          'calc.1': { sites: [{ species: [{ element: `Cu` }], abc: [0, 0, 0] }] },
+        },
+      },
+      `results["calc.1"]`,
+    ],
+  ] as [string, unknown, string][])(
+    `handles %s via bracket notation`,
+    (_, data, expected_path) => {
+      const paths = scan_renderable_paths(data)
+      expect(paths.get(expected_path)?.type).toBe(`structure`)
+    },
+  )
+
+  test(`all scanned paths resolve back to the original value`, () => {
+    // resolve_path mirror (same logic as JsonBrowser.svelte)
+    function resolve_path(root: unknown, path: string): unknown {
+      if (!path) return root
+      const segments: string[] = []
+      const segment_re = /\["([^"]+)"\]|\[(\d+)\]|([^.[\]]+)/g
+      let match: RegExpExecArray | null
+      while ((match = segment_re.exec(path)) !== null) {
+        segments.push(match[1] ?? match[2] ?? match[3])
+      }
+      let current: unknown = root
+      for (const segment of segments) {
+        if (current === null || current === undefined || typeof current !== `object`) {
+          return undefined
+        }
+        current = (current as Record<string, unknown>)[segment]
+      }
+      return current
+    }
+    for (const [path] of fixture_paths) {
+      const resolved = resolve_path(fixture, path)
+      expect(resolved, `resolve_path failed for '${path}'`).not.toBeUndefined()
+      // Re-detect should return the same type
+      expect(detect_view_type(resolved)).toBe(fixture_paths.get(path)?.type)
+    }
+  })
+})
+
+describe(`is_plottable_data`, () => {
+  test.each([
+    [`column-based with 2 numeric cols`, true, { x: [1, 2, 3], y: [4, 5, 6] }],
+    [`column-based with 3 numeric cols`, true, { x: [1, 2], y: [3, 4], z: [5, 6] }],
+    [
+      `row-based with 2 numeric cols`,
+      true,
+      [
+        { a: 1, b: 2, name: `x` },
+        { a: 3, b: 4, name: `y` },
+        { a: 5, b: 6, name: `z` },
+      ],
+    ],
+    [
+      `column-based with null first elements`,
+      true,
+      {
+        x: [null, 2, 3],
+        y: [4, 5, 6],
+      },
+    ],
+    [
+      `row-based with null first row values`,
+      true,
+      [
+        { a: null, b: 4 },
+        { a: 2, b: 5 },
+        { a: 3, b: 6 },
+      ],
+    ],
+    [
+      `column-based with 1 numeric col (not plottable)`,
+      false,
+      {
+        name: [`Si`, `Ge`, `C`],
+        energy: [-5.4, -4.6, -7.4],
+      },
+    ],
+    [
+      `row-based with 1 numeric col (not plottable)`,
+      false,
+      [
+        { a: 1, name: `x` },
+        { a: 2, name: `y` },
+      ],
+    ],
+    [
+      `column-based with NaN values (typeof NaN === number)`,
+      true,
+      {
+        a: [NaN, 2, 3],
+        b: [4, 5, 6],
+      },
+    ],
+    [
+      `column-based with Infinity values`,
+      true,
+      {
+        a: [Infinity, 2, 3],
+        b: [4, 5, 6],
+      },
+    ],
+    [
+      `column-based with mixed types (some numbers)`,
+      true,
+      {
+        a: [1, `two`, 3],
+        b: [4, 5, 6],
+      },
+    ],
+    [
+      `row-based with NaN and mixed values`,
+      true,
+      [
+        { a: 1, b: `x` },
+        { a: NaN, b: 4 },
+        { a: 3, b: 6 },
+      ],
+    ],
+    [`empty array`, false, []],
+    [`non-tabular object`, false, { foo: `bar` }],
+    [`null`, false, null],
+    [`undefined`, false, undefined],
+  ] as [string, boolean, unknown][])(`%s -> %s`, (_, expected, val) => {
+    expect(is_plottable_data(val)).toBe(expected)
+  })
+})
+
+describe(`scan_renderable_paths with plot`, () => {
+  test(`registers both table and plot badges for plottable tabular data`, () => {
+    const data = { x: [1, 2, 3], y: [4, 5, 6], z: [7, 8, 9] }
+    const paths = scan_renderable_paths(data)
+    const types = [...paths.values()].map((info) => info.type)
+    expect(types).toContain(`table`)
+    expect(types).toContain(`plot`)
+    // plot path uses \x00 suffix to co-exist with table at same data path
+    expect(paths.has(`\x00plot`)).toBe(true)
+    expect(paths.get(`\x00plot`)?.type).toBe(`plot`)
+  })
+
+  test(`registers only table badge for non-plottable tabular data`, () => {
+    const data = { name: [`Si`, `Ge`, `C`], energy: [-5.4, -4.6, -7.4] }
+    const paths = scan_renderable_paths(data)
+    const types = [...paths.values()].map((info) => info.type)
+    expect(types).toContain(`table`)
+    expect(types).not.toContain(`plot`)
+  })
+})
+
+// Helper to resolve dotted paths like "structures.Cu_FCC"
+const resolve = (obj: Record<string, unknown>, path: string): unknown =>
+  path
+    .split(`.`)
+    .reduce<unknown>((current, key) => (current as Record<string, unknown>)?.[key], obj)