@jupyterlab/galata 5.0.0-alpha.2 → 5.0.0-alpha.21

package/src/helpers/activity.ts

@@ -0,0 +1,115 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import { ElementHandle, Page } from '@playwright/test';
+import * as Utils from '../utils';
+
+/**
+ * Activity helper
+ */
+export class ActivityHelper {
+  constructor(readonly page: Page) {}
+
+  /**
+   * JupyterLab launcher selector
+   */
+  get launcherSelector(): string {
+    return Utils.xpBuildActivityTabSelector('Launcher');
+  }
+
+  /**
+   * Close all widgets in the main area
+   */
+  async closeAll(): Promise<void> {
+    await this.page.evaluate(async (launcherSelector: string) => {
+      await window.jupyterapp.commands.execute('application:close-all');
+      await window.galata.waitForXPath(launcherSelector);
+    }, this.launcherSelector);
+  }
+
+  /**
+   * Whether a tab is active or not
+   *
+   * @param name Activity name
+   * @returns Active status
+   */
+  async isTabActive(name: string): Promise<boolean> {
+    const tab = await this.getTab(name);
+    return (
+      (tab &&
+        (await tab.evaluate((tab: Element) =>
+          tab.classList.contains('lm-mod-current')
+        ))) ??
+      false
+    );
+  }
+
+  /**
+   * Get a handle on a tab
+   *
+   * @param name Activity name
+   * @returns Handle on the tab or null if the tab is not found
+   */
+  getTab(name?: string): Promise<ElementHandle<Element> | null> {
+    const page = this.page;
+    const tabSelector = name
+      ? Utils.xpBuildActivityTabSelector(name)
+      : Utils.xpBuildActiveActivityTabSelector();
+    return page.$(`xpath=${tabSelector}`);
+  }
+
+  /**
+   * Get a handle on a panel
+   *
+   * @param name Activity name
+   * @returns Handle on the tab or null if the tab is not found
+   */
+  async getPanel(name?: string): Promise<ElementHandle<Element> | null> {
+    const page = this.page;
+    const tab = await this.getTab(name);
+    if (tab) {
+      const id = await tab.evaluate((tab: Element) =>
+        tab.getAttribute('data-id')
+      );
+      return await page.$(`xpath=${Utils.xpBuildActivityPanelSelector(id!)}`);
+    }
+
+    return null;
+  }
+
+  /**
+   * Close a panel from its tab name
+   *
+   * @param name Activity name
+   */
+  async closePanel(name: string): Promise<void> {
+    await this.activateTab(name);
+    await this.page.evaluate(async (launcherSelector: string) => {
+      await window.jupyterapp.commands.execute('application:close');
+      await window.galata.waitForXPath(launcherSelector);
+    }, this.launcherSelector);
+  }
+
+  /**
+   * Activate a tab is active
+   *
+   * @param name Activity name
+   * @returns Whether the action is successful
+   */
+  async activateTab(name: string): Promise<boolean> {
+    const tab = await this.getTab(name);
+    if (tab) {
+      await tab.click();
+      await this.page.waitForFunction(
+        ({ tab }) => {
+          return tab.classList.contains('jp-mod-current');
+        },
+        { tab }
+      );
+
+      return true;
+    }
+
+    return false;
+  }
+}

package/src/helpers/debuggerpanel.ts

@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) Jupyter Development Team.
+ * Distributed under the terms of the Modified BSD License.
+ */
+
+import { ElementHandle, Page } from '@playwright/test';
+import { SidebarHelper } from './sidebar';
+import { NotebookHelper } from './notebook';
+import { waitForCondition } from '../utils';
+
+const DEBUGGER_ITEM = 'debugger-icon';
+
+/**
+ * Debugger Helper
+ */
+export class DebuggerHelper {
+  constructor(
+    readonly page: Page,
+    readonly sidebar: SidebarHelper,
+    readonly notebook: NotebookHelper
+  ) {}
+
+  /**
+   * Returns true if debugger toolbar item is enabled, false otherwise
+   */
+  async isOn(): Promise<boolean> {
+    if (!(await this.notebook.isAnyActive())) {
+      return false;
+    }
+    const item = await this.notebook.getToolbarItem(DEBUGGER_ITEM);
+    if (item) {
+      const button = await item.$('button');
+      if (button) {
+        return (await button.getAttribute('aria-pressed')) === 'true';
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Enables the debugger toolbar item
+   */
+  async switchOn(): Promise<void> {
+    await waitForCondition(async () => {
+      const item = await this.notebook.getToolbarItem(DEBUGGER_ITEM);
+      if (item) {
+        const button = await item.$('button');
+        if (button) {
+          return (await button.getAttribute('aria-disabled')) !== 'true';
+        }
+      }
+      return false;
+    }, 2000);
+    if (!(await this.isOn())) {
+      await this.notebook.clickToolbarItem(DEBUGGER_ITEM);
+    }
+  }
+
+  /**
+   * Disables the debugger toolbar item
+   */
+  async switchOff(): Promise<void> {
+    if (await this.isOn()) {
+      await this.notebook.clickToolbarItem(DEBUGGER_ITEM);
+    }
+  }
+
+  /**
+   *  Returns true if debugger panel is open, false otherwise
+   */
+  async isOpen(): Promise<boolean> {
+    return await this.sidebar.isTabOpen('jp-debugger-sidebar');
+  }
+
+  /**
+   * Returns handle to the variables panel content
+   */
+  async getVariablesPanel(): Promise<ElementHandle<Element> | null> {
+    return this._getPanel('.jp-DebuggerVariables');
+  }
+
+  /**
+   * Waits for variables to be populated in the variables panel
+   */
+  async waitForVariables(): Promise<void> {
+    await this.page.waitForSelector('.jp-DebuggerVariables-body ul');
+  }
+
+  /**
+   * render variable
+   */
+  async renderVariable(name: string): Promise<void> {
+    await this.page
+      .locator(`.jp-DebuggerVariables :text("${name}")`)
+      .click({ button: 'right' });
+    await this.page
+      .locator('.lm-Menu-itemLabel:text("Render Variable")')
+      .click();
+    await this.page.waitForSelector('.jp-VariableRendererPanel-renderer');
+  }
+
+  /**
+   * Returns handle to callstack panel content
+   */
+  async getCallStackPanel(): Promise<ElementHandle<Element> | null> {
+    return this._getPanel('.jp-DebuggerCallstack');
+  }
+
+  /**
+   * Waits for the callstack body to populate in the callstack panel
+   */
+  async waitForCallStack(): Promise<void> {
+    await this.page.waitForSelector(
+      '.jp-DebuggerCallstack-body >> .jp-DebuggerCallstackFrame'
+    );
+  }
+
+  /**
+   * Returns handle to breakpoints panel content
+   */
+  async getBreakPointsPanel(): Promise<ElementHandle<Element> | null> {
+    return this._getPanel('.jp-DebuggerBreakpoints');
+  }
+
+  /**
+   * Waits for the breakpoints to appear in the breakpoints panel
+   */
+  async waitForBreakPoints(): Promise<void> {
+    await this.page.waitForSelector(
+      '.jp-DebuggerBreakpoints >> .jp-DebuggerBreakpoint'
+    );
+  }
+
+  /**
+   * Returns handle to sources panel content
+   */
+  async getSourcePanel(): Promise<ElementHandle<Element> | null> {
+    return this._getPanel('.jp-DebuggerSources');
+  }
+
+  /**
+   * Waits for sources to be populated in the sources panel
+   */
+  async waitForSources(): Promise<void> {
+    await this.page.waitForSelector('.jp-DebuggerSources-body >> .jp-Editor', {
+      state: 'visible'
+    });
+  }
+
+  private async _getPanel(
+    selector: string
+  ): Promise<ElementHandle<Element> | null> {
+    const panel = await this.sidebar.getContentPanel('right');
+    if (panel) {
+      return panel.$(selector);
+    }
+    return null;
+  }
+}

package/src/helpers/filebrowser.ts

@@ -0,0 +1,228 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import { Page } from '@playwright/test';
+import * as path from 'path';
+import { ContentsHelper } from '../contents';
+import * as Utils from '../utils';
+
+/**
+ * File Browser Helpers
+ */
+export class FileBrowserHelper {
+  constructor(readonly page: Page, readonly contents: ContentsHelper) {}
+
+  /**
+   * Create the selector for a file in the file browser
+   *
+   * @param fileName File name
+   * @returns XPath to file in file browser
+   */
+  xpBuildFileSelector(fileName: string): string {
+    return `//div[@id='filebrowser']//li[./span[${Utils.xpContainsClass(
+      'jp-DirListing-itemText'
+    )} and ./span[text()="${fileName}"]]]`;
+  }
+
+  /**
+   * Create the selector for a directory in the file browser
+   *
+   * @param dirName Directory name
+   * @returns XPath to directory in file browser
+   */
+  xpBuildDirectorySelector(dirName: string): string {
+    return `//div[@id='filebrowser']//li[@data-isdir='true' and ./span[${Utils.xpContainsClass(
+      'jp-DirListing-itemText'
+    )} and ./span[text()="${dirName}"]]]`;
+  }
+
+  /**
+   * Reveal a file in the file browser.
+   *
+   * It will open intermediate folders if needed.
+   *
+   * @param filePath File path
+   */
+  async revealFileInBrowser(filePath: string): Promise<void> {
+    const pos = filePath.lastIndexOf('/');
+    const fileName = path.basename(filePath);
+    if (pos >= 0) {
+      const dirPath = filePath.substring(0, pos);
+      await this.openDirectory(dirPath);
+    }
+
+    await Utils.waitForCondition(async () => {
+      return await this.isFileListedInBrowser(fileName);
+    });
+  }
+
+  /**
+   * Whether the file is listed in the file browser or not.
+   *
+   * @param fileName File name
+   * @returns File status
+   */
+  async isFileListedInBrowser(fileName: string): Promise<boolean> {
+    const item = await this.page.$(
+      `xpath=${this.xpBuildFileSelector(fileName)}`
+    );
+    return item !== null;
+  }
+
+  /**
+   * Get the full path of the currently opened directory
+   *
+   * @returns Directory full path
+   */
+  async getCurrentDirectory(): Promise<string> {
+    return await this.page.evaluate(() => {
+      let directory = '';
+      const spans = document.querySelectorAll(
+        '.jp-FileBrowser .jp-FileBrowser-crumbs span'
+      );
+      const numSpans = spans.length;
+      if (numSpans > 1) {
+        directory = spans[numSpans - 2].getAttribute('title') ?? '';
+      }
+
+      return directory;
+    });
+  }
+
+  /**
+   * Open a file
+   *
+   * Note: This will double click on the file;
+   * an editor needs to be available for the given file type.
+   *
+   * @param filePath Notebook path
+   * @returns Action success status
+   */
+  async open(filePath: string): Promise<boolean> {
+    await this.revealFileInBrowser(filePath);
+    const name = path.basename(filePath);
+
+    const fileItem = await this.page.$(
+      `xpath=${this.xpBuildFileSelector(name)}`
+    );
+    if (fileItem) {
+      await fileItem.click({ clickCount: 2 });
+      await this.page.waitForSelector(Utils.xpBuildActivityTabSelector(name), {
+        state: 'visible'
+      });
+    } else {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Open the Home directory.
+   *
+   * @returns Action success status
+   */
+  async openHomeDirectory(): Promise<boolean> {
+    const homeButton = await this.page.$(
+      '.jp-FileBrowser .jp-FileBrowser-crumbs span'
+    );
+    if (!homeButton) {
+      return false;
+    }
+    await homeButton.click();
+
+    await this.page.waitForFunction(() => {
+      const spans = document.querySelectorAll(
+        '.jp-FileBrowser .jp-FileBrowser-crumbs span'
+      );
+      return (
+        // The home is the root if no preferred dir is defined.
+        spans.length === 2 && spans[0].classList.contains('jp-BreadCrumbs-home')
+      );
+    });
+
+    // wait for DOM rerender
+    await this.page.waitForTimeout(200);
+
+    return true;
+  }
+
+  /**
+   * Open a given directory in the file browser
+   *
+   * @param dirPath Directory path
+   * @returns Action success status
+   */
+  async openDirectory(dirPath: string): Promise<boolean> {
+    if (!(await this.openHomeDirectory())) {
+      return false;
+    }
+
+    const directories = dirPath.split('/');
+    let path = '';
+
+    for (const directory of directories) {
+      if (directory.trim() === '') {
+        continue;
+      }
+      if (path !== '') {
+        path += '/';
+      }
+
+      path += directory;
+
+      if (!(await this._openDirectory(directory))) {
+        return false;
+      }
+
+      await Utils.waitForCondition(async () => {
+        return (await this.getCurrentDirectory()) === path;
+      });
+    }
+
+    return true;
+  }
+
+  /**
+   * Trigger a file browser refresh
+   */
+  async refresh(): Promise<void> {
+    const page = this.page;
+    const item = await page.$(
+      `xpath=//div[@id='filebrowser']//button[${Utils.xpContainsClass(
+        'jp-ToolbarButtonComponent'
+      )} and .//*[@data-icon='ui-components:refresh']]`
+    );
+
+    if (item) {
+      // wait for network response or timeout
+      await Promise.race([
+        page.waitForTimeout(2000),
+        this.contents.waitForAPIResponse(async () => {
+          await item.click();
+        })
+      ]);
+      // wait for DOM rerender
+      await page.waitForTimeout(200);
+    } else {
+      throw new Error('Could not find refresh toolbar item');
+    }
+  }
+
+  protected async _openDirectory(dirName: string): Promise<boolean> {
+    const item = await this.page.$(
+      `xpath=${this.xpBuildDirectorySelector(dirName)}`
+    );
+    if (item === null) {
+      return false;
+    }
+
+    await this.contents.waitForAPIResponse(async () => {
+      await item.click({ clickCount: 2 });
+    });
+    // wait for DOM rerender
+    await this.page.waitForTimeout(200);
+
+    return true;
+  }
+}

package/src/helpers/index.ts

@@ -0,0 +1,15 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+export * from './activity';
+export * from './filebrowser';
+export * from './kernel';
+export * from './logconsole';
+export * from './menu';
+export * from './notebook';
+export * from './performance';
+export * from './sidebar';
+export * from './statusbar';
+export * from './style';
+export * from './theme';
+export * from './debuggerpanel';

package/src/helpers/kernel.ts

@@ -0,0 +1,39 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import { Page } from '@playwright/test';
+import * as Utils from '../utils';
+
+/**
+ * Kernels and sessions helpers
+ *
+ * These helpers are using JupyterLab serviceManager in Javascript. There
+ * are therefore not available if the page is not loaded.
+ */
+export class KernelHelper {
+  constructor(readonly page: Page) {}
+
+  /**
+   * Whether a sessions is running or not.
+   *
+   * @returns Running status
+   */
+  async isAnyRunning(): Promise<boolean> {
+    return await this.page.evaluate(() => {
+      return !window.jupyterapp.serviceManager.sessions.running().next().done;
+    });
+  }
+
+  /**
+   * Shutdown all sessions.
+   */
+  async shutdownAll(): Promise<void> {
+    await this.page.evaluate(async () => {
+      await window.jupyterapp.serviceManager.sessions.shutdownAll();
+    });
+
+    await Utils.waitForCondition(async () => {
+      return (await this.isAnyRunning()) === false;
+    });
+  }
+}

package/src/helpers/logconsole.ts

@@ -0,0 +1,32 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import { Page } from '@playwright/test';
+
+/**
+ * LogConsole helpers
+ */
+export class LogConsoleHelper {
+  constructor(readonly page: Page) {}
+
+  /**
+   * Get the number of log messages in the log console panel.
+   *
+   * @returns Number of log messages
+   */
+  async logCount(): Promise<number> {
+    return await this.page.evaluate(() => {
+      let count = 0;
+      const logPanels = document.querySelectorAll(
+        '.jp-LogConsolePanel .lm-StackedPanel-child'
+      );
+      logPanels.forEach(logPanel => {
+        if (!logPanel.classList.contains('lm-mod-hidden')) {
+          count += logPanel.querySelectorAll('.jp-OutputArea-child').length;
+        }
+      });
+
+      return count;
+    });
+  }
+}