@centreon/js-config 24.4.20 → 24.4.22

package/cypress/e2e/commands.ts

@@ -1,4 +1,6 @@
 /* eslint-disable @typescript-eslint/no-namespace */
+import path from 'path';
+import 'cypress-wait-until';
 
 import './commands/configuration';
 import './commands/monitoring';
@@ -7,10 +9,53 @@ import installLogsCollector from 'cypress-terminal-report/src/installLogsCollect
 
 installLogsCollector({ enableExtendedCollector: true });
 
+const apiBase = '/centreon/api';
+const apiActionV1 = `${apiBase}/index.php`;
 const apiLoginV2 = '/centreon/authentication/providers/configurations/local';
 
 const artifactIllegalCharactersMatcher = /[,\s/|<>*?:"]/g;
 
+export enum PatternType {
+  contains = '*',
+  endsWith = '$',
+  equals = '',
+  startsWith = '^'
+}
+
+interface GetByLabelProps {
+  label: string;
+  patternType?: PatternType;
+  tag?: string;
+}
+
+Cypress.Commands.add(
+  'getByLabel',
+  ({
+    tag = '',
+    patternType = PatternType.equals,
+    label
+  }: GetByLabelProps): Cypress.Chainable => {
+    return cy.get(`${tag}[aria-label${patternType}="${label}"]`);
+  }
+);
+
+interface GetByTestIdProps {
+  patternType?: PatternType;
+  tag?: string;
+  testId: string;
+}
+
+Cypress.Commands.add(
+  'getByTestId',
+  ({
+    tag = '',
+    patternType = PatternType.equals,
+    testId
+  }: GetByTestIdProps): Cypress.Chainable => {
+    return cy.get(`${tag}[data-testid${patternType}="${testId}"]`);
+  }
+);
+
 Cypress.Commands.add('getWebVersion', (): Cypress.Chainable => {
   return cy
     .exec(
@@ -59,7 +104,7 @@ interface NavigateToProps {
 
 Cypress.Commands.add(
   'navigateTo',
-  ({ rootItemNumber, subMenu, page }): void => {
+  ({ rootItemNumber, subMenu, page }: NavigateToProps): void => {
     if (subMenu) {
       cy.hoverRootMenuItem(rootItemNumber)
         .contains(subMenu)
@@ -100,6 +145,24 @@ Cypress.Commands.add(
   }
 );
 
+Cypress.Commands.add('getContainerId', (containerName: string) => {
+  cy.log(`Getting container id of ${containerName}`);
+
+  return cy.task('getContainerId', containerName);
+});
+
+Cypress.Commands.add('getContainerIpAddress', (containerName: string) => {
+  cy.log(`Getting container ip address of ${containerName}`);
+
+  return cy.task('getContainerIpAddress', containerName);
+});
+
+Cypress.Commands.add('getContainersLogs', () => {
+  cy.log('Getting containers logs');
+
+  return cy.task('getContainersLogs');
+});
+
 interface CopyFromContainerProps {
   destination: string;
   name?: string;
@@ -108,38 +171,54 @@ interface CopyFromContainerProps {
 
 Cypress.Commands.add(
   'copyFromContainer',
-  (
-    {
-      name = Cypress.env('dockerName'),
-      source,
-      destination
-    }: CopyFromContainerProps,
-    options?: Partial<Cypress.ExecOptions>
-  ) => {
-    return cy.exec(`docker cp ${name}:${source} "${destination}"`, options);
+  ({ name = 'web', source, destination }: CopyFromContainerProps) => {
+    cy.log(`Copy content from ${name}:${source} to ${destination}`);
+
+    return cy.task('copyFromContainer', {
+      destination,
+      serviceName: name,
+      source
+    });
   }
 );
 
+export enum CopyToContainerContentType {
+  Directory = 'directory',
+  File = 'file'
+}
+
 interface CopyToContainerProps {
   destination: string;
   name?: string;
   source: string;
+  type: CopyToContainerContentType;
 }
 
 Cypress.Commands.add(
   'copyToContainer',
-  (
-    {
-      name = Cypress.env('dockerName'),
+  ({ name = 'web', source, destination, type }: CopyToContainerProps) => {
+    cy.log(`Copy content from ${source} to ${name}:${destination}`);
+
+    return cy.task('copyToContainer', {
+      destination,
+      serviceName: name,
       source,
-      destination
-    }: CopyToContainerProps,
-    options?: Partial<Cypress.ExecOptions>
-  ) => {
-    return cy.exec(`docker cp ${source} ${name}:${destination}`, options);
+      type
+    });
   }
 );
 
+Cypress.Commands.add('loginAsAdminViaApiV2', (): Cypress.Chainable => {
+  return cy.request({
+    body: {
+      login: 'admin',
+      password: 'Centreon!2021'
+    },
+    method: 'POST',
+    url: apiLoginV2
+  });
+});
+
 interface LoginByTypeOfUserProps {
   jsonName?: string;
   loginViaApi?: boolean;
@@ -186,6 +265,33 @@ Cypress.Commands.add(
   }
 );
 
+Cypress.Commands.add('logout', (): void => {
+  cy.getByLabel({ label: 'Profile' }).should('exist').click();
+
+  cy.intercept({
+    method: 'GET',
+    times: 1,
+    url: '/centreon/api/latest/authentication/logout'
+  }).as('logout');
+
+  cy.contains(/^Logout$/).click();
+
+  cy.wait('@logout').its('response.statusCode').should('eq', 302);
+
+  // https://github.com/cypress-io/cypress/issues/25841
+  cy.clearAllCookies();
+});
+
+Cypress.Commands.add('logoutViaAPI', (): Cypress.Chainable => {
+  return cy
+    .request({
+      method: 'GET',
+      url: '/centreon/authentication/logout'
+    })
+    .visit('/')
+    .getByLabel({ label: 'Alias', tag: 'input' });
+});
+
 Cypress.Commands.add(
   'visitEmptyPage',
   (): Cypress.Chainable =>
@@ -197,32 +303,91 @@ Cypress.Commands.add(
       .visit('/waiting-page')
 );
 
-Cypress.Commands.add('waitForContainerAndSetToken', (): Cypress.Chainable => {
-  return cy.setUserTokenApiV1();
-});
-
 interface ExecInContainerProps {
-  command: string;
+  command: string | Array<string>;
   name: string;
 }
 
+interface ExecInContainerResult {
+  exitCode: number;
+  output: string;
+}
+
 Cypress.Commands.add(
   'execInContainer',
   ({ command, name }: ExecInContainerProps): Cypress.Chainable => {
-    return cy
-      .exec(`docker exec -i ${name} ${command}`, { failOnNonZeroExit: false })
-      .then((result) => {
-        if (result.code) {
-          // output will not be truncated
-          throw new Error(`
-            Execution of "${command}" failed
-            Exit code: ${result.code}
-            Stdout:\n${result.stdout}
-            Stderr:\n${result.stderr}`);
-        }
+    const commands =
+      typeof command === 'string' || command instanceof String
+        ? [command]
+        : command;
+
+    const results = commands.reduce(
+      (acc, runCommand) => {
+        cy.task<ExecInContainerResult>(
+          'execInContainer',
+          { command: runCommand, name },
+          { timeout: 600000 }
+        ).then((result) => {
+          if (result.exitCode) {
+            cy.log(result.output);
+
+            // output will not be truncated
+            throw new Error(`
+Execution of "${runCommand}" failed
+Exit code: ${result.exitCode}
+Output:\n${result.output}`);
+          }
+
+          acc.output = `${acc.output}${result.output}`;
+        });
 
-        return cy.wrap(result);
-      });
+        return acc;
+      },
+      { exitCode: 0, output: '' }
+    );
+
+    return cy.wrap(results);
+  }
+);
+
+interface RequestOnDatabaseProps {
+  database: string;
+  query: string;
+}
+
+Cypress.Commands.add(
+  'requestOnDatabase',
+  ({ database, query }: RequestOnDatabaseProps): Cypress.Chainable => {
+    return cy.task('requestOnDatabase', { database, query });
+  }
+);
+
+interface SetUserTokenApiV1Props {
+  login?: string;
+  password?: string;
+}
+
+Cypress.Commands.add(
+  'setUserTokenApiV1',
+  ({
+    login = 'admin',
+    password = 'Centreon!2021'
+  }: SetUserTokenApiV1Props = {}): Cypress.Chainable => {
+    return cy
+      .request({
+        body: {
+          password,
+          username: login
+        },
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded'
+        },
+        method: 'POST',
+        url: `${apiActionV1}?action=authenticate`
+      })
+      .then(({ body }) =>
+        window.localStorage.setItem('userTokenApiV1', body.authToken)
+      );
   }
 );
 
@@ -232,6 +397,7 @@ interface PortBinding {
 }
 
 interface StartContainerProps {
+  command?: string;
   image: string;
   name: string;
   portBindings: Array<PortBinding>;
@@ -239,145 +405,88 @@ interface StartContainerProps {
 
 Cypress.Commands.add(
   'startContainer',
-  ({ name, image, portBindings }: StartContainerProps): Cypress.Chainable => {
+  ({
+    command,
+    name,
+    image,
+    portBindings
+  }: StartContainerProps): Cypress.Chainable => {
     cy.log(`Starting container ${name} from image ${image}`);
 
     return cy.task(
       'startContainer',
-      { image, name, portBindings },
+      { command, image, name, portBindings },
       { timeout: 600000 } // 10 minutes because docker pull can be very slow
     );
   }
 );
 
-Cypress.Commands.add(
-  'createDirectory',
-  (directoryPath: string): Cypress.Chainable => {
-    return cy.task('createDirectory', directoryPath);
-  }
-);
-
-interface StartWebContainerProps {
-  name?: string;
-  os?: string;
+interface StartContainersProps {
+  composeFile?: string;
+  databaseImage?: string;
+  moduleName?: string;
+  openidImage?: string;
+  profiles?: Array<string>;
+  samlImage?: string;
   useSlim?: boolean;
-  version?: string;
+  webOs?: string;
+  webVersion?: string;
 }
 
 Cypress.Commands.add(
-  'startWebContainer',
+  'startContainers',
   ({
-    name = Cypress.env('dockerName'),
-    os = Cypress.env('WEB_IMAGE_OS'),
+    composeFile,
+    databaseImage = Cypress.env('DATABASE_IMAGE'),
+    moduleName = 'centreon-web',
+    openidImage = `docker.centreon.com/centreon/keycloak:${Cypress.env(
+      'OPENID_IMAGE_VERSION'
+    )}`,
+    profiles = [],
+    samlImage = `docker.centreon.com/centreon/keycloak:${Cypress.env(
+      'SAML_IMAGE_VERSION'
+    )}`,
     useSlim = true,
-    version = Cypress.env('WEB_IMAGE_VERSION')
-  }: StartWebContainerProps = {}): Cypress.Chainable => {
+    webOs = Cypress.env('WEB_IMAGE_OS'),
+    webVersion = Cypress.env('WEB_IMAGE_VERSION')
+  }: StartContainersProps = {}): Cypress.Chainable => {
+    cy.log('Starting containers ...');
+
+    let composeFilePath = composeFile;
+    if (!composeFile) {
+      const cypressDir = path.dirname(Cypress.config('configFile'));
+      composeFilePath = `${cypressDir}/../../../.github/docker/docker-compose.yml`;
+    }
+
     const slimSuffix = useSlim ? '-slim' : '';
 
-    const image = `docker.centreon.com/centreon/centreon-web${slimSuffix}-${os}:${version}`;
+    const webImage = `docker.centreon.com/centreon/${moduleName}${slimSuffix}-${webOs}:${webVersion}`;
 
     return cy
-      .startContainer({
-        image,
-        name,
-        portBindings: [{ destination: 4000, source: 80 }]
-      })
+      .task(
+        'startContainers',
+        {
+          composeFile: composeFilePath,
+          databaseImage,
+          openidImage,
+          profiles,
+          samlImage,
+          webImage
+        },
+        { timeout: 600000 } // 10 minutes because docker pull can be very slow
+      )
       .then(() => {
         const baseUrl = 'http://127.0.0.1:4000';
 
         Cypress.config('baseUrl', baseUrl);
 
-        return cy.task(
-          'waitOn',
-          `${baseUrl}/centreon/api/latest/platform/installation/status`
-        );
+        return cy.wrap(null);
       })
       .visit('/') // this is necessary to refresh browser cause baseUrl has changed (flash appears in video)
       .setUserTokenApiV1();
   }
 );
 
-interface StopWebContainerProps {
-  name?: string;
-}
-
-Cypress.Commands.add(
-  'stopWebContainer',
-  ({
-    name = Cypress.env('dockerName')
-  }: StopWebContainerProps = {}): Cypress.Chainable => {
-    const logDirectory = `results/logs/${Cypress.spec.name.replace(
-      artifactIllegalCharactersMatcher,
-      '_'
-    )}/${Cypress.currentTest.title.replace(
-      artifactIllegalCharactersMatcher,
-      '_'
-    )}`;
-
-    return cy
-      .visitEmptyPage()
-      .createDirectory(logDirectory)
-      .copyFromContainer({
-        destination: `${logDirectory}/broker`,
-        name,
-        source: '/var/log/centreon-broker'
-      })
-      .copyFromContainer({
-        destination: `${logDirectory}/engine`,
-        name,
-        source: '/var/log/centreon-engine'
-      })
-      .copyFromContainer({
-        destination: `${logDirectory}/centreon`,
-        name,
-        source: '/var/log/centreon'
-      })
-      .copyFromContainer({
-        destination: `${logDirectory}/centreon-gorgone`,
-        name,
-        source: '/var/log/centreon-gorgone'
-      })
-      .then(() => {
-        if (Cypress.env('WEB_IMAGE_OS').includes('alma')) {
-          return cy.copyFromContainer({
-            destination: `${logDirectory}/php`,
-            name,
-            source: '/var/log/php-fpm'
-          });
-        }
-
-        return cy.copyFromContainer(
-          {
-            destination: `${logDirectory}/php8.1-fpm-centreon-error.log`,
-            name,
-            source: '/var/log/php8.1-fpm-centreon-error.log'
-          },
-          { failOnNonZeroExit: false }
-        );
-      })
-      .then(() => {
-        if (Cypress.env('WEB_IMAGE_OS').includes('alma')) {
-          return cy.copyFromContainer({
-            destination: `${logDirectory}/httpd`,
-            name,
-            source: '/var/log/httpd'
-          });
-        }
-
-        return cy.copyFromContainer(
-          {
-            destination: `${logDirectory}/apache2`,
-            name,
-            source: '/var/log/apache2'
-          },
-          { failOnNonZeroExit: false }
-        );
-      })
-      .exec(`chmod -R 755 "${logDirectory}"`)
-      .stopContainer({ name });
-  }
-);
-
 interface StopContainerProps {
   name: string;
 }
@@ -387,20 +496,109 @@ Cypress.Commands.add(
   ({ name }: StopContainerProps): Cypress.Chainable => {
     cy.log(`Stopping container ${name}`);
 
-    cy.exec(`docker logs ${name}`).then(({ stdout }) => {
-      cy.writeFile(
-        `results/logs/${Cypress.spec.name.replace(
-          artifactIllegalCharactersMatcher,
-          '_'
-        )}/${Cypress.currentTest.title.replace(
-          artifactIllegalCharactersMatcher,
-          '_'
-        )}/container-${name}.log`,
-        stdout
+    return cy.task('stopContainer', { name });
+  }
+);
+
+Cypress.Commands.add('stopContainers', (): Cypress.Chainable => {
+  cy.log('Stopping containers ...');
+
+  const logDirectory = `results/logs/${Cypress.spec.name.replace(
+    artifactIllegalCharactersMatcher,
+    '_'
+  )}/${Cypress.currentTest.title.replace(
+    artifactIllegalCharactersMatcher,
+    '_'
+  )}`;
+
+  const name = 'web';
+
+  return cy
+    .visitEmptyPage()
+    .createDirectory(logDirectory)
+    .getContainersLogs()
+    .then((containersLogs: Array<Array<string>>) => {
+      Object.entries(containersLogs).forEach(([containerName, logs]) => {
+        cy.writeFile(
+          `results/logs/${Cypress.spec.name.replace(
+            artifactIllegalCharactersMatcher,
+            '_'
+          )}/${Cypress.currentTest.title.replace(
+            artifactIllegalCharactersMatcher,
+            '_'
+          )}/container-${containerName}.log`,
+          logs
+        );
+      });
+    })
+    .copyFromContainer({
+      destination: `${logDirectory}/broker`,
+      name,
+      source: '/var/log/centreon-broker'
+    })
+    .copyFromContainer({
+      destination: `${logDirectory}/engine`,
+      name,
+      source: '/var/log/centreon-engine'
+    })
+    .copyFromContainer({
+      destination: `${logDirectory}/centreon`,
+      name,
+      source: '/var/log/centreon'
+    })
+    .copyFromContainer({
+      destination: `${logDirectory}/centreon-gorgone`,
+      name,
+      source: '/var/log/centreon-gorgone'
+    })
+    .then(() => {
+      if (Cypress.env('WEB_IMAGE_OS').includes('alma')) {
+        return cy.copyFromContainer({
+          destination: `${logDirectory}/php`,
+          name,
+          source: '/var/log/php-fpm'
+        });
+      }
+
+      return cy.copyFromContainer(
+        {
+          destination: `${logDirectory}/php8.1-fpm-centreon-error.log`,
+          name,
+          source: '/var/log/php8.1-fpm-centreon-error.log'
+        },
+        { failOnNonZeroExit: false }
+      );
+    })
+    .then(() => {
+      if (Cypress.env('WEB_IMAGE_OS').includes('alma')) {
+        return cy.copyFromContainer({
+          destination: `${logDirectory}/httpd`,
+          name,
+          source: '/var/log/httpd'
+        });
+      }
+
+      return cy.copyFromContainer(
+        {
+          destination: `${logDirectory}/apache2`,
+          name,
+          source: '/var/log/apache2'
+        },
+        { failOnNonZeroExit: false }
       );
-    });
+    })
+    .exec(`chmod -R 755 "${logDirectory}"`)
+    .task(
+      'stopContainers',
+      {},
+      { timeout: 600000 } // 10 minutes because docker pull can be very slow
+    );
+});
 
-    return cy.task('stopContainer', { name });
+Cypress.Commands.add(
+  'createDirectory',
+  (directoryPath: string): Cypress.Chainable => {
+    return cy.task('createDirectory', directoryPath);
   }
 );
 
@@ -576,6 +774,19 @@ declare global {
         command,
         name
       }: ExecInContainerProps) => Cypress.Chainable;
+      getByLabel: ({
+        patternType,
+        tag,
+        label
+      }: GetByLabelProps) => Cypress.Chainable;
+      getByTestId: ({
+        patternType,
+        tag,
+        testId
+      }: GetByTestIdProps) => Cypress.Chainable;
+      getContainerId: (containerName: string) => Cypress.Chainable;
+      getContainerIpAddress: (containerName: string) => Cypress.Chainable;
+      getContainersLogs: () => Cypress.Chainable;
       getIframeBody: () => Cypress.Chainable;
       getTimeFromHeader: () => Cypress.Chainable;
       getWebVersion: () => Cypress.Chainable;
@@ -586,36 +797,51 @@ declare global {
         dashboard: Dashboard,
         patch: PatchDashboardBody
       ) => Cypress.Chainable;
-
+      loginAsAdminViaApiV2: () => Cypress.Chainable;
       loginByTypeOfUser: ({
         jsonName,
         loginViaApi
       }: LoginByTypeOfUserProps) => Cypress.Chainable;
+      logout: () => void;
+      logoutViaAPI: () => Cypress.Chainable;
       moveSortableElement: (direction: string) => Cypress.Chainable;
       navigateTo: ({
         page,
         rootItemNumber,
         subMenu
       }: NavigateToProps) => Cypress.Chainable;
+      requestOnDatabase: ({
+        database,
+        query
+      }: RequestOnDatabaseProps) => Cypress.Chainable;
+      setUserTokenApiV1: ({
+        login,
+        password
+      }?: SetUserTokenApiV1Props) => Cypress.Chainable;
       shareDashboardToUser: ({
         dashboardName,
         userName,
         role
       }: ShareDashboardToUserProps) => Cypress.Chainable;
       startContainer: ({
+        command,
         name,
-        image
+        image,
+        portBindings
       }: StartContainerProps) => Cypress.Chainable;
-      startWebContainer: ({
-        name,
-        os,
+      startContainers: ({
+        composeFile,
+        databaseImage,
+        moduleName,
+        openidImage,
+        profiles,
         useSlim,
-        version
-      }?: StartWebContainerProps) => Cypress.Chainable;
+        webOs,
+        webVersion
+      }?: StartContainersProps) => Cypress.Chainable;
       stopContainer: ({ name }: StopContainerProps) => Cypress.Chainable;
-      stopWebContainer: ({ name }?: StopWebContainerProps) => Cypress.Chainable;
+      stopContainers: () => Cypress.Chainable;
       visitEmptyPage: () => Cypress.Chainable;
-      waitForContainerAndSetToken: () => Cypress.Chainable;
     }
   }
 }

package/cypress/e2e/configuration.ts

@@ -13,7 +13,6 @@ import tasks from './tasks';
 
 interface ConfigurationOptions {
   cypressFolder?: string;
-  dockerName?: string;
   env?: Record<string, unknown>;
   envFile?: string;
   isDevelopment?: boolean;
@@ -24,7 +23,6 @@ export default ({
   specPattern,
   cypressFolder,
   isDevelopment,
-  dockerName,
   env,
   envFile
 }: ConfigurationOptions): Cypress.ConfigOptions => {
@@ -41,6 +39,7 @@ export default ({
   return defineConfig({
     chromeWebSecurity: false,
     defaultCommandTimeout: 6000,
+    downloadsFolder: `${resultsFolder}/downloads`,
     e2e: {
       excludeSpecPattern: ['*.js', '*.ts', '*.md'],
       fixturesFolder: 'fixtures',
@@ -60,16 +59,17 @@ export default ({
     },
     env: {
       ...env,
+      DATABASE_IMAGE: 'bitnami/mariadb:10.5',
       OPENID_IMAGE_VERSION: process.env.MAJOR || '24.04',
+      SAML_IMAGE_VERSION: process.env.MAJOR || '24.04',
       WEB_IMAGE_OS: 'alma9',
-      WEB_IMAGE_VERSION: webImageVersion,
-      dockerName: dockerName || 'centreon-dev'
+      WEB_IMAGE_VERSION: webImageVersion
     },
     execTimeout: 60000,
     requestTimeout: 10000,
     retries: 0,
     screenshotsFolder: `${resultsFolder}/screenshots`,
-    video: true,
+    video: isDevelopment,
     videoCompression: 0,
     videosFolder: `${resultsFolder}/videos`
   });

package/cypress/e2e/plugins.ts

@@ -11,7 +11,7 @@ export default (
     const width = 1920;
     const height = 1080;
 
-    if (browser.family === 'chromium') {
+    if (browser.family === 'chromium' && browser.name !== 'electron') {
       if (browser.isHeadless) {
         launchOptions.args.push('--headless=new');
       }

package/cypress/e2e/tasks.ts

@@ -1,10 +1,40 @@
+/* eslint-disable no-console */
 import { execSync } from 'child_process';
 import { existsSync, mkdirSync } from 'fs';
+import path from 'path';
 
-import Docker from 'dockerode';
+import tar from 'tar-fs';
+import {
+  DockerComposeEnvironment,
+  GenericContainer,
+  StartedDockerComposeEnvironment,
+  StartedTestContainer,
+  Wait,
+  getContainerRuntimeClient
+} from 'testcontainers';
+import { createConnection } from 'mysql2/promise';
+
+interface Containers {
+  [key: string]: StartedTestContainer;
+}
 
 export default (on: Cypress.PluginEvents): void => {
-  const docker = new Docker();
+  let dockerEnvironment: StartedDockerComposeEnvironment | null = null;
+  const containers: Containers = {};
+
+  const getContainer = (containerName): StartedTestContainer => {
+    let container;
+
+    if (dockerEnvironment !== null) {
+      container = dockerEnvironment.getContainer(`${containerName}-1`);
+    } else if (containers[containerName]) {
+      container = containers[containerName];
+    } else {
+      throw new Error(`Cannot get container ${containerName}`);
+    }
+
+    return container;
+  };
 
   interface PortBinding {
     destination: number;
@@ -12,6 +42,7 @@ export default (on: Cypress.PluginEvents): void => {
   }
 
   interface StartContainerProps {
+    command?: string;
     image: string;
     name: string;
     portBindings: Array<PortBinding>;
@@ -22,6 +53,48 @@ export default (on: Cypress.PluginEvents): void => {
   }
 
   on('task', {
+    copyFromContainer: async ({ destination, serviceName, source }) => {
+      try {
+        if (dockerEnvironment !== null) {
+          const container = dockerEnvironment.getContainer(`${serviceName}-1`);
+
+          await container
+            .copyArchiveFromContainer(source)
+            .then((archiveStream) => {
+              return new Promise<void>((resolve) => {
+                const dest = tar.extract(destination);
+                archiveStream.pipe(dest);
+                dest.on('finish', resolve);
+              });
+            });
+        }
+      } catch (error) {
+        console.error(error);
+      }
+
+      return null;
+    },
+    copyToContainer: async ({ destination, serviceName, source, type }) => {
+      const container = getContainer(serviceName);
+
+      if (type === 'directory') {
+        await container.copyDirectoriesToContainer([
+          {
+            source,
+            target: destination
+          }
+        ]);
+      } else if (type === 'file') {
+        await container.copyFilesToContainer([
+          {
+            source,
+            target: destination
+          }
+        ]);
+      }
+
+      return null;
+    },
     createDirectory: async (directoryPath: string) => {
       if (!existsSync(directoryPath)) {
         mkdirSync(directoryPath, { recursive: true });
@@ -29,70 +102,150 @@ export default (on: Cypress.PluginEvents): void => {
 
       return null;
     },
+    execInContainer: async ({ command, name }) => {
+      const { exitCode, output } = await getContainer(name).exec([
+        'bash',
+        '-c',
+        command
+      ]);
+
+      return { exitCode, output };
+    },
+    getContainerId: (containerName: string) =>
+      getContainer(containerName).getId(),
+    getContainerIpAddress: (containerName: string) => {
+      const container = getContainer(containerName);
+
+      const networkNames = container.getNetworkNames();
+
+      return container.getIpAddress(networkNames[0]);
+    },
+    getContainersLogs: async () => {
+      try {
+        const { dockerode } = (await getContainerRuntimeClient()).container;
+        const loggedContainers = await dockerode.listContainers();
+
+        return loggedContainers.reduce((acc, container) => {
+          const containerName = container.Names[0].replace('/', '');
+          acc[containerName] = execSync(`docker logs -t ${container.Id}`, {
+            stdio: 'pipe'
+          }).toString('utf8');
+
+          return acc;
+        }, {});
+      } catch (error) {
+        console.warn('Cannot get containers logs');
+        console.warn(error);
+
+        return null;
+      }
+    },
+    requestOnDatabase: async ({ database, query }) => {
+      let container: StartedTestContainer | null = null;
+
+      if (dockerEnvironment !== null) {
+        container = dockerEnvironment.getContainer('db-1');
+      } else {
+        container = getContainer('web');
+      }
+
+      const client = await createConnection({
+        database,
+        host: container.getHost(),
+        password: 'centreon',
+        port: container.getMappedPort(3306),
+        user: 'centreon'
+      });
+
+      const [rows, fields] = await client.execute(query);
+
+      await client.end();
+
+      return [rows, fields];
+    },
     startContainer: async ({
+      command,
       image,
       name,
       portBindings = []
     }: StartContainerProps) => {
-      const imageList = execSync(
-        'docker image list --format "{{.Repository}}:{{.Tag}}"'
-      ).toString('utf8');
-
-      if (
-        !imageList.match(
-          new RegExp(
-            `^${image.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&')}`,
-            'm'
-          )
-        )
-      ) {
-        execSync(`docker pull ${image}`);
-      }
+      let container = await new GenericContainer(image).withName(name);
 
-      const webContainers = await docker.listContainers({
-        all: true,
-        filters: { name: [name] }
+      portBindings.forEach(({ source, destination }) => {
+        container = container.withExposedPorts({
+          container: source,
+          host: destination
+        });
       });
-      if (webContainers.length) {
-        return webContainers[0];
-      }
 
-      const container = await docker.createContainer({
-        AttachStderr: true,
-        AttachStdin: false,
-        AttachStdout: true,
-        ExposedPorts: portBindings.reduce((accumulator, currentValue) => {
-          accumulator[`${currentValue.source}/tcp`] = {};
-
-          return accumulator;
-        }, {}),
-        HostConfig: {
-          PortBindings: portBindings.reduce((accumulator, currentValue) => {
-            accumulator[`${currentValue.source}/tcp`] = [
-              {
-                HostIP: '127.0.0.1',
-                HostPort: `${currentValue.destination}`
-              }
-            ];
-
-            return accumulator;
-          }, {})
-        },
-        Image: image,
-        OpenStdin: false,
-        StdinOnce: false,
-        Tty: true,
-        name
-      });
+      if (command) {
+        container
+          .withCommand(['bash', '-c', command])
+          .withWaitStrategy(Wait.forSuccessfulCommand('ls'));
+      }
 
-      await container.start();
+      containers[name] = await container.start();
 
       return container;
     },
+    startContainers: async ({
+      composeFile,
+      databaseImage,
+      openidImage,
+      profiles,
+      samlImage,
+      webImage
+    }) => {
+      try {
+        const composeFileDir = path.dirname(composeFile);
+        const composeFileName = path.basename(composeFile);
+
+        dockerEnvironment = await new DockerComposeEnvironment(
+          composeFileDir,
+          composeFileName
+        )
+          .withEnvironment({
+            MYSQL_IMAGE: databaseImage,
+            OPENID_IMAGE: openidImage,
+            SAML_IMAGE: samlImage,
+            WEB_IMAGE: webImage
+          })
+          .withProfiles(...profiles)
+          .withWaitStrategy(
+            'web-1',
+            Wait.forAll([
+              Wait.forHealthCheck(),
+              Wait.forLogMessage('Centreon is ready')
+            ])
+          )
+          .up();
+
+        return null;
+      } catch (error) {
+        if (error instanceof Error) {
+          console.error(error.message);
+        }
+
+        throw error;
+      }
+    },
     stopContainer: async ({ name }: StopContainerProps) => {
-      const container = await docker.getContainer(name);
-      await container.kill();
-      await container.remove();
+      if (containers[name]) {
+        const container = containers[name];
+
+        await container.stop();
+
+        delete containers[name];
+      }
+
+      return null;
+    },
+    stopContainers: async () => {
+      if (dockerEnvironment !== null) {
+        await dockerEnvironment.down();
+
+        dockerEnvironment = null;
+      }
 
       return null;
     },

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@centreon/js-config",
     "description": "Centreon Frontend shared build configuration",
-    "version": "24.4.20",
+    "version": "24.4.22",
     "repository": {
         "type": "git",
         "url": "git+https://github.com/centreon/centreon-frontend.git"
@@ -24,23 +24,23 @@
         "cypress"
     ],
     "peerDependencies": {
-        "prettier": "^3.0.0",
-        "eslint": "^8.53.0"
+        "eslint": "^8.53.0",
+        "prettier": "^3.0.0"
     },
     "dependencies": {
-        "@badeball/cypress-cucumber-preprocessor": "^19.1.0",
+        "@badeball/cypress-cucumber-preprocessor": "^20.0.1",
         "@bahmutov/cypress-esbuild-preprocessor": "^2.2.0",
         "@esbuild-plugins/node-globals-polyfill": "^0.2.3",
         "@esbuild-plugins/node-modules-polyfill": "^0.2.2",
         "@tsconfig/node16": "^16.1.1",
         "@tsconfig/node20": "^20.1.2",
         "@types/cypress-cucumber-preprocessor": "^4.0.5",
-        "@types/dockerode": "^3.3.23",
+        "cypress": "^13.6.4",
         "cypress-multi-reporters": "^1.6.4",
-        "cypress-terminal-report": "^5.3.9",
-        "dockerode": "^4.0.0",
-        "dotenv": "^16.3.1",
-        "esbuild": "^0.19.5",
+        "cypress-terminal-report": "^6.0.0",
+        "cypress-wait-until": "^3.0.1",
+        "dotenv": "^16.4.1",
+        "esbuild": "^0.20.0",
         "eslint": "^8.53.0",
         "eslint-config-airbnb": "19.0.4",
         "eslint-config-prettier": "^8.5.0",
@@ -58,6 +58,9 @@
         "eslint-plugin-react-hooks": "^4.5.0",
         "eslint-plugin-sort-keys-fix": "^1.1.2",
         "eslint-plugin-typescript-sort-keys": "^2.1.0",
-        "mochawesome": "^7.1.3"
+        "mochawesome": "^7.1.3",
+        "mysql2": "^3.9.1",
+        "tar-fs": "^3.0.4",
+        "testcontainers": "^10.7.1"
     }
 }