@jahia/cypress 3.25.0 → 3.26.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});
+};
+