Merge pull request #2218 from RedisInsight/e2e/feature/RI-4530-fixed-subscription-autodiscovery

E2e/feature/ri 4530 fixed subscription autodiscovery

Author: vlad-dargel

tests/e2e/helpers/conf.ts

@@ -99,7 +99,9 @@ export const cloudDatabaseConfig = {
     port: process.env.E2E_CLOUD_DATABASE_PORT || '',
     databaseName: `${process.env.E2E_CLOUD_DATABASE_NAME || 'cloud-database'}-${uniqueId}`,
     databaseUsername: process.env.E2E_CLOUD_DATABASE_USERNAME,
-    databasePassword: process.env.E2E_CLOUD_DATABASE_PASSWORD
+    databasePassword: process.env.E2E_CLOUD_DATABASE_PASSWORD,
+    accessKey: process.env.E2E_CLOUD_API_ACCESS_KEY || '',
+    secretKey: process.env.E2E_CLOUD_API_SECRET_KEY || ''
 };
 
 export const ossStandaloneNoPermissionsConfig = {

tests/e2e/helpers/database.ts

@@ -53,12 +53,12 @@ export async function discoverSentinelDatabase(databaseParameters: SentinelParam
  */
 export async function addNewREClusterDatabase(databaseParameters: AddNewDatabaseParameters): Promise<void> {
     // Fill the add database form
-    await myRedisDatabasePage.AddRedisDatabase.addAutodiscoverREClucterDatabase(databaseParameters);
+    await myRedisDatabasePage.AddRedisDatabase.addAutodiscoverREClusterDatabase(databaseParameters);
     // Click on submit button
     await t
         .click(myRedisDatabasePage.AddRedisDatabase.addRedisDatabaseButton)
     // Wait for database to be exist in the list of Autodiscover databases and select it
-        .expect(autoDiscoverREDatabases.databaseNames.withExactText(databaseParameters.databaseName ?? '').exists).ok('The database not displayed', { timeout: 10000 })
+        .expect(autoDiscoverREDatabases.databaseName.withExactText(databaseParameters.databaseName ?? '').exists).ok('The database not displayed', { timeout: 10000 })
         .typeText(autoDiscoverREDatabases.search, databaseParameters.databaseName ?? '')
         .click(autoDiscoverREDatabases.databaseCheckbox)
     // Click Add selected databases button
@@ -87,20 +87,23 @@ export async function addOSSClusterDatabase(databaseParameters: OSSClusterParame
  * @param cloudAPIAccessKey The Cloud API Access Key
  * @param cloudAPISecretKey The Cloud API Secret Key
  */
-export async function addNewRECloudDatabase(cloudAPIAccessKey: string, cloudAPISecretKey: string): Promise<string> {
+export async function autodiscoverRECloudDatabase(cloudAPIAccessKey: string, cloudAPISecretKey: string): Promise<string> {
     // Fill the add database form and Submit
     await myRedisDatabasePage.AddRedisDatabase.addAutodiscoverRECloudDatabase(cloudAPIAccessKey, cloudAPISecretKey);
     await t.click(myRedisDatabasePage.AddRedisDatabase.addRedisDatabaseButton);
+    await t.expect(autoDiscoverREDatabases.title.withExactText('Redis Enterprise Cloud Subscriptions').exists).ok('Subscriptions list not displayed', { timeout: 120000 });
     // Select subscriptions
     await t.click(myRedisDatabasePage.AddRedisDatabase.selectAllCheckbox);
     await t.click(myRedisDatabasePage.AddRedisDatabase.showDatabasesButton);
     // Select databases for adding
-    const databaseName = await browserPage.getDatabasesName();
-    await t.click(myRedisDatabasePage.AddRedisDatabase.selectAllCheckbox);
+    const databaseName = await autoDiscoverREDatabases.getDatabaseName();
+    await t.click(autoDiscoverREDatabases.databaseCheckbox);
     await t.click(autoDiscoverREDatabases.addSelectedDatabases);
     // Wait for database to be exist in the My redis databases list
+    await t.expect(autoDiscoverREDatabases.title.withExactText('Redis Enterprise Databases Added').exists).ok('Added databases list not displayed', { timeout: 20000 });
     await t.click(autoDiscoverREDatabases.viewDatabasesButton);
-    await t.expect(myRedisDatabasePage.dbNameList.withExactText(databaseName).exists).ok('The database not displayed', { timeout: 10000 });
+    // uncomment when fixed db will be added to cloud subscription
+    // await t.expect(myRedisDatabasePage.dbNameList.withExactText(databaseName).exists).ok('The database not displayed', { timeout: 10000 });
     return databaseName;
 }
 

tests/e2e/pageObjects/auto-discover-redis-enterprise-databases.ts

@@ -15,5 +15,10 @@ export class AutoDiscoverREDatabases extends BasePage {
     viewDatabasesButton = Selector('[data-testid=btn-view-databases]');
     //TEXT INPUTS (also referred to as 'Text fields')
     title = Selector('[data-testid=title]');
-    databaseNames = Selector('[data-testid^=db_name_]');
+    databaseName = Selector('[data-testid^=db_name_]');
+
+    // Get databases name
+    async getDatabaseName(): Promise<string> {
+        return this.databaseName.textContent;
+    }
 }

tests/e2e/pageObjects/browser-page.ts

@@ -195,7 +195,6 @@ export class BrowserPage extends InstancePage {
     keySizeDetails = Selector('[data-testid=key-size-text]');
     keyLengthDetails = Selector('[data-testid=key-length-text]');
     keyNameInTheList = Selector(this.cssSelectorKey);
-    databaseNames = Selector('[data-testid^=db_name_]');
     hashFieldsList = Selector('[data-testid^=hash-field-] span');
     hashValuesList = Selector('[data-testid^=hash-field-value-] span');
     hashField = Selector('[data-testid^=hash-field-]').nth(0);
@@ -755,11 +754,6 @@ export class BrowserPage extends InstancePage {
             .click(this.saveMemberButton);
     }
 
-    //Get databases name
-    async getDatabasesName(): Promise<string> {
-        return this.databaseNames.textContent;
-    }
-
     //Open key details
     async openKeyDetails(keyName: string): Promise<void> {
         await this.searchByKeyName(keyName);

tests/e2e/pageObjects/components/myRedisDatabase/add-redis-database.ts

@@ -180,7 +180,7 @@ export class AddRedisDatabase {
      * Adding a new database from RE Cluster via auto-discover flow
      * @param parameters the parameters of the database
      */
-    async addAutodiscoverREClucterDatabase(parameters: AddNewDatabaseParameters): Promise<void> {
+    async addAutodiscoverREClusterDatabase(parameters: AddNewDatabaseParameters): Promise<void> {
         await t
             .click(this.addDatabaseButton)
             .click(this.addAutoDiscoverDatabase)
@@ -199,8 +199,7 @@ export class AddRedisDatabase {
     async addAutodiscoverRECloudDatabase(cloudAPIAccessKey: string, cloudAPISecretKey: string): Promise<void> {
         await t
             .click(this.addDatabaseButton)
-            .click(this.addAutoDiscoverDatabase)
-            .click(this.redisCloudProType);
+            .click(this.addAutoDiscoverDatabase);
         await t
             .typeText(this.accessKeyInput, cloudAPIAccessKey, { replace: true, paste: true })
             .typeText(this.secretKeyInput, cloudAPISecretKey, { replace: true, paste: true });

tests/e2e/pageObjects/my-redis-databases-page.ts

@@ -72,6 +72,8 @@ export class MyRedisDatabasePage extends BasePage {
     successResultsAccordion = Selector('[data-testid^=success-results-]');
     partialResultsAccordion = Selector('[data-testid^=partial-results-]');
     failedResultsAccordion = Selector('[data-testid^=failed-results-]');
+    // CONTAINERS
+    databaseContainer = Selector('.databaseContainer');
 
     /**
      * Click on the database by name

tests/e2e/tests/smoke/database/add-standalone-db.e2e.ts

@@ -1,18 +1,14 @@
 import { t } from 'testcafe';
 import { Chance } from 'chance';
 import {
-    addNewREClusterDatabase,
     addOSSClusterDatabase,
     acceptLicenseTerms,
-    deleteDatabase,
-    addRECloudDatabase
+    deleteDatabase
 } from '../../../helpers/database';
 import {
     commonUrl,
     ossStandaloneConfig,
-    ossClusterConfig,
-    redisEnterpriseClusterConfig,
-    cloudDatabaseConfig
+    ossClusterConfig
 } from '../../../helpers/conf';
 import { env, rte } from '../../../helpers/constants';
 import { BrowserPage, MyRedisDatabasePage } from '../../../pageObjects';
@@ -86,16 +82,6 @@ test
         await myRedisDatabasePage.clickOnEditDBByName(databaseName);
         await t.expect(myRedisDatabasePage.AddRedisDatabase.timeoutInput.value).eql(connectionTimeout, 'Connection timeout is not customized');
     });
-test
-    .meta({ rte: rte.reCluster })
-    .after(async() => {
-        await deleteDatabase(redisEnterpriseClusterConfig.databaseName);
-    })('Verify that user can add database from RE Cluster via auto-discover flow', async() => {
-        await addNewREClusterDatabase(redisEnterpriseClusterConfig);
-        // Verify that user can see an indicator of databases that are added using autodiscovery and not opened yet
-        // Verify new connection badge for RE cluster
-        await myRedisDatabasePage.verifyDatabaseStatusIsVisible(redisEnterpriseClusterConfig.databaseName);
-    });
 test
     .meta({ env: env.web, rte: rte.ossCluster })
     .after(async() => {
@@ -105,15 +91,3 @@ test
         // Verify new connection badge for OSS cluster
         await myRedisDatabasePage.verifyDatabaseStatusIsVisible(ossClusterConfig.ossClusterDatabaseName);
     });
-
-test
-    .meta({ rte: rte.reCloud })
-    .after(async() => {
-        await deleteDatabase(cloudDatabaseConfig.databaseName);
-    })('Verify that user can add database from RE Cloud via auto-discover flow', async() => {
-        await addRECloudDatabase(cloudDatabaseConfig);
-        // Verify new connection badge for RE cloud
-        await myRedisDatabasePage.verifyDatabaseStatusIsVisible(cloudDatabaseConfig.databaseName);
-        // Verify redis stack icon for RE Cloud with all 5 modules
-        await t.expect(myRedisDatabasePage.redisStackIcon.visible).ok('Redis Stack icon not found for RE Cloud db with all 5 modules');
-    });

tests/e2e/tests/smoke/database/autodiscover-db.e2e.ts

@@ -0,0 +1,60 @@
+import { t } from 'testcafe';
+import {
+    addNewREClusterDatabase,
+    acceptLicenseTerms,
+    deleteDatabase,
+    addRECloudDatabase,
+    autodiscoverRECloudDatabase
+} from '../../../helpers/database';
+import {
+    commonUrl,
+    redisEnterpriseClusterConfig,
+    cloudDatabaseConfig
+} from '../../../helpers/conf';
+import { rte } from '../../../helpers/constants';
+import { MyRedisDatabasePage } from '../../../pageObjects';
+import { Common } from '../../../helpers/common';
+
+const myRedisDatabasePage = new MyRedisDatabasePage();
+
+let databaseName: string;
+
+fixture `Add database`
+    .meta({ type: 'smoke' })
+    .page(commonUrl)
+    .beforeEach(async() => {
+        await acceptLicenseTerms();
+    });
+test
+    .meta({ rte: rte.reCluster })
+    .after(async() => {
+        await deleteDatabase(redisEnterpriseClusterConfig.databaseName);
+    })('Verify that user can add database from RE Cluster via auto-discover flow', async() => {
+        await addNewREClusterDatabase(redisEnterpriseClusterConfig);
+        // Verify that user can see an indicator of databases that are added using autodiscovery and not opened yet
+        // Verify new connection badge for RE cluster
+        await myRedisDatabasePage.verifyDatabaseStatusIsVisible(redisEnterpriseClusterConfig.databaseName);
+    });
+test
+    .meta({ rte: rte.reCloud })
+    .after(async() => {
+        await deleteDatabase(cloudDatabaseConfig.databaseName);
+    })('Verify that user can add database from RE Cloud', async() => {
+        await addRECloudDatabase(cloudDatabaseConfig);
+        // Verify new connection badge for RE cloud
+        await myRedisDatabasePage.verifyDatabaseStatusIsVisible(cloudDatabaseConfig.databaseName);
+        // Verify redis stack icon for RE Cloud with all 5 modules
+        await t.expect(myRedisDatabasePage.redisStackIcon.visible).ok('Redis Stack icon not found for RE Cloud db with all 5 modules');
+    });
+test
+    .meta({ rte: rte.reCloud })
+    .after(async() => {
+        // await deleteDatabase(databaseName);
+    })('Verify that user can connect to the RE Cloud database via auto-discover flow', async t => {
+        // Verify that user can see the Cloud auto-discovery option selected by default when switching to the auto-discovery of databases
+        databaseName = await autodiscoverRECloudDatabase(cloudDatabaseConfig.accessKey, cloudDatabaseConfig.secretKey);
+        // uncomment when fixed db will be added to cloud subscription
+        // await myRedisDatabasePage.clickOnDBByName(databaseName);
+        // // Verify that user can add database from fixed subscription
+        // await t.expect(Common.getPageUrl()).contains('browser', 'The added RE Cloud database not opened');
+    });

tests/e2e/tests/smoke/database/edit-db.e2e.ts

@@ -1,5 +1,5 @@
 import { ClientFunction } from 'testcafe';
-import { acceptLicenseTerms, deleteDatabase, addNewStandaloneDatabase, addNewREClusterDatabase, addNewRECloudDatabase } from '../../../helpers/database';
+import { acceptLicenseTerms, deleteDatabase, addNewStandaloneDatabase, addNewREClusterDatabase } from '../../../helpers/database';
 import { MyRedisDatabasePage } from '../../../pageObjects';
 import {
     commonUrl,
@@ -42,11 +42,3 @@ test
         await myRedisDatabasePage.clickOnDBByName(ossStandaloneConfig.databaseName);
         await t.expect(getPageUrl()).contains('browser', 'Browser page not opened');
     });
-// skiped until the RE Cloud connection is implemented
-test.skip
-    .meta({ rte: rte.reCloud })('Verify that user can connect to the RE Cloud database', async t => {
-    // TODO: add api keys from env
-        const databaseName = await addNewRECloudDatabase('', '');
-        await myRedisDatabasePage.clickOnDBByName(databaseName);
-        await t.expect(getPageUrl()).contains('browser', 'The edit view is not opened');
-    });