@centreon/js-config 24.10.3 → 24.10.4

package/cypress/e2e/configuration.ts

@@ -1,16 +1,21 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable import/extensions */
 /* eslint-disable import/no-unresolved */
 
 import { execSync } from 'child_process';
 
 import { defineConfig } from 'cypress';
+import installLogsPrinter from 'cypress-terminal-report/src/installLogsPrinter';
+import { config as configDotenv } from 'dotenv';
 
-import setupNodeEvents from './plugins';
+import esbuildPreprocessor from './esbuild-preprocessor';
+import plugins from './plugins';
+import tasks from './tasks';
 
 interface ConfigurationOptions {
   cypressFolder?: string;
-  dockerName?: string;
   env?: Record<string, unknown>;
+  envFile?: string;
   isDevelopment?: boolean;
   specPattern: string;
 }
@@ -19,12 +24,14 @@ export default ({
   specPattern,
   cypressFolder,
   isDevelopment,
-  dockerName,
-  env
+  env,
+  envFile
 }: ConfigurationOptions): Cypress.ConfigOptions => {
-  const resultsFolder = `${cypressFolder || 'cypress'}/results${
-    isDevelopment ? '/dev' : ''
-  }`;
+  if (envFile) {
+    configDotenv({ path: envFile });
+  }
+
+  const resultsFolder = `${cypressFolder || '.'}/results`;
 
   const webImageVersion = execSync('git rev-parse --abbrev-ref HEAD')
     .toString('utf8')
@@ -32,47 +39,57 @@ export default ({
 
   return defineConfig({
     chromeWebSecurity: false,
-    defaultCommandTimeout: 6000,
+    defaultCommandTimeout: 20000,
+    downloadsFolder: `${resultsFolder}/downloads`,
     e2e: {
       excludeSpecPattern: ['*.js', '*.ts', '*.md'],
-      setupNodeEvents,
-      specPattern
+      fixturesFolder: 'fixtures',
+      reporter: require.resolve('cypress-multi-reporters'),
+      reporterOptions: {
+        configFile: `${__dirname}/reporter-config.js`
+      },
+      setupNodeEvents: async (cypressOn, config) => {
+        const on = require('cypress-on-fix')(cypressOn)
+        installLogsPrinter(on, {
+          commandTrimLength: 5000,
+          defaultTrimLength: 5000,
+        });
+        on('task', {
+          logVersion(message) {
+            console.log(`[LOG]: ${message}`);
+            return null;
+          },
+        });
+        await esbuildPreprocessor(on, config);
+        tasks(on);
+
+        return plugins(on, config);
+      },
+      specPattern,
+      supportFile: 'support/e2e.{js,jsx,ts,tsx}',
+      testIsolation: true,
     },
     env: {
       ...env,
-      OPENID_IMAGE_VERSION: '23.04',
+      DATABASE_IMAGE: 'bitnami/mariadb:10.11',
+      OPENID_IMAGE_VERSION: process.env.MAJOR || '24.04',
+      SAML_IMAGE_VERSION: process.env.MAJOR || '24.04',
+      STABILITY: 'unstable',
+      TARGET_STABILITY: 'unstable',
       WEB_IMAGE_OS: 'alma9',
-      WEB_IMAGE_VERSION: webImageVersion,
-      dockerName: dockerName || 'centreon-dev'
+      WEB_IMAGE_VERSION: webImageVersion
     },
-    execTimeout: 120000,
-    reporter: 'mochawesome',
-    reporterOptions: {
-      html: false,
-      json: true,
-      overwrite: true,
-      reportDir: `${resultsFolder}/reports`,
-      reportFilename: '[name]-report.json'
+    execTimeout: 60000,
+    requestTimeout: 20000,
+    retries: {
+      openMode: 0,
+      runMode: 2
     },
-    requestTimeout: 10000,
-    retries: 0,
     screenshotsFolder: `${resultsFolder}/screenshots`,
-    setupNodeEvents: (on, config) => {
-      on('before:browser:launch', (browser, launchOptions) => {
-        if (browser.name === 'chrome' && browser.isHeadless) {
-          launchOptions.args = launchOptions.args.map((arg) => {
-            if (arg === '--headless') {
-              return '--headless=new';
-            }
-
-            return arg;
-          });
-        }
-
-        return launchOptions;
-      });
-    },
-    video: true,
-    videosFolder: `${resultsFolder}/videos`
+    video: isDevelopment,
+    videoCompression: 0,
+    videosFolder: `${resultsFolder}/videos`,
+    viewportHeight: 1080,
+    viewportWidth: 1920
   });
 };

package/cypress/e2e/esbuild-preprocessor.ts

@@ -0,0 +1,26 @@
+import { NodeGlobalsPolyfillPlugin } from '@esbuild-plugins/node-globals-polyfill';
+import { NodeModulesPolyfillPlugin } from '@esbuild-plugins/node-modules-polyfill';
+import { addCucumberPreprocessorPlugin } from '@badeball/cypress-cucumber-preprocessor';
+import createBundler from '@bahmutov/cypress-esbuild-preprocessor';
+import createEsbuildPlugin from '@badeball/cypress-cucumber-preprocessor/esbuild';
+
+export default async (
+  on: Cypress.PluginEvents,
+  config: Cypress.PluginConfigOptions
+): Promise<void> => {
+  await addCucumberPreprocessorPlugin(on, config);
+
+  on(
+    'file:preprocessor',
+    createBundler({
+      plugins: [
+        createEsbuildPlugin(config),
+        NodeModulesPolyfillPlugin(),
+        NodeGlobalsPolyfillPlugin({
+          buffer: true,
+          process: true
+        })
+      ]
+    })
+  );
+};

package/cypress/e2e/plugins.ts

@@ -3,131 +3,60 @@
 /* eslint-disable @typescript-eslint/no-var-requires */
 /* eslint-disable no-param-reassign */
 
-import Docker from 'dockerode';
-import { addCucumberPreprocessorPlugin } from '@badeball/cypress-cucumber-preprocessor';
-import webpackPreprocessor from '@cypress/webpack-preprocessor';
-
-const docker = new Docker();
-
-const getWebpackOptions = (config): object => {
-  return {
-    module: {
-      rules: [
-        {
-          exclude: [/node_modules/],
-          test: /\.ts?$/,
-          use: [
-            {
-              loader: 'swc-loader'
-            }
-          ]
-        },
-        {
-          test: /\.feature$/,
-          use: [
-            {
-              loader: '@badeball/cypress-cucumber-preprocessor/webpack',
-              options: config
-            }
-          ]
-        }
-      ]
-    },
-    resolve: {
-      extensions: ['.ts', '.js']
-    }
-  };
-};
-
-export default async (on, config): Promise<void> => {
-  await addCucumberPreprocessorPlugin(on, config);
+import fs from 'fs';
+import path from 'path';
+
+export default (
+  on: Cypress.PluginEvents,
+  config: Cypress.PluginConfigOptions
+): Cypress.PluginConfigOptions => {
+  on('before:browser:launch', (browser, launchOptions) => {
+    const width = 1920;
+    const height = 1080;
+
+    if (browser.family === 'chromium' && browser.name !== 'electron') {
+      if (browser.isHeadless) {
+        launchOptions.args.push('--headless=new');
+      }
 
-  const webpackOptions = await getWebpackOptions(config);
-  const options = {
-    webpackOptions
-  };
+      // flags description : https://github.com/GoogleChrome/chrome-launcher/blob/main/docs/chrome-flags-for-tools.md
+      launchOptions.args.push('--disable-gpu');
+      launchOptions.args.push('--auto-open-devtools-for-tabs');
+      launchOptions.args.push('--disable-extensions');
+      launchOptions.args.push('--hide-scrollbars');
+      launchOptions.args.push('--mute-audio');
 
-  on('file:preprocessor', webpackPreprocessor(options));
+      // force screen to be non-retina and just use our given resolution
+      launchOptions.args.push('--force-device-scale-factor=1');
 
-  on('before:browser:launch', (browser = {}, launchOptions) => {
-    if ((browser as { name }).name === 'chrome') {
-      launchOptions.args.push('--disable-gpu');
-      launchOptions.args = launchOptions.args.filter(
-        (element) => element !== '--disable-dev-shm-usage'
-      );
+      launchOptions.args.push(`--window-size=${width},${height}`);
     }
 
     return launchOptions;
   });
 
-  interface PortBinding {
-    destination: number;
-    source: number;
-  }
-
-  interface StartContainerProps {
-    image: string;
-    name: string;
-    portBindings: Array<PortBinding>;
-  }
-
-  interface StopContainerProps {
-    name: string;
-  }
-
-  on('task', {
-    startContainer: async ({
-      image,
-      name,
-      portBindings = []
-    }: StartContainerProps) => {
-      const webContainers = await docker.listContainers({
-        all: true,
-        filters: { name: [name] }
+  on('after:run', (results) => {
+    const testRetries: { [key: string]: Number } = {};
+    if ('runs' in results) {
+      results.runs.forEach((run) => {
+        run.tests.forEach((test) => {
+          console.log(test)
+          if (test.attempts && test.attempts.length > 1 && test.state === 'passed') {
+            const testTitle = test.title.join(' > '); // Convert the array to a string
+            testRetries[testTitle] = test.attempts.length - 1;
+          }
+        });
       });
-      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: '0.0.0.0',
-                HostPort: `${currentValue.destination}`
-              }
-            ];
-
-            return accumulator;
-          }, {})
-        },
-        Image: image,
-        OpenStdin: false,
-        StdinOnce: false,
-        Tty: true,
-        name
-      });
-
-      await container.start();
+    }
 
-      return container;
-    },
-    stopContainer: async ({ name }: StopContainerProps) => {
-      const container = await docker.getContainer(name);
-      await container.kill();
-      await container.remove();
+    // Save the testRetries object to a file in the e2e/results directory
+    const resultFilePath = path.join(
+      __dirname,
+      '../../../../tests/e2e/results',
+      'retries.json'
+    );
 
-      return null;
-    }
+    fs.writeFileSync(resultFilePath, JSON.stringify(testRetries, null, 2));
   });
 
   return config;

package/cypress/e2e/reporter-config.js

@@ -0,0 +1,13 @@
+module.exports = {
+  mochawesomeReporterOptions: {
+    consoleReporter: 'none',
+    html: false,
+    json: true,
+    overwrite: true,
+    reportDir: 'results/reports',
+    reportFilename: '[name]-report.json'
+  },
+  reporterEnabled: `mochawesome,${require.resolve(
+    '@badeball/cypress-cucumber-preprocessor/pretty-reporter'
+  )}`
+};

package/cypress/e2e/tasks.ts

@@ -0,0 +1,273 @@
+/* eslint-disable no-console */
+import { execSync } from 'child_process';
+import { existsSync, mkdirSync } from 'fs';
+import path from 'path';
+
+import tar from 'tar-fs';
+import {
+  DockerComposeEnvironment,
+  GenericContainer,
+  StartedDockerComposeEnvironment,
+  StartedTestContainer,
+  Wait,
+  getContainerRuntimeClient
+} from 'testcontainers';
+import { createConnection } from 'mysql2/promise';
+
+interface Containers {
+  [key: string]: StartedTestContainer;
+}
+
+class NotFoundContainerError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'NotFoundContainerError';
+  }
+}
+
+export default (on: Cypress.PluginEvents): void => {
+  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 NotFoundContainerError(`Cannot get container ${containerName}`);
+    }
+
+    return container;
+  };
+
+  interface PortBinding {
+    destination: number;
+    source: number;
+  }
+
+  interface StartContainerProps {
+    command?: string;
+    image: string;
+    name: string;
+    portBindings: Array<PortBinding>;
+  }
+
+  interface StopContainerProps {
+    name: string;
+  }
+
+  on('task', {
+    copyFromContainer: async ({ destination, serviceName, source }) => {
+      try {
+        const container = getContainer(serviceName);
+
+        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) {
+        if (error instanceof NotFoundContainerError) {
+          console.log(`Cannot get ${source} from container ${serviceName} because it doesn't exist.`);
+        } else {
+          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 });
+      }
+
+      return null;
+    },
+    execInContainer: async ({ command, name }) => {
+      const { exitCode, output } = await getContainer(name).exec([
+        'bash',
+        '-c',
+        `${command}${command.match(/[\n\r]/) ? '' : ' 2>&1'}`
+      ]);
+
+      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;
+      }
+    },
+    getContainerMappedPort: async ({ containerName, containerPort }) => {
+      const container = getContainer(containerName);
+
+      return container.getMappedPort(containerPort);
+    },
+    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.query(query);
+
+      await client.end();
+
+      return [rows, fields];
+    },
+    startContainer: async ({
+      command,
+      image,
+      name,
+      portBindings = []
+    }: StartContainerProps) => {
+      let container = await new GenericContainer(image).withName(name);
+
+      portBindings.forEach(({ source, destination }) => {
+        container = container.withExposedPorts({
+          container: source,
+          host: destination
+        });
+      });
+
+      if (command) {
+        container
+          .withCommand(['bash', '-c', command])
+          .withWaitStrategy(Wait.forSuccessfulCommand('ls'));
+      }
+
+      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)
+          .withStartupTimeout(120000)
+          .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) => {
+      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;
+    },
+    waitOn: async (url: string) => {
+      execSync(`npx wait-on ${url}`);
+
+      return null;
+    }
+  });
+};

package/eslint/base.typescript.eslintrc.js

@@ -21,11 +21,15 @@ module.exports = {
           }
         ],
         '@typescript-eslint/camelcase': 'off',
-        '@typescript-eslint/consistent-type-definitions': [
+        '@typescript-eslint/consistent-type-definitions': ['off', 'interface'],
+        '@typescript-eslint/explicit-function-return-type': [
           'error',
-          'interface'
+          {
+            allowExpressions: true,
+            allowHigherOrderFunctions: true,
+            allowTypedFunctionExpressions: true
+          }
         ],
-        '@typescript-eslint/explicit-function-return-type': ['error'],
         '@typescript-eslint/explicit-member-accessibility': [
           'error',
           {
@@ -76,13 +80,21 @@ module.exports = {
           }
         ],
         camelcase: 'off',
+        'import/no-cycle': 'off',
+        'import/no-named-as-default': 'warn',
         'no-shadow': 'off',
         'no-unused-expressions': 'off'
       },
       settings: {
+        'import/parsers': {
+          '@typescript-eslint/parser': ['.ts', '.tsx']
+        },
         'import/resolver': {
           alias: {
             extensions: ['.ts', '.tsx', '.js', '.jsx']
+          },
+          typescript: {
+            alwaysTryTypes: true
           }
         }
       }