switch to executeCode

Author: midleman

test/e2e/pages/quickInput.ts

@@ -40,7 +40,7 @@ export class QuickInput {
 		});
 	}
 
-	async waitForQuickInputOpened({ timeout = 10000 }: { timeout?: number } = {}): Promise<void> {
+	async waitForQuickInputOpened({ timeout = 3000 }: { timeout?: number } = {}): Promise<void> {
 		await expect(this.code.driver.page.locator(QuickInput.QUICK_INPUT_INPUT)).toBeVisible({ timeout });
 	}
 

test/e2e/pages/quickaccess.ts

@@ -139,7 +139,7 @@ export class QuickAccess {
 
 			// Await for quick input widget opened
 			try {
-				await this.quickInput.waitForQuickInputOpened();
+				await this.quickInput.waitForQuickInputOpened({ timeout: 3000 });
 			} catch (err) {
 				await this.code.driver.page.keyboard.press('Escape');
 				throw err;

test/e2e/tests/reticulate/helpers/verifyReticulateFunction.ts

@@ -3,8 +3,8 @@
  *  Licensed under the Elastic License 2.0. See LICENSE.txt for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { expect } from '@playwright/test';
 import { Application } from '../../../infra/index.js';
+import { expect } from '../../_test.setup.js';
 
 export const RETICULATE_SESSION = 'Python (reticulate)';
 
@@ -18,50 +18,42 @@ export async function verifyReticulateFunctionality(
 	const { console, sessions, variables } = app.workbench;
 
 	// Create a variable x in Python session
-	await sessions.select(pythonSessionId, true);
-	await runCodeExpectVariable(app, `x=${xValue}`, { name: 'x', value: xValue });
+	await expect(async () => {
+		await console.executeCode('Python', `x = ${xValue}`);
+		await variables.expectVariableToBe('x', xValue, 2000);
+	}, 'Can create variable in Python session').toPass();
 
 	// Switch to the R session and create an R variable `y` by accessing the Python
 	// variable `x` through reticulate.
-	await console.clearButton.click();
-	await sessions.select(rSessionId);
-	await runCodeExpectVariable(app, 'y<-reticulate::py$x', { name: 'y', value: xValue });
+	await expect(async () => {
+		await console.executeCode('R', 'y<-reticulate::py$x');
+		await variables.expectVariableToBe('y', xValue, 2000);
+	}, 'Can access Python variable x from R').toPass();
 
 	// Clear the console again and re-check to ensure the R-side variable persists.
 	await console.clearButton.click();
 	await variables.expectVariableToBe('y', xValue);
 
 	// Verify able to overwrite the R variable `y` with an integer literal on the R side.
-	await runCodeExpectVariable(app, `y <- ${yValue}L`, { name: 'y', value: yValue });
+	await expect(async () => {
+		await console.executeCode('R', `y <- ${yValue}L`);
+		await variables.expectVariableToBe('y', yValue, 2000);
+	}, 'Can overwrite the R variable').toPass();
 
 	// Verify executing reticulate::repl_python() moves focus to the reticulate session
 	await console.pasteCodeToConsole(`reticulate::repl_python(input = "z = ${zValue}")`, true);
 	await sessions.expectSessionPickerToBe(pythonSessionId, 20000);
 	await console.clearButton.click();
 
 	// Print the R variable r.y (should reflect the R-side value) and ensure it appears in the console
-	await runCodeExpectOutput(app, 'print(r.y)', yValue);
-
-	// Print the Python variable z (created via repl_python) and ensure it appears as well
-	await runCodeExpectOutput(app, 'print(z)', zValue);
-}
-
-async function runCodeExpectVariable(app: Application, code: string, variable: { name: string; value: string } = { name: '', value: '' }) {
-	const { console, variables } = app.workbench;
-
 	await expect(async () => {
-		await console.sendInterrupt();
-		await console.pasteCodeToConsole(code, true);
-		await variables.expectVariableToBe(variable.name, variable.value, 2000);
-	}, 'Run code and wait for variable to be present').toPass({ timeout: 10000 });
-}
-
-async function runCodeExpectOutput(app: Application, commmand: string, value: string) {
-	const { console } = app.workbench;
+		await console.executeCode('Python', 'print(r.y)');
+		await console.waitForConsoleContents(yValue, { timeout: 5000 });
+	}, 'Can print the R variable r.y from Python').toPass();
 
+	// Print the Python variable z (created via repl_python) and ensure it appears as well
 	await expect(async () => {
-		await console.sendInterrupt();
-		await console.pasteCodeToConsole(commmand, true);
-		await console.waitForConsoleContents(value, { timeout: 2000 });
-	}, 'Run code and expect console output').toPass({ timeout: 10000 });
+		await console.executeCode('Python', 'print(z)');
+		await console.waitForConsoleContents(zValue, { timeout: 5000 });
+	}, 'Can print the Python variable z from Python').toPass();
 }