Add algorithm test for exareme

api/src/engine/connectors/exareme/tests/e2e/k-means.e2e-spec.ts

@@ -78,7 +78,7 @@ describe('ExaremeService', () => {
 
       expect(
         data.rawdata['data'][0]['leftacgganteriorcingulategyrus'],
-      ).toBeCloseTo(4.197, 3);
+      ).toBeCloseTo(4.197, 2);
     });
   });
 });

api/src/engine/connectors/exareme/tests/e2e/naive-bayes.e2e-spec.ts

 import { Test, TestingModule } from '@nestjs/testing';
-import { RawResult } from 'src/engine/models/result/raw-result.model';
 import { AppModule } from '../../../../../main/app.module';
 import { ENGINE_SERVICE } from '../../../../engine.constants';
 import { IEngineService } from '../../../../engine.interfaces';
 import { ExperimentCreateInput } from '../../../../models/experiment/input/experiment-create.input';
+import { RawResult } from '../../../../models/result/raw-result.model';
 import {
   createExperiment,
   generateNumber,

api/src/engine/connectors/exareme/tests/e2e/one-way-anova.e2e-spec.ts

+import { Test, TestingModule } from '@nestjs/testing';
+import { AppModule } from '../../../../../main/app.module';
+import { ENGINE_SERVICE } from '../../../../engine.constants';
+import { IEngineService } from '../../../../engine.interfaces';
+import { ExperimentCreateInput } from '../../../../models/experiment/input/experiment-create.input';
+import { RawResult } from '../../../../models/result/raw-result.model';
+import {
+  createExperiment,
+  generateNumber,
+  TEST_PATHOLOGIES,
+  TIMEOUT_DURATION_SECONDS,
+  waitForResult,
+} from '../../interfaces/test-utilities';
+
+jest.setTimeout(1000 * TIMEOUT_DURATION_SECONDS);
+
+describe('ExaremeService', () => {
+  let exaremeService: IEngineService;
+
+  beforeEach(async () => {
+    const moduleRef: TestingModule = await Test.createTestingModule({
+      imports: [AppModule],
+    }).compile();
+
+    exaremeService = await moduleRef.resolve<IEngineService>(ENGINE_SERVICE);
+  });
+  const modelSlug = `anova-1way-${generateNumber()}`;
+  const algorithmId = 'ANOVA_ONEWAY';
+
+  const input: ExperimentCreateInput = {
+    name: modelSlug,
+    variables: ['lefthippocampus'],
+    coVariables: ['ppmicategory'],
+    datasets: TEST_PATHOLOGIES.dementia.datasets
+      .filter((d) => d.code === 'ppmi')
+      .map((d) => d.code),
+    domain: TEST_PATHOLOGIES.dementia.code,
+    algorithm: {
+      id: algorithmId,
+      type: 'string',
+      parameters: [],
+    },
+    filter: '',
+  };
+
+  describe('Integration Test for experiment API', () => {
+    it(`create ${algorithmId}`, async () => {
+      const experiment = await createExperiment(input, exaremeService);
+
+      expect(experiment).toBeTruthy();
+      expect(experiment?.status).toStrictEqual('pending');
+
+      expect(experiment?.id).toBeTruthy();
+
+      const experimentResult = await waitForResult(
+        experiment?.id ?? '',
+        exaremeService,
+      );
+
+      expect(experimentResult).toBeTruthy();
+      expect(experimentResult.status).toStrictEqual('success');
+      expect(experimentResult.results.length).toBeGreaterThanOrEqual(4);
+    });
+  });
+});

api/src/engine/connectors/exareme/tests/e2e/pca.e2e-spec.ts

+import { Test, TestingModule } from '@nestjs/testing';
+import { AppModule } from '../../../../../main/app.module';
+import { ENGINE_SERVICE } from '../../../../engine.constants';
+import { IEngineService } from '../../../../engine.interfaces';
+import { ExperimentCreateInput } from '../../../../models/experiment/input/experiment-create.input';
+import { RawResult } from '../../../../models/result/raw-result.model';
+import {
+  createExperiment,
+  generateNumber,
+  TEST_PATHOLOGIES,
+  TIMEOUT_DURATION_SECONDS,
+  waitForResult,
+} from '../../interfaces/test-utilities';
+
+jest.setTimeout(1000 * TIMEOUT_DURATION_SECONDS);
+
+describe('ExaremeService', () => {
+  let exaremeService: IEngineService;
+
+  beforeEach(async () => {
+    const moduleRef: TestingModule = await Test.createTestingModule({
+      imports: [AppModule],
+    }).compile();
+
+    exaremeService = await moduleRef.resolve<IEngineService>(ENGINE_SERVICE);
+  });
+  const modelSlug = `pca-${generateNumber()}`;
+  const algorithmId = 'PCA';
+
+  const input: ExperimentCreateInput = {
+    name: modelSlug,
+    variables: ['lefthippocampus', 'rightthalamusproper', 'leftthalamusproper'],
+    coVariables: ['alzheimerbroadcategory'],
+    datasets: TEST_PATHOLOGIES.dementia.datasets
+      .filter((d) => d.code !== 'fake_longitudinal')
+      .map((d) => d.code),
+    domain: TEST_PATHOLOGIES.dementia.code,
+    algorithm: {
+      id: algorithmId,
+      type: 'string',
+      parameters: [
+        { id: 'standardize', value: ['false'] },
+        { id: 'coding', value: ['null'] },
+      ],
+    },
+    filter: '',
+  };
+
+  describe('Integration Test for experiment API', () => {
+    it(`create ${algorithmId}`, async () => {
+      const experiment = await createExperiment(input, exaremeService);
+
+      expect(experiment).toBeTruthy();
+      expect(experiment?.status).toStrictEqual('pending');
+
+      expect(experiment?.id).toBeTruthy();
+
+      const experimentResult = await waitForResult(
+        experiment?.id ?? '',
+        exaremeService,
+      );
+
+      expect(experimentResult).toBeTruthy();
+      expect(experimentResult.status).toStrictEqual('success');
+      expect(experimentResult.results.length).toBeGreaterThanOrEqual(4);
+      const data = experimentResult.results[0] as RawResult;
+
+      expect(data.rawdata['data']['eigenvalues'][1]).toBeCloseTo(0.433, 3);
+    });
+  });
+});

api/src/engine/connectors/exareme/tests/e2e/pearson-correlation.e2e-spec.ts

+import { Test, TestingModule } from '@nestjs/testing';
+import { AppModule } from '../../../../../main/app.module';
+import { ENGINE_SERVICE } from '../../../../engine.constants';
+import { IEngineService } from '../../../../engine.interfaces';
+import { ExperimentCreateInput } from '../../../../models/experiment/input/experiment-create.input';
+import { RawResult } from '../../../../models/result/raw-result.model';
+import {
+  createExperiment,
+  generateNumber,
+  TEST_PATHOLOGIES,
+  TIMEOUT_DURATION_SECONDS,
+  waitForResult,
+} from '../../interfaces/test-utilities';
+
+jest.setTimeout(1000 * TIMEOUT_DURATION_SECONDS);
+
+describe('ExaremeService', () => {
+  let exaremeService: IEngineService;
+
+  beforeEach(async () => {
+    const moduleRef: TestingModule = await Test.createTestingModule({
+      imports: [AppModule],
+    }).compile();
+
+    exaremeService = await moduleRef.resolve<IEngineService>(ENGINE_SERVICE);
+  });
+  const modelSlug = `pearson-${generateNumber()}`;
+  const algorithmId = 'PEARSON_CORRELATION';
+
+  const input: ExperimentCreateInput = {
+    name: modelSlug,
+    variables: ['righthippocampus'],
+    coVariables: ['lefthippocampus'],
+    datasets: TEST_PATHOLOGIES.dementia.datasets
+      .filter((d) => d.code !== 'fake_longitudinal')
+      .map((d) => d.code),
+    domain: TEST_PATHOLOGIES.dementia.code,
+    algorithm: {
+      id: algorithmId,
+      type: 'string',
+      parameters: [
+        { id: 'standardize', value: ['false'] },
+        { id: 'coding', value: ['null'] },
+      ],
+    },
+    filter: '',
+  };
+
+  describe('Integration Test for experiment API', () => {
+    it(`create ${algorithmId}`, async () => {
+      const experiment = await createExperiment(input, exaremeService);
+
+      expect(experiment).toBeTruthy();
+      expect(experiment?.status).toStrictEqual('pending');
+
+      expect(experiment?.id).toBeTruthy();
+
+      const experimentResult = await waitForResult(
+        experiment?.id ?? '',
+        exaremeService,
+      );
+
+      expect(experimentResult).toBeTruthy();
+      expect(experimentResult.status).toStrictEqual('success');
+      expect(experimentResult.results.length).toBeGreaterThanOrEqual(2);
+      const data = experimentResult.results[0] as RawResult;
+
+      expect(
+        data.rawdata['data']['Pearson correlation coefficient'][0][0],
+      ).toBeCloseTo(0.924, 3);
+    });
+  });
+});

api/src/engine/connectors/exareme/tests/e2e/t-test-independant.e2e-spec.ts

+import { Test, TestingModule } from '@nestjs/testing';
+import { AppModule } from '../../../../../main/app.module';
+import { ENGINE_SERVICE } from '../../../../engine.constants';
+import { IEngineService } from '../../../../engine.interfaces';
+import { ExperimentCreateInput } from '../../../../models/experiment/input/experiment-create.input';
+import { RawResult } from '../../../../models/result/raw-result.model';
+import {
+  createExperiment,
+  generateNumber,
+  TEST_PATHOLOGIES,
+  TIMEOUT_DURATION_SECONDS,
+  waitForResult,
+} from '../../interfaces/test-utilities';
+
+jest.setTimeout(1000 * TIMEOUT_DURATION_SECONDS);
+
+describe('ExaremeService', () => {
+  let exaremeService: IEngineService;
+
+  beforeEach(async () => {
+    const moduleRef: TestingModule = await Test.createTestingModule({
+      imports: [AppModule],
+    }).compile();
+
+    exaremeService = await moduleRef.resolve<IEngineService>(ENGINE_SERVICE);
+  });
+  const modelSlug = `ttest-idp-${generateNumber()}`;
+  const algorithmId = 'TTEST_INDEPENDENT';
+
+  const input: ExperimentCreateInput = {
+    name: modelSlug,
+    variables: [
+      'rightpcggposteriorcingulategyrus',
+      'leftpcggposteriorcingulategyrus',
+      'rightacgganteriorcingulategyrus',
+      'leftacgganteriorcingulategyrus',
+      'rightmcggmiddlecingulategyrus',
+      'leftmcggmiddlecingulategyrus',
+      'rightphgparahippocampalgyrus',
+    ],
+    coVariables: ['gender'],
+    datasets: TEST_PATHOLOGIES.dementia.datasets
+      .filter((d) => d.code !== 'fake_longitudinal')
+      .map((d) => d.code),
+    domain: TEST_PATHOLOGIES.dementia.code,
+    algorithm: {
+      id: algorithmId,
+      type: 'string',
+      parameters: [
+        {
+          id: 'xlevels',
+          value: ['M', 'F'],
+        },
+        {
+          id: 'testvalue',
+          value: ['3.0'],
+        },
+        {
+          id: 'hypothesis',
+          value: ['greaterthan'],
+        },
+        {
+          id: 'effectsize',
+          value: ['1'],
+        },
+        {
+          id: 'ci',
+          value: ['1'],
+        },
+        {
+          id: 'meandiff',
+          value: ['1'],
+        },
+      ],
+    },
+    filter: '',
+  };
+
+  describe('Integration Test for experiment API', () => {
+    it(`create ${algorithmId}`, async () => {
+      const experiment = await createExperiment(input, exaremeService);
+
+      expect(experiment).toBeTruthy();
+      expect(experiment?.status).toStrictEqual('pending');
+
+      expect(experiment?.id).toBeTruthy();
+
+      const experimentResult = await waitForResult(
+        experiment?.id ?? '',
+        exaremeService,
+      );
+
+      expect(experimentResult).toBeTruthy();
+      expect(experimentResult.status).toStrictEqual('success');
+      expect(experimentResult.results.length).toBeGreaterThanOrEqual(1);
+      const data = experimentResult.results[0] as RawResult;
+
+      expect(data.rawdata['data'][0]['t_value']).toBeCloseTo(18.477, 3);
+    });
+  });
+});

api/src/engine/connectors/exareme/tests/e2e/t-test-one-sample.e2e-spec.ts

+import { Test, TestingModule } from '@nestjs/testing';
+import { AppModule } from '../../../../../main/app.module';
+import { ENGINE_SERVICE } from '../../../../engine.constants';
+import { IEngineService } from '../../../../engine.interfaces';
+import { ExperimentCreateInput } from '../../../../models/experiment/input/experiment-create.input';
+import { RawResult } from '../../../../models/result/raw-result.model';
+import {
+  createExperiment,
+  generateNumber,
+  TEST_PATHOLOGIES,
+  TIMEOUT_DURATION_SECONDS,
+  waitForResult,
+} from '../../interfaces/test-utilities';
+
+jest.setTimeout(1000 * TIMEOUT_DURATION_SECONDS);
+
+describe('ExaremeService', () => {
+  let exaremeService: IEngineService;
+
+  beforeEach(async () => {
+    const moduleRef: TestingModule = await Test.createTestingModule({
+      imports: [AppModule],
+    }).compile();
+
+    exaremeService = await moduleRef.resolve<IEngineService>(ENGINE_SERVICE);
+  });
+  const modelSlug = `ttest-1s-${generateNumber()}`;
+  const algorithmId = 'TTEST_ONESAMPLE';
+
+  const input: ExperimentCreateInput = {
+    name: modelSlug,
+    variables: ['righthippocampus', 'lefthippocampus'],
+    coVariables: ['gender', ' alzheimerbroadcategory'],
+    datasets: TEST_PATHOLOGIES.dementia.datasets
+      .filter((d) => d.code !== 'fake_longitudinal')
+      .map((d) => d.code),
+    domain: TEST_PATHOLOGIES.dementia.code,
+    algorithm: {
+      id: algorithmId,
+      type: 'string',
+      parameters: [
+        {
+          id: 'testvalue',
+          value: ['3.0'],
+        },
+        {
+          id: 'hypothesis',
+          value: ['different'],
+        },
+        {
+          id: 'effectsize',
+          value: ['1'],
+        },
+        {
+          id: 'ci',
+          value: ['1'],
+        },
+        {
+          id: 'meandiff',
+          value: ['1'],
+        },
+      ],
+    },
+    filter: '',
+  };
+
+  describe('Integration Test for experiment API', () => {
+    it(`create ${algorithmId}`, async () => {
+      const experiment = await createExperiment(input, exaremeService);
+
+      expect(experiment).toBeTruthy();
+      expect(experiment?.status).toStrictEqual('pending');
+
+      expect(experiment?.id).toBeTruthy();
+
+      const experimentResult = await waitForResult(
+        experiment?.id ?? '',
+        exaremeService,
+      );
+
+      expect(experimentResult).toBeTruthy();
+      expect(experimentResult.status).toStrictEqual('success');
+      expect(experimentResult.results.length).toBeGreaterThanOrEqual(1);
+      const data = experimentResult.results[0] as RawResult;
+
+      expect(data.rawdata['data'][0]['t_value']).toBeCloseTo(8.155, 3);
+    });
+  });
+});

api/src/engine/connectors/exareme/tests/e2e/t-test-paired.e2e-spec.ts

+import { Test, TestingModule } from '@nestjs/testing';
+import { AppModule } from '../../../../../main/app.module';
+import { ENGINE_SERVICE } from '../../../../engine.constants';
+import { IEngineService } from '../../../../engine.interfaces';
+import { ExperimentCreateInput } from '../../../../models/experiment/input/experiment-create.input';
+import { RawResult } from '../../../../models/result/raw-result.model';
+import {
+  createExperiment,
+  generateNumber,
+  TEST_PATHOLOGIES,
+  TIMEOUT_DURATION_SECONDS,
+  waitForResult,
+} from '../../interfaces/test-utilities';
+
+jest.setTimeout(1000 * TIMEOUT_DURATION_SECONDS);
+
+describe('ExaremeService', () => {
+  let exaremeService: IEngineService;
+
+  beforeEach(async () => {
+    const moduleRef: TestingModule = await Test.createTestingModule({
+      imports: [AppModule],
+    }).compile();
+
+    exaremeService = await moduleRef.resolve<IEngineService>(ENGINE_SERVICE);
+  });
+  const modelSlug = `ttest-paired-${generateNumber()}`;
+  const algorithmId = 'TTEST_PAIRED';
+
+  const input: ExperimentCreateInput = {
+    name: modelSlug,
+    variables: ['lefthippocampus', 'righthippocampus'],
+    datasets: TEST_PATHOLOGIES.dementia.datasets
+      .filter((d) => d.code !== 'fake_longitudinal')
+      .map((d) => d.code),
+    domain: TEST_PATHOLOGIES.dementia.code,
+    algorithm: {
+      id: algorithmId,
+      type: 'string',
+      parameters: [
+        {
+          id: 'hypothesis',
+          value: ['different'],
+        },
+      ],
+    },
+    filter: '',
+  };
+
+  describe('Integration Test for experiment API', () => {
+    it(`create ${algorithmId}`, async () => {
+      const experiment = await createExperiment(input, exaremeService);
+
+      expect(experiment).toBeTruthy();
+      expect(experiment?.status).toStrictEqual('pending');
+
+      expect(experiment?.id).toBeTruthy();
+
+      const experimentResult = await waitForResult(
+        experiment?.id ?? '',
+        exaremeService,
+      );
+
+      expect(experimentResult).toBeTruthy();
+      expect(experimentResult.status).toStrictEqual('success');
+      expect(experimentResult.results.length).toBeGreaterThanOrEqual(1);
+      const data = experimentResult.results[0] as RawResult;
+
+      console.log(data.rawdata['data']);
+
+      //expect(data.rawdata['data'][0]['t_value']).toBeCloseTo(-63.2, 3);
+    });
+  });
+});

api/src/engine/connectors/exareme/tests/e2e/two-way-anova.e2e-spec.ts

+import { Test, TestingModule } from '@nestjs/testing';
+import { AppModule } from '../../../../../main/app.module';
+import { ENGINE_SERVICE } from '../../../../engine.constants';
+import { IEngineService } from '../../../../engine.interfaces';
+import { ExperimentCreateInput } from '../../../../models/experiment/input/experiment-create.input';
+import { RawResult } from '../../../../models/result/raw-result.model';
+import {
+  createExperiment,
+  generateNumber,
+  TEST_PATHOLOGIES,
+  TIMEOUT_DURATION_SECONDS,
+  waitForResult,
+} from '../../interfaces/test-utilities';
+
+jest.setTimeout(1000 * TIMEOUT_DURATION_SECONDS);
+
+describe('ExaremeService', () => {
+  let exaremeService: IEngineService;
+
+  beforeEach(async () => {
+    const moduleRef: TestingModule = await Test.createTestingModule({
+      imports: [AppModule],
+    }).compile();
+
+    exaremeService = await moduleRef.resolve<IEngineService>(ENGINE_SERVICE);
+  });
+  const modelSlug = `anova-2way-${generateNumber()}`;
+  const algorithmId = 'ANOVA';
+
+  const input: ExperimentCreateInput = {
+    name: modelSlug,
+    variables: ['lefthippocampus'],
+    coVariables: ['alzheimerbroadcategory'],
+    datasets: TEST_PATHOLOGIES.dementia.datasets
+      .filter((d) => d.code !== 'fake_longitudinal')
+      .map((d) => d.code),
+    domain: TEST_PATHOLOGIES.dementia.code,
+    algorithm: {
+      id: algorithmId,
+      type: 'string',
+      parameters: [
+        {
+          id: 'bins',
+          value: ['40'],
+        },
+        {
+          id: 'iterations_max_number',
+          value: ['20'],
+        },
+        {
+          id: 'sstype',
+          value: ['2'],
+        },
+        {
+          id: 'outputformat',
+          value: ['pfa'],
+        },
+        {
+          id: 'design',
+          value: ['additive'],
+        },
+      ],
+    },
+    filter: '',
+  };
+
+  describe('Integration Test for experiment API', () => {
+    it(`create ${algorithmId}`, async () => {
+      const experiment = await createExperiment(input, exaremeService);
+
+      expect(experiment).toBeTruthy();
+      expect(experiment?.status).toStrictEqual('pending');
+
+      expect(experiment?.id).toBeTruthy();
+
+      const experimentResult = await waitForResult(
+        experiment?.id ?? '',
+        exaremeService,
+      );
+
+      expect(experimentResult).toBeTruthy();
+      expect(experimentResult.status).toStrictEqual('success');
+      expect(experimentResult.results.length).toBeGreaterThanOrEqual(1);
+      const data = experimentResult.results[0] as RawResult;
+
+      expect(data.rawdata['data'][0]['sumofsquares']).toBeCloseTo(34.196, 3);
+    });
+  });
+});