@centreon/js-config 24.4.29 → 24.4.30

package/cypress/component/commands.tsx

@@ -18,6 +18,15 @@ interface MountProps {
   Component: React.ReactNode;
   options?: object;
 }
+interface Resolution {
+  height: number;
+  width: number;
+}
+
+interface MakeSnapshotWithCustomResolution {
+  resolution: Resolution;
+  title: string;
+}
 
 export enum Method {
   DELETE = 'DELETE',
@@ -53,6 +62,7 @@ interface Query {
 
 export interface InterceptAPIRequestProps<T> {
   alias: string;
+  delay?: number;
   method: Method;
   path: string;
   query?: Query;
@@ -68,7 +78,8 @@ Cypress.Commands.add(
     response,
     alias,
     query,
-    statusCode = 200
+    statusCode = 200,
+    delay = 500
   }: InterceptAPIRequestProps<T>): void => {
     cy.interceptRequest(
       method,
@@ -77,14 +88,14 @@ Cypress.Commands.add(
         const getQuery = req?.url?.searchParams?.get(query?.name);
         if (query && equals(query.value, getQuery)) {
           return res(
-            ctx.delay(500),
+            ctx.delay(delay),
             ctx.json(response),
             ctx.status(statusCode)
           );
         }
         if (!getQuery && isNil(query)) {
           return res(
-            ctx.delay(500),
+            ctx.delay(delay),
             ctx.json(response),
             ctx.status(statusCode)
           );
@@ -97,20 +108,32 @@ Cypress.Commands.add(
   }
 );
 
-Cypress.Commands.add('moveSortableElement', ({ element, direction }): void => {
-  const key = `{${direction}arrow}`;
+interface MoveSortableElementProps {
+  direction: 'up' | 'down' | 'left' | 'right';
+  element: Cypress.Chainable<JQuery<HTMLElement>>;
+  times?: number;
+}
 
-  element.type(' ', {
-    force: true,
-    scrollBehavior: false
-  });
-  element.eq(-1).type(key, {
-    scrollBehavior: false
-  });
-  element.eq(-1).type(' ', {
-    scrollBehavior: false
-  });
-});
+Cypress.Commands.add(
+  'moveSortableElement',
+  ({ element, direction, times = 1 }: MoveSortableElementProps): void => {
+    const key = `{${direction}arrow}`;
+
+    element.type(' ', {
+      force: true,
+      scrollBehavior: false
+    });
+
+    Array.from({ length: times }).forEach(() => {
+      element.eq(-1).type(key, {
+        scrollBehavior: false
+      });
+    });
+    element.eq(-1).type(' ', {
+      scrollBehavior: false
+    });
+  }
+);
 
 Cypress.Commands.add(
   'moveSortableElementUsingAriaLabel',
@@ -137,6 +160,15 @@ Cypress.Commands.add('makeSnapshot', (title?: string) => {
   cy.matchImageSnapshot(title);
 });
 
+Cypress.Commands.add(
+  'makeSnapshotWithCustomResolution',
+  ({ title, resolution }: MakeSnapshotWithCustomResolution) => {
+    const { width, height } = resolution;
+    cy.viewport(width, height);
+    cy.matchImageSnapshot(title);
+  }
+);
+
 Cypress.Commands.add('cssDisableMotion', (): void => {
   Cypress.on('window:before:load', (cyWindow) => {
     disableMotion(cyWindow);
@@ -148,13 +180,22 @@ declare global {
     interface Chainable {
       adjustViewport: () => Cypress.Chainable;
       cssDisableMotion: () => Cypress.Chainable;
+      getRequestCalls: (alias) => Cypress.Chainable;
       interceptAPIRequest: <T extends object>(
         props: InterceptAPIRequestProps<T>
       ) => Cypress.Chainable;
       interceptRequest: (method, path, mock, alias) => Cypress.Chainable;
       makeSnapshot: (title?: string) => void;
+      makeSnapshotWithCustomResolution: ({
+        title,
+        resolution
+      }: MakeSnapshotWithCustomResolution) => Cypress.Chainable;
       mount: ({ Component, options }: MountProps) => Cypress.Chainable;
-      moveSortableElement: ({ element, direction }) => void;
+      moveSortableElement: ({
+        element,
+        direction,
+        times
+      }: MoveSortableElementProps) => void;
       moveSortableElementUsingAriaLabel: ({ ariaLabel, direction }) => void;
       waitForRequest: (alias) => Cypress.Chainable;
     }

package/cypress/component/configuration.js

@@ -3,6 +3,7 @@ const { defineConfig } = require('cypress');
 const {
   addMatchImageSnapshotPlugin
 } = require('@simonsmith/cypress-image-snapshot/plugin');
+const cypressCodeCoverageTask = require('@cypress/code-coverage/task');
 
 module.exports = ({
   webpackConfig,
@@ -25,9 +26,12 @@ module.exports = ({
       setupNodeEvents: (on, config) => {
         addMatchImageSnapshotPlugin(on, config);
 
+        cypressCodeCoverageTask(on, config);
+
         on('before:browser:launch', (browser, launchOptions) => {
           if (browser.name === 'chrome' && browser.isHeadless) {
             launchOptions.args.push('--headless=new');
+            launchOptions.args.push('--force-color-profile=srgb');
           }
 
           return launchOptions;
@@ -37,8 +41,17 @@ module.exports = ({
       supportFile: `${mainCypressFolder}/support/component.tsx`
     },
     env: {
-      ...env,
-      baseUrl: 'http://localhost:9092'
+      baseUrl: 'http://localhost:9092',
+      codeCoverage: {
+        exclude: [
+          'cypress/**/*.*',
+          'packages/**',
+          'node_modules',
+          '**/*.js',
+          '**/*.spec.tsx'
+        ]
+      },
+      ...env
     },
     reporter: 'mochawesome',
     reporterOptions: {

package/cypress/component/excludeNodeModulesFromCoverage.js

@@ -0,0 +1,36 @@
+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 coveragesWithoutNodeModules = Object.entries(outFileJson)
+    .map(([key, value]) => {
+      if (key.includes('node_modules')) {
+        return undefined;
+      }
+
+      return [key, value];
+    })
+    .filter((v) => v);
+
+  const finalOutJson = coveragesWithoutNodeModules.reduce(
+    (acc, [key, value]) => ({
+      ...acc,
+      [key]: value
+    }),
+    {}
+  );
+
+  fs.writeFileSync(
+    path.resolve(filePath),
+    JSON.stringify(finalOutJson, null, 2)
+  );
+} catch (error) {
+  logError(error.message);
+}

package/cypress/e2e/commands/configuration.ts

@@ -1,5 +1,7 @@
 /* eslint-disable @typescript-eslint/no-namespace */
 
+import { Action } from 'e2e/features/ACLs/commands';
+
 const apiBase = '/centreon/api';
 const apiActionV1 = `${apiBase}/index.php`;
 
@@ -138,6 +140,102 @@ Cypress.Commands.add(
   }
 );
 
+interface Contact {
+  admin?: boolean;
+  alias?: string | null;
+  authenticationType?: 'local' | 'ldap';
+  email: string;
+  enableNotifications?: boolean;
+  GUIAccess?: boolean;
+  language?: string;
+  name: string;
+  password: string;
+}
+
+Cypress.Commands.add(
+  'addContact',
+  ({
+    admin = true,
+    alias = null,
+    authenticationType = 'local',
+    email,
+    enableNotifications = true,
+    GUIAccess = true,
+    language = 'en_US',
+    name,
+    password
+  }: Contact): Cypress.Chainable => {
+    const contactAdmin = admin ? 1 : 0;
+    const contactAlias = alias === null ? name : alias;
+    const contactEnableNotifications = enableNotifications ? 1 : 0;
+    const contactGUIAccess = GUIAccess ? 1 : 0;
+
+    return cy
+      .executeActionViaClapi({
+        bodyContent: {
+          action: 'ADD',
+          object: 'CONTACT',
+          values: `${name};${contactAlias};${email};${password};${contactAdmin};${contactGUIAccess};${language};${authenticationType}`
+        }
+      })
+      .then(() => {
+        const contactParams = {
+          enable_notifications: contactEnableNotifications
+        };
+        Object.entries(contactParams).map(([paramName, paramValue]) => {
+          if (paramValue === null) {
+            return null;
+          }
+
+          return cy.executeActionViaClapi({
+            bodyContent: {
+              action: 'SETPARAM',
+              object: 'CONTACT',
+              values: `${name};${paramName};${paramValue}`
+            }
+          });
+        });
+
+        return cy.wrap(null);
+      });
+  }
+);
+
+interface ContactGroup {
+  alias?: string | null;
+  contacts: string[];
+  name: string;
+}
+
+Cypress.Commands.add(
+  'addContactGroup',
+  ({ alias = null, contacts, name }: ContactGroup): Cypress.Chainable => {
+    const contactGroupAlias = alias === null ? name : alias;
+
+    return cy
+      .executeActionViaClapi({
+        bodyContent: {
+          action: 'ADD',
+          object: 'CG',
+          values: `${name};${contactGroupAlias}`
+        }
+      })
+      .then(() => {
+        contacts.map((contact) => {
+          return cy.executeActionViaClapi({
+            bodyContent: {
+              action: 'ADDCONTACT',
+              object: 'CG',
+              values: `${name};${contact}`
+            }
+          });
+        });
+
+        return cy.wrap(null);
+      });
+  }
+);
+
 interface Host {
   activeCheckEnabled?: boolean;
   address?: string;
@@ -208,6 +306,26 @@ Cypress.Commands.add(
   }
 );
 
+interface HostGroup {
+  alias?: string | null;
+  name: string;
+}
+
+Cypress.Commands.add(
+  'addHostGroup',
+  ({ alias = null, name }: HostGroup): Cypress.Chainable => {
+    const hostGroupAlias = alias === null ? name : alias;
+
+    return cy.executeActionViaClapi({
+      bodyContent: {
+        action: 'ADD',
+        object: 'HG',
+        values: `${name};${hostGroupAlias}`
+      }
+    });
+  }
+);
+
 interface ServiceTemplate {
   activeCheckEnabled?: boolean;
   checkCommand?: string | null;
@@ -329,6 +447,45 @@ Cypress.Commands.add(
   }
 );
 
+interface ServiceGroup {
+  alias?: string | null;
+  hostsAndServices: string[][];
+  name: string;
+}
+
+Cypress.Commands.add(
+  'addServiceGroup',
+  ({
+    alias = null,
+    hostsAndServices,
+    name
+  }: ServiceGroup): Cypress.Chainable => {
+    const serviceGroupAlias = alias === null ? name : alias;
+
+    return cy
+      .executeActionViaClapi({
+        bodyContent: {
+          action: 'ADD',
+          object: 'SG',
+          values: `${name};${serviceGroupAlias}`
+        }
+      })
+      .then(() => {
+        hostsAndServices.map((hostAndService) => {
+          return cy.executeActionViaClapi({
+            bodyContent: {
+              action: 'ADDSERVICE',
+              object: 'SG',
+              values: `${name};${hostAndService[0]},${hostAndService[1]}`
+            }
+          });
+        });
+
+        return cy.wrap(null);
+      });
+  }
+);
+
 Cypress.Commands.add(
   'applyPollerConfiguration',
   (pollerName = 'Central'): Cypress.Chainable => {
@@ -341,12 +498,179 @@ Cypress.Commands.add(
   }
 );
 
+interface ACLGroup {
+  alias?: string | null;
+  contacts?: string[];
+  contactGroups?: string[];
+  name: string;
+}
+
+Cypress.Commands.add(
+  'addACLGroup',
+  ({
+    alias = null,
+    contacts = [],
+    contactGroups = [],
+    name
+  }: ACLGroup): Cypress.Chainable => {
+    const ACLGroupALias = alias === null ? name : alias;
+
+    return cy
+      .executeActionViaClapi({
+        bodyContent: {
+          action: 'ADD',
+          object: 'ACLGROUP',
+          values: `${name};${ACLGroupALias}`
+        }
+      })
+      .then(() => {
+        if (contacts) {
+          contacts.map((contact) => {
+            cy.executeActionViaClapi({
+              bodyContent: {
+                action: 'ADDCONTACT',
+                object: 'ACLGROUP',
+                values: `${name};${contact}`
+              }
+            });
+          });
+        }
+        if (contactGroups) {
+          contactGroups.map((contactGroup) => {
+            cy.executeActionViaClapi({
+              bodyContent: {
+                action: 'ADDCONTACTGROUP',
+                object: 'ACLGROUP',
+                values: `${name};${contactGroup}`
+              }
+            });
+          });
+        }
+      });
+  }
+);
+
+interface ACLMenu {
+  name: string;
+  rule?: string[];
+  alias?: string | null;
+  includeChildren?: boolean;
+  readOnly?: boolean;
+}
+
+Cypress.Commands.add(
+  'addACLMenu',
+  ({
+    name,
+    rule = [],
+    alias = null,
+    includeChildren = true,
+    readOnly = false
+  }: ACLMenu): Cypress.Chainable => {
+    const ACLMenuAlias = alias === null ? name : alias;
+    const action = readOnly ? 'GRANTRO' : 'GRANTRW';
+    const children = includeChildren ? '1' : '0';
+
+    return cy
+      .executeActionViaClapi({
+        bodyContent: {
+          action: 'ADD',
+          object: 'ACLMENU',
+          values: `${name};${ACLMenuAlias}`
+        }
+      })
+      .then(() => {
+        if (rule.length == 0) {
+          return cy.wrap(null);
+        }
+
+        let ruleCommand = '';
+        rule.map((rulePage, index) => {
+          ruleCommand += rulePage + (index == rule.length - 1 ? '' : ';');
+        });
+        cy.executeActionViaClapi({
+          bodyContent: {
+            action: action,
+            object: 'ACLMENU',
+            values: `${name};${children};${ruleCommand}`
+          }
+        });
+        return cy.wrap(null);
+      });
+  }
+);
+
+interface ACLAction {
+  name: string;
+  description: string;
+  actions?: Action[];
+}
+
+Cypress.Commands.add(
+  'addACLAction',
+  ({ name, description, actions = [] }: ACLAction): Cypress.Chainable => {
+    return cy
+      .executeActionViaClapi({
+        bodyContent: {
+          action: 'ADD',
+          object: 'ACLACTION',
+          values: `${name};${description}`
+        }
+      })
+      .then(() => {
+        if (actions.length == 0) {
+          return cy.wrap(null);
+        }
+
+        let actionCommand = '';
+        actions.map((action, index) => {
+          actionCommand += action + (index == actions.length - 1 ? '' : '|');
+        });
+        cy.executeActionViaClapi({
+          bodyContent: {
+            action: 'GRANT',
+            object: 'ACLACTION',
+            values: `${name};${actionCommand}`
+          }
+        });
+        return cy.wrap(null);
+      });
+  }
+);
+
+interface ACLResource {
+  name: string;
+  alias?: string | null;
+}
+
+Cypress.Commands.add(
+  'addACLResource',
+  ({ name, alias = null }: ACLResource): Cypress.Chainable => {
+    const ACLResourcesAlias = alias === null ? name : alias;
+    return cy.executeActionViaClapi({
+      bodyContent: {
+        action: 'ADD',
+        object: 'ACLRESOURCE',
+        values: `${name};${ACLResourcesAlias}`
+      }
+    });
+  }
+);
+
 declare global {
   namespace Cypress {
     interface Chainable {
+      addACLAction: (props: ACLAction) => Cypress.Chainable;
+      addACLGroup: (props: ACLGroup) => Cypress.Chainable;
+      addACLMenu: (props: ACLMenu) => Cypress.Chainable;
+      addACLResource: (props: ACLResource) => Cypress.Chainable;
       addCheckCommand: (props: CheckCommand) => Cypress.Chainable;
+      addContact: (props: Contact) => Cypress.Chainable;
+      addContactGroup: (props: ContactGroup) => Cypress.Chainable;
       addHost: (props: Host) => Cypress.Chainable;
+      addHostGroup: (props: HostGroup) => Cypress.Chainable;
       addService: (props: Service) => Cypress.Chainable;
+      addServiceGroup: (props: ServiceGroup) => Cypress.Chainable;
       addServiceTemplate: (props: ServiceTemplate) => Cypress.Chainable;
       addTimePeriod: (props: TimePeriod) => Cypress.Chainable;
       applyPollerConfiguration: (props?: string) => Cypress.Chainable;