Merge branch 'refs/heads/main' into gh/actions/test

# Conflicts:
#	.github/workflows/pipeline-build-macos.yml
#	.github/workflows/tests.yml

Author: egor-zalenski

.github/workflows/tests-backend.yml

@@ -20,7 +20,7 @@ jobs:
     runs-on: ubuntu-latest
     environment:
       name: staging
-      url: ${{ env.DEFAULT_GITHUB_PAGES_URL }}/${{ github.run_id }}/${{ env.REPORT_NAME }}/report
+      url: ${{ env.DEFAULT_GITHUB_PAGES_URL }}/${{ github.run_id }}/${{ env.REPORT_NAME }}
     steps:
     - uses: actions/checkout@v4
 

.github/workflows/tests-frontend.yml

@@ -14,7 +14,7 @@ jobs:
     name: Frontend tests
     environment:
       name: staging
-      url: ${{ env.DEFAULT_GITHUB_PAGES_URL }}/${{ github.run_id }}/${{ env.REPORT_NAME }}/report
+      url: ${{ env.DEFAULT_GITHUB_PAGES_URL }}/${{ github.run_id }}/${{ env.REPORT_NAME }}
     steps:
     - uses: actions/checkout@v4
 

.github/workflows/tests-integration.yml

@@ -157,6 +157,7 @@ jobs:
     runs-on: ubuntu-latest
     name: Final coverage
     needs: run-tests
+    if: always()
     steps:
     - uses: actions/checkout@v4
 
@@ -171,7 +172,7 @@ jobs:
     - name: Download coverage artifacts
       uses: actions/download-artifact@v4
       with:
-        pattern: coverages-artifacts
+        name: coverages-artifacts
         path: ./coverages
 
     - name: Calculate coverage across all tests runs

tests/e2e/package.json

@@ -65,7 +65,7 @@
     "selenium-webdriver": "^4.25.0",
     "sqlite3": "^5.1.7",
     "supertest": "^7.0.0",
-    "testcafe": "3.6.2",
+    "testcafe": "3.7.0",
     "testcafe-browser-provider-electron": "0.0.21",
     "testcafe-reporter-html": "1.4.6",
     "testcafe-reporter-json": "2.2.0",

tests/e2e/tests/web/critical-path/memory-efficiency/recommendations.e2e.ts

@@ -12,6 +12,7 @@ import { DatabaseAPIRequests } from '../../../../helpers/api/api-database';
 import { RecommendationsActions } from '../../../../common-actions/recommendations-actions';
 import { Common } from '../../../../helpers/common';
 import { APIKeyRequests } from '../../../../helpers/api/api-keys';
+import { Telemetry } from '../../../../helpers';
 
 const memoryEfficiencyPage = new MemoryEfficiencyPage();
 const myRedisDatabasePage = new MyRedisDatabasePage();
@@ -21,6 +22,16 @@ const workbenchPage = new WorkbenchPage();
 const databaseHelper = new DatabaseHelper();
 const databaseAPIRequests = new DatabaseAPIRequests();
 const apiKeyRequests = new APIKeyRequests();
+const telemetry = new Telemetry();
+
+const logger = telemetry.createLogger();
+
+const telemetryEvent = 'DATABASE_ANALYSIS_TIPS_COLLAPSED';
+const expectedProperties = [
+    'databaseId',
+    'provider',
+    'recommendation'
+];
 
 // const externalPageLink = 'https://docs.redis.com/latest/ri/memory-optimizations/';
 let keyName = `recomKey-${Common.generateWord(10)}`;
@@ -46,6 +57,7 @@ fixture `Memory Efficiency Recommendations`
         await databaseAPIRequests.deleteStandaloneDatabaseApi(ossStandaloneConfig);
     });
 test
+    .requestHooks(logger)
     .before(async t => {
         await databaseHelper.acceptLicenseTermsAndAddDatabaseApi(ossStandaloneBigConfig);
         // Go to Analysis Tools page
@@ -82,6 +94,10 @@ test
         // Verify that user can expand/collapse recommendation
         const expandedTextContaiterSize = await memoryEfficiencyPage.getRecommendationByName(luaScriptRecommendation).offsetHeight;
         await t.click(memoryEfficiencyPage.getRecommendationButtonByName(luaScriptRecommendation));
+
+        //Verify telemetry event
+        await telemetry.verifyEventHasProperties(telemetryEvent, expectedProperties, logger);
+
         await t.expect(memoryEfficiencyPage.getRecommendationByName(luaScriptRecommendation).offsetHeight)
             .lt(expandedTextContaiterSize, 'Lua script recommendation not collapsed');
         await t.click(memoryEfficiencyPage.getRecommendationButtonByName(luaScriptRecommendation));

tests/e2e/tests/web/critical-path/pub-sub/subscribe-unsubscribe.e2e.ts

@@ -4,13 +4,24 @@ import { commonUrl, ossStandaloneConfig, ossStandaloneV5Config } from '../../../
 import { rte } from '../../../../helpers/constants';
 import { verifyMessageDisplayingInPubSub } from '../../../../helpers/pub-sub';
 import { DatabaseAPIRequests } from '../../../../helpers/api/api-database';
+import { Telemetry } from '../../../../helpers';
 
 const myRedisDatabasePage = new MyRedisDatabasePage();
 const pubSubPage = new PubSubPage();
 const workbenchPage = new WorkbenchPage();
 const databaseHelper = new DatabaseHelper();
 const databaseAPIRequests = new DatabaseAPIRequests();
 const browserPage = new BrowserPage();
+const telemetry = new Telemetry();
+
+const logger = telemetry.createLogger();
+
+const telemetryEvent = 'PUBSUB_MESSAGES_CLEARED';
+const expectedProperties = [
+    'databaseId',
+    'messages',
+    'provider'
+];
 
 fixture `Subscribe/Unsubscribe from a channel`
     .meta({ rte: rte.standalone, type: 'critical_path' })
@@ -145,13 +156,17 @@ test('Verify that the Message field input is preserved until user Publish a mess
     // Verify that the Channel field input is preserved until user modify it (publishing a message does not clear the field)
     await t.expect(pubSubPage.channelNameInput.value).eql('testChannel', 'Channel input is empty', { timeout: 10000 });
 });
-test('Verify that user can clear all the messages from the pubsub window', async t => {
+test.requestHooks(logger)('Verify that user can clear all the messages from the pubsub window', async t => {
     await pubSubPage.subsribeToChannelAndPublishMessage('testChannel', 'message');
     await pubSubPage.publishMessage('testChannel2', 'second m');
     // Verify the tooltip text 'Clear Messages' appears on hover the clear button
     await t.hover(pubSubPage.clearPubSubButton);
     await t.expect(pubSubPage.clearButtonTooltip.textContent).contains('Clear Messages', 'Clear Messages tooltip not displayed');
     await t.click(pubSubPage.clearPubSubButton);
+
+    //Verify telemetry event
+    await telemetry.verifyEventHasProperties(telemetryEvent, expectedProperties, logger);
+
     // Verify that the clear of the messages does not affect the subscription state
     await t.expect(pubSubPage.subscribeStatus.textContent).eql('You are  subscribed', 'User is not subscribed', { timeout: 10000 });
     // Verify that the Messages counter is reset after clear messages

tests/e2e/tests/web/critical-path/rdi/add-rdi-instance.e2e.ts

@@ -7,7 +7,7 @@ import { RdiInstancePage } from '../../../../pageObjects/rdi-instance-page';
 import { commonUrl } from '../../../../helpers/conf';
 import { RdiPopoverOptions, RedisOverviewPage } from '../../../../helpers/constants';
 import { MyRedisDatabasePage } from '../../../../pageObjects';
-import { Common, DatabaseHelper } from '../../../../helpers';
+import { Common, DatabaseHelper, Telemetry } from '../../../../helpers';
 import { RdiApiRequests } from '../../../../helpers/api/api-rdi';
 import { goBackHistory } from '../../../../helpers/utils';
 
@@ -18,6 +18,22 @@ const myRedisDatabasePage = new MyRedisDatabasePage();
 const databaseHelper = new DatabaseHelper();
 const rdiApiRequests = new RdiApiRequests();
 
+const telemetry = new Telemetry();
+
+const logger = telemetry.createLogger();
+
+const telemetryEvents = ['RDI_INSTANCE_LIST_SEARCHED','RDI_START_OPTION_SELECTED'];
+
+const instanceExpectedProperties = [
+    'instancesFullCount',
+    'instancesSearchedCount'
+];
+
+const pipelineExpectedProperties = [
+    'id',
+    'option'
+];
+
 const rdiInstance: RdiInstance = {
     alias: 'Alias',
     url: 'https://11.111.111.111',
@@ -104,19 +120,24 @@ test('Verify that user can add and remove RDI', async() => {
 
     await t.expect(rdiInstancesListPage.emptyRdiList.textContent).contains('Redis Data Integration', 'The instance is not removed');
 });
-test
+test.requestHooks(logger)
     .after(async() => {
         await rdiInstancesListPage.deleteAllInstance();
     })('Verify that user can search by RDI', async() => {
         await rdiInstancesListPage.addRdi(rdiInstance);
         await rdiInstancesListPage.addRdi(rdiInstance2);
         await t.typeText(rdiInstancesListPage.searchInput, rdiInstance2.alias);
+
+        //Verify telemetry event
+        await telemetry.verifyEventHasProperties(telemetryEvents[0], instanceExpectedProperties, logger);
+
         const addedRdiInstance = await rdiInstancesListPage.getRdiInstanceValuesByIndex(0);
         await t.expect(addedRdiInstance.alias).eql(rdiInstance2.alias, 'correct item is displayed');
 
         await t.expect(await rdiInstancesListPage.rdiInstanceRow.count).eql(1, 'search works incorrectly');
     });
-test('Verify that sorting on the list of rdi saved when rdi opened', async t => {
+test.requestHooks(logger)
+('Verify that sorting on the list of rdi saved when rdi opened', async t => {
     // Sort by Connection Type
     await rdiInstancesListPage.addRdi(rdiInstance);
     await rdiInstancesListPage.addRdi(rdiInstance3);
@@ -128,6 +149,10 @@ test('Verify that sorting on the list of rdi saved when rdi opened', async t =>
     await rdiInstancesListPage.compareInstances(actualDatabaseList, sortedByAlias);
     await rdiInstancesListPage.clickRdiByName(rdiInstance.alias);
     await rdiInstancePage.selectStartPipelineOption(RdiPopoverOptions.Pipeline);
+
+    //verify telemetry event
+    await telemetry.verifyEventHasProperties(telemetryEvents[1], pipelineExpectedProperties, logger);
+
     await t.click(rdiInstancePage.RdiHeader.breadcrumbsLink);
     actualDatabaseList = await rdiInstancesListPage.getAllRdiNames();
     await rdiInstancesListPage.compareInstances(actualDatabaseList, sortedByAlias);

tests/e2e/tests/web/critical-path/settings/settings.e2e.ts

@@ -2,10 +2,21 @@ import { MyRedisDatabasePage, SettingsPage } from '../../../../pageObjects';
 import { rte } from '../../../../helpers/constants';
 import { DatabaseHelper } from '../../../../helpers/database';
 import { commonUrl } from '../../../../helpers/conf';
+import { Common, Telemetry } from '../../../../helpers';
 
 const myRedisDatabasePage = new MyRedisDatabasePage();
 const settingsPage = new SettingsPage();
 const databaseHelper = new DatabaseHelper();
+const telemetry = new Telemetry();
+
+const logger = telemetry.createLogger();
+
+const telemetryEvent = 'SETTINGS_WORKBENCH_EDITOR_CLEAR_CHANGED';
+
+const expectedProperties = [
+    'currentValue',
+    'newValue'
+];
 
 const explicitErrorHandler = (): void => {
     window.addEventListener('error', e => {
@@ -52,5 +63,19 @@ test('Verify that user can turn on/off Analytics in Settings in the application'
         await myRedisDatabasePage.reloadPage();
         await t.click(settingsPage.accordionPrivacySettings);
         await t.expect(await settingsPage.getAnalyticsSwitcherValue()).eql(value, 'Analytics was switched properly');
+        // Verify that telemetry is turned off
+        if(value === false){
+            await t.click(settingsPage.accordionWorkbenchSettings);
+            //turn on and turn off option
+            await t.click(settingsPage.switchEditorCleanupOption);
+            await t.click(settingsPage.switchEditorCleanupOption);
+
+            try {
+                await telemetry.verifyEventHasProperties(telemetryEvent, expectedProperties, logger);
+                await t.expect(true).eql(false, 'telemetry is sent when analytics is disabled');
+            } catch (error) {
+                await t.expect(true).eql(true, 'telemetry is not sent when analytics is disabled');
+            }
+        }
     }
 });

tests/e2e/tests/web/critical-path/slow-log/slow-log.e2e.ts

@@ -3,13 +3,29 @@ import { rte } from '../../../../helpers/constants';
 import { DatabaseHelper } from '../../../../helpers/database';
 import { commonUrl, ossStandaloneBigConfig } from '../../../../helpers/conf';
 import { DatabaseAPIRequests } from '../../../../helpers/api/api-database';
+import { Telemetry } from '../../../../helpers';
 
 const slowLogPage = new SlowLogPage();
 const myRedisDatabasePage = new MyRedisDatabasePage();
 const browserPage = new BrowserPage();
 const overviewPage = new ClusterDetailsPage();
 const databaseHelper = new DatabaseHelper();
 const databaseAPIRequests = new DatabaseAPIRequests();
+const telemetry = new Telemetry();
+
+const logger = telemetry.createLogger();
+
+const telemetryEvents = ['SLOWLOG_CLEARED','SLOWLOG_LOADED'];
+const clearExpectedProperties = [
+    'databaseId',
+    'provider'
+];
+
+const loadExpectedProperties = [
+    'databaseId',
+    'numberOfCommands',
+    'provider'
+];
 
 const slowerThanParameter = 1;
 let maxCommandLength = 50;
@@ -108,7 +124,8 @@ test('Verify that user can set slowlog-log-slower-than value in milliseconds and
     await t.expect(parseFloat(microsecondsDuration.replace(' ', '')) / 1000).eql(parseFloat(millisecondsDuration));
     await t.expect(parseFloat(microsecondsDuration.replace(' ', ''))).eql(parseFloat(millisecondsDuration) * 1000);
 });
-test('Verify that user can reset settings to default on Slow Log page', async t => {
+test.requestHooks(logger)
+('Verify that user can reset settings to default on Slow Log page', async t => {
     // Set slowlog-max-len=0
     command = 'info';
     await slowLogPage.changeSlowerThanParameter(slowerThanParameter, slowLogPage.slowLogConfigureMicroSecondsUnit);
@@ -117,12 +134,20 @@ test('Verify that user can reset settings to default on Slow Log page', async t
     await t.expect(slowLogPage.slowLogCommandValue.withExactText(command).exists).ok('Logged command not found');
     await t.click(slowLogPage.slowLogClearButton);
     await t.click(slowLogPage.slowLogConfirmClearButton);
+
+    //Verify telemetry event
+    await telemetry.verifyEventHasProperties(telemetryEvents[0], clearExpectedProperties, logger);
+
     // Verify that user can clear Slow Log
     await t.expect(slowLogPage.slowLogEmptyResult.exists).ok('Slow log is not cleared');
 
     // Set slower than parameter and max length
     await slowLogPage.changeSlowerThanParameter(slowerThanParameter, slowLogPage.slowLogConfigureMicroSecondsUnit);
     await slowLogPage.changeMaxLengthParameter(maxCommandLength);
+
+    //Verify telemetry event
+    await telemetry.verifyEventHasProperties(telemetryEvents[1], loadExpectedProperties, logger);
+
     // Reset settings to default
     await slowLogPage.resetToDefaultConfig();
     // Compare configuration after re-setting

tests/e2e/tests/web/critical-path/workbench/default-scripts-area.e2e.ts

@@ -18,12 +18,28 @@ const telemetry = new Telemetry();
 let indexName = chance.word({ length: 5 });
 let keyName = chance.word({ length: 5 });
 const logger = telemetry.createLogger();
-const telemetryEvent = 'EXPLORE_PANEL_TUTORIAL_OPENED';
+const tutorialTelemetryEvent = 'EXPLORE_PANEL_TUTORIAL_OPENED';
+const workbenchTelemetryEvents = ['WORKBENCH_COMMAND_SUBMITTED','WORKBENCH_MODE_CHANGED']
 const telemetryPath = 'static/tutorials/ds/hashes.md';
-const expectedProperties = [
+const tutorialExpectedProperties = [
     'databaseId',
     'path'
 ];
+const workbenchExpectedProperties = [
+    'command',
+    'databaseId',
+    'multiple',
+    'pipeline',
+    'provider',
+    'rawMode',
+    'results'
+];
+const rawModeExpectedProperties = [
+    'changedFromMode',
+    'changedToMode',
+    'databaseId',
+    'provider',
+];
 
 fixture `Default scripts area at Workbench`
     .meta({ type: 'critical_path', rte: rte.standalone })
@@ -53,20 +69,24 @@ test
             `FT.INFO "${indexName}"`;
         // Send commands
         await workbenchPage.sendCommandInWorkbench(commandsForSend.join('\n'));
+        await telemetry.verifyEventHasProperties(workbenchTelemetryEvents[0], workbenchExpectedProperties, logger);
         // Run automatically added "FT._LIST" and "FT.INFO {index}" scripts
         await workbenchPage.NavigationHeader.togglePanel(true);
         const tutorials = await workbenchPage.InsightsPanel.setActiveTab(ExploreTabs.Tutorials);
         await t.click(tutorials.dataStructureAccordionTutorialButton);
         await t.click(tutorials.internalLinkWorkingWithHashes);
 
         // Verify that telemetry event 'WORKBENCH_ENABLEMENT_AREA_GUIDE_OPENED' sent and has all expected properties
-        await telemetry.verifyEventHasProperties(telemetryEvent, expectedProperties, logger);
-        await telemetry.verifyEventPropertyValue(telemetryEvent, 'path', telemetryPath, logger);
+        await telemetry.verifyEventHasProperties(tutorialTelemetryEvent, tutorialExpectedProperties, logger);
+        await telemetry.verifyEventPropertyValue(tutorialTelemetryEvent, 'path', telemetryPath, logger);
 
         await workbenchPage.sendCommandInWorkbench(addedScript);
 
         // Check the FT._LIST result
         await t.expect(workbenchPage.queryTextResult.textContent).contains(indexName, 'The result of the FT._LIST command not found');
+        // Verify telemetry event
+        await t.click(workbenchPage.rawModeBtn);
+        await telemetry.verifyEventHasProperties(workbenchTelemetryEvents[1], rawModeExpectedProperties, logger);
         // Check the FT.INFO result
         await t.switchToIframe(workbenchPage.iframe);
         await t.expect(workbenchPage.queryColumns.textContent).contains('name', 'The result of the FT.INFO command not found');