@centreon/js-config 24.10.3 → 24.10.5

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,12 +140,109 @@ Cypress.Commands.add(
   }
 );
 
+interface Contact {
+  GUIAccess?: boolean;
+  admin?: boolean;
+  alias?: string | null;
+  authenticationType?: 'local' | 'ldap';
+  email: string;
+  enableNotifications?: 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: Array<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;
   alias?: string | null;
   checkCommand?: string | null;
   checkPeriod?: string | null;
+  hostGroup?: string;
   maxCheckAttempts?: number | null;
   name: string;
   passiveCheckEnabled?: boolean;
@@ -159,6 +258,7 @@ Cypress.Commands.add(
     alias = null,
     checkCommand = null,
     checkPeriod = null,
+    hostGroup = '',
     maxCheckAttempts = 1,
     name,
     passiveCheckEnabled = true,
@@ -176,7 +276,7 @@ Cypress.Commands.add(
         bodyContent: {
           action: 'ADD',
           object: 'HOST',
-          values: `${name};${hostAlias};${address};${template};${poller};`
+          values: `${name};${hostAlias};${address};${template};${poller};${hostGroup}`
         }
       })
       .then(() => {
@@ -206,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;
@@ -327,6 +447,45 @@ Cypress.Commands.add(
   }
 );
 
+interface ServiceGroup {
+  alias?: string | null;
+  hostsAndServices: Array<Array<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 => {
@@ -339,12 +498,182 @@ Cypress.Commands.add(
   }
 );
 
+interface ACLGroup {
+  alias?: string | null;
+  contactGroups?: Array<string>;
+  contacts?: Array<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.forEach((contact) => {
+            cy.executeActionViaClapi({
+              bodyContent: {
+                action: 'ADDCONTACT',
+                object: 'ACLGROUP',
+                values: `${name};${contact}`
+              }
+            });
+          });
+        }
+        if (contactGroups) {
+          contactGroups.forEach((contactGroup) => {
+            cy.executeActionViaClapi({
+              bodyContent: {
+                action: 'ADDCONTACTGROUP',
+                object: 'ACLGROUP',
+                values: `${name};${contactGroup}`
+              }
+            });
+          });
+        }
+      });
+  }
+);
+
+interface ACLMenu {
+  alias?: string | null;
+  includeChildren?: boolean;
+  name: string;
+  readOnly?: boolean;
+  rule?: Array<string>;
+}
+
+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.forEach((rulePage, index) => {
+          ruleCommand += rulePage + (index == rule.length - 1 ? '' : ';');
+        });
+        cy.executeActionViaClapi({
+          bodyContent: {
+            action,
+            object: 'ACLMENU',
+            values: `${name};${children};${ruleCommand}`
+          }
+        });
+
+        return cy.wrap(null);
+      });
+  }
+);
+
+interface ACLAction {
+  actions?: Array<Action>;
+  description: string;
+  name: string;
+}
+
+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.forEach((action, index) => {
+          actionCommand += action + (index == actions.length - 1 ? '' : '|');
+        });
+        cy.executeActionViaClapi({
+          bodyContent: {
+            action: 'GRANT',
+            object: 'ACLACTION',
+            values: `${name};${actionCommand}`
+          }
+        });
+
+        return cy.wrap(null);
+      });
+  }
+);
+
+interface ACLResource {
+  alias?: string | null;
+  name: string;
+}
+
+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;

package/cypress/e2e/commands/monitoring.ts

@@ -0,0 +1,225 @@
+/* eslint-disable @typescript-eslint/no-namespace */
+
+const apiBase = '/centreon/api';
+const apiActionV1 = `${apiBase}/index.php`;
+
+const getStatusNumberFromString = (status: string): number => {
+  const statuses = {
+    critical: '2',
+    down: '1',
+    ok: '0',
+    unknown: '3',
+    unreachable: '2',
+    up: '0',
+    warning: '1'
+  };
+
+  if (status in statuses) {
+    return statuses[status];
+  }
+
+  throw new Error(`Status ${status} does not exist`);
+};
+
+interface HostCheck {
+  host: string;
+  isForced?: boolean;
+}
+
+Cypress.Commands.add(
+  'scheduleHostCheck',
+  ({
+    host,
+    isForced = true
+  }: ServiceCheck): Cypress.Chainable => {
+    let query = `SELECT id FROM resources WHERE name = '${host}' AND type = 1`;
+
+    return cy
+      .requestOnDatabase({
+        database: 'centreon_storage',
+        query
+      })
+      .then(([rows]) => {
+        if (rows.length === 0) {
+          throw new Error(`Cannot find host ${host}`);
+        }
+
+        const hostId = rows[0].id;
+
+        return cy.request({
+          body: {
+            check: {
+              is_forced: isForced
+            },
+            resources: [
+              {
+                id: hostId,
+                parent: null,
+                type: 'host'
+              }
+            ]
+          },
+          method: 'POST',
+          timeout: 30000,
+          url: '/centreon/api/latest/monitoring/resources/check'
+        }).then((response) => {
+          expect(response.status).to.eq(204);
+
+          return cy.wrap(null);
+        });
+      });
+  }
+);
+
+interface ServiceCheck {
+  host: string;
+  isForced?: boolean;
+  service: string;
+}
+
+Cypress.Commands.add(
+  'scheduleServiceCheck',
+  ({
+    host,
+    isForced = true,
+    service
+  }: ServiceCheck): Cypress.Chainable => {
+    let query = `SELECT parent_id, id FROM resources WHERE parent_name = '${host}' AND name = '${service}'`;
+
+    return cy
+      .requestOnDatabase({
+        database: 'centreon_storage',
+        query
+      })
+      .then(([rows]) => {
+        if (rows.length === 0) {
+          throw new Error(`Cannot find service ${host} / ${service}`);
+        }
+
+        const hostId = rows[0].parent_id;
+        const serviceId = rows[0].id;
+
+        return cy.request({
+          body: {
+            check: {
+              is_forced: isForced
+            },
+            resources: [
+              {
+                id: serviceId,
+                parent: {
+                  id: hostId
+                },
+                type: 'service'
+              }
+            ]
+          },
+          method: 'POST',
+          timeout: 30000,
+          url: '/centreon/api/latest/monitoring/resources/check'
+        }).then((response) => {
+          expect(response.status).to.eq(204);
+
+          return cy.wrap(null);
+        });
+      });
+  }
+);
+
+
+interface SubmitResult {
+  host: string;
+  output: string;
+  perfdata?: string | null;
+  service?: string | null;
+  status: string;
+}
+
+Cypress.Commands.add(
+  'submitResults',
+  (results: Array<SubmitResult>): Cypress.Chainable => {
+    results.forEach(
+      ({ host, output, perfdata = '', service = null, status }) => {
+        const timestampNow = Math.floor(Date.now() / 1000) - 15;
+        const updatetime = timestampNow.toString();
+
+        const result = {
+          host,
+          output,
+          perfdata,
+          service,
+          status: getStatusNumberFromString(status),
+          updatetime
+        };
+
+        cy.request({
+          body: {
+            results: [result]
+          },
+          headers: {
+            'Content-Type': 'application/json',
+            'centreon-auth-token': window.localStorage.getItem('userTokenApiV1')
+          },
+          method: 'POST',
+          url: `${apiActionV1}?action=submit&object=centreon_submit_results`
+        });
+      }
+    );
+
+    return cy.wrap(null);
+  }
+);
+
+interface Downtime {
+  host: string;
+  service?: string | null;
+}
+
+Cypress.Commands.add(
+  'waitForDowntime',
+  (downtime: Downtime): Cypress.Chainable => {
+    cy.log('Checking hosts in database');
+
+    let query = `SELECT COUNT(d.downtime_id) AS count_downtimes FROM downtimes as d
+      INNER JOIN hosts as h ON h.host_id = d.host_id AND h.name = '${downtime.host}'`;
+    if (downtime.service) {
+      query += ` INNER JOIN services as s ON s.service_id = d.service_id AND s.description = '${downtime.service}'`;
+    }
+    query += ` WHERE d.started=1`;
+    if (!downtime.service) {
+      query += ` AND d.service_id = 0`;
+    }
+
+    cy.log(query);
+
+    cy.waitUntil(() => {
+      return cy
+        .requestOnDatabase({
+          database: 'centreon_storage',
+          query
+        })
+        .then(([rows]) => {
+          const foundDowntimesCount = rows.length ? rows[0].count_downtimes : 0;
+
+          cy.log('Downtime count in database', foundDowntimesCount);
+
+          return cy.wrap(foundDowntimesCount > 0);
+        });
+    });
+
+    return cy.wrap(null);
+  }
+);
+
+declare global {
+  namespace Cypress {
+    interface Chainable {
+      scheduleHostCheck: (hostCheck) => Cypress.Chainable;
+      scheduleServiceCheck: (serviceCheck) => Cypress.Chainable;
+      submitResults: (props: Array<SubmitResult>) => Cypress.Chainable;
+      waitForDowntime: (downtime: Downtime) => Cypress.Chainable;
+    }
+  }
+}
+
+export {};