@jahia/cypress 3.25.0 → 3.27.0

package/src/page-object/moonstone/menu.ts

@@ -1,8 +1,10 @@
 import {BaseComponent} from '../baseComponent';
 import {getComponentByRole} from '../utils';
+import Chainable = Cypress.Chainable;
 
 export class Menu extends BaseComponent {
     static defaultSelector = '.moonstone-menu:not(.moonstone-hidden)'
+    static overlaySelector = '.moonstone-menu_overlay';
 
     submenu(item: string, menu: string): Menu {
         this.get().find('.moonstone-menuItem').contains(item).scrollIntoView().should('be.visible');
@@ -29,4 +31,8 @@ export class Menu extends BaseComponent {
         this.get().find(`.moonstone-menuItem[data-sel-role="${item}"]`).trigger('click');
         return this;
     }
+
+    close(): Chainable<unknown> {
+        return cy.get(Menu.overlaySelector).click('topRight');
+    }
 }

package/src/utils/JCRHelper.ts

@@ -87,3 +87,20 @@ export const getNodeTypes = (filter = {}): Cypress.Chainable => {
         queryFile: 'graphql/jcr/query/getNodeTypes.graphql'
     });
 };
+
+export const uploadFile = (fixturePath: string, parentPathOrId: string, name: string, mimeType: string): Cypress.Chainable => {
+    return cy.fixture(fixturePath, 'binary')
+        .then(image => {
+            const blob = Cypress.Blob.binaryStringToBlob(image, mimeType);
+            const file = new File([blob], name, {type: blob.type});
+            return cy.apollo({
+                mutationFile: 'graphql/jcr/mutation/uploadFile.graphql',
+                variables: {
+                    parentPathOrId,
+                    name,
+                    mimeType,
+                    file
+                }
+            });
+        });
+};

package/src/utils/SAMHelper.ts

@@ -1,36 +1,67 @@
-/*
-    When Jahia is starting or performing provisioning operations
-    it is expected for the SAM probe to alternate beween GREEN, YELLOW and RED statuses.
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import Chainable = Cypress.Chainable
 
-    The primary use of this method is to wait until a Jahia platform stabilizes after a startup or
-    provisioning operation.
-
-    Instead of waiting only for one occurence of a GREEN status, this function will wait until the a
-    GREEN status was returned a number of consecutive times (greenMatchCount).
-*/
-export const waitUntilSAMStatusGreen = (severity = 'MEDIUM', timeout = 60000, interval = 500, greenMatchCount = 10) : void => {
-    let greenCount = 0;
-    let lastGraphqlResponse = {};
-    cy.waitUntil(() =>
-        cy.apollo({
+/**
+ * Simple health check query
+ * @param severity the severity of the health check, default is MEDIUM
+ * @param probeHealthFilter the filter for the health check probes, default is GREEN
+ */
+export const healthCheck = (severity = 'MEDIUM', probeHealthFilter = 'GREEN'): Chainable<any> => {
+    return cy
+        .apollo({
             fetchPolicy: 'no-cache',
             queryFile: 'graphql/sam/healthStatus.graphql',
             variables: {
-                severity: severity
+                severity,
+                probeHealthFilter
             }
-        }).then(result => {
-            const healthStatus = result?.data?.admin?.jahia?.healthCheck?.status;
-            lastGraphqlResponse = result?.data?.admin?.jahia?.healthCheck;
+        })
+        .then((response: any) => {
+            return response?.data?.admin?.jahia?.healthCheck;
+        });
+};
+
+/**
+ * Wait until the health check returns the expected health
+ * @param expectedHealth the expected health status
+ * @param severity the severity of the health check, default is MEDIUM
+ * @param probeHealthFilter the filter for the health check probes, default is GREEN
+ * @param timeout the timeout in milliseconds, default is 60000
+ * @param interval the interval in milliseconds, default is 500
+ * @param statusMatchCount the number of consecutive status matches before the waitUntil resolves, default is 1
+ */
+export const waitUntilSAMStatus = ({expectedHealth, severity = 'MEDIUM', probeHealthFilter = 'GREEN', timeout = 60000, interval = 500, statusMatchCount = 1}) : void => {
+    let statusCount = 0;
+    let lastGraphqlResponse = {};
+    cy.waitUntil(() =>
+        healthCheck(severity, probeHealthFilter).then(result => {
+            lastGraphqlResponse = result;
+            const healthStatus = result?.status;
             if (healthStatus) {
-                greenCount = healthStatus.health === 'GREEN' ? greenCount + 1 : 0;
-                return greenCount >= greenMatchCount;
+                statusCount = healthStatus.health === expectedHealth ? statusCount + 1 : 0;
+                return statusCount >= statusMatchCount;
             }
         }),
     {
-        errorMsg: `Timeout waiting for SAM to be green for severity: ${severity}. Last GraphQL response: ${JSON.stringify(lastGraphqlResponse)}`,
+        errorMsg: `Timeout waiting for SAM to be ${expectedHealth} for severity: ${severity} and probeHealthFilter: ${probeHealthFilter}. Last GraphQL response: ${JSON.stringify(lastGraphqlResponse)}`,
         timeout: timeout,
         verbose: true,
         interval: interval
     });
 };
 
+/**
+ When Jahia is starting or performing provisioning operations
+ it is expected for the SAM probe to alternate beween GREEN, YELLOW and RED statuses.
+
+ The primary use of this method is to wait until a Jahia platform stabilizes after a startup or
+ provisioning operation.
+
+ Instead of waiting only for one occurence of a GREEN status, this function will wait until the a
+ GREEN status was returned a number of consecutive times (greenMatchCount).
+ */
+export const waitUntilSAMStatusGreen = (severity = 'MEDIUM', timeout = 60000, interval = 500, greenMatchCount = 10) : void => {
+    // We use YELLOW as the probeHealthFilter because we are not interested in potential GREEN probes in the response
+    waitUntilSAMStatus({expectedHealth: 'GREEN', severity, probeHealthFilter: 'YELLOW', timeout, interval, statusMatchCount: greenMatchCount});
+};
+

package/src/utils/SSHHelper.ts

@@ -0,0 +1,49 @@
+import {NodeSSH, SSHExecCommandResponse} from 'node-ssh';
+
+interface connection {
+    hostname: string
+    port: string
+    username: string
+    password: string
+}
+
+/**
+ * Execute SSH commands on a specific host. Returns a promise that resolves to the command result.
+ * Rejects if the commands fail (exit code is not 0).
+ * @param commands Array of SSH commands to execute
+ * @param connection Connection details
+ */
+export const sshCommands = (commands: Array<string>, connection: connection): Promise<SSHExecCommandResponse> => {
+    return new Promise((resolve, reject) => {
+        const ssh = new NodeSSH();
+        console.info('[SSH] connection to:', connection.hostname, ' (port: ', connection.port, ')');
+        console.info('[SSH] commands:', commands);
+        console.info('[SSH] ', connection);
+        ssh.connect({
+            host: connection.hostname,
+            port: parseInt(connection.port, 10),
+            username: connection.username,
+            password: connection.password
+        })
+            .then(() => {
+                ssh.exec(commands.join(';'), [], {stream: 'both'})
+                    .then(function (result) {
+                        console.info('[SSH] Successfully executed commands: ', commands);
+                        console.info('[SSH] Result: ', result);
+                        if (result.code === 0) {
+                            resolve(result); // Resolve to command result
+                        } else {
+                            reject(new Error(`Commands "${commands}" failed with exit code ${result.code} on host ${connection.hostname}. Stdout:${result.stdout}, Stderr: ${result.stderr}`));
+                        }
+                    })
+                    .catch(reason => {
+                        console.error('[SSH] Failed to execute commands: ', commands);
+                        reject(reason);
+                    });
+            })
+            .catch(reason => {
+                console.error('[SSH] Failed to connect to: ', connection.hostname);
+                reject(reason);
+            });
+    });
+};

package/src/utils/index.ts

@@ -1,9 +1,10 @@
+export * from './ClusterHelper';
+export * from './GraphQLHelper';
+export * from './JahiaPlatformHelper';
 export * from './JCRHelper';
 export * from './PublicationAndWorkflowHelper';
+export * from './SAMHelper';
 export * from './SiteHelper';
+export * from './SSHHelper';
 export * from './UsersHelper';
 export * from './VanityUrlHelper';
-export * from './ClusterHelper';
-export * from './JahiaPlatformHelper';
-export * from './GraphQLHelper';
-export * from './SAMHelper';