@datagrok/proteomics 1.0.0 → 1.2.0

package/src/tests/subcellular-location.ts

@@ -0,0 +1,361 @@
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+import {category, test, expect} from '@datagrok-libraries/test/src/test';
+import {SEMTYPE} from '../utils/proteomics-types';
+import {
+  getSubcellularLocations,
+  LOCATION_COLORS,
+  mergeStreamTsv,
+  ORGANISM_TAXONOMY,
+  parseSubcellularLocation,
+  ProgressCb,
+  runWithConcurrency,
+  STORE,
+} from '../analysis/subcellular-location';
+import {ORGANISM_LIST} from '../analysis/enrichment';
+import {ensureLocationColumn} from '../viewers/volcano';
+
+// CRITICAL: `grok.dapi.userDataStorage` returns a NEW UserDataStorage instance
+// per access (see js-api dapi.ts: `get userDataStorage() { return new ... }`).
+// Patching the instance's `put`/`get` would only stick for one call, then the
+// next access creates a fresh instance with the original methods. Patch the
+// PROTOTYPE so every fresh instance picks up our spy. Restore the originals in
+// finally to avoid leaking across tests.
+function patchUserDataStorage(opts: {
+  get?: (name: string, currentUser?: boolean) => Promise<any>;
+  put?: (name: string, data: any, currentUser?: boolean) => Promise<void>;
+}): () => void {
+  const proto = (grok.dapi.userDataStorage as any).constructor.prototype;
+  const origGet = proto.get;
+  const origPut = proto.put;
+  if (opts.get) proto.get = opts.get;
+  if (opts.put) proto.put = opts.put;
+  return () => {
+    proto.get = origGet;
+    proto.put = origPut;
+  };
+}
+
+// Locked CK-omics hex palette (Subcellular_Location_Classification_README.txt §COLOR
+// SCHEME / CKomics_tool2.py get_location_colors). ARGB = 0xFF000000 | RRGGBB.
+const EXPECTED_HEX: Record<string, string> = {
+  'Nucleus': '#FF6B6B', 'Cytoplasm': '#ECDC44', 'Mitochondria': '#45B7D1',
+  'ER': '#96CEB4', 'Golgi': '#FAAFFE', 'Plasma Membrane': '#DDA0DD',
+  'Lysosome': '#F39C12', 'Peroxisome': '#E17055', 'Ribosome': '#A29BFE',
+  'Extracellular': '#FD79A8', 'Vesicles': '#FDCB6E', 'Unknown': '#CCCCCC',
+};
+
+category('SubcellularLocation', () => {
+  test('SEMTYPE.SUBCELLULAR_LOCATION literal is stable', async () => {
+    expect(SEMTYPE.SUBCELLULAR_LOCATION, 'Proteomics-SubcellularLocation');
+  });
+
+  // H1 guard: every organism the enrichment dialog offers must have a taxonomy
+  // id, or its gene-fallback subcellular lookup silently runs unfiltered and can
+  // resolve to the wrong species. Locks the two lists in sync against drift.
+  test('every ORGANISM_LIST code has an ORGANISM_TAXONOMY mapping', async () => {
+    for (const org of ORGANISM_LIST) {
+      expect(typeof ORGANISM_TAXONOMY[org.code], 'number');
+      expect(ORGANISM_TAXONOMY[org.code] > 0, true);
+    }
+  });
+
+  test('classifier: subcellular field used before GO fallback', async () => {
+    // Subcell says Nucleus, GO says mitochondrion — subcell wins (tried first).
+    expect(parseSubcellularLocation('Nucleus {ECO:0000269}.', 'mitochondrion [GO:0005739]'),
+      'Nucleus');
+  });
+
+  test('classifier: GO used only when subcellular field has no match', async () => {
+    expect(parseSubcellularLocation('', 'cytoplasm [GO:0005737]'), 'Cytoplasm');
+    expect(parseSubcellularLocation('phosphopyruvate hydratase complex',
+      'ribosome [GO:0005840]'), 'Ribosome');
+  });
+
+  test('classifier: earliest character position wins across categories', async () => {
+    // "Mitochondrion" appears before "Nucleus" → Mitochondria.
+    expect(parseSubcellularLocation('Mitochondrion. Nucleus.', ''), 'Mitochondria');
+    // Reverse order → Nucleus.
+    expect(parseSubcellularLocation('Nucleus. Mitochondrion.', ''), 'Nucleus');
+  });
+
+  test('classifier: ties broken by keyword-map insertion order (Nucleus before Cytoplasm)', async () => {
+    // Both keywords start at position 0 of their own scan; Nucleus is iterated
+    // first (strict < on position keeps the first-iterated category).
+    expect(parseSubcellularLocation('nucleus', ''), 'Nucleus');
+    expect(parseSubcellularLocation('cytoplasm', ''), 'Cytoplasm');
+  });
+
+  test('classifier: raw string not pre-stripped (matches inside SUBCELLULAR LOCATION: ... {ECO})', async () => {
+    expect(parseSubcellularLocation(
+      'SUBCELLULAR LOCATION: Cytoplasm {ECO:0000269|PubMed:1234}. Nucleus {ECO:0000250}.', ''),
+    'Cytoplasm');
+  });
+
+  test('classifier: empty / no-match → Unknown', async () => {
+    expect(parseSubcellularLocation('', ''), 'Unknown');
+    expect(parseSubcellularLocation('some unrelated free text', 'nothing spatial here'),
+      'Unknown');
+  });
+
+  test('LOCATION_COLORS: all 12 ARGB ints equal the locked hex conversion', async () => {
+    const keys = Object.keys(EXPECTED_HEX);
+    expect(keys.length, 12);
+    for (const k of keys) {
+      const argb = 0xFF000000 | parseInt(EXPECTED_HEX[k].slice(1), 16);
+      expect(LOCATION_COLORS[k], argb);
+    }
+    expect(Object.keys(LOCATION_COLORS).length, 12);
+  });
+
+  test('mergeStreamTsv: header skipped, positional parse, reviewed beats unreviewed', async () => {
+    const tsv = [
+      'Entry\tSubcellular location [CC]\tGene Ontology (cellular component)\tReviewed\tGene Names (primary)',
+      'P1\tNucleus.\t\tunreviewed\tGENA',
+      'P1\tMitochondrion.\t\treviewed\tGENA',
+      'P2\t\t\tunreviewed\tGENB',
+    ].join('\n');
+    const {locByAcc, geneByAcc} = mergeStreamTsv(tsv);
+    // P1: reviewed Mitochondria overwrites the earlier unreviewed Nucleus.
+    expect(locByAcc.get('P1'), 'Mitochondria');
+    // P2: no location anywhere → Unknown.
+    expect(locByAcc.get('P2'), 'Unknown');
+    expect(geneByAcc.get('P1'), 'GENA');
+    expect(geneByAcc.get('P2'), 'GENB');
+  });
+
+  test('mergeStreamTsv: existing Unknown is overwritten by a later non-Unknown', async () => {
+    const tsv = [
+      'Entry\tSubcellular location [CC]\tGO\tReviewed\tGene',
+      'P9\t\t\tunreviewed\tG9',
+      'P9\tGolgi apparatus.\t\tunreviewed\tG9',
+    ].join('\n');
+    const {locByAcc} = mergeStreamTsv(tsv);
+    expect(locByAcc.get('P9'), 'Golgi');
+  });
+
+  // --- 13-08 gap-closure tests ---
+
+  // Test A: runWithConcurrency holds the in-flight cap. No network — uses
+  // deferred Promises around a tracked concurrentMax counter.
+  test('runWithConcurrency caps in-flight tasks at the supplied limit', async () => {
+    let inFlight = 0;
+    let concurrentMax = 0;
+    const items = new Array(20).fill(0).map((_, i) => i);
+    await runWithConcurrency(items, 6, async () => {
+      inFlight++;
+      if (inFlight > concurrentMax) concurrentMax = inFlight;
+      await new Promise((r) => setTimeout(r, 5));
+      inFlight--;
+      return null;
+    });
+    expect(concurrentMax <= 6, true, 'concurrentMax should be ≤ 6');
+    expect(concurrentMax >= 2, true, 'should have observed parallel execution');
+  });
+
+  // Test B: getSubcellularLocations emits progress callbacks with non-decreasing
+  // `done` within phase. Monkey-patches fetchProxy, userDataStorage.put, AND
+  // userDataStorage.get — the last one is critical: a previous test run may
+  // have populated real on-disk storage, which would silently mark every
+  // accession as a cache hit and skip the fetch loop entirely.
+  test('getSubcellularLocations emits non-decreasing progress per phase', async () => {
+    const tsvBody = (acc: string) =>
+      'Entry\tSubcellular location [CC]\tGO\tReviewed\tGene Names (primary)\n' +
+      `${acc}\tNucleus.\t\treviewed\tGENE1\n`;
+
+    const origFetch = grok.dapi.fetchProxy;
+    (grok.dapi as any).fetchProxy = async (url: string) => {
+      // Extract the first accession out of the query so each chunk returns
+      // a single resolved entry — that's enough to exercise progress.
+      const m = /accession%3A([A-Z0-9]+)/.exec(url);
+      const acc = m ? m[1] : 'P00000';
+      return {ok: true, status: 200, text: async () => tsvBody(acc)} as Response;
+    };
+    const restore = patchUserDataStorage({
+      get: async () => ({}),
+      put: async () => {},
+    });
+
+    try {
+      const accessions: string[] = [];
+      for (let i = 0; i < 250; i++) accessions.push(`TESTB${String(i).padStart(5, '0')}`);
+      const calls: {done: number; total: number; phase: string}[] = [];
+      const progress: ProgressCb = (done, total, phase) => calls.push({done, total, phase});
+
+      await getSubcellularLocations(accessions, 'hsapiens', progress);
+
+      // 250/100 ⇒ 3 accession chunks.
+      const accCalls = calls.filter((c) => c.phase === 'fetch-acc');
+      expect(accCalls.length, 3);
+      expect(accCalls[0].total, 3);
+      // Non-decreasing within phase (worker-interleaved → not strictly monotonic).
+      for (let i = 1; i < accCalls.length; i++)
+        expect(accCalls[i].done >= accCalls[i - 1].done, true,
+          'fetch-acc done should be non-decreasing');
+      // Final tuple of the last entered phase reaches done === total.
+      const last = accCalls[accCalls.length - 1];
+      expect(last.done, last.total, 'last fetch-acc tuple should have done === total');
+    } finally {
+      (grok.dapi as any).fetchProxy = origFetch;
+      restore();
+    }
+  });
+
+  // Test C: userDataStorage.put is called at least twice during a fetch lasting
+  // longer than CACHE_FLUSH_INTERVAL_MS (5 s default). Spy via wrapping.
+  test('getSubcellularLocations writes the cache incrementally during fetch', async () => {
+    // We can't shorten CACHE_FLUSH_INTERVAL_MS without exporting it (and the
+    // plan locks it as a tuning knob), so this test runs a fetch that lasts
+    // ~6 s — long enough for the timer to fire at least once mid-fetch plus
+    // the final finally-flush. Per-chunk delay × chunk count is what stretches
+    // wall-clock; with 3 chunks and a 2.2 s per-chunk delay, total ≈ 6 s with
+    // FETCH_CONCURRENCY=6 (all parallel) or longer if serialized.
+    //
+    // The robustness invariant we assert is: put was called >= 2 times. The
+    // exact count depends on timer-vs-fetch interleaving; 2 covers (a) one
+    // timer fire mid-fetch + (b) the finally flush. We intentionally do not
+    // assert >2 — a CI VM might run the entire fetch inside one tick.
+    const tsvBody = (acc: string) =>
+      'Entry\tSubcellular location [CC]\tGO\tReviewed\tGene Names (primary)\n' +
+      `${acc}\tNucleus.\t\treviewed\tGENE1\n`;
+
+    const origFetch = grok.dapi.fetchProxy;
+    // First chunk completes at ~1 s (populates `fetched`); second chunk runs
+    // until ~6 s. The 5 s flush timer fires at t=5 s while the second chunk
+    // is still in flight — `fetched` is already non-empty from chunk 1, so
+    // flushCache actually writes (put #1). Finally flushes (put #2). This is
+    // the only interleaving that proves the timer-driven incremental cache
+    // works, not just the post-pass single flush.
+    let callIdx = 0;
+    (grok.dapi as any).fetchProxy = async (url: string) => {
+      const myIdx = callIdx++;
+      const delayMs = myIdx === 0 ? 1000 : 6000;
+      await new Promise((r) => setTimeout(r, delayMs));
+      const m = /accession%3A([A-Z0-9]+)/.exec(url);
+      const acc = m ? m[1] : 'P00000';
+      return {ok: true, status: 200, text: async () => tsvBody(acc)} as Response;
+    };
+    let putCalls = 0;
+    const restore = patchUserDataStorage({
+      // Empty cache → all accessions go to fetch loop → flushCache has work.
+      get: async () => ({}),
+      put: async () => { putCalls++; },
+    });
+
+    try {
+      // 150 accessions → 2 ACC_CHUNK groups (size 100). Worker pool with
+      // concurrency=6 starts both chunks at t=0; staggered delays handle the
+      // interleaving above.
+      const accessions: string[] = [];
+      for (let i = 0; i < 150; i++) accessions.push(`TESTC${String(i).padStart(5, '0')}`);
+      await getSubcellularLocations(accessions, 'hsapiens');
+      expect(putCalls >= 2, true,
+        `userDataStorage.put should be called >= 2 times (got ${putCalls})`);
+    } finally {
+      (grok.dapi as any).fetchProxy = origFetch;
+      restore();
+    }
+  }, {timeout: 30000});
+
+  // Make sure STORE is exported and matches the documented key — guards
+  // against accidental rename that would silently fork the on-disk cache
+  // from the volcanoOptions toast-cache-peek path.
+  test('STORE export matches the documented userDataStorage key', async () => {
+    expect(STORE, 'proteomics-subcell-loc');
+  });
+
+  // Test D: ensureLocationColumn short-circuits when the accession-set hash
+  // tag matches the current set. We don't know the FNV-1a hash from the test,
+  // so we exercise the contract end-to-end: (1) first call populates the
+  // column AND stamps the hash tag; (2) second call with fetchProxy spy that
+  // would throw if invoked still completes — proving the short-circuit fires;
+  // (3) mutating the accession set invalidates the hash and re-triggers fetch.
+  test('ensureLocationColumn short-circuits on accession-set hash match', async () => {
+    const tsvBody = (acc: string) =>
+      'Entry\tSubcellular location [CC]\tGO\tReviewed\tGene Names (primary)\n' +
+      `${acc}\tNucleus.\t\treviewed\tGENE1\n`;
+
+    const origFetch = grok.dapi.fetchProxy;
+    let fetchCalled = 0;
+    (grok.dapi as any).fetchProxy = async (url: string) => {
+      fetchCalled++;
+      const m = /accession%3A([A-Z0-9]+)/.exec(url);
+      const acc = m ? m[1] : 'TESTD00';
+      return {ok: true, status: 200, text: async () => tsvBody(acc)} as Response;
+    };
+    // Empty cache → first call goes through fetch path so the hash gets stamped.
+    const restore = patchUserDataStorage({
+      get: async () => ({}),
+      put: async () => {},
+    });
+
+    try {
+      const idCol = DG.Column.fromStrings('Primary Protein ID',
+        ['TESTD01', 'TESTD02', 'TESTD03', 'TESTD04', 'TESTD05']);
+      idCol.semType = SEMTYPE.PROTEIN_ID;
+      const df = DG.DataFrame.fromColumns([idCol]);
+
+      // (1) Populate + stamp the hash tag.
+      await ensureLocationColumn(df);
+      const firstFetchCount = fetchCalled;
+      expect(firstFetchCount >= 1, true, 'first call should fetch from UniProt');
+
+      // (2) Same accession set → short-circuit, no new fetch.
+      await ensureLocationColumn(df);
+      expect(fetchCalled, firstFetchCount,
+        'second call on same accession set should short-circuit (no new fetch)');
+
+      // (3) Mutate one accession → hash invalidates → fetch resumes.
+      idCol.set(0, 'TESTD99');
+      await ensureLocationColumn(df);
+      expect(fetchCalled > firstFetchCount, true,
+        'third call with mutated accession should fetch again');
+    } finally {
+      (grok.dapi as any).fetchProxy = origFetch;
+      restore();
+    }
+  });
+
+  // Test E: ensureLocationColumn forwards the progress callback through to
+  // getSubcellularLocations AND fires 'init-column' after bulk-init.
+  test('ensureLocationColumn forwards progress through fetch + emits init-column', async () => {
+    const tsvBody = (acc: string) =>
+      'Entry\tSubcellular location [CC]\tGO\tReviewed\tGene Names (primary)\n' +
+      `${acc}\tNucleus.\t\treviewed\tGENE1\n`;
+
+    const origFetch = grok.dapi.fetchProxy;
+    (grok.dapi as any).fetchProxy = async (url: string) => {
+      const m = /accession%3A([A-Z0-9]+)/.exec(url);
+      const acc = m ? m[1] : 'TESTE00';
+      return {ok: true, status: 200, text: async () => tsvBody(acc)} as Response;
+    };
+    const restore = patchUserDataStorage({
+      get: async () => ({}),
+      put: async () => {},
+    });
+
+    try {
+      const idCol = DG.Column.fromStrings('Primary Protein ID',
+        ['TESTE01', 'TESTE02', 'TESTE03']);
+      idCol.semType = SEMTYPE.PROTEIN_ID;
+      const df = DG.DataFrame.fromColumns([idCol]);
+
+      const phases: string[] = [];
+      const progress: ProgressCb = (_done, _total, phase) => phases.push(phase);
+
+      await ensureLocationColumn(df, progress);
+
+      expect(phases.includes('fetch-acc'), true,
+        'progress should fire at least once with phase=fetch-acc');
+      expect(phases.includes('init-column'), true,
+        'progress should fire with phase=init-column after bulk-init');
+      // 'init-column' should be the last tick — tests can rely on this for
+      // closing the dialog's pi cleanly.
+      expect(phases[phases.length - 1], 'init-column',
+        'init-column should be the final progress phase');
+    } finally {
+      (grok.dapi as any).fetchProxy = origFetch;
+      restore();
+    }
+  });
+});

package/src/tests/uniprot-panel.ts

@@ -0,0 +1,202 @@
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+import {category, test, expect} from '@datagrok-libraries/test/src/test';
+import {
+  renderUniProtWidget,
+  renderPerGroupBars,
+  findHostDataFrameForProtein,
+} from '../panels/uniprot-panel';
+import {setGroups} from '../analysis/experiment-setup';
+import {SEMTYPE} from '../utils/proteomics-types';
+
+/** Builds a fixture DataFrame mimicking a 4-sample, 3-protein post-DE table.
+ *  Cells indexed by row 0 (first protein P11111) have known values so the
+ *  test can assert mean/SD computation exactly. */
+function makeFixtureDf(opts: {
+  groupColsExist?: boolean;
+  withGroupsTag?: boolean;
+  withProteinId?: boolean;
+  row0AllNan?: boolean;
+} = {}): DG.DataFrame {
+  const {
+    groupColsExist = true,
+    withGroupsTag = true,
+    withProteinId = true,
+    row0AllNan = false,
+  } = opts;
+
+  const cols: DG.Column[] = [];
+  if (withProteinId) {
+    const pid = DG.Column.fromStrings('Primary Protein ID', ['P11111', 'P22222', 'P33333']);
+    pid.semType = SEMTYPE.PROTEIN_ID;
+    cols.push(pid);
+  }
+  if (groupColsExist) {
+    // Row 0 — g1: [1, 3] → mean=2, sd=√2; g2: [5, 7] → mean=6, sd=√2
+    const s1 = row0AllNan ? [NaN, 1.0, 1.0] : [1.0, 1.5, 2.0];
+    const s2 = row0AllNan ? [NaN, 3.0, 1.0] : [3.0, 2.5, 2.5];
+    const s3 = row0AllNan ? [NaN, 4.0, 4.0] : [5.0, 4.0, 5.0];
+    const s4 = row0AllNan ? [NaN, 6.0, 4.0] : [7.0, 6.0, 5.5];
+    const c1 = DG.Column.fromList('double' as DG.ColumnType, 'Sample1', s1);
+    const c2 = DG.Column.fromList('double' as DG.ColumnType, 'Sample2', s2);
+    const c3 = DG.Column.fromList('double' as DG.ColumnType, 'Sample3', s3);
+    const c4 = DG.Column.fromList('double' as DG.ColumnType, 'Sample4', s4);
+    if (row0AllNan) {
+      c1.set(0, null); c2.set(0, null); c3.set(0, null); c4.set(0, null);
+    }
+    cols.push(c1, c2, c3, c4);
+  }
+  const df = DG.DataFrame.fromColumns(cols);
+  if (withGroupsTag && groupColsExist) {
+    setGroups(df, {
+      group1: {name: 'Control', columns: ['Sample1', 'Sample2']},
+      group2: {name: 'Treatment', columns: ['Sample3', 'Sample4']},
+    });
+  }
+  df.name = `panel-fixture-${Math.random().toString(36).slice(2, 8)}`;
+  return df;
+}
+
+/** Mock UniProtEntry compatible with renderUniProtWidget's expected fields. */
+function makeMockEntry(accession: string): any {
+  return {
+    accession,
+    proteinDescription: {recommendedName: {fullName: {value: 'Mock Protein'}}},
+    genes: [{geneName: {value: 'MOCK1'}}],
+    organism: {scientificName: 'Homo sapiens'},
+    comments: [],
+    uniProtKBCrossReferences: [],
+  };
+}
+
+category('Proteomics: 14-04', () => {
+  test('uniprotPanelPerGroupBarsRender', async () => {
+    const df = makeFixtureDf();
+    const tv = grok.shell.addTableView(df);
+    try {
+      const dom = renderUniProtWidget(makeMockEntry('P11111'), 'P11111');
+      // Header
+      expect(dom.textContent?.includes('Per-Group Quantities'), true);
+      // Two SVG rect bars
+      const rects = dom.querySelectorAll('rect');
+      expect(rects.length, 2);
+      // Two `(n=2)` labels
+      const texts = Array.from(dom.querySelectorAll('text'))
+        .map((t) => t.textContent ?? '');
+      const nTwoCount = texts.filter((t) => t.includes('(n=2)')).length;
+      expect(nTwoCount, 2);
+      // Two mean/SD text rows in 0.85em — one per non-empty group. Match on
+      // exact-leaf divs (no nested div children) so the parent container's
+      // concatenated textContent doesn't double-count.
+      const meanLines = Array.from(dom.querySelectorAll('div'))
+        .filter((d) => d.querySelector(':scope > div') === null)
+        .map((d) => d.textContent ?? '')
+        .filter((t) => /mean=.*SD=/.test(t));
+      expect(meanLines.length, 2);
+    } finally {
+      tv.close();
+    }
+  });
+
+  test('uniprotPanelPerGroupBarsEmptyState', async () => {
+    // No groups tag — findHostDataFrameForProtein returns null, so the section is omitted entirely.
+    const df = makeFixtureDf({withGroupsTag: false});
+    const tv = grok.shell.addTableView(df);
+    try {
+      const dom = renderUniProtWidget(makeMockEntry('P11111'), 'P11111');
+      // The section is not even rendered when no host DataFrame is found, so the
+      // SVG rect count is zero and the header is absent.
+      const rects = dom.querySelectorAll('rect');
+      expect(rects.length, 0);
+      expect(dom.textContent?.includes('Per-Group Quantities'), false);
+    } finally {
+      tv.close();
+    }
+  });
+
+  test('uniprotPanelPerGroupBarsColors', async () => {
+    const df = makeFixtureDf();
+    const tv = grok.shell.addTableView(df);
+    try {
+      const dom = renderUniProtWidget(makeMockEntry('P11111'), 'P11111');
+      const rects = dom.querySelectorAll('rect');
+      expect(rects.length, 2);
+      expect(rects[0].getAttribute('fill'), '#FF00FF'); // group1 magenta
+      expect(rects[1].getAttribute('fill'), '#00FFFF'); // group2 cyan
+    } finally {
+      tv.close();
+    }
+  });
+
+  test('uniprotPanelPerGroupMeanSDComputation', async () => {
+    // Custom fixture: row 0 group1=[1,3], group2=[5,7] → mean=2/6, SD=√2≈1.414.
+    const cols: DG.Column[] = [];
+    const pid = DG.Column.fromStrings('Primary Protein ID', ['P11111']);
+    pid.semType = SEMTYPE.PROTEIN_ID;
+    cols.push(pid);
+    cols.push(DG.Column.fromList('double' as DG.ColumnType, 'S1', [1.0]));
+    cols.push(DG.Column.fromList('double' as DG.ColumnType, 'S2', [3.0]));
+    cols.push(DG.Column.fromList('double' as DG.ColumnType, 'S3', [5.0]));
+    cols.push(DG.Column.fromList('double' as DG.ColumnType, 'S4', [7.0]));
+    const df = DG.DataFrame.fromColumns(cols);
+    setGroups(df, {
+      group1: {name: 'Control', columns: ['S1', 'S2']},
+      group2: {name: 'Treatment', columns: ['S3', 'S4']},
+    });
+    df.name = 'mean-sd-fixture';
+    const tv = grok.shell.addTableView(df);
+    try {
+      const dom = renderPerGroupBars(df, 'P11111');
+      expect(dom !== null, true);
+      const meanLines = Array.from(dom!.querySelectorAll('div'))
+        .map((d) => d.textContent ?? '')
+        .filter((t) => /mean=.*SD=/.test(t));
+      // Two non-empty groups produce two mean/SD lines.
+      expect(meanLines.length, 2);
+      // Sample SD (n-1 denominator): variance = ((1-2)^2 + (3-2)^2)/(2-1) = 2 → SD = √2 ≈ 1.41
+      const g1Match = meanLines.find((l) => l.startsWith('Control:'));
+      const g2Match = meanLines.find((l) => l.startsWith('Treatment:'));
+      expect(g1Match !== undefined, true);
+      expect(g2Match !== undefined, true);
+      expect(g1Match!.includes('mean=2.00'), true);
+      expect(g1Match!.includes('SD=1.41'), true);
+      expect(g2Match!.includes('mean=6.00'), true);
+      expect(g2Match!.includes('SD=1.41'), true);
+    } finally {
+      tv.close();
+    }
+  });
+
+  test('uniprotPanelPerGroupBarsAllNanProtein', async () => {
+    const df = makeFixtureDf({row0AllNan: true});
+    const tv = grok.shell.addTableView(df);
+    try {
+      const dom = renderPerGroupBars(df, 'P11111');
+      // Returns the empty-state element (ui.divText), no SVG.
+      expect(dom !== null, true);
+      expect(dom!.tagName.toLowerCase(), 'div');
+      expect((dom!.textContent ?? '').includes('No per-group quantities available'), true);
+      expect(dom!.querySelectorAll('rect').length, 0);
+    } finally {
+      tv.close();
+    }
+  });
+
+  test('findHostDataFrameForProteinPrefersActiveTable', async () => {
+    const df1 = makeFixtureDf();
+    const df2 = makeFixtureDf();
+    const tv1 = grok.shell.addTableView(df1);
+    const tv2 = grok.shell.addTableView(df2);
+    try {
+      // tv2 is the most recently added, so it is active.
+      const host = findHostDataFrameForProtein('P11111');
+      expect(host !== null, true);
+      // Both DFs match — preference is the active one (tv.dataFrame).
+      const activeDf = grok.shell.tv?.dataFrame;
+      expect(host === activeDf, true);
+    } finally {
+      tv1.close();
+      tv2.close();
+    }
+  });
+});