@alfresco/aca-playwright-shared 5.1.1 → 5.2.0

package/esm2022/utils/utils.mjs

@@ -0,0 +1,145 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+const crypto = require('crypto');
+import * as path from 'path';
+import { format, subDays, subMonths, endOfMonth } from 'date-fns';
+import StreamZip from 'node-stream-zip';
+class Utils {
+    static string257Long = 'x'.repeat(257);
+    static string513Long = 'x'.repeat(513);
+    static random() {
+        return crypto.getRandomValues(new Uint32Array(1))[0].toString(36).substring(0, 5).toLowerCase();
+    }
+    static retryCall(fn, retry = 30, delay = 1500) {
+        const pause = (duration) => new Promise((res) => setTimeout(res, duration));
+        const run = (retries) => {
+            return fn().catch((err) => (retries > 1 ? pause(delay).then(() => run(retries - 1)) : Promise.reject(err)));
+        };
+        return run(retry);
+    }
+    static formatDate(date) {
+        return new Date(date).toLocaleDateString('en-US');
+    }
+    /**
+     * Method used to login user with navigation. Also waits for the page to load after login
+     *
+     * @param loginPage page context passed from the test
+     * @param username username string
+     * @param password password string
+     * @param errorMessage error message string if the login fails
+     *
+     */
+    static async tryLoginUser(loginPage, username, password, errorMessage = 'Error ') {
+        try {
+            await loginPage.loginUser({ username, password }, { withNavigation: true, waitForLoading: true });
+        }
+        catch (error) {
+            console.error(`${errorMessage}: ${error}`);
+        }
+    }
+    /**
+     * Method used to delete nodes and sites from user's account
+     *
+     * @param nodesApi nodesApi initialized with user credentials passed from the test
+     * @param trashcanApi trashcanApi initialized with user credentials passed from the test
+     * @param errorMessage error message string if the deleting sites/nodes fails
+     * @param sitesApi sitesApi initialized with user credentials passed from the test
+     * @param sitesToDelete array of sites' ids
+     *
+     */
+    static async deleteNodesSitesEmptyTrashcan(nodesApi, trashcanApi, errorMessage = 'Error ', sitesApi, sitesToDelete) {
+        try {
+            await nodesApi?.deleteCurrentUserNodes();
+            await trashcanApi?.emptyTrashcan();
+            if (sitesToDelete?.length > 0) {
+                await sitesApi?.deleteSites(sitesToDelete);
+            }
+        }
+        catch (error) {
+            console.error(`${errorMessage}: ${error}`);
+        }
+    }
+    static async uploadFileNewVersion(personalFilesPage, fileFromOS) {
+        const fileInput = await personalFilesPage.page.$('#app-upload-file-version');
+        await fileInput.setInputFiles(path.join(__dirname, `../resources/test-files/${fileFromOS}.docx`));
+    }
+    static async reloadPageIfRowNotVisible(pageContext, nodeName, errorMessage = 'reloadPageIfRowNotVisible Error ') {
+        try {
+            if (!(await pageContext.dataTable.getRowByName(nodeName).isVisible())) {
+                await pageContext.page.reload({ waitUntil: 'load' });
+            }
+        }
+        catch (error) {
+            console.error(`${errorMessage}: ${error}`);
+        }
+    }
+    static async reloadPageIfDatatableEmpty(pageContext, errorMessage = 'reloadPageIfDatatableEmpty Error ') {
+        try {
+            if ((await pageContext.dataTable.getEmptyFolderLocator.isVisible()) || (await pageContext.dataTable.emptyListTitle.isVisible())) {
+                await pageContext.page.reload({ waitUntil: 'load' });
+            }
+        }
+        catch (error) {
+            console.error(`${errorMessage}: ${error}`);
+        }
+    }
+    static getCurrentAndPreviousDay(currentDate = new Date()) {
+        let formattedDate;
+        let formattedDate2;
+        const formatDate = (date) => {
+            return format(date, 'dd-MMM-yy').toUpperCase();
+        };
+        if (currentDate.getDate() === 1) {
+            const lastDayOfPreviousMonth = endOfMonth(subMonths(currentDate, 1));
+            formattedDate = formatDate(lastDayOfPreviousMonth);
+            formattedDate2 = formatDate(subDays(lastDayOfPreviousMonth, 1));
+        }
+        else {
+            formattedDate = formatDate(currentDate);
+            formattedDate2 = formatDate(subDays(currentDate, 1));
+        }
+        return { currentDate: formattedDate, previousDate: formattedDate2 };
+    }
+    static async verifyZipFileContent(filePath, fileOrFolderName) {
+        const zip = new StreamZip({
+            file: filePath,
+            storeEntries: true
+        });
+        return new Promise((resolve) => {
+            zip.on('ready', () => {
+                const entries = zip.entries();
+                const found = this.isFileOrFolderInEntries(entries, fileOrFolderName);
+                zip.close();
+                resolve(found);
+            });
+        });
+    }
+    static isFileOrFolderInEntries(entries, fileOrFolderName) {
+        return fileOrFolderName.some((name) => {
+            return Object.keys(entries).some((entry) => entry.includes(name));
+        });
+    }
+}
+export { Utils };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../projects/aca-playwright-shared/src/utils/utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,MAAM,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AACjC,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAE7B,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAClE,OAAO,SAAS,MAAM,iBAAiB,CAAC;AAGxC,MAAa,KAAK;IAChB,MAAM,CAAU,aAAa,GAAG,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAChD,MAAM,CAAU,aAAa,GAAG,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAEhD,MAAM,CAAC,MAAM;QACX,OAAO,MAAM,CAAC,eAAe,CAAC,IAAI,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC;IAClG,CAAC;IAED,MAAM,CAAC,SAAS,CAAC,EAAsB,EAAE,QAAgB,EAAE,EAAE,QAAgB,IAAI;QAC/E,MAAM,KAAK,GAAG,CAAC,QAAgB,EAAE,EAAE,CAAC,IAAI,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,UAAU,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC;QAEpF,MAAM,GAAG,GAAG,CAAC,OAAe,EAAgB,EAAE;YAC5C,OAAO,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAC9G,CAAC,CAAC;QAEF,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC;IACpB,CAAC;IAED,MAAM,CAAC,UAAU,CAAC,IAAY;QAC5B,OAAO,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC;IACpD,CAAC;IAED;;;;;;;;OAQG;IACH,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,SAAoB,EAAE,QAAgB,EAAE,QAAgB,EAAE,YAAY,GAAG,QAAQ;QACzG,IAAI;YACF,MAAM,SAAS,CAAC,SAAS,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE,EAAE,cAAc,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,CAAC,CAAC;SACnG;QAAC,OAAO,KAAK,EAAE;YACd,OAAO,CAAC,KAAK,CAAC,GAAG,YAAY,KAAK,KAAK,EAAE,CAAC,CAAC;SAC5C;IACH,CAAC;IAED;;;;;;;;;OASG;IACH,MAAM,CAAC,KAAK,CAAC,6BAA6B,CACxC,QAAmB,EACnB,WAAyB,EACzB,YAAY,GAAG,QAAQ,EACvB,QAAmB,EACnB,aAAwB;QAExB,IAAI;YACF,MAAM,QAAQ,EAAE,sBAAsB,EAAE,CAAC;YACzC,MAAM,WAAW,EAAE,aAAa,EAAE,CAAC;YACnC,IAAI,aAAa,EAAE,MAAM,GAAG,CAAC,EAAE;gBAC7B,MAAM,QAAQ,EAAE,WAAW,CAAC,aAAa,CAAC,CAAC;aAC5C;SACF;QAAC,OAAO,KAAK,EAAE;YACd,OAAO,CAAC,KAAK,CAAC,GAAG,YAAY,KAAK,KAAK,EAAE,CAAC,CAAC;SAC5C;IACH,CAAC;IAED,MAAM,CAAC,KAAK,CAAC,oBAAoB,CAAC,iBAAoC,EAAE,UAAkB;QACxF,MAAM,SAAS,GAAG,MAAM,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC,0BAA0B,CAAC,CAAC;QAC7E,MAAM,SAAS,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,2BAA2B,UAAU,OAAO,CAAC,CAAC,CAAC;IACpG,CAAC;IAED,MAAM,CAAC,KAAK,CAAC,yBAAyB,CACpC,WAAmG,EACnG,QAAgB,EAChB,YAAY,GAAG,kCAAkC;QAEjD,IAAI;YACF,IAAI,CAAC,CAAC,MAAM,WAAW,CAAC,SAAS,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,SAAS,EAAE,CAAC,EAAE;gBACrE,MAAM,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC,CAAC;aACtD;SACF;QAAC,OAAO,KAAK,EAAE;YACd,OAAO,CAAC,KAAK,CAAC,GAAG,YAAY,KAAK,KAAK,EAAE,CAAC,CAAC;SAC5C;IACH,CAAC;IAED,MAAM,CAAC,KAAK,CAAC,0BAA0B,CACrC,WAA+G,EAC/G,YAAY,GAAG,mCAAmC;QAElD,IAAI;YACF,IAAI,CAAC,MAAM,WAAW,CAAC,SAAS,CAAC,qBAAqB,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,MAAM,WAAW,CAAC,SAAS,CAAC,cAAc,CAAC,SAAS,EAAE,CAAC,EAAE;gBAC/H,MAAM,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC,CAAC;aACtD;SACF;QAAC,OAAO,KAAK,EAAE;YACd,OAAO,CAAC,KAAK,CAAC,GAAG,YAAY,KAAK,KAAK,EAAE,CAAC,CAAC;SAC5C;IACH,CAAC;IAED,MAAM,CAAC,wBAAwB,CAAC,WAAW,GAAG,IAAI,IAAI,EAAE;QACtD,IAAI,aAAqB,CAAC;QAC1B,IAAI,cAAsB,CAAC;QAE3B,MAAM,UAAU,GAAG,CAAC,IAAU,EAAU,EAAE;YACxC,OAAO,MAAM,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC,WAAW,EAAE,CAAC;QACjD,CAAC,CAAC;QAEF,IAAI,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,EAAE;YAC/B,MAAM,sBAAsB,GAAS,UAAU,CAAC,SAAS,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,CAAC;YAC3E,aAAa,GAAG,UAAU,CAAC,sBAAsB,CAAC,CAAC;YACnD,cAAc,GAAG,UAAU,CAAC,OAAO,CAAC,sBAAsB,EAAE,CAAC,CAAC,CAAC,CAAC;SACjE;aAAM;YACL,aAAa,GAAG,UAAU,CAAC,WAAW,CAAC,CAAC;YACxC,cAAc,GAAG,UAAU,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,CAAC;SACtD;QAED,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,CAAC;IACtE,CAAC;IAED,MAAM,CAAC,KAAK,CAAC,oBAAoB,CAAC,QAAgB,EAAE,gBAA0B;QAC5E,MAAM,GAAG,GAAG,IAAI,SAAS,CAAC;YACxB,IAAI,EAAE,QAAQ;YACd,YAAY,EAAE,IAAI;SACnB,CAAC,CAAC;QAEH,OAAO,IAAI,OAAO,CAAU,CAAC,OAAO,EAAE,EAAE;YACtC,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE;gBACnB,MAAM,OAAO,GAAG,GAAG,CAAC,OAAO,EAAE,CAAC;gBAC9B,MAAM,KAAK,GAAG,IAAI,CAAC,uBAAuB,CAAC,OAAO,EAAE,gBAAgB,CAAC,CAAC;gBACtE,GAAG,CAAC,KAAK,EAAE,CAAC;gBACZ,OAAO,CAAC,KAAK,CAAC,CAAC;YACjB,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,MAAM,CAAC,uBAAuB,CAAC,OAA+C,EAAE,gBAA0B;QAChH,OAAO,gBAAgB,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE;YACpC,OAAO,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;QACpE,CAAC,CAAC,CAAC;IACL,CAAC;;SA3IU,KAAK","sourcesContent":["/*!\n * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Alfresco Example Content Application\n *\n * This file is part of the Alfresco Example Content Application.\n * If the software was purchased under a paid Alfresco license, the terms of\n * the paid license agreement will prevail. Otherwise, the software is\n * provided under the following open source license terms:\n *\n * The Alfresco Example Content Application is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * The Alfresco Example Content Application is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.\n */\n\nconst crypto = require('crypto');\nimport * as path from 'path';\nimport { LoginPage, MyLibrariesPage, PersonalFilesPage, FavoritesLibrariesPage, SearchPage, SharedPage, TrashPage } from '../page-objects';\nimport { format, subDays, subMonths, endOfMonth } from 'date-fns';\nimport StreamZip from 'node-stream-zip';\nimport { NodesApi, SitesApi, TrashcanApi } from '../api';\n\nexport class Utils {\n  static readonly string257Long = 'x'.repeat(257);\n  static readonly string513Long = 'x'.repeat(513);\n\n  static random(): string {\n    return crypto.getRandomValues(new Uint32Array(1))[0].toString(36).substring(0, 5).toLowerCase();\n  }\n\n  static retryCall(fn: () => Promise<any>, retry: number = 30, delay: number = 1500): Promise<any> {\n    const pause = (duration: number) => new Promise((res) => setTimeout(res, duration));\n\n    const run = (retries: number): Promise<any> => {\n      return fn().catch((err) => (retries > 1 ? pause(delay).then(() => run(retries - 1)) : Promise.reject(err)));\n    };\n\n    return run(retry);\n  }\n\n  static formatDate(date: string): string {\n    return new Date(date).toLocaleDateString('en-US');\n  }\n\n  /**\n   * Method used to login user with navigation. Also waits for the page to load after login\n   *\n   * @param loginPage page context passed from the test\n   * @param username username string\n   * @param password password string\n   * @param errorMessage error message string if the login fails\n   *\n   */\n  static async tryLoginUser(loginPage: LoginPage, username: string, password: string, errorMessage = 'Error '): Promise<void> {\n    try {\n      await loginPage.loginUser({ username, password }, { withNavigation: true, waitForLoading: true });\n    } catch (error) {\n      console.error(`${errorMessage}: ${error}`);\n    }\n  }\n\n  /**\n   * Method used to delete nodes and sites from user's account\n   *\n   * @param nodesApi nodesApi initialized with user credentials passed from the test\n   * @param trashcanApi trashcanApi initialized with user credentials passed from the test\n   * @param errorMessage error message string if the deleting sites/nodes fails\n   * @param sitesApi sitesApi initialized with user credentials passed from the test\n   * @param sitesToDelete array of sites' ids\n   *\n   */\n  static async deleteNodesSitesEmptyTrashcan(\n    nodesApi?: NodesApi,\n    trashcanApi?: TrashcanApi,\n    errorMessage = 'Error ',\n    sitesApi?: SitesApi,\n    sitesToDelete?: string[]\n  ): Promise<void> {\n    try {\n      await nodesApi?.deleteCurrentUserNodes();\n      await trashcanApi?.emptyTrashcan();\n      if (sitesToDelete?.length > 0) {\n        await sitesApi?.deleteSites(sitesToDelete);\n      }\n    } catch (error) {\n      console.error(`${errorMessage}: ${error}`);\n    }\n  }\n\n  static async uploadFileNewVersion(personalFilesPage: PersonalFilesPage, fileFromOS: string): Promise<void> {\n    const fileInput = await personalFilesPage.page.$('#app-upload-file-version');\n    await fileInput.setInputFiles(path.join(__dirname, `../resources/test-files/${fileFromOS}.docx`));\n  }\n\n  static async reloadPageIfRowNotVisible(\n    pageContext: PersonalFilesPage | MyLibrariesPage | FavoritesLibrariesPage | SearchPage | SharedPage,\n    nodeName: string,\n    errorMessage = 'reloadPageIfRowNotVisible Error '\n  ): Promise<void> {\n    try {\n      if (!(await pageContext.dataTable.getRowByName(nodeName).isVisible())) {\n        await pageContext.page.reload({ waitUntil: 'load' });\n      }\n    } catch (error) {\n      console.error(`${errorMessage}: ${error}`);\n    }\n  }\n\n  static async reloadPageIfDatatableEmpty(\n    pageContext: PersonalFilesPage | MyLibrariesPage | FavoritesLibrariesPage | SearchPage | SharedPage | TrashPage,\n    errorMessage = 'reloadPageIfDatatableEmpty Error '\n  ): Promise<void> {\n    try {\n      if ((await pageContext.dataTable.getEmptyFolderLocator.isVisible()) || (await pageContext.dataTable.emptyListTitle.isVisible())) {\n        await pageContext.page.reload({ waitUntil: 'load' });\n      }\n    } catch (error) {\n      console.error(`${errorMessage}: ${error}`);\n    }\n  }\n\n  static getCurrentAndPreviousDay(currentDate = new Date()): { currentDate: string; previousDate: string } {\n    let formattedDate: string;\n    let formattedDate2: string;\n\n    const formatDate = (date: Date): string => {\n      return format(date, 'dd-MMM-yy').toUpperCase();\n    };\n\n    if (currentDate.getDate() === 1) {\n      const lastDayOfPreviousMonth: Date = endOfMonth(subMonths(currentDate, 1));\n      formattedDate = formatDate(lastDayOfPreviousMonth);\n      formattedDate2 = formatDate(subDays(lastDayOfPreviousMonth, 1));\n    } else {\n      formattedDate = formatDate(currentDate);\n      formattedDate2 = formatDate(subDays(currentDate, 1));\n    }\n\n    return { currentDate: formattedDate, previousDate: formattedDate2 };\n  }\n\n  static async verifyZipFileContent(filePath: string, fileOrFolderName: string[]): Promise<boolean> {\n    const zip = new StreamZip({\n      file: filePath,\n      storeEntries: true\n    });\n\n    return new Promise<boolean>((resolve) => {\n      zip.on('ready', () => {\n        const entries = zip.entries();\n        const found = this.isFileOrFolderInEntries(entries, fileOrFolderName);\n        zip.close();\n        resolve(found);\n      });\n    });\n  }\n\n  private static isFileOrFolderInEntries(entries: { [name: string]: StreamZip.ZipEntry }, fileOrFolderName: string[]): boolean {\n    return fileOrFolderName.some((name) => {\n      return Object.keys(entries).some((entry) => entry.includes(name));\n    });\n  }\n}\n"]}