@alfresco/aca-playwright-shared 8.1.0-36718859092 → 8.1.0-36827201917

package/fesm2022/alfresco-aca-playwright-shared.mjs

@@ -232,8 +232,8 @@ const crypto = require('crypto');
 class Utils {
     static { this.string257Long = 'x'.repeat(257); }
     static { this.string513Long = 'x'.repeat(513); }
-    static random() {
-        return crypto.getRandomValues(new Uint32Array(1))[0].toString(36).substring(0, 5).toLowerCase();
+    static random(length = 5) {
+        return Array.from(crypto.getRandomValues(new Uint8Array(length)), (b) => (b % 36).toString(36)).join('');
     }
     static retryCall(fn, retry = 30, delay = 1500) {
         const pause = (duration) => new Promise((res) => setTimeout(res, duration));
@@ -5480,60 +5480,6 @@ class FileActionsApi {
             throw new Error(message);
         }
     }
-    async queryNodesSearchHighlight(searchTerm) {
-        const data = {
-            query: {
-                query: `cm:name:"${searchTerm}*"`,
-                language: 'afts'
-            },
-            filterQueries: [{ query: `+TYPE:'cm:folder' OR +TYPE:'cm:content'` }],
-            highlight: {
-                prefix: "<span class='aca-highlight'>",
-                postfix: '</span>',
-                fields: [
-                    {
-                        field: 'cm:title'
-                    },
-                    {
-                        field: 'cm:name'
-                    },
-                    {
-                        field: 'cm:description',
-                        snippetCount: 1
-                    },
-                    {
-                        field: 'cm:content',
-                        snippetCount: 1
-                    }
-                ]
-            }
-        };
-        try {
-            return this.apiService.search.search(data);
-        }
-        catch {
-            return new ResultSetPaging();
-        }
-    }
-    async waitForNodesSearchHighlight(searchTerm, data) {
-        const predicate = (totalItems) => totalItems === data.expect;
-        const apiCall = async () => {
-            try {
-                return (await this.queryNodesSearchHighlight(searchTerm)).list?.pagination?.totalItems || 0;
-            }
-            catch (error) {
-                logger.warn(`queryNodesSearchHighlight failed for "${searchTerm}": ${JSON.stringify(error)}`);
-                return 0;
-            }
-        };
-        try {
-            await waitForApi(apiCall, predicate, 30, 2500);
-            logger.log(`waitForNodesSearchHighlight: Found ${data.expect} nodes with search term "${searchTerm}"`);
-        }
-        catch (error) {
-            logger.error(`Error: ${JSON.stringify(error)}`);
-        }
-    }
     async updateNodeContent(nodeId, content, majorVersion = true, comment, newName) {
         try {
             const opts = { majorVersion };
@@ -6742,6 +6688,42 @@ class SearchApi {
             throw new Error(errorMessage);
         }
     }
+    async waitForContentIndexing(contentTerm, expectedFileName, maxRetries) {
+        const query = {
+            query: {
+                query: `cm:content:"${contentTerm}"`,
+                language: 'afts'
+            },
+            filterQueries: [{ query: "+TYPE:'cm:content'" }],
+            paging: { skipCount: 0, maxItems: 25 }
+        };
+        const retryLimit = maxRetries ?? 90;
+        let retryCount = 0;
+        let found = false;
+        do {
+            let result;
+            try {
+                result = await this.apiService.search.search(query);
+            }
+            catch {
+                result = new ResultSetPaging();
+            }
+            found = (result.list?.entries ?? []).some((entry) => entry.entry?.name === expectedFileName);
+            if (!found) {
+                retryCount++;
+                if (retryCount % 10 === 0) {
+                    logger.info(`waitForContentIndexing: Still waiting for content "${contentTerm}" in "${expectedFileName}" after ${retryCount} retries (max ${retryLimit}).`);
+                }
+                if (retryCount >= retryLimit) {
+                    const message = `waitForContentIndexing: content "${contentTerm}" not indexed for "${expectedFileName}" after ${retryLimit} retries`;
+                    logger.error(message);
+                    throw new Error(message);
+                }
+                await Utils.delayInSeconds(1);
+            }
+        } while (!found);
+        logger.info(`waitForContentIndexing: content "${contentTerm}" is indexed for "${expectedFileName}".`);
+    }
 }
 
 /*!