diff --git a/api/src/engine/connectors/exareme/tests/test-utilities.ts b/api/src/engine/connectors/exareme/interfaces/test-utilities.ts
similarity index 94%
rename from api/src/engine/connectors/exareme/tests/test-utilities.ts
rename to api/src/engine/connectors/exareme/interfaces/test-utilities.ts
index 116863a5dffb798ed9c6bbca23fdeeb48785c942..2ad1c79e8384dfb1a12fe8dbe75511720dfe4e1f 100644
--- a/api/src/engine/connectors/exareme/tests/test-utilities.ts
+++ b/api/src/engine/connectors/exareme/interfaces/test-utilities.ts
@@ -68,10 +68,14 @@ const uid = (): string =>
     return v.toString(16);
   });
 
+const generateNumber = (): string => {
+  return Math.round(Math.random() * 10000).toString();
+};
 export {
   createExperiment,
   uid,
   waitForResult,
+  generateNumber,
   TEST_PATHOLOGIES,
   TIMEOUT_DURATION_SECONDS,
 };
diff --git a/api/src/engine/connectors/exareme/tests/e2e/3c.e2e-spec.ts b/api/src/engine/connectors/exareme/tests/e2e/3c.e2e-spec.ts
new file mode 100644
index 0000000000000000000000000000000000000000..26a9cc152c6c6ff9cf870dc04c9d73d0522a0a42
--- /dev/null
+++ b/api/src/engine/connectors/exareme/tests/e2e/3c.e2e-spec.ts
@@ -0,0 +1,74 @@
+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 {
+  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 = `3c-${generateNumber()}`;
+  const algorithmId = 'THREE_C';
+
+  const input: ExperimentCreateInput = {
+    name: modelSlug,
+    variables: ['lefthippocampus', 'righthippocampus', 'leftcaudate'],
+    coVariables: ['gender', 'agegroup'],
+    datasets: TEST_PATHOLOGIES.dementia.datasets
+      .filter((d) => d.code === 'ppmi' || d.code === 'edsd')
+      .map((d) => d.code),
+    domain: TEST_PATHOLOGIES.dementia.code,
+    algorithm: {
+      id: algorithmId,
+      type: 'string',
+      parameters: [
+        { id: 'dx', value: ['alzheimerbroadcategory'] },
+        { id: 'c2_feature_selection_method', value: ['RF'] },
+        { id: 'c2_num_clusters_method', value: ['Euclidean'] },
+        { id: 'c2_num_clusters', value: ['6'] },
+        { id: 'c2_clustering_method', value: ['Euclidean'] },
+        { id: 'c3_feature_selection_method', value: ['RF'] },
+        { id: 'c3_classification_method', value: ['RF'] },
+      ],
+    },
+    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);
+    });
+  });
+});
diff --git a/api/src/engine/connectors/exareme/tests/units/calibration-belt.e2e-spec.ts b/api/src/engine/connectors/exareme/tests/e2e/calibration-belt.e2e-spec.ts
similarity index 91%
rename from api/src/engine/connectors/exareme/tests/units/calibration-belt.e2e-spec.ts
rename to api/src/engine/connectors/exareme/tests/e2e/calibration-belt.e2e-spec.ts
index 34d674bd3c7877b7a91abe86bba9d1364073c7c7..377b4ec1dc846449d51243f2ae6f1cf9d0ef58d8 100644
--- a/api/src/engine/connectors/exareme/tests/units/calibration-belt.e2e-spec.ts
+++ b/api/src/engine/connectors/exareme/tests/e2e/calibration-belt.e2e-spec.ts
@@ -5,10 +5,11 @@ import { IEngineService } from '../../../../engine.interfaces';
 import { ExperimentCreateInput } from '../../../../models/experiment/input/experiment-create.input';
 import {
   createExperiment,
+  generateNumber,
   TEST_PATHOLOGIES,
   TIMEOUT_DURATION_SECONDS,
   waitForResult,
-} from '../test-utilities';
+} from '../../interfaces/test-utilities';
 
 jest.setTimeout(1000 * TIMEOUT_DURATION_SECONDS);
 
@@ -23,7 +24,7 @@ describe('ExaremeService', () => {
     exaremeService = await moduleRef.resolve<IEngineService>(ENGINE_SERVICE);
   });
 
-  const modelSlug = `calibration-belt-${Math.round(Math.random() * 10000)}`;
+  const modelSlug = `calibration-belt-${generateNumber()}`;
   const algorithmId = 'CALIBRATION_BELT';
 
   const input: ExperimentCreateInput = {
@@ -80,7 +81,7 @@ describe('ExaremeService', () => {
       expect(experimentResult.status).toStrictEqual('success');
       expect(experimentResult).toBeTruthy();
 
-      expect(experimentResult.results).toHaveLength(1);
+      expect(experimentResult.results.length).toBeGreaterThanOrEqual(1);
     });
   });
 });
diff --git a/api/src/engine/connectors/exareme/tests/e2e/cart.e2e-spec.ts b/api/src/engine/connectors/exareme/tests/e2e/cart.e2e-spec.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b6a10af1ec50db1d68d52970f9b561fd80a0e22a
--- /dev/null
+++ b/api/src/engine/connectors/exareme/tests/e2e/cart.e2e-spec.ts
@@ -0,0 +1,72 @@
+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 {
+  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 = `cart-${generateNumber()}`;
+  const algorithmId = 'CART';
+
+  const input: ExperimentCreateInput = {
+    name: modelSlug,
+    coVariables: ['lefthippocampus', 'righthippocampus'],
+    variables: ['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: 'max_depth', value: ['3'] },
+        { id: 'no_split_points', value: ['10'] },
+      ],
+    },
+    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 r0 = experimentResult.results[0] as RawResult;
+
+      expect(r0?.rawdata['data'].gain).toEqual(0.6142216049382716);
+    });
+  });
+});
diff --git a/api/src/engine/connectors/exareme/tests/e2e/descriptiveStatistics.e2e-spec.ts b/api/src/engine/connectors/exareme/tests/e2e/descriptiveStatistics.e2e-spec.ts
new file mode 100644
index 0000000000000000000000000000000000000000..96fb1c2d64aa62350999e9c2f558e254d975ff0a
--- /dev/null
+++ b/api/src/engine/connectors/exareme/tests/e2e/descriptiveStatistics.e2e-spec.ts
@@ -0,0 +1,70 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { GroupsResult } from 'src/engine/models/result/groups-result.model';
+import { TableResult } from 'src/engine/models/result/table-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 {
+  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 = `statistics-${generateNumber()}`;
+  const algorithmId = 'DESCRIPTIVE_STATS';
+
+  const input: ExperimentCreateInput = {
+    name: modelSlug,
+    variables: ['lefthippocampus', '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: [],
+    },
+    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 r0 = experimentResult.results[0] as GroupsResult;
+      const table = r0.groups[0].results[0] as TableResult;
+
+      expect(table.data[0][2]).toEqual(474);
+    });
+  });
+});
diff --git a/api/src/engine/connectors/exareme/tests/e2e/id3.e2e-spec.ts b/api/src/engine/connectors/exareme/tests/e2e/id3.e2e-spec.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b13fc5f9868184d674f70d63e8b132c4a3c7988e
--- /dev/null
+++ b/api/src/engine/connectors/exareme/tests/e2e/id3.e2e-spec.ts
@@ -0,0 +1,71 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { GroupsResult } from 'src/engine/models/result/groups-result.model';
+import { RawResult } from 'src/engine/models/result/raw-result.model';
+import { TableResult } from 'src/engine/models/result/table-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 {
+  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 = `id3-${generateNumber()}`;
+  const algorithmId = 'ID3';
+
+  const input: ExperimentCreateInput = {
+    name: modelSlug,
+    variables: ['alzheimerbroadcategory'],
+    coVariables: ['gender', 'agegroup'],
+    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: 'iterations_max_number', value: ['20'] }],
+    },
+    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']['data'][0][2]).toEqual('+80y');
+    });
+  });
+});
diff --git a/api/src/engine/connectors/exareme/tests/e2e/k-means.e2e-spec.ts b/api/src/engine/connectors/exareme/tests/e2e/k-means.e2e-spec.ts
new file mode 100644
index 0000000000000000000000000000000000000000..83485ebdcc352d05713bbc31b15e1e82c8c0ee32
--- /dev/null
+++ b/api/src/engine/connectors/exareme/tests/e2e/k-means.e2e-spec.ts
@@ -0,0 +1,84 @@
+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 {
+  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 = `kmeans-${generateNumber()}`;
+  const algorithmId = 'KMEANS';
+
+  const input: ExperimentCreateInput = {
+    name: modelSlug,
+    variables: ['leftacgganteriorcingulategyrus', 'rightcerebellumexterior'],
+    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: 'k',
+          value: ['4'],
+        },
+        {
+          id: 'e',
+          value: ['1'],
+        },
+        {
+          id: 'iterations_max_number',
+          value: ['1000'],
+        },
+      ],
+    },
+    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]['leftacgganteriorcingulategyrus'],
+      ).toBeCloseTo(4.197, 3);
+    });
+  });
+});
diff --git a/api/src/engine/connectors/exareme/tests/e2e/kaplan-meier.e2e-spec.ts b/api/src/engine/connectors/exareme/tests/e2e/kaplan-meier.e2e-spec.ts
new file mode 100644
index 0000000000000000000000000000000000000000..03f9932948bad18779cc7c2291eafdfd410d95d5
--- /dev/null
+++ b/api/src/engine/connectors/exareme/tests/e2e/kaplan-meier.e2e-spec.ts
@@ -0,0 +1,84 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { ParamType } from 'src/engine/models/experiment/input/algorithm-parameter.input';
+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 {
+  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 = `kaplan-meier-${generateNumber()}`;
+  const algorithmId = 'KAPLAN_MEIER';
+
+  const input: ExperimentCreateInput = {
+    name: modelSlug,
+    variables: ['alzheimerbroadcategory'],
+    coVariables: ['apoe4'],
+    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: 'outcome_pos',
+          value: ['AD'],
+        },
+        {
+          id: 'outcome_neg',
+          value: ['MCI'],
+        },
+        {
+          id: 'max_age',
+          value: ['100'],
+        },
+        {
+          id: 'total_duration',
+          value: ['1100'],
+        },
+      ],
+    },
+    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);
+    });
+  });
+});
diff --git a/api/src/engine/connectors/exareme/tests/e2e/linear-regression.e2e-spec.ts b/api/src/engine/connectors/exareme/tests/e2e/linear-regression.e2e-spec.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fbb5ab6914182ec8ccd0e9607da67e57fdb49e9d
--- /dev/null
+++ b/api/src/engine/connectors/exareme/tests/e2e/linear-regression.e2e-spec.ts
@@ -0,0 +1,82 @@
+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 {
+  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 = `linear-${generateNumber()}`;
+  const algorithmId = 'LINEAR_REGRESSION';
+
+  const input: ExperimentCreateInput = {
+    name: modelSlug,
+    variables: ['lefthippocampus'],
+    coVariables: ['leftpcuprecuneus'],
+    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: 'referencevalues',
+          value: ['[{"name":"alzheimerbroadcategory","val":"Other"}]'],
+        },
+        {
+          id: 'encodingparameter',
+          value: ['dummycoding'],
+        },
+      ],
+    },
+    filter:
+      '{"condition":"AND","rules":[{"id":"subjectageyears","field":"subjectageyears","type":"integer","input":"number","operator":"greater","value":"65"}],"valid":true}',
+  };
+
+  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']['coefficients'][0]['estimate']).toBeCloseTo(
+        0.986,
+        3,
+      );
+    });
+  });
+});
diff --git a/api/src/engine/connectors/exareme/tests/e2e/logistic-regression.e2e-spec.ts b/api/src/engine/connectors/exareme/tests/e2e/logistic-regression.e2e-spec.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1ea5e53a29479e7764d40014b4f6bb2a5aa7628b
--- /dev/null
+++ b/api/src/engine/connectors/exareme/tests/e2e/logistic-regression.e2e-spec.ts
@@ -0,0 +1,72 @@
+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 {
+  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 = `logistic-${generateNumber()}`;
+  const algorithmId = 'LOGISTIC_REGRESSION';
+
+  const input: ExperimentCreateInput = {
+    name: modelSlug,
+    variables: ['gender'],
+    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: 'positive_level', value: ['M'] },
+        { id: 'negative_level', value: ['F'] },
+      ],
+    },
+    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']['Coefficients'][0]).toBeCloseTo(-7.628, 3);
+    });
+  });
+});
diff --git a/api/src/engine/connectors/exareme/tests/e2e/multiple-histograms.e2e-spec.ts b/api/src/engine/connectors/exareme/tests/e2e/multiple-histograms.e2e-spec.ts
new file mode 100644
index 0000000000000000000000000000000000000000..28c7fb4a4d0e8d4b43295fc562d033852a9e2d1c
--- /dev/null
+++ b/api/src/engine/connectors/exareme/tests/e2e/multiple-histograms.e2e-spec.ts
@@ -0,0 +1,66 @@
+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 {
+  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 = `histograms-${generateNumber()}`;
+  const algorithmId = 'MULTIPLE_HISTOGRAMS';
+
+  const input: ExperimentCreateInput = {
+    name: modelSlug,
+    variables: ['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: 'bins', value: ['{ "lefthippocampus" : 35 }'] }],
+    },
+    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(3);
+    });
+  });
+});