@centreon/js-config 23.10.65 → 24.4.0

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(
@@ -34,6 +79,34 @@ Cypress.Commands.add('getIframeBody', (): Cypress.Chainable => {
     .then(cy.wrap);
 });
 
+Cypress.Commands.add(
+  'waitForElementInIframe',
+  (iframeSelector, elementSelector) => {
+    cy.waitUntil(
+      () =>
+        cy.get(iframeSelector).then(($iframe) => {
+          const iframeBody = $iframe[0].contentDocument.body;
+          if (iframeBody) {
+            const $element = Cypress.$(iframeBody).find(elementSelector);
+
+            return $element.length > 0 && $element.is(':visible');
+          }
+
+          return false;
+        }),
+      {
+        errorMsg: 'The element is not visible within the iframe',
+        interval: 5000,
+        timeout: 100000
+      }
+    ).then((isVisible) => {
+      if (!isVisible) {
+        throw new Error('The element is not visible');
+      }
+    });
+  }
+);
+
 Cypress.Commands.add(
   'hoverRootMenuItem',
   (rootItemNumber: number): Cypress.Chainable => {
@@ -59,7 +132,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 +173,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 +199,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;
@@ -178,16 +285,42 @@ Cypress.Commands.add(
       .getByLabel({ label: 'Connect', tag: 'button' })
       .click();
 
-    return cy
-      .get('.SnackbarContent-root > .MuiPaper-root')
-      .then(($snackbar) => {
-        if ($snackbar.text().includes('Login succeeded')) {
-          cy.wait('@getNavigationList');
-        }
-      });
+    return cy.get('.MuiAlert-message').then(($snackbar) => {
+      if ($snackbar.text().includes('Login succeeded')) {
+        cy.wait('@getNavigationList');
+        cy.get('.MuiAlert-message').should('not.be.visible');
+      }
+    });
   }
 );
 
+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 =>
@@ -199,32 +332,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)
+      );
   }
 );
 
@@ -234,6 +426,7 @@ interface PortBinding {
 }
 
 interface StartContainerProps {
+  command?: string;
   image: string;
   name: string;
   portBindings: Array<PortBinding>;
@@ -241,145 +434,212 @@ 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;
+interface StopContainerProps {
+  name: string;
 }
 
 Cypress.Commands.add(
-  'stopWebContainer',
-  ({
-    name = Cypress.env('dockerName')
-  }: StopWebContainerProps = {}): Cypress.Chainable => {
+  'stopContainer',
+  ({ name }: StopContainerProps): Cypress.Chainable => {
+    cy.log(`Stopping container ${name}`);
+
+    return cy.task('stopContainer', { name });
+  }
+);
+
+Cypress.Commands.add(
+  'getLogDirectory',
+  (): Cypress.Chainable => {
     const logDirectory = `results/logs/${Cypress.spec.name.replace(
-      artifactIllegalCharactersMatcher,
-      '_'
-    )}/${Cypress.currentTest.title.replace(
-      artifactIllegalCharactersMatcher,
-      '_'
-    )}`;
+        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'
-      })
-      .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 }
-        );
-      })
       .exec(`chmod -R 755 "${logDirectory}"`)
-      .stopContainer({ name });
+      .wrap(logDirectory);
   }
 );
 
-interface StopContainerProps {
+interface CopyWebContainerLogsProps {
   name: string;
 }
 
 Cypress.Commands.add(
-  'stopContainer',
-  ({ name }: StopContainerProps): Cypress.Chainable => {
-    cy.log(`Stopping container ${name}`);
+  'copyWebContainerLogs',
+  ({ name }: CopyWebContainerLogsProps): Cypress.Chainable => {
+    cy.log(`Getting logs from container ${name} ...`);
+
+    return cy.getLogDirectory().then((logDirectory) => {
+      let sourcePhpLogs = '/var/log/php8.1-fpm-centreon-error.log';
+      let targetPhpLogs = `${logDirectory}/php8.1-fpm-centreon-error.log`;
+      let sourceApacheLogs = '/var/log/apache2';
+      let targetApacheLogs = `${logDirectory}/apache2`;
+      if (Cypress.env('WEB_IMAGE_OS').includes('alma')) {
+        sourcePhpLogs = '/var/log/php-fpm';
+        targetPhpLogs = `${logDirectory}/php`;
+        sourceApacheLogs = '/var/log/httpd';
+        targetApacheLogs = `${logDirectory}/httpd`;
+      }
 
-    cy.exec(`docker logs ${name}`).then(({ stdout }) => {
-      cy.writeFile(
-        `cypress/results/logs/${Cypress.spec.name.replace(
-          artifactIllegalCharactersMatcher,
-          '_'
-        )}/${Cypress.currentTest.title.replace(
-          artifactIllegalCharactersMatcher,
-          '_'
-        )}/container-${name}.log`,
-        stdout
-      );
+      return cy
+        .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'
+        })
+        .copyFromContainer({
+          destination: targetPhpLogs,
+          name,
+          source: sourcePhpLogs,
+        })
+        .copyFromContainer({
+          destination: targetApacheLogs,
+          name,
+          source: sourceApacheLogs,
+        })
+        .exec(`chmod -R 755 "${logDirectory}"`);
+      });
+});
+
+Cypress.Commands.add('stopContainers', (): Cypress.Chainable => {
+  cy.log('Stopping containers ...');
+
+  const name = 'web';
+
+  return cy
+    .visitEmptyPage()
+    .getLogDirectory()
+    .then((logDirectory) => {
+      return cy
+        .getContainersLogs()
+        .then((containersLogs: Array<Array<string>>) => {
+          if (!containersLogs) {
+            return;
+          }
+
+          Object.entries(containersLogs).forEach(([containerName, logs]) => {
+            cy.writeFile(
+              `${logDirectory}/container-${containerName}.log`,
+              logs
+            );
+          });
+        })
+        .copyWebContainerLogs({ name })
+        .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);
   }
 );
 
@@ -416,6 +676,41 @@ Cypress.Commands.add(
   }
 );
 
+Cypress.Commands.add(
+  'insertDashboardWithWidget',
+  (dashboardBody, patchBody) => {
+    cy.request({
+      body: {
+        ...dashboardBody
+      },
+      method: 'POST',
+      url: '/centreon/api/latest/configuration/dashboards'
+    }).then((response) => {
+      const dashboardId = response.body.id;
+      cy.waitUntil(
+        () => {
+          return cy
+            .request({
+              method: 'GET',
+              url: `/centreon/api/latest/configuration/dashboards/${dashboardId}`
+            })
+            .then((getResponse) => {
+              return getResponse.body && getResponse.body.id === dashboardId;
+            });
+        },
+        {
+          timeout: 10000
+        }
+      );
+      cy.request({
+        body: patchBody,
+        method: 'PATCH',
+        url: `/centreon/api/latest/configuration/dashboards/${dashboardId}`
+      });
+    });
+  }
+);
+
 interface ShareDashboardToUserProps {
   dashboardName: string;
   role: string;
@@ -430,6 +725,30 @@ interface ListingRequestResult {
   };
 }
 
+interface PatchDashboardBody {
+  panels: Array<{
+    layout: {
+      height: number;
+      min_height: number;
+      min_width: number;
+      width: number;
+      x: number;
+      y: number;
+    };
+    name: string;
+    widget_settings: {
+      options: {
+        description: {
+          content: string;
+          enabled: boolean;
+        };
+        name: string;
+      };
+    };
+    widget_type: string;
+  }>;
+}
+
 Cypress.Commands.add(
   'shareDashboardToUser',
   ({ dashboardName, userName, role }: ShareDashboardToUserProps): void => {
@@ -465,7 +784,7 @@ Cypress.Commands.add(
 
 Cypress.Commands.add('getTimeFromHeader', (): Cypress.Chainable => {
   return cy
-    .get('header div[data-cy="clock"]', { timeout: 10000 })
+    .get('header div[data-cy="clock"]', { timeout: 20000 })
     .should('be.visible')
     .then(($time) => {
       const headerTime = $time.children()[1].textContent;
@@ -491,46 +810,85 @@ declare global {
         props: CopyToContainerProps,
         options?: Partial<Cypress.ExecOptions>
       ) => Cypress.Chainable;
+      copyWebContainerLogs: (props: CopyWebContainerLogsProps) => Cypress.Chainable;
       createDirectory: (directoryPath: string) => Cypress.Chainable;
       execInContainer: ({
         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;
+      getLogDirectory: () => Cypress.Chainable;
       getTimeFromHeader: () => Cypress.Chainable;
       getWebVersion: () => Cypress.Chainable;
       hoverRootMenuItem: (rootItemNumber: number) => Cypress.Chainable;
       insertDashboard: (dashboard: Dashboard) => Cypress.Chainable;
       insertDashboardList: (fixtureFile: string) => Cypress.Chainable;
+      insertDashboardWithWidget: (
+        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;
+      waitForElementInIframe: (
+        iframeSelector: string,
+        elementSelector: string
+      ) => Cypress.Chainable;
       stopContainer: ({ name }: StopContainerProps) => Cypress.Chainable;
-      stopWebContainer: ({ name }?: StopWebContainerProps) => Cypress.Chainable;
+      stopContainers: () => Cypress.Chainable;
       visitEmptyPage: () => Cypress.Chainable;
-      waitForContainerAndSetToken: () => Cypress.Chainable;
     }
   }
 }