@centreon/js-config 24.4.1-MON-move-code-coverage-archive.3 → 24.4.1-MON-23368-containers.81

package/cypress/e2e/commands.ts

@@ -100,6 +100,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,15 +126,14 @@ 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
+    });
   }
 );
 
@@ -129,13 +146,11 @@ interface CopyToContainerProps {
 Cypress.Commands.add(
   'copyToContainer',
   (
-    {
-      name = Cypress.env('dockerName'),
-      source,
-      destination
-    }: CopyToContainerProps,
+    { name = 'web', source, destination }: CopyToContainerProps,
     options?: Partial<Cypress.ExecOptions>
   ) => {
+    cy.log(`Copy content from ${source} to ${name}:${destination}`);
+
     return cy.exec(`docker cp ${source} ${name}:${destination}`, options);
   }
 );
@@ -202,27 +217,59 @@ Cypress.Commands.add('waitForContainerAndSetToken', (): Cypress.Chainable => {
 });
 
 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) {
+            // 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 });
   }
 );
 
@@ -232,6 +279,7 @@ interface PortBinding {
 }
 
 interface StartContainerProps {
+  command?: string;
   image: string;
   name: string;
   portBindings: Array<PortBinding>;
@@ -239,145 +287,71 @@ 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 {
+  databaseImage?: 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'),
+    databaseImage = Cypress.env('DATABASE_IMAGE'),
+    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 ...');
+
     const slimSuffix = useSlim ? '-slim' : '';
 
-    const image = `docker.centreon.com/centreon/centreon-web${slimSuffix}-${os}:${version}`;
+    const webImage = `docker.centreon.com/centreon/centreon-web${slimSuffix}-${webOs}:${webVersion}`;
 
     return cy
-      .startContainer({
-        image,
-        name,
-        portBindings: [{ destination: 4000, source: 80 }]
-      })
+      .task(
+        'startContainers',
+        { 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 +361,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.task('stopContainer', { name });
+      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
+    );
+});
+
+Cypress.Commands.add(
+  'createDirectory',
+  (directoryPath: string): Cypress.Chainable => {
+    return cy.task('createDirectory', directoryPath);
   }
 );
 
@@ -576,6 +639,9 @@ declare global {
         command,
         name
       }: ExecInContainerProps) => 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,7 +652,6 @@ declare global {
         dashboard: Dashboard,
         patch: PatchDashboardBody
       ) => Cypress.Chainable;
-
       loginByTypeOfUser: ({
         jsonName,
         loginViaApi
@@ -597,23 +662,31 @@ declare global {
         rootItemNumber,
         subMenu
       }: NavigateToProps) => Cypress.Chainable;
+      requestOnDatabase: ({
+        database,
+        query
+      }: RequestOnDatabaseProps) => Cypress.Chainable;
       shareDashboardToUser: ({
         dashboardName,
         userName,
         role
       }: ShareDashboardToUserProps) => Cypress.Chainable;
       startContainer: ({
+        command,
         name,
-        image
+        image,
+        portBindings
       }: StartContainerProps) => Cypress.Chainable;
-      startWebContainer: ({
-        name,
-        os,
+      startContainers: ({
+        databaseImage,
+        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,39 @@
+/* eslint-disable no-console */
 import { execSync } from 'child_process';
 import { existsSync, mkdirSync } from 'fs';
 
-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 +41,7 @@ export default (on: Cypress.PluginEvents): void => {
   }
 
   interface StartContainerProps {
+    command?: string;
     image: string;
     name: string;
     portBindings: Array<PortBinding>;
@@ -22,6 +52,27 @@ 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;
+    },
     createDirectory: async (directoryPath: string) => {
       if (!existsSync(directoryPath)) {
         mkdirSync(directoryPath, { recursive: true });
@@ -29,70 +80,143 @@ 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 ({
+      composeFilePath = `${__dirname}/../../../../../.github/docker/`,
+      databaseImage,
+      openidImage,
+      profiles,
+      samlImage,
+      webImage
+    }) => {
+      try {
+        const composeFile = 'docker-compose.yml';
+
+        dockerEnvironment = await new DockerComposeEnvironment(
+          composeFilePath,
+          composeFile
+        )
+          .withEnvironment({
+            MYSQL_IMAGE: databaseImage,
+            OPENID_IMAGE: openidImage,
+            SAML_IMAGE: samlImage,
+            WEB_IMAGE: webImage
+          })
+          .withProfiles(...profiles)
+          .withWaitStrategy('web', Wait.forHealthCheck())
+          .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.1-MON-move-code-coverage-archive.3",
+    "version": "24.4.1-MON-23368-containers.81",
     "repository": {
         "type": "git",
         "url": "git+https://github.com/centreon/centreon-frontend.git"
@@ -24,11 +24,11 @@
         "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",
@@ -37,10 +37,10 @@
         "@types/cypress-cucumber-preprocessor": "^4.0.5",
         "@types/dockerode": "^3.3.23",
         "cypress-multi-reporters": "^1.6.4",
-        "cypress-terminal-report": "^5.3.9",
-        "dockerode": "^4.0.0",
+        "cypress-terminal-report": "^5.3.10",
+        "dockerode": "^4.0.2",
         "dotenv": "^16.3.1",
-        "esbuild": "^0.19.5",
+        "esbuild": "^0.19.11",
         "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.7.0",
+        "tar-fs": "^3.0.4",
+        "testcontainers": "^10.5.0"
     }
 }

package/cypress/component/excludeNodeModulesFromCoverage.js

@@ -1,35 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-
-const filePath = process.argv[2];
-
-const { error: logError } = console;
-
-try {
-  const outFile = fs.readFileSync(path.resolve(filePath)).toString();
-  const outFileJson = JSON.parse(outFile);
-
-  const finalOutJson = Object.entries(outFileJson)
-    .map(([key, value]) => {
-      if (key.includes('node_modules')) {
-        return undefined;
-      }
-
-      return [key, value];
-    })
-    .filter((v) => v)
-    .reduce(
-      (acc, [key, value]) => ({
-        ...acc,
-        [key]: value
-      }),
-      {}
-    );
-
-  fs.writeFileSync(
-    path.resolve(filePath),
-    JSON.stringify(finalOutJson, null, 2)
-  );
-} catch (error) {
-  logError(error.message);
-}