fix: add test

Author: astandrik

tests/suites/sidebar/Sidebar.ts

@@ -69,6 +69,7 @@ export class Sidebar {
 
     async clickSettings() {
         await this.settingsButton.click();
+        await this.drawer.waitFor({state: 'visible'});
     }
 
     async clickInformation() {
@@ -176,4 +177,59 @@ export class Sidebar {
         const switchControl = experimentItem.locator('xpath=../../..//input[@type="checkbox"]');
         return switchControl.isChecked();
     }
+
+    async closeDrawer(): Promise<void> {
+        await this.drawer.page().keyboard.press('Escape');
+        await this.drawer.waitFor({state: 'hidden'});
+    }
+
+    // ACL Syntax methods
+    async getAclSyntaxRadioGroup(): Promise<Locator> {
+        // First, find the settings item that contains the ACL syntax title
+        const aclSettingsItem = this.drawer
+            .locator('.gn-settings__item')
+            .filter({hasText: 'ACL syntax format'});
+
+        // Then find the radio button group within that item
+        return aclSettingsItem.locator('.g-radio-button');
+    }
+
+    async getSelectedAclSyntax(): Promise<string> {
+        const radioGroup = await this.getAclSyntaxRadioGroup();
+        const checkedOption = radioGroup.locator('.g-radio-button__option_checked');
+        const text = await checkedOption.textContent();
+        return text?.trim() || '';
+    }
+
+    async selectAclSyntax(syntax: 'KiKiMr' | 'YDB Short' | 'YDB' | 'YQL'): Promise<void> {
+        // Ensure drawer is visible first
+        await this.drawer.waitFor({state: 'visible'});
+
+        const radioGroup = await this.getAclSyntaxRadioGroup();
+        const option = radioGroup.locator(`.g-radio-button__option:has-text("${syntax}")`);
+        await option.click();
+        // Small delay to ensure the setting is saved
+        await this.drawer.page().waitForTimeout(100);
+    }
+
+    async getAclSyntaxOptions(): Promise<string[]> {
+        const radioGroup = await this.getAclSyntaxRadioGroup();
+        const options = radioGroup.locator('.g-radio-button__option');
+        const count = await options.count();
+        const texts: string[] = [];
+        for (let i = 0; i < count; i++) {
+            const text = await options.nth(i).textContent();
+            if (text) {
+                texts.push(text.trim());
+            }
+        }
+        return texts;
+    }
+
+    async isAclSyntaxSettingVisible(): Promise<boolean> {
+        const aclSetting = this.drawer
+            .locator('.gn-settings__item')
+            .filter({hasText: 'ACL syntax format'});
+        return aclSetting.isVisible();
+    }
 }

tests/suites/tenant/diagnostics/Diagnostics.ts

@@ -3,6 +3,7 @@ import type {Locator, Page} from '@playwright/test';
 import {retryAction} from '../../../utils/retryAction';
 import {MemoryViewer} from '../../memoryViewer/MemoryViewer';
 import {NodesPage} from '../../nodes/NodesPage';
+import type {Sidebar} from '../../sidebar/Sidebar';
 import {StoragePage} from '../../storage/StoragePage';
 import {VISIBILITY_TIMEOUT} from '../TenantPage';
 
@@ -229,6 +230,33 @@ export const TopShardsHistoricalColumns = [
     TOP_SHARDS_COLUMNS_IDS.IntervalEnd,
 ];
 
+export const ACL_SYNTAX_TEST_CONFIGS = [
+    {
+        syntax: 'YQL' as const,
+        patterns: {
+            USERS: 'CONNECT',
+            'METADATA-READERS': 'LIST',
+            'DATA-READERS': 'SELECT ROW',
+        },
+    },
+    {
+        syntax: 'KiKiMr' as const,
+        patterns: {
+            USERS: 'ConnectDatabase',
+            'METADATA-READERS': 'List',
+            'DATA-READERS': 'SelectRow',
+        },
+    },
+    {
+        syntax: 'YDB Short' as const,
+        patterns: {
+            USERS: 'connect',
+            'METADATA-READERS': 'list',
+            'DATA-READERS': 'select_row',
+        },
+    },
+];
+
 export class Diagnostics {
     table: Table;
     storage: StoragePage;
@@ -536,4 +564,71 @@ export class Diagnostics {
             .waitFor({state: 'visible', timeout: VISIBILITY_TIMEOUT});
         return true;
     }
+
+    async getEffectiveRightsFromTable(): Promise<Record<string, string>> {
+        const rightsTable = this.page.locator('.ydb-access-rights__rights-table');
+        await rightsTable.waitFor({state: 'visible', timeout: VISIBILITY_TIMEOUT});
+
+        const rows = await rightsTable.locator('tbody tr').all();
+        const rights: Record<string, string> = {};
+
+        for (const row of rows) {
+            const cells = await row.locator('td').all();
+            if (cells.length >= 3) {
+                // Get the subject name from the avatar component
+                const subjectElement = cells[0].locator('.ydb-subject-with-avatar__subject');
+                const subject = await subjectElement.textContent();
+                const effectiveRights = await cells[2].textContent();
+                if (subject && effectiveRights) {
+                    rights[subject.trim()] = effectiveRights.trim();
+                }
+            }
+        }
+
+        return rights;
+    }
+
+    async waitForTableDataToLoad(): Promise<void> {
+        // Wait for the table to be visible and have at least one row of data
+        const rightsTable = this.page.locator('.ydb-access-rights__rights-table');
+        await rightsTable.waitFor({state: 'visible', timeout: VISIBILITY_TIMEOUT});
+        await rightsTable
+            .locator('tbody tr')
+            .first()
+            .waitFor({state: 'visible', timeout: VISIBILITY_TIMEOUT});
+        // Additional small delay to ensure data is fully loaded
+        await this.page.waitForTimeout(500);
+    }
+
+    async getPermissionLabelsInGrantDialog(): Promise<string[]> {
+        const labels = await this.page
+            .locator('.ydb-grant-access__rights-wrapper .g-switch__text')
+            .all();
+        const texts: string[] = [];
+        for (const label of labels) {
+            const text = await label.textContent();
+            if (text) {
+                texts.push(text.trim());
+            }
+        }
+        return texts;
+    }
+
+    async switchAclSyntaxAndGetRights(
+        sidebar: Sidebar,
+        syntax: 'KiKiMr' | 'YDB Short' | 'YDB' | 'YQL',
+    ): Promise<Record<string, string>> {
+        // Switch syntax
+        await sidebar.clickSettings();
+        await sidebar.selectAclSyntax(syntax);
+        await sidebar.closeDrawer();
+
+        // Refresh the page data by navigating away and back
+        await this.clickTab(DiagnosticsTab.Info);
+        await this.clickTab(DiagnosticsTab.Access);
+        await this.waitForTableDataToLoad();
+
+        // Get and return the rights
+        return await this.getEffectiveRightsFromTable();
+    }
 }

tests/suites/tenant/diagnostics/tabs/access.test.ts

@@ -1,7 +1,8 @@
 import {expect, test} from '@playwright/test';
 
+import {Sidebar} from '../../../sidebar/Sidebar';
 import {TenantPage} from '../../TenantPage';
-import {Diagnostics, DiagnosticsTab} from '../Diagnostics';
+import {ACL_SYNTAX_TEST_CONFIGS, Diagnostics, DiagnosticsTab} from '../Diagnostics';
 
 const newSubject = 'foo';
 
@@ -127,4 +128,38 @@ test.describe('Diagnostics Access tab', async () => {
         // Verify that "foo" appears in the rights table
         await expect(diagnostics.isSubjectInRightsTable(newSubject)).resolves.toBe(true);
     });
+
+    test('Effective rights display changes when switching ACL syntax', async ({page}) => {
+        const pageQueryParams = {
+            schema: '/local',
+            database: '/local',
+            tenantPage: 'diagnostics',
+            diagnosticsTab: 'access',
+        };
+        const tenantPage = new TenantPage(page);
+        await tenantPage.goto(pageQueryParams);
+
+        const diagnostics = new Diagnostics(page);
+        const sidebar = new Sidebar(page);
+
+        // Run tests for each syntax configuration
+        const results: Record<string, Record<string, string>> = {};
+
+        for (const config of ACL_SYNTAX_TEST_CONFIGS) {
+            const rights = await diagnostics.switchAclSyntaxAndGetRights(sidebar, config.syntax);
+            expect(rights).toBeTruthy();
+
+            // Verify expected patterns
+            for (const [subject, pattern] of Object.entries(config.patterns)) {
+                expect(rights[subject]).toContain(pattern);
+            }
+
+            results[config.syntax] = rights;
+        }
+
+        // Verify that permission formats are different between syntaxes
+        expect(results.YQL?.['USERS']).not.toEqual(results.KiKiMr?.['USERS']);
+        expect(results.KiKiMr?.['USERS']).not.toEqual(results['YDB Short']?.['USERS']);
+        expect(results.YQL?.['DATA-READERS']).not.toEqual(results['YDB Short']?.['DATA-READERS']);
+    });
 });