@datagrok/peptides 1.17.0 → 1.17.2

package/src/tests/table-view.ts

@@ -1,14 +1,16 @@
 import * as DG from 'datagrok-api/dg';
 
-import {category, test, before, expect, delay, after} from '@datagrok-libraries/utils/src/test';
+import {after, awaitCheck, before, category, delay, expect, test} from '@datagrok-libraries/utils/src/test';
 import {_package} from '../package-test';
-import {CLUSTER_TYPE, PeptidesModel} from '../model';
+import {PeptidesModel, VIEWER_TYPE} from '../model';
 import {startAnalysis} from '../widgets/peptides';
-import {scaleActivity} from '../utils/misc';
+import {initSelection, scaleActivity} from '../utils/misc';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {COLUMNS_NAMES, SCALING_METHODS} from '../utils/constants';
 import {TEST_COLUMN_NAMES} from './utils';
 import {showMonomerTooltip} from '../utils/tooltips';
+import {CLUSTER_TYPE, LogoSummaryTable} from '../viewers/logo-summary';
+import {MonomerPosition} from '../viewers/sar-viewer';
 
 category('Table view', () => {
   let df: DG.DataFrame;
@@ -49,7 +51,7 @@ category('Table view', () => {
 
   test('Visible columns', async () => {
     const gridCols = model.analysisView.grid.columns;
-    const posCols = model.positionColumns.toArray().map((col) => col.name);
+    const posCols = model.positionColumns!.map((col) => col.name);
     for (let colIdx = 1; colIdx < gridCols.length; colIdx++) {
       const col = gridCols.byIndex(colIdx)!;
       const tableColName = col.column!.name;
@@ -63,100 +65,108 @@ category('Table view', () => {
   test('Mutation Cliffs selection', async () => {
     const selection = model.df.selection;
 
-    for (const [position, selectedMonomers] of Object.entries(model.mutationCliffsSelection))
+    const mpViewer = model.findViewer(VIEWER_TYPE.MONOMER_POSITION) as MonomerPosition;
+    await awaitCheck(() => mpViewer.mutationCliffs !== null, 'mutation cliffs haven\'t been generated', 2000);
+
+    for (const [position, selectedMonomers] of Object.entries(mpViewer.mutationCliffsSelection))
       expect(selectedMonomers.length, 0, `Selection is not empty for position ${position} after initialization`);
 
     // Select first monomer-position pair
-    model.modifyMutationCliffsSelection(firstPair);
-    expect(model.mutationCliffsSelection[firstPair.positionOrClusterType].includes(firstPair.monomerOrCluster), true,
+    mpViewer.modifyMutationCliffsSelection(firstPair);
+    expect(mpViewer.mutationCliffsSelection[firstPair.positionOrClusterType].includes(firstPair.monomerOrCluster), true,
       `Monomer ${firstPair.monomerOrCluster} is not selected at position ${firstPair.positionOrClusterType}`);
     expect(selection.trueCount, firstPair.mcCount, `Selection count is not equal to ${firstPair.mcCount} ` +
       `for monomer ${firstPair.monomerOrCluster} at position ${firstPair.positionOrClusterType}`);
 
     // Select second monomer-position pair
-    model.modifyMutationCliffsSelection(secondPair, {shiftPressed: true, ctrlPressed: false});
-    expect(model.mutationCliffsSelection[secondPair.positionOrClusterType].includes(secondPair.monomerOrCluster), true,
-      `Monomer ${secondPair.monomerOrCluster} is not selected at position ${secondPair.positionOrClusterType}`);
+    mpViewer.modifyMutationCliffsSelection(secondPair, {shiftPressed: true, ctrlPressed: false});
+    expect(mpViewer.mutationCliffsSelection[secondPair.positionOrClusterType].includes(secondPair.monomerOrCluster),
+      true, `Monomer ${secondPair.monomerOrCluster} is not selected at position ${secondPair.positionOrClusterType}`);
     expect(selection.trueCount, secondPair.mcCount + firstPair.mcCount, `Selection count is not equal ` +
       `to ${secondPair.mcCount + firstPair.mcCount} for monomer ${secondPair.monomerOrCluster} at ` +
       `position ${secondPair.positionOrClusterType}`);
 
     // Deselect second monomer-position pair
-    model.modifyMutationCliffsSelection(secondPair, {shiftPressed: true, ctrlPressed: true});
-    expect(model.mutationCliffsSelection[secondPair.positionOrClusterType].includes(secondPair.monomerOrCluster), false,
-      `Monomer ${secondPair.monomerOrCluster} is still selected at position ${secondPair.positionOrClusterType} after deselection`);
+    mpViewer.modifyMutationCliffsSelection(secondPair, {shiftPressed: true, ctrlPressed: true});
+    expect(mpViewer.mutationCliffsSelection[secondPair.positionOrClusterType].includes(secondPair.monomerOrCluster),
+      false, `Monomer ${secondPair.monomerOrCluster} is still selected at position ` +
+      `${secondPair.positionOrClusterType} after deselection`);
     expect(selection.trueCount, firstPair.mcCount, `Selection count is not equal to ${firstPair.mcCount} ` +
       `for monomer ${firstPair.monomerOrCluster} at position ${firstPair.positionOrClusterType}`);
 
     // Clear monomer-position selection
-    model.initMutationCliffsSelection();
-    for (const [position, selectedMonomers] of Object.entries(model.mutationCliffsSelection)) {
+    mpViewer.mutationCliffsSelection = initSelection(mpViewer.positionColumns);
+    for (const [position, selectedMonomers] of Object.entries(mpViewer.mutationCliffsSelection)) {
       expect(selectedMonomers.length, 0, `Selection is not empty for position ${position} after clearing ` +
         `monomer-position selection`);
     }
     expect(selection.trueCount, 0, `Selection count is not equal to 0 after clearing monomer-position selection`);
 
+    const lstViewer = model.findViewer(VIEWER_TYPE.LOGO_SUMMARY_TABLE) as LogoSummaryTable | null;
+    expect(lstViewer !== null, true, `Couldn't find Logo Summary Table viewer`);
     // Select first cluster
-    model.modifyClusterSelection(firstCluster);
-    expect(model.clusterSelection[firstCluster.positionOrClusterType].includes(firstCluster.monomerOrCluster), true,
-      `Cluster ${firstCluster.monomerOrCluster} is not selected`);
+    lstViewer!.modifyClusterSelection(firstCluster);
+    expect(lstViewer!.clusterSelection[firstCluster.positionOrClusterType].includes(firstCluster.monomerOrCluster),
+      true, `Cluster ${firstCluster.monomerOrCluster} is not selected`);
     expect(selection.trueCount, firstCluster.count, `Selection count is not equal to ${firstCluster.count} for ` +
       `cluster ${firstCluster.monomerOrCluster}`);
 
     // Select second cluster
-    model.modifyClusterSelection(secondCluster, {shiftPressed: true, ctrlPressed: false});
-    expect(model.clusterSelection[secondCluster.positionOrClusterType].includes(secondCluster.monomerOrCluster), true,
-      `Cluster ${secondCluster.monomerOrCluster} is not selected`);
+    lstViewer!.modifyClusterSelection(secondCluster, {shiftPressed: true, ctrlPressed: false});
+    expect(lstViewer!.clusterSelection[secondCluster.positionOrClusterType].includes(secondCluster.monomerOrCluster),
+      true, `Cluster ${secondCluster.monomerOrCluster} is not selected`);
     expect(selection.trueCount, firstCluster.count + secondCluster.count, `Selection count is not equal to ` +
-      `${firstCluster.count + secondCluster.count} for cluster ${firstCluster.monomerOrCluster} and cluster ${secondCluster.monomerOrCluster}`);
+      `${firstCluster.count + secondCluster.count} for cluster ${firstCluster.monomerOrCluster} and cluster 
+      ${secondCluster.monomerOrCluster}`);
 
     // Deselect first cluster
-    model.modifyClusterSelection(firstCluster, {shiftPressed: true, ctrlPressed: true});
-    expect(model.clusterSelection[firstCluster.positionOrClusterType].includes(firstCluster.monomerOrCluster), false,
-      `Cluster ${firstCluster.monomerOrCluster} is still selected after deselection`);
+    lstViewer!.modifyClusterSelection(firstCluster, {shiftPressed: true, ctrlPressed: true});
+    expect(lstViewer!.clusterSelection[firstCluster.positionOrClusterType].includes(firstCluster.monomerOrCluster),
+      false, `Cluster ${firstCluster.monomerOrCluster} is still selected after deselection`);
     expect(selection.trueCount, secondCluster.count, `Selection count is not equal to ${secondCluster.count} for ` +
       `cluster ${secondCluster.monomerOrCluster} after deselection of cluster ${firstCluster.monomerOrCluster}`);
 
     // Clear selection
-    model.initClusterSelection();
-    expect(model.isClusterSelectionEmpty, true, `Selection is not empty after clearing cluster selection`);
+    lstViewer!.initClusterSelection();
+    expect(lstViewer!.isClusterSelectionEmpty, true, `Selection is not empty after clearing cluster selection`);
     expect(selection.trueCount, 0, `Selection count is not equal to 0 after clearing cluster selection`);
   });
 
   test('Invariant Map selection', async () => {
     const selection = model.df.selection;
 
-    for (const [position, filteredMonomers] of Object.entries(model.invariantMapSelection))
+    for (const [position, filteredMonomers] of Object.entries(model.webLogoSelection))
       expect(filteredMonomers.length, 0, `Filter is not empty for position ${position} after initialization`);
 
     // Select by second monomer-position pair
-    model.modifyInvariantMapSelection(secondPair);
-    expect(model.invariantMapSelection[secondPair.positionOrClusterType].includes(secondPair.monomerOrCluster), true,
+    model.modifyWebLogoSelection(secondPair);
+    expect(model.webLogoSelection[secondPair.positionOrClusterType].includes(secondPair.monomerOrCluster), true,
       `Monomer ${secondPair.monomerOrCluster} is not filtered at position ${secondPair.positionOrClusterType}`);
     expect(selection.trueCount, secondPair.imCount, `Filter count is not equal to ${secondPair.imCount} ` +
       `for monomer ${secondPair.monomerOrCluster} at position ${secondPair.positionOrClusterType}`);
 
     // Select by first monomer-position pair
-    model.modifyInvariantMapSelection(firstPair, {shiftPressed: true, ctrlPressed: false});
-    expect(model.invariantMapSelection[firstPair.positionOrClusterType].includes(firstPair.monomerOrCluster), true,
+    model.modifyWebLogoSelection(firstPair, {shiftPressed: true, ctrlPressed: false});
+    expect(model.webLogoSelection[firstPair.positionOrClusterType].includes(firstPair.monomerOrCluster), true,
       `Monomer ${firstPair.monomerOrCluster} is not filtered at position ${firstPair.positionOrClusterType}`);
     expect(selection.trueCount, secondPair.imCount, `Filter count is not equal to ${secondPair.imCount} ` +
       `for monomer ${firstPair.monomerOrCluster} at position ${firstPair.positionOrClusterType}`);
 
     // Deselect filter for second monomer-position pair
-    model.modifyInvariantMapSelection(secondPair, {shiftPressed: true, ctrlPressed: true});
-    expect(model.invariantMapSelection[secondPair.positionOrClusterType].includes(secondPair.monomerOrCluster), false,
-      `Monomer ${secondPair.monomerOrCluster} is still filtered at position ${secondPair.positionOrClusterType} after ` +
-      `deselection`);
+    model.modifyWebLogoSelection(secondPair, {shiftPressed: true, ctrlPressed: true});
+    expect(model.webLogoSelection[secondPair.positionOrClusterType].includes(secondPair.monomerOrCluster),
+      false, `Monomer ${secondPair.monomerOrCluster} is still filtered at position 
+      ${secondPair.positionOrClusterType} after deselection`);
     expect(selection.trueCount, firstPair.imCount, `Filter count is not equal to ${firstPair.imCount} ` +
       `for monomer ${firstPair.monomerOrCluster} at position ${firstPair.positionOrClusterType} after deselection of ` +
       `monomer ${secondPair.monomerOrCluster} at position ${secondPair.positionOrClusterType}`);
 
     // Clear selection
-    model.initInvariantMapSelection();
+    expect(model.positionColumns !== null, true, `Position columns are not initialized`);
+    model.webLogoSelection = initSelection(model.positionColumns!);
     expect(selection.trueCount, 0, `Filter count is not equal to ${0} after clearing monomer-position filter`);
 
-    for (const [position, filteredMonomers] of Object.entries(model.invariantMapSelection)) {
+    for (const [position, filteredMonomers] of Object.entries(model.webLogoSelection)) {
       expect(filteredMonomers.length, 0, `Filter is not empty for position ${position} after clearing ` +
         `monomer-position filter`);
     }

package/src/tests/utils.ts

@@ -1,81 +1,5 @@
-import * as DG from 'datagrok-api/dg';
-
-import {expect} from '@datagrok-libraries/utils/src/test';
-import {PeptideSimilaritySpaceWidget, createPeptideSimilaritySpaceViewer} from '../utils/peptide-similarity-space';
-import {
-  createDimensinalityReducingWorker,
-} from '@datagrok-libraries/ml/src/workers/dimensionality-reducing-worker-creator';
-import {StringMetrics} from '@datagrok-libraries/ml/src/typed-metrics';
-import {IReduceDimensionalityResult} from '@datagrok-libraries/ml/src/reduce-dimensionality';
-
 export enum TEST_COLUMN_NAMES {
   SEQUENCE = 'sequence',
   ACTIVITY = 'activity',
   CLUSTER = 'cluster',
 }
-
-/**
- * Tests if a table has non zero rows and columns.
- *
- * @param {DG.DataFrame} table Target table.
- */
-export function _testTableIsNotEmpty(table: DG.DataFrame): void {
-  expect(table.columns.length > 0 && table.rowCount > 0, true);
-}
-
-/**
- * Tests if peptide space viewer is drawing without exceptions.
- *
- * @param {DG.DataFrame} table Demo table.
- * @param {DG.TableView} view Demo view.
- */
-export async function _testViewerIsDrawing(table: DG.DataFrame, view: DG.TableView): Promise<void> {
-  const widget = new PeptideSimilaritySpaceWidget(table.getCol('AlignedSequence'), view);
-  await widget.draw();
-}
-
-/**
- * Tests if dimensionality reducer works for both the method and the measure chosen.
- *
- * @param {Array<string>} columnData Strings to process.
- * @param {string} method Embedding method.
- * @param {string} measure Measure to apply to a pair of strings.
- */
-export async function _testDimensionalityReducer(
-  columnData: Array<string>, method: StringMetrics, measure: string): Promise<void> {
-  const cyclesCount = 100;
-
-  const reduceDimRes: IReduceDimensionalityResult = await createDimensinalityReducingWorker(
-    {data: columnData, metric: measure as StringMetrics}, method, {cycles: cyclesCount});
-  const embcols = reduceDimRes.embedding;
-
-  const [X, Y] = embcols as Array<Float32Array>;
-
-  expect(X.every((v) => v !== null && !Number.isNaN(v)), true);
-  expect(Y.every((v) => v !== null && !Number.isNaN(v)), true);
-}
-
-/**
- * Tests if PeptideSimilaritySpaceViewer works for both the method and the measure chosen.
- *
- * @export
- * @param {DG.DataFrame} table Table.
- * @param {DG.Column} alignedSequencesColumn Aligned sequences column.
- * @param {string} method Embedding method.
- * @param {string} measure Strings similarity measure.
- * @param {number} cyclesCount Number of embedding iterations.
- * @param {(DG.TableView | null)} view Viewer to show graphics on.
- * @param {(string | null)} [activityColumnName] Name of column with activity.
- */
-export async function _testPeptideSimilaritySpaceViewer(table: DG.DataFrame, alignedSequencesColumn: DG.Column,
-  method: string, measure: string, cyclesCount: number): Promise<void> {
-  const viewer = await createPeptideSimilaritySpaceViewer(
-    table, method, measure, cyclesCount, alignedSequencesColumn, undefined);
-  const df = viewer.dataFrame;
-
-  const axesNames = ['~X', '~Y', '~MW'];
-  const axes = axesNames.map((v) => df.getCol(v).getRawData() as Float32Array);
-
-  for (const ax of axes)
-    expect(ax.every((v) => v !== null && !Number.isNaN(v)), true);
-}

package/src/tests/viewers.ts

@@ -1,26 +1,31 @@
 import * as DG from 'datagrok-api/dg';
 
 import {after, before, category, delay, expect, test, testViewer} from '@datagrok-libraries/utils/src/test';
-import {aligned1} from './test-data';
-import {CLUSTER_TYPE, PeptidesModel, VIEWER_TYPE} from '../model';
+import {PeptidesModel, VIEWER_TYPE} from '../model';
 import {_package} from '../package-test';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {scaleActivity} from '../utils/misc';
 import {startAnalysis} from '../widgets/peptides';
-import {SELECTION_MODE, MonomerPosition, MostPotentResidues} from '../viewers/sar-viewer';
+import {MonomerPosition, MostPotentResidues, SELECTION_MODE} from '../viewers/sar-viewer';
 import {SCALING_METHODS} from '../utils/constants';
-import {LST_PROPERTIES, LogoSummaryTable} from '../viewers/logo-summary';
+import {CLUSTER_TYPE, LogoSummaryTable, LST_PROPERTIES} from '../viewers/logo-summary';
 import {PositionHeight} from '@datagrok-libraries/bio/src/viewers/web-logo';
 import {TEST_COLUMN_NAMES} from './utils';
 import {showTooltip} from '../utils/tooltips';
 
 category('Viewers: Basic', () => {
-  const df = DG.DataFrame.fromCsv(aligned1);
+  let df: DG.DataFrame;
+
+  before(async () => {
+    df = DG.DataFrame.fromCsv(await _package.files.readAsText('tests/HELM_small.csv'));
+    await delay(500);
+  });
+
   const viewers = DG.Func.find({package: 'Peptides', tags: ['viewer']}).map((f) => f.friendlyName);
   for (const v of viewers) {
     test(v, async () => {
-      await testViewer(v, df.clone(), {detectSemanticTypes: true});
-    }, {skipReason: 'GROK-11534'});
+      await testViewer(v, df.clone(), {detectSemanticTypes: true, arbitraryDfTest: false});
+    });
   }
 });
 
@@ -57,8 +62,13 @@ category('Viewers: Monomer-Position', () => {
     const cellCoordinates = {col: '9', row: 6};
     const gc = mpViewer.viewerGrid.cell(cellCoordinates.col, cellCoordinates.row);
     const mp = mpViewer.getMonomerPosition(gc);
-    expect(showTooltip(model.df, model.settings.columns!, {monomerPosition: mp, x: 0, y: 0, mpStats: model.monomerPositionStats}),
-      true, `Tooltip is not shown for grid cell at column '${cellCoordinates.col}', row ${cellCoordinates.row}`);
+    expect(showTooltip(model.df, activityCol, Object.entries(model!.settings!.columns!), {
+      monomerPosition: mp,
+      x: 0,
+      y: 0,
+      mpStats: model!.monomerPositionStats!,
+    }),
+    true, `Tooltip is not shown for grid cell at column '${cellCoordinates.col}', row ${cellCoordinates.row}`);
   });
 
   test('Modes', async () => {
@@ -111,8 +121,13 @@ category('Viewers: Most Potent Residues', () => {
     const cellCoordinates = {col: 'Diff', row: 6};
     const gc = mprViewer.viewerGrid.cell(cellCoordinates.col, cellCoordinates.row);
     const mp = mprViewer.getMonomerPosition(gc);
-    expect(showTooltip(model.df, model.settings.columns!, {monomerPosition: mp, x: 0, y: 0, mpStats: model.monomerPositionStats}),
-      true, `Tooltip is not shown for grid cell at column '${cellCoordinates.col}', row ${cellCoordinates.row}`);
+    expect(showTooltip(model.df, activityCol, Object.entries(model!.settings!.columns!), {
+      monomerPosition: mp,
+      x: 0,
+      y: 0,
+      mpStats: model!.monomerPositionStats!,
+    }),
+    true, `Tooltip is not shown for grid cell at column '${cellCoordinates.col}', row ${cellCoordinates.row}`);
   });
 });
 
@@ -165,7 +180,10 @@ category('Viewers: Logo Summary Table', () => {
 
   test('Tooltip', async () => {
     const cluster = '0';
-    const tooltipElement = lstViewer.showTooltip({monomerOrCluster: cluster, positionOrClusterType: CLUSTER_TYPE.ORIGINAL}, 0, 0);
+    const tooltipElement = lstViewer.showTooltip({
+      monomerOrCluster: cluster,
+      positionOrClusterType: CLUSTER_TYPE.ORIGINAL,
+    }, 0, 0);
     expect(tooltipElement !== null, true, `Tooltip is not shown for cluster '${cluster}'`);
   });
 }, {clear: false});

package/src/tests/widgets.ts

@@ -1,19 +1,20 @@
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 
-import {category, test, before, expect, delay, after} from '@datagrok-libraries/utils/src/test';
+import {after, before, category, delay, expect, test} from '@datagrok-libraries/utils/src/test';
 import {_package} from '../package-test';
-import {CLUSTER_TYPE, PeptidesModel, VIEWER_TYPE} from '../model';
+import {PeptidesModel, VIEWER_TYPE} from '../model';
 import {scaleActivity} from '../utils/misc';
 import {startAnalysis} from '../widgets/peptides';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import * as C from '../utils/constants';
-import {PANES_INPUTS, SETTINGS_PANES, getSettingsDialog} from '../widgets/settings';
+import {getSettingsDialog, PANES_INPUTS, SETTINGS_PANES} from '../widgets/settings';
 import {getDistributionWidget} from '../widgets/distribution';
 import {mutationCliffsWidget} from '../widgets/mutation-cliffs';
 import {TEST_COLUMN_NAMES} from './utils';
 import wu from 'wu';
-import {LogoSummaryTable} from '../viewers/logo-summary';
+import {CLUSTER_TYPE, LogoSummaryTable} from '../viewers/logo-summary';
+import {MonomerPosition} from '../viewers/sar-viewer';
 
 category('Widgets: Settings', () => {
   let df: DG.DataFrame;
@@ -88,7 +89,14 @@ category('Widgets: Distribution panel', () => {
   after(async () => await delay(3000));
 
   test('UI', async () => {
-    getDistributionWidget(model.df, model);
+    model.df.selection.set(0, true);
+    await delay(1000);
+    const lstViewer = model.findViewer(VIEWER_TYPE.LOGO_SUMMARY_TABLE) as LogoSummaryTable | null;
+    getDistributionWidget(model.df, {
+      peptideSelection: DG.BitSet.create(model.df.rowCount), columns: model.settings!.columns!,
+      activityCol: scaledActivityCol, clusterSelection: lstViewer!.clusterSelection, clusterColName: clusterCol.name,
+      monomerPositionSelection: model.webLogoSelection,
+    });
   });
 });
 
@@ -120,7 +128,18 @@ category('Widgets: Mutation cliffs', () => {
   after(async () => await delay(3000));
 
   test('UI', async () => {
-    mutationCliffsWidget(model.df, model);
+    const sarViewer = model.findViewer(VIEWER_TYPE.MONOMER_POSITION) as MonomerPosition;
+    sarViewer.keyPressed = true; //required to emulate cell selection
+    sarViewer._viewerGrid!.dataFrame.currentCell = sarViewer._viewerGrid?.dataFrame.cell(0, '1')!;
+    await delay(1000);
+    mutationCliffsWidget(model.df, {
+      mutationCliffs: sarViewer.mutationCliffs!,
+      mutationCliffsSelection: sarViewer.mutationCliffsSelection,
+      gridColumns: model.analysisView.grid.columns,
+      sequenceColumnName: sarViewer.sequenceColumnName,
+      positionColumns: sarViewer.positionColumns,
+      activityCol: scaledActivityCol,
+    });
   });
 });
 
@@ -165,7 +184,7 @@ category('Widgets: Actions', () => {
     const currentTable = grok.shell.t;
 
     expect(currentTable.getTag(C.TAGS.MULTIPLE_VIEWS), '1', 'Current table is expected to have multiple views tag');
-    expect(currentTable.getTag(C.TAGS.UUID), newViewId, 'Current table is expected to have the same UUID as new view');
+    expect(currentTable.getTag(DG.TAGS.ID), newViewId, 'Current table is expected to have the same UUID as new view');
     expect(currentTable.rowCount, 1, 'Current table is expected to have 1 row');
 
     await delay(500);
@@ -189,11 +208,11 @@ category('Widgets: Actions', () => {
       throw new Error('Logo summary table viewer is not found');
 
     // Check that custom clusters are not created yet
-    expect(wu(model.customClusters).toArray().length, 0, 'Expected to have 0 custom clusters before creating one');
+    expect(wu(lstViewer.customClusters).toArray().length, 0, 'Expected to have 0 custom clusters before creating one');
 
     // Create custom cluster
     lstViewer.clusterFromSelection();
-    const customClusterList = wu(model.customClusters).toArray();
+    const customClusterList = wu(lstViewer.customClusters).toArray();
     expect(customClusterList.length, 1, 'Expected to have 1 custom cluster');
     const clustName = customClusterList[0].name;
     expect(model.df.col(clustName) !== null, true, 'Expected to have custom cluster column in the table');
@@ -201,9 +220,9 @@ category('Widgets: Actions', () => {
       'Expected to have custom cluster in the Logo Summary Table');
 
     // Remove custom cluster
-    model.modifyClusterSelection({monomerOrCluster: clustName, positionOrClusterType: CLUSTER_TYPE.CUSTOM});
+    lstViewer.modifyClusterSelection({monomerOrCluster: clustName, positionOrClusterType: CLUSTER_TYPE.CUSTOM});
     lstViewer.removeCluster();
-    expect(wu(model.customClusters).toArray().length, 0, 'Expected to have 0 custom clusters after removing one');
+    expect(wu(lstViewer.customClusters).toArray().length, 0, 'Expected to have 0 custom clusters after removing one');
     expect(model.df.col(clustName) === null, true,
       'Expected to have no custom cluster column in the table');
     expect(lstViewer.viewerGrid.table.getCol(C.LST_COLUMN_NAMES.CLUSTER).categories.indexOf(clustName) === -1, true,