RI-6570 Verify read operations for all key types in the browsers module (#4723)

* test: verify read operation for string, hash, list, set, sorted set, stream and JSON keys in browsers module
* refactor: extend the API to support adding string, list, sorted set, and JSON keys
* refactor: extend the API to support adding TTL to set, hash, and stream keys
* extend browser page locators to provide helpers for checking the state of the keys in the details drawer
- export common logic for building string buffers and reuse it as a helper function

re #RI-6570

Author: valkirilov

tests/playwright/helpers/api/api-keys.ts

@@ -7,6 +7,7 @@ import {
     SetKeyParameters,
     StreamKeyParameters,
 } from '../../types'
+import { stringToBuffer } from '../utils'
 
 const bufferPathMask = '/databases/databaseId/keys?encoding=buffer'
 export class APIKeyRequests {
@@ -15,20 +16,44 @@ export class APIKeyRequests {
         private databaseAPIRequests: DatabaseAPIRequests,
     ) {}
 
+    async addStringKeyApi(
+        keyParameters: { keyName: string; value: string; expire?: number },
+        databaseParameters: AddNewDatabaseParameters,
+    ): Promise<void> {
+        const databaseId = await this.databaseAPIRequests.getDatabaseIdByName(
+            databaseParameters.databaseName,
+        )
+        const requestBody = {
+            keyName: stringToBuffer(keyParameters.keyName),
+            value: stringToBuffer(keyParameters.value),
+            expire: keyParameters?.expire,
+        }
+
+        const response = await this.apiClient.post(
+            `/databases/${databaseId}/string?encoding=buffer`,
+            requestBody,
+        )
+
+        if (response.status !== 201) {
+            throw new Error('The creation of new String key request failed')
+        }
+    }
+
     async addHashKeyApi(
-        keyParameters: HashKeyParameters,
+        keyParameters: HashKeyParameters & { expire?: number },
         databaseParameters: AddNewDatabaseParameters,
     ): Promise<void> {
         const databaseId = await this.databaseAPIRequests.getDatabaseIdByName(
             databaseParameters.databaseName,
         )
         const requestBody = {
-            keyName: Buffer.from(keyParameters.keyName, 'utf-8'),
+            keyName: stringToBuffer(keyParameters.keyName),
             fields: keyParameters.fields.map((fields) => ({
                 ...fields,
-                field: Buffer.from(fields.field, 'utf-8'),
-                value: Buffer.from(fields.value, 'utf-8'),
+                field: stringToBuffer(fields.field),
+                value: stringToBuffer(fields.value),
             })),
+            expire: keyParameters?.expire,
         }
         const response = await this.apiClient.post(
             `/databases/${databaseId}/hash?encoding=buffer`,
@@ -38,22 +63,48 @@ export class APIKeyRequests {
             throw new Error('The creation of new Hash key request failed')
     }
 
+    async addListKeyApi(
+        keyParameters: { keyName: string; elements: string[]; expire?: number },
+        databaseParameters: AddNewDatabaseParameters,
+    ): Promise<void> {
+        const databaseId = await this.databaseAPIRequests.getDatabaseIdByName(
+            databaseParameters.databaseName,
+        )
+        const requestBody = {
+            keyName: stringToBuffer(keyParameters.keyName),
+            elements: keyParameters.elements.map((element) =>
+                stringToBuffer(element),
+            ),
+            expire: keyParameters?.expire,
+        }
+
+        const response = await this.apiClient.post(
+            `/databases/${databaseId}/list?encoding=buffer`,
+            requestBody,
+        )
+
+        if (response.status !== 201) {
+            throw new Error('The creation of new List key request failed')
+        }
+    }
+
     async addStreamKeyApi(
-        keyParameters: StreamKeyParameters,
+        keyParameters: StreamKeyParameters & { expire?: number },
         databaseParameters: AddNewDatabaseParameters,
     ): Promise<void> {
         const databaseId = await this.databaseAPIRequests.getDatabaseIdByName(
             databaseParameters.databaseName,
         )
         const requestBody = {
-            keyName: Buffer.from(keyParameters.keyName, 'utf-8'),
+            keyName: stringToBuffer(keyParameters.keyName),
             entries: keyParameters.entries.map((member) => ({
                 ...member,
                 fields: member.fields.map(({ name, value }) => ({
-                    name: Buffer.from(name, 'utf-8'),
-                    value: Buffer.from(value, 'utf-8'),
+                    name: stringToBuffer(name),
+                    value: stringToBuffer(value),
                 })),
             })),
+            expire: keyParameters?.expire,
         }
         const response = await this.apiClient.post(
             `/databases/${databaseId}/streams?encoding=buffer`,
@@ -64,17 +115,18 @@ export class APIKeyRequests {
     }
 
     async addSetKeyApi(
-        keyParameters: SetKeyParameters,
+        keyParameters: SetKeyParameters & { expire?: number },
         databaseParameters: AddNewDatabaseParameters,
     ): Promise<void> {
         const databaseId = await this.databaseAPIRequests.getDatabaseIdByName(
             databaseParameters.databaseName,
         )
         const requestBody = {
-            keyName: Buffer.from(keyParameters.keyName, 'utf-8'),
+            keyName: stringToBuffer(keyParameters.keyName),
             members: keyParameters.members.map((member) =>
-                Buffer.from(member, 'utf-8'),
+                stringToBuffer(member),
             ),
+            expire: keyParameters?.expire,
         }
         const response = await this.apiClient.post(
             `/databases/${databaseId}/set?encoding=buffer`,
@@ -84,6 +136,62 @@ export class APIKeyRequests {
             throw new Error('The creation of new Set key request failed')
     }
 
+    async addZSetKeyApi(
+        keyParameters: {
+            keyName: string
+            members: Array<{ name: string; score: number }>
+            expire?: number
+        },
+        databaseParameters: AddNewDatabaseParameters,
+    ): Promise<void> {
+        const databaseId = await this.databaseAPIRequests.getDatabaseIdByName(
+            databaseParameters.databaseName,
+        )
+        const requestBody = {
+            keyName: stringToBuffer(keyParameters.keyName),
+            members: keyParameters.members.map((member) => ({
+                name: stringToBuffer(member.name),
+                score: member.score,
+            })),
+            expire: keyParameters?.expire,
+        }
+
+        const response = await this.apiClient.post(
+            `/databases/${databaseId}/zSet?encoding=buffer`,
+            requestBody,
+        )
+
+        if (response.status !== 201) {
+            throw new Error('The creation of new ZSet key request failed')
+        }
+    }
+
+    async addJsonKeyApi(
+        keyParameters: { keyName: string; value: any; expire?: number },
+        databaseParameters: AddNewDatabaseParameters,
+    ): Promise<void> {
+        const databaseId = await this.databaseAPIRequests.getDatabaseIdByName(
+            databaseParameters.databaseName,
+        )
+        const requestBody: any = {
+            keyName: stringToBuffer(keyParameters.keyName),
+            data: JSON.stringify(keyParameters.value),
+        }
+
+        if (keyParameters.expire) {
+            requestBody.expire = keyParameters.expire
+        }
+
+        const response = await this.apiClient.post(
+            `/databases/${databaseId}/rejson-rl?encoding=buffer`,
+            requestBody,
+        )
+
+        if (response.status !== 201) {
+            throw new Error('The creation of new JSON key request failed')
+        }
+    }
+
     async searchKeyByNameApi(
         keyName: string,
         databaseName: string,
@@ -92,9 +200,8 @@ export class APIKeyRequests {
             cursor: '0',
             match: keyName,
         }
-        const databaseId = await this.databaseAPIRequests.getDatabaseIdByName(
-            databaseName,
-        )
+        const databaseId =
+            await this.databaseAPIRequests.getDatabaseIdByName(databaseName)
         const response = await this.apiClient.post(
             bufferPathMask.replace('databaseId', databaseId),
             requestBody,
@@ -108,15 +215,14 @@ export class APIKeyRequests {
         keyName: string,
         databaseName: string,
     ): Promise<void> {
-        const databaseId = await this.databaseAPIRequests.getDatabaseIdByName(
-            databaseName,
-        )
+        const databaseId =
+            await this.databaseAPIRequests.getDatabaseIdByName(databaseName)
         const doesKeyExist = await this.searchKeyByNameApi(
             keyName,
             databaseName,
         )
         if (doesKeyExist.length > 0) {
-            const requestBody = { keyNames: [Buffer.from(keyName, 'utf-8')] }
+            const requestBody = { keyNames: [stringToBuffer(keyName)] }
             const response = await this.apiClient.delete(
                 bufferPathMask.replace('databaseId', databaseId),
                 {

tests/playwright/helpers/utils.ts

@@ -32,3 +32,7 @@ export async function navigateToStandaloneInstance(page: Page): Promise<void> {
     await expect(db).toBeVisible({ timeout: 5000 })
     await db.first().click()
 }
+
+export function stringToBuffer(str: string): Buffer {
+    return Buffer.from(str, 'utf-8')
+}