E2e/feature/add telemetry events

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');

tests/e2e/tests/web/regression/settings/settings.e2e.ts

@@ -4,17 +4,29 @@ import {
     commonUrl, ossClusterConfig,
 } from '../../../../helpers/conf';
 import { DatabaseAPIRequests } from '../../../../helpers/api/api-database';
-import { Common, DatabaseHelper } from '../../../../helpers';
+import { Common, DatabaseHelper, Telemetry } from '../../../../helpers';
 
 const browserPage = new BrowserPage();
 const databaseAPIRequests = new DatabaseAPIRequests();
 const workbenchPage = new WorkbenchPage();
 const settingsPage = new SettingsPage();
 const memoryEfficiencyPage = new MemoryEfficiencyPage();
 const databaseHelper = new DatabaseHelper();
+const telemetry = new Telemetry();
+
+const logger = telemetry.createLogger();
 
 let keyName = Common.generateWord(20);
 
+const telemetryEvents = ['SETTINGS_DATE_TIME_FORMAT_CHANGED','DATABASE_ANALYSIS_STARTED'];
+const settingsExpectedProperties = [
+    'currentFormat'
+];
+const databaseAnalysisExpectedProperties = [
+    'databaseId',
+    'provider'
+];
+
 fixture `DataTime format setting`
     .meta({
         type: 'regression',
@@ -33,7 +45,9 @@ fixture `DataTime format setting`
         await databaseAPIRequests.deleteAllDatabasesApi();
         await settingsPage.selectTimeZoneDropdown('local');
     });
-test('Verify that user can select date time format', async t => {
+test
+    .requestHooks(logger)
+('Verify that user can select date time format', async t => {
     const defaultDateRegExp = /^([01]\d|2[0-3]):[0-5]\d:[0-5]\d \d{1,2} (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \d{4}$/;
     const selectedDateReqExp = /^(0[1-9]|[12]\d|3[01])\.(0[1-9]|1[0-2])\.\d{4} ([01]\d|2[0-3]):[0-5]\d:[0-5]\d$/;
     keyName = `DateTimeTestKey-${Common.generateWord(5)}`;
@@ -51,6 +65,9 @@ test('Verify that user can select date time format', async t => {
     await t.click(workbenchPage.NavigationPanel.settingsButton);
     await t.click(settingsPage.accordionAppearance);
     await settingsPage.selectDataFormatDropdown(selectorForOption);
+    //Verify telemetry event
+    await telemetry.verifyEventHasProperties(telemetryEvents[0], settingsExpectedProperties, logger);
+
     await t.expect(settingsPage.selectFormatDropdown.textContent).eql(selectedOption, 'option is not selected');
     await t.expect(selectedDateReqExp.test(await settingsPage.dataPreview.textContent)).ok(`preview is not valid for ${selectedOption}`);
 
@@ -70,7 +87,8 @@ test('Verify that user can select date time format', async t => {
     await t.expect(selectedDateReqExp.test(dateTime)).ok('date is not in default format HH:mm:ss.SSS d MMM yyyy');
 });
 
-test('Verify that user can set custom date time format', async t => {
+test .requestHooks(logger)
+('Verify that user can set custom date time format', async t => {
     const enteredFormat = 'MMM dd yyyy/ HH.mm.ss';
     const enteredDateReqExp = /^(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (0[1-9]|[12]\d|3[01]) \d{4}\/ ([01]\d|2[0-3])\.[0-5]\d\.[0-5]\d$/;
 
@@ -84,5 +102,9 @@ test('Verify that user can set custom date time format', async t => {
     await t.click(settingsPage.NavigationPanel.analysisPageButton);
     await t.click(memoryEfficiencyPage.databaseAnalysisTab);
     await t.click(memoryEfficiencyPage.newReportBtn);
+
+    //Verify telemetry event
+    await telemetry.verifyEventHasProperties(telemetryEvents[1], databaseAnalysisExpectedProperties, logger);
+
     await t.expect(enteredDateReqExp.test((await memoryEfficiencyPage.selectedReport.textContent).trim())).ok(`custom format is not working ${enteredFormat}`);
 });