chore: Run selected part of the query

Author: astandrik

tests/suites/tenant/queryEditor/models/QueryEditor.ts

@@ -144,6 +144,27 @@ export class QueryEditor {
         await this.editorTextArea.focus();
     }
 
+    async selectText(startLine: number, startColumn: number, endLine: number, endColumn: number) {
+        await this.editorTextArea.evaluate(
+            (_, coords) => {
+                const editor = window.ydbEditor;
+                if (editor) {
+                    editor.setSelection({
+                        startLineNumber: coords.startLine,
+                        startColumn: coords.startColumn,
+                        endLineNumber: coords.endLine,
+                        endColumn: coords.endColumn,
+                    });
+                }
+            },
+            {startLine, startColumn, endLine, endColumn},
+        );
+    }
+
+    async pressKeys(key: string) {
+        await this.editorTextArea.press(key);
+    }
+
     async closeSettingsDialog() {
         await this.settingsDialog.clickButton(ButtonNames.Cancel);
     }

tests/suites/tenant/queryEditor/models/ResultTable.ts

@@ -24,11 +24,13 @@ export class ResultTable {
     private table: Locator;
     private preview: Locator;
     private resultHead: Locator;
+    private resultWrapper: Locator;
 
     constructor(selector: Locator) {
         this.table = selector.locator('.ydb-query-result-sets-viewer__result');
         this.preview = selector.locator('.kv-preview__result');
         this.resultHead = selector.locator('.ydb-query-result-sets-viewer__head');
+        this.resultWrapper = selector.locator('.ydb-query-result-sets-viewer__result-wrapper');
     }
 
     async isVisible() {
@@ -70,4 +72,34 @@ export class ResultTable {
         await this.resultHead.waitFor({state: 'visible', timeout: VISIBILITY_TIMEOUT});
         return this.resultHead.innerText();
     }
+
+    async getResultTabs() {
+        const tabs = this.resultWrapper.locator(
+            '.ydb-query-result-sets-viewer__tabs .g-tabs__item',
+        );
+        await tabs.first().waitFor({state: 'visible', timeout: VISIBILITY_TIMEOUT});
+        return tabs;
+    }
+
+    async getResultTabsCount() {
+        const tabs = await this.getResultTabs();
+        return tabs.count();
+    }
+
+    async getResultTabTitle(index: number) {
+        const tabs = await this.getResultTabs();
+        const tab = tabs.nth(index);
+        await tab.waitFor({state: 'visible', timeout: VISIBILITY_TIMEOUT});
+        return tab.getAttribute('title');
+    }
+
+    async hasMultipleResultTabs() {
+        const tabs = this.resultWrapper.locator('.ydb-query-result-sets-viewer__tabs');
+        try {
+            await tabs.waitFor({state: 'visible', timeout: VISIBILITY_TIMEOUT});
+            return true;
+        } catch {
+            return false;
+        }
+    }
 }

tests/suites/tenant/queryEditor/queryEditor.test.ts

@@ -12,6 +12,7 @@ import {
     QueryTabs,
     ResultTabNames,
 } from './models/QueryEditor';
+import {executeSelectedQueryWithKeybinding} from './utils';
 
 test.describe('Test Query Editor', async () => {
     const testQuery = 'SELECT 1, 2, 3, 4, 5;';
@@ -241,4 +242,30 @@ test.describe('Test Query Editor', async () => {
 
         await expect(queryEditor.waitForStatus('Completed')).resolves.toBe(true);
     });
+
+    test('Running selected query executes only selected part', async ({page}) => {
+        const queryEditor = new QueryEditor(page);
+        const multiQuery = 'SELECT 1;\nSELECT 2;';
+
+        // First verify running the entire query produces two results
+        await queryEditor.setQuery(multiQuery);
+        await queryEditor.clickRunButton();
+        await expect(queryEditor.waitForStatus('Completed')).resolves.toBe(true);
+
+        // Verify there are two result tabs
+        await expect(queryEditor.resultTable.getResultTabsCount()).resolves.toBe(2);
+        await expect(queryEditor.resultTable.getResultTabTitle(0)).resolves.toBe('Result #1');
+        await expect(queryEditor.resultTable.getResultTabTitle(1)).resolves.toBe('Result #2');
+
+        // Then verify running only selected part produces one result
+        await queryEditor.focusEditor();
+        await queryEditor.selectText(1, 1, 1, 9);
+
+        // Use keyboard shortcut to run selected query
+        await executeSelectedQueryWithKeybinding(page);
+
+        await expect(queryEditor.waitForStatus('Completed')).resolves.toBe(true);
+        await expect(queryEditor.resultTable.hasMultipleResultTabs()).resolves.toBe(false);
+        await expect(queryEditor.resultTable.getResultHeadText()).resolves.toBe('Result(1)');
+    });
 });

tests/suites/tenant/queryEditor/utils.ts

@@ -0,0 +1,20 @@
+import type {Page} from '@playwright/test';
+
+export const executeSelectedQueryWithKeybinding = async (page: Page) => {
+    const isMac = process.platform === 'darwin';
+    const browserName = page.context().browser()?.browserType().name() ?? 'chromium';
+    const modifierKey = browserName === 'webkit' ? 'Meta' : 'Control';
+
+    if (browserName !== 'webkit' || isMac) {
+        await page.keyboard.down(modifierKey);
+        await page.keyboard.down('Shift');
+        await page.keyboard.press('Enter');
+        await page.keyboard.up('Shift');
+        await page.keyboard.up(modifierKey);
+    } else {
+        await page.keyboard.press('Meta+Shift+Enter');
+    }
+
+    // Add a small delay to ensure the event is processed
+    await page.waitForTimeout(1000);
+};