refactor: clean and harden LCMS flow with general codebase cleanup

Author: Nicolass67

src/__tests__/units/components/hplc_viewer.test.js

@@ -0,0 +1,99 @@
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import configureStore from 'redux-mock-store';
+import { Provider } from 'react-redux';
+import { createTheme } from '@mui/material';
+import { ThemeProvider } from '@mui/styles';
+
+import HPLCViewer from '../../../components/hplc_viewer';
+import { LIST_LAYOUT } from '../../../constants/list_layout';
+
+jest.mock('../../../components/cmd_bar/index', () => (props) => (
+  <div data-testid="cmd-bar">
+    {props.editorOnly ? 'editorOnly' : 'editable'}-{props.hideThreshold ? 'hideThreshold' : 'showThreshold'}
+  </div>
+));
+
+jest.mock('../../../components/d3_line_rect/index', () => (props) => (
+  <div data-testid="viewer-line-rect">
+    tic:{props.ticEntities?.length || 0}-uvvis:{props.uvvisEntities?.length || 0}-mz:{props.mzEntities?.length || 0}
+  </div>
+));
+
+jest.mock('../../../components/panel/index', () => (props) => (
+  <div data-testid="panel-viewer">
+    {props.integration ? 'hasIntegration' : 'noIntegration'}
+  </div>
+));
+
+const mockStore = configureStore([]);
+const theme = createTheme();
+
+const renderWithStore = (state, extraProps = {}) => {
+  const store = mockStore(state);
+  return render(
+    <Provider store={store}>
+      <ThemeProvider theme={theme}>
+        <HPLCViewer
+          operations={[]}
+          entityFileNames={[]}
+          userManualLink={{}}
+          molSvg=""
+          theoryMass=""
+          descriptions={[]}
+          canChangeDescription={false}
+          onDescriptionChanged={() => {}}
+          editorOnly={true}
+          {...extraProps}
+        />
+      </ThemeProvider>
+    </Provider>,
+  );
+};
+
+describe('<HPLCViewer />', () => {
+  it('renders empty view when there are no entities', () => {
+    renderWithStore({
+      curve: { listCurves: [], curveIdx: 0 },
+      layout: LIST_LAYOUT.LC_MS,
+      integration: { present: { integrations: [] } },
+      hplcMs: {},
+    });
+
+    expect(screen.queryByTestId('cmd-bar')).not.toBeInTheDocument();
+    expect(screen.queryByTestId('viewer-line-rect')).not.toBeInTheDocument();
+    expect(screen.queryByTestId('panel-viewer')).not.toBeInTheDocument();
+  });
+
+  it('renders LCMS blocks with split entities and selected integration', () => {
+    const entities = [
+      {
+        csCategory: ['tic', 'positive'],
+        feature: { xUnit: 'min', yUnit: 'intensity' },
+        topic: { x: [1, 2], y: [10, 20] },
+      },
+      {
+        csCategory: ['uvvis'],
+        feature: { xUnit: 'nm', yUnit: 'AU' },
+        topic: { x: [210], y: [0.4] },
+      },
+      {
+        csCategory: ['mz', 'negative'],
+        feature: { xUnit: 'm/z', yUnit: 'counts' },
+        topic: { x: [100], y: [5] },
+      },
+    ];
+
+    renderWithStore({
+      curve: { listCurves: entities, curveIdx: 1 },
+      layout: LIST_LAYOUT.LC_MS,
+      integration: { present: { integrations: [null, { id: 'int-2' }, null] } },
+      hplcMs: { tic: { polarity: 'positive' } },
+    });
+
+    expect(screen.getByTestId('cmd-bar')).toHaveTextContent('editorOnly-hideThreshold');
+    expect(screen.getByTestId('viewer-line-rect')).toHaveTextContent('tic:1-uvvis:1-mz:1');
+    expect(screen.getByTestId('panel-viewer')).toHaveTextContent('hasIntegration');
+  });
+});

src/__tests__/units/components/panel/info.test.js

@@ -1,5 +1,5 @@
 import React from "react";
-import { render, screen } from '@testing-library/react'; 
+import { render } from '@testing-library/react'; 
 import InfoPanel from '../../../../components/panel/info';
 import configureStore from 'redux-mock-store'
 import { Provider } from 'react-redux';
@@ -19,7 +19,7 @@ const store = mockStore({
     shifts: [],
   },
   simulation: {
-
+    nmrSimPeaks: [],
   },
   detector: {
     curves: [
@@ -29,10 +29,12 @@ const store = mockStore({
       },
     ],
   },
-  meta: {}
-});
-const failedStore = mockStore({
-
+  meta: {
+    dscMetaData: {},
+  },
+  hplcMs: {
+    uvvis: { spectraList: [], listWaveLength: [] },
+  },
 });
 const dispatchMock = () => Promise.resolve({});
 store.dispatch = jest.fn(dispatchMock);
@@ -43,8 +45,14 @@ const theme = createTheme({
   },
 });
 
-const feature = {
-
+const feature = {};
+const baseProps = {
+  feature,
+  integration: {},
+  editorOnly: false,
+  molSvg: '',
+  descriptions: '',
+  canChangeDescription: false,
 };
 
 describe("<InfoPanel />", () => {
@@ -55,23 +63,11 @@ describe("<InfoPanel />", () => {
     }
   });
 
-  test('Cannot render info panel',  () => {
-    const renderer = 
-      <AppWrapper store={store}>
-        <ThemeProvider theme={theme}>
-          <InfoPanel expand={false} onExapnd={() => {}} />
-        </ThemeProvider>
-      </AppWrapper>
-    ;
-    const {queryByTestId} = render(renderer);
-    expect(queryByTestId('PanelInfo')).not.toBeInTheDocument();
-  });
-
-  test('Render info panel', () => {
+  test('Render info panel',  () => {
     const renderer = 
       <AppWrapper store={store}>
         <ThemeProvider theme={theme}>
-          <InfoPanel expand={false} onExapnd={() => {}} feature={feature} />
+          <InfoPanel expand={false} onExapnd={() => {}} {...baseProps} />
         </ThemeProvider>
       </AppWrapper>
     ;

src/__tests__/units/helpers/extractEntityLCMS.test.tsx

@@ -0,0 +1,151 @@
+import {
+  classify,
+  getLcMsInfo,
+  isLcMsGroup,
+  splitAndReindexEntities,
+} from '../../../helpers/extractEntityLCMS';
+
+describe('extractEntityLCMS helpers', () => {
+  describe('getLcMsInfo', () => {
+    it('prefers explicit lcms fields when present', () => {
+      const entity = {
+        lcmsKind: 'mz',
+        lcmsPolarity: 'negative',
+        csCategory: ['tic positive'],
+      };
+
+      expect(getLcMsInfo(entity)).toEqual({
+        kind: 'mz',
+        polarity: 'negative',
+      });
+    });
+
+    it('detects tic positive from csCategory', () => {
+      const entity = {
+        csCategory: ['mass tic', 'positive mode'],
+      };
+
+      expect(getLcMsInfo(entity)).toEqual({
+        kind: 'tic',
+        polarity: 'positive',
+      });
+    });
+
+    it('detects mz from dataType when categories are missing', () => {
+      const entity = {
+        dataType: 'Mass Spectrum',
+      };
+
+      expect(getLcMsInfo(entity)).toEqual({
+        kind: 'mz',
+        polarity: 'neutral',
+      });
+    });
+
+    it('detects tic from units fallback', () => {
+      const entity = {
+        spectra: [
+          {
+            xUnit: 'Time',
+            yUnit: 'Intensity',
+          },
+        ],
+      };
+
+      expect(getLcMsInfo(entity)).toEqual({
+        kind: 'tic',
+        polarity: 'neutral',
+      });
+    });
+
+    it('returns unknown when no signal can classify entity', () => {
+      expect(getLcMsInfo({})).toEqual({
+        kind: 'unknown',
+        polarity: 'neutral',
+      });
+    });
+  });
+
+  describe('classify', () => {
+    it('returns unknown label for unknown entities', () => {
+      expect(classify({})).toEqual('unknown');
+    });
+
+    it('returns composite label for known entities', () => {
+      expect(classify({ csCategory: ['uvvis', 'positive'] })).toEqual('uvvis_positive');
+    });
+  });
+
+  describe('splitAndReindexEntities', () => {
+    it('splits by kind, sorts by polarity and sets curveIdx', () => {
+      const ticNegative: any = { csCategory: ['tic', 'negative'] };
+      const ticPositive: any = { csCategory: ['tic', 'positive'] };
+      const mzNeutral = { csCategory: ['mz'] };
+      const uvvis = { csCategory: ['uvvis'] };
+      const unknown = {};
+
+      const result = splitAndReindexEntities([
+        ticNegative,
+        ticPositive,
+        mzNeutral,
+        uvvis,
+        unknown,
+      ]);
+
+      expect(result.ticEntities).toHaveLength(2);
+      expect(result.ticEntities[0]).not.toBe(ticPositive);
+      expect(result.ticEntities[1]).not.toBe(ticNegative);
+      expect(result.ticEntities[0]).toMatchObject({ csCategory: ['tic', 'positive'] });
+      expect(result.ticEntities[1]).toMatchObject({ csCategory: ['tic', 'negative'] });
+      expect(result.ticEntities[0].curveIdx).toEqual(0);
+      expect(result.ticEntities[1].curveIdx).toEqual(1);
+
+      expect(result.mzEntities).toHaveLength(1);
+      expect(result.mzEntities[0]).not.toBe(mzNeutral);
+      expect(result.mzEntities[0]).toMatchObject({ csCategory: ['mz'] });
+      expect(result.mzEntities[0].curveIdx).toEqual(0);
+
+      expect(result.uvvisEntities).toEqual([
+        expect.objectContaining({ csCategory: ['uvvis'] }),
+      ]);
+      expect(result.unknownEntities).toEqual([
+        expect.objectContaining({}),
+      ]);
+      expect(result.dataEntities[0]).toMatchObject({ csCategory: ['mz'] });
+      expect(result.allEntities).toHaveLength(5);
+      expect(result.ticEntities[0].lcmsKind).toEqual('tic');
+      expect(result.ticEntities[0].lcmsPolarity).toEqual('positive');
+      expect(ticPositive.lcmsKind).toBeUndefined();
+      expect(ticPositive.lcmsPolarity).toBeUndefined();
+    });
+  });
+
+  describe('isLcMsGroup', () => {
+    it('returns false on empty input', () => {
+      expect(isLcMsGroup([])).toEqual(false);
+      expect(isLcMsGroup(null as any)).toEqual(false);
+    });
+
+    it('returns true when uvvis + tic is present', () => {
+      const entities = [
+        { csCategory: ['uvvis'] },
+        { csCategory: ['tic', 'positive'] },
+      ];
+
+      expect(isLcMsGroup(entities)).toEqual(true);
+    });
+
+    it('returns true when uvvis + mz is present', () => {
+      const entities = [
+        { csCategory: ['uvvis'] },
+        { csCategory: ['mz', 'negative'] },
+      ];
+
+      expect(isLcMsGroup(entities)).toEqual(true);
+    });
+
+    it('returns false when uvvis exists alone', () => {
+      expect(isLcMsGroup([{ csCategory: ['uvvis'] }])).toEqual(false);
+    });
+  });
+});