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

package/src/playwright-config.ts

@@ -0,0 +1,26 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import { PlaywrightTestConfig } from '@playwright/test';
+
+// Default Playwright configuration for JupyterLab
+module.exports = {
+  reporter: [
+    [process.env.CI ? 'github' : 'list'],
+    ['html', { open: process.env.CI ? 'never' : 'on-failure' }]
+  ],
+  reportSlowTests: null,
+  timeout: 60000,
+  use: {
+    // Browser options
+    // headless: false,
+    // slowMo: 500,
+
+    // Context options
+    viewport: { width: 1024, height: 768 },
+
+    // Artifacts
+    // trace: 'on-first-retry',
+    video: 'retain-on-failure'
+  }
+} as PlaywrightTestConfig;

package/src/utils.ts

@@ -0,0 +1,264 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import { URLExt } from '@jupyterlab/coreutils';
+import { ElementHandle, Page } from '@playwright/test';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+
+/**
+ * Read a file as a base-64 string
+ *
+ * @param filePath Local file path
+ * @returns Base 64 encoded file content
+ */
+export function base64EncodeFile(filePath: string): string {
+  const content = fs.readFileSync(filePath);
+  return content.toString('base64');
+}
+
+/**
+ * Private page config data for the Jupyter application.
+ */
+let configData: { [key: string]: string } | null = null;
+
+// Get config data
+async function getConfigData(page: Page): Promise<{ [key: string]: string }> {
+  if (configData) {
+    return configData;
+  }
+
+  configData = Object.create(null);
+
+  const el = await page.$('#jupyter-config-data');
+
+  if (!el) {
+    return {};
+  }
+
+  configData = JSON.parse((await el?.textContent()) ?? '{}');
+
+  for (const key in configData) {
+    // PageConfig expects strings
+    if (typeof configData[key] !== 'string') {
+      configData[key] = JSON.stringify(configData[key]);
+    }
+  }
+
+  return configData!;
+}
+
+/**
+ * Get a url-encoded item from `body.data` and decode it
+ * We should never have any encoded URLs anywhere else in code
+ * until we are building an actual request.
+ */
+async function getBodyData(page: Page, key: string): Promise<string> {
+  const val = await page.evaluate(key => document.body.dataset[key], key);
+  if (typeof val === 'undefined') {
+    return '';
+  }
+  return decodeURIComponent(val);
+}
+
+/**
+ * Get the Jupyter server base URL stored in the index.html file
+ *
+ * @param page Playwright page model
+ * @returns Base URL
+ */
+export async function getBaseUrl(page: Page): Promise<string> {
+  return URLExt.normalize((await getOption(page, 'baseUrl')) || '/');
+}
+
+/**
+ * Get the classes of an element
+ *
+ * @param element Element handle
+ * @returns Classes list
+ */
+export async function getElementClassList(
+  element: ElementHandle
+): Promise<string[]> {
+  if (!element) {
+    return [];
+  }
+
+  const className = await element.getProperty('className');
+  if (className) {
+    const classNameList = await className.jsonValue();
+    if (typeof classNameList === 'string') {
+      return classNameList.split(' ');
+    }
+  }
+
+  return [];
+}
+
+/**
+ * List the content of a local directory
+ *
+ * @param dirPath Local directory path
+ * @param filePaths List to populate with the directory content
+ * @returns Content of the directory
+ */
+export function getFilesInDirectory(
+  dirPath: string,
+  filePaths?: string[]
+): string[] {
+  const files = fs.readdirSync(dirPath);
+
+  filePaths = filePaths || [];
+
+  for (const file of files) {
+    if (file.startsWith('.')) {
+      continue;
+    }
+    if (fs.statSync(dirPath + '/' + file).isDirectory()) {
+      filePaths = getFilesInDirectory(dirPath + '/' + file, filePaths);
+    } else {
+      filePaths.push(path.join(dirPath, '/', file));
+    }
+  }
+
+  return filePaths;
+}
+
+/**
+ * Get the value of an option stored in the page config object
+ *
+ * @param page Playwright page model
+ * @param name Option name
+ * @returns Option value
+ */
+export async function getOption(page: Page, name: string): Promise<string> {
+  return (await getConfigData(page))[name] ?? (await getBodyData(page, name));
+}
+
+/**
+ * Get the token stored in the page config object
+ *
+ * @param page Playwright page model
+ * @returns Token
+ */
+export async function getToken(page: Page): Promise<string> {
+  return (
+    (await getOption(page, 'token')) ||
+    (await getBodyData(page, 'jupyterApiToken'))
+  );
+}
+
+/**
+ * Wait for a function to return true until timeout
+ *
+ * @param fn Condition
+ * @param timeout Time out
+ */
+export async function waitForCondition(
+  fn: () => boolean | Promise<boolean>,
+  timeout?: number
+): Promise<void> {
+  return new Promise((resolve, reject) => {
+    let checkTimer: NodeJS.Timeout | null = null;
+    let timeoutTimer: NodeJS.Timeout | null = null;
+    const check = async () => {
+      checkTimer = null;
+      if (await Promise.resolve(fn())) {
+        if (timeoutTimer) {
+          clearTimeout(timeoutTimer);
+        }
+        resolve();
+      } else {
+        checkTimer = setTimeout(check, 200);
+      }
+    };
+
+    void check();
+
+    if (timeout) {
+      timeoutTimer = setTimeout(() => {
+        timeoutTimer = null;
+        if (checkTimer) {
+          clearTimeout(checkTimer);
+        }
+        reject(new Error('Timed out waiting for condition to be fulfilled.'));
+      }, timeout);
+    }
+  });
+}
+
+/**
+ * Wait for an element to emit 'transitionend' event.
+ *
+ * @param page Playwright page model object
+ * @param element Element or selector to watch
+ */
+export async function waitForTransition(
+  page: Page,
+  element: ElementHandle<Element> | string
+): Promise<void> {
+  const el = typeof element === 'string' ? await page.$(element) : element;
+
+  if (el) {
+    return page.evaluate(el => {
+      return new Promise(resolve => {
+        const onEndHandler = () => {
+          el.removeEventListener('transitionend', onEndHandler);
+          resolve();
+        };
+        el.addEventListener('transitionend', onEndHandler);
+      });
+    }, el);
+  }
+
+  return Promise.reject();
+}
+
+// Selector builders
+
+/**
+ * Get the selector to look for a specific class
+ *
+ * @param className Class name
+ * @returns Selector
+ */
+export function xpContainsClass(className: string): string {
+  return `contains(concat(" ", normalize-space(@class), " "), " ${className} ")`;
+}
+
+/**
+ * Get the selector to look for a specific activity tab
+ *
+ * @param name Activity name
+ * @returns Selector
+ */
+export function xpBuildActivityTabSelector(name: string): string {
+  return `//div[${xpContainsClass('jp-Activity')}]/ul/li[${xpContainsClass(
+    'lm-TabBar-tab'
+  )} and ./div[text()="${name}" and ${xpContainsClass('lm-TabBar-tabLabel')}]]`;
+}
+
+/**
+ * Get the selector to look for a specific activity panel
+ *
+ * @param id Activity id
+ * @returns Selector
+ */
+export function xpBuildActivityPanelSelector(id: string): string {
+  return `//div[@id='${id}' and ${xpContainsClass(
+    'jp-Activity'
+  )} and ${xpContainsClass('lm-DockPanel-widget')}]`;
+}
+
+/**
+ * Get the selector to look for the currently active activity tab
+ *
+ * @returns Selector
+ */
+export function xpBuildActiveActivityTabSelector(): string {
+  return `//div[${xpContainsClass('jp-Activity')}]/ul/li[${xpContainsClass(
+    'lm-TabBar-tab'
+  )} and ${xpContainsClass('lm-mod-current')} and ./div[${xpContainsClass(
+    'lm-TabBar-tabLabel'
+  )}]]`;
+}

package/src/vega-statistics.d.ts

@@ -0,0 +1,15 @@
+/*
+ * Copyright (c) Jupyter Development Team.
+ * Distributed under the terms of the Modified BSD License.
+ */
+
+// Type definitions for vega-statistics
+// Project: vega-statistics
+// Definitions by: Jupyter Development Team
+
+declare module 'vega-statistics' {
+  export function quartiles(
+    array: number[],
+    accessor?: (t: any) => number
+  ): [number, number, number];
+}

package/lib/global.d.ts

@@ -1,23 +0,0 @@
-import { JupyterFrontEnd } from '@jupyterlab/application';
-import { IGalataInpage } from './inpage/tokens';
-declare global {
-    interface Window {
-        /**
-         * Access JupyterLab Application object
-         *
-         * @deprecated since v4
-         * Please use window.jupyterapp to access the Jupyter Application
-         */
-        jupyterlab?: JupyterFrontEnd;
-        /**
-         * Access Jupyter Application object
-         */
-        jupyterapp: JupyterFrontEnd;
-        /**
-         * Access to Galata In-Page helpers
-         *
-         * Those helpers are injected when navigating to JupyterLab page
-         */
-        galataip: IGalataInpage;
-    }
-}

package/lib/global.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"global.js","sourceRoot":"","sources":["../src/global.ts"],"names":[],"mappings":";AAAA,yDAAyD;AACzD,0CAA0C;AAC1C,sCAAsC;AACtC,2DAA2D"}

package/lib/inpage/tokens.d.ts

@@ -1,135 +0,0 @@
-import { IRouter, JupyterFrontEnd } from '@jupyterlab/application';
-import { IDocumentManager } from '@jupyterlab/docmanager';
-import { ISettingRegistry } from '@jupyterlab/settingregistry';
-/**
- * Cell execution callbacks interface
- */
-export interface INotebookRunCallback {
-    /**
-     * Callback before scrolling to the cell
-     */
-    onBeforeScroll?: () => Promise<void>;
-    /**
-     * Callback after scrolling to teh cell
-     */
-    onAfterScroll?: () => Promise<void>;
-    /**
-     * Callback after cell execution
-     */
-    onAfterCellRun?: (cellIndex: number) => Promise<void>;
-}
-/**
- * waitForSelector options
- */
-export interface IWaitForSelectorOptions {
-    /**
-     * Test for the element to be hidden.
-     */
-    hidden?: boolean;
-}
-export declare const PLUGIN_ID_ROUTER = "@jupyterlab/application-extension:router";
-export declare const PLUGIN_ID_DOC_MANAGER = "@jupyterlab/docmanager-extension:plugin";
-export declare const PLUGIN_ID_SETTINGS = "@jupyterlab/apputils-extension:settings";
-export interface IPluginNameToInterfaceMap {
-    [PLUGIN_ID_ROUTER]: IRouter;
-    [PLUGIN_ID_DOC_MANAGER]: IDocumentManager;
-    [PLUGIN_ID_SETTINGS]: ISettingRegistry;
-}
-/**
- * Galata In-Page interface
- */
-export interface IGalataInpage {
-    /**
-     * Delete all cells of the active notebook
-     */
-    deleteNotebookCells(): Promise<void>;
-    /**
-     * Get the index of a toolbar item
-     *
-     * @param itemName Item name
-     * @returns Index
-     */
-    getNotebookToolbarItemIndex(itemName: string): number;
-    /**
-     * Get an application plugin
-     *
-     * @param pluginId Plugin ID
-     * @returns Application plugin
-     */
-    getPlugin<K extends keyof IPluginNameToInterfaceMap>(pluginId: K): Promise<IPluginNameToInterfaceMap[K] | undefined>;
-    /**
-     * Test if a cell is selected in the active notebook
-     *
-     * @param cellIndex Cell index
-     * @returns Whether the cell is selected or not
-     */
-    isNotebookCellSelected(cellIndex: number): boolean;
-    /**
-     * Test if a element is visible or not
-     *
-     * @param el Element
-     * @returns Test result
-     */
-    isElementVisible(el: HTMLElement): boolean;
-    /**
-     * Save the active notebook
-     */
-    saveActiveNotebook(): Promise<void>;
-    /**
-     * Set the application theme
-     *
-     * @param themeName Theme name
-     */
-    setTheme(themeName: string): Promise<void>;
-    /**
-     * Run the active notebook
-     */
-    runActiveNotebook(): Promise<void>;
-    /**
-     * Run the active notebook cell by cell
-     * and execute the callback after each cell execution
-     *
-     * @param callback Callback
-     */
-    runActiveNotebookCellByCell(callback?: INotebookRunCallback): Promise<void>;
-    /**
-     * Wait for the route to be on path and close all documents
-     *
-     * @param path Path to monitor
-     */
-    waitForLaunch(path?: string): Promise<void>;
-    /**
-     * Wait for the route to be on path and close all documents
-     *
-     * @param path Path to monitor
-     */
-    waitForNotebookRun(): Promise<void>;
-    /**
-     * Wait for an element to be found from a CSS selector
-     *
-     * @param selector CSS selector
-     * @param node Element
-     * @param options Options
-     * @returns Selected element
-     */
-    waitForSelector(selector: string, node?: Element, options?: IWaitForSelectorOptions): Promise<Node | null>;
-    /**
-     * Waits for the given `timeout` in milliseconds.
-     *
-     * @param timeout A timeout to wait for
-     */
-    waitForTimeout(duration: number): Promise<void>;
-    /**
-     * Wait for an element to be found from a XPath
-     *
-     * @param selector CSS selector
-     * @param node Element
-     * @param options Options
-     * @returns Selected element
-     */
-    waitForXPath(selector: string, node?: Element, options?: IWaitForSelectorOptions): Promise<Node | null>;
-    /**
-     * Application object
-     */
-    readonly app: JupyterFrontEnd;
-}

package/lib/inpage/tokens.js

@@ -1,9 +0,0 @@
-"use strict";
-// Copyright (c) Bloomberg Finance LP.
-// Distributed under the terms of the Modified BSD License.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PLUGIN_ID_SETTINGS = exports.PLUGIN_ID_DOC_MANAGER = exports.PLUGIN_ID_ROUTER = void 0;
-exports.PLUGIN_ID_ROUTER = '@jupyterlab/application-extension:router';
-exports.PLUGIN_ID_DOC_MANAGER = '@jupyterlab/docmanager-extension:plugin';
-exports.PLUGIN_ID_SETTINGS = '@jupyterlab/apputils-extension:settings';
-//# sourceMappingURL=tokens.js.map

package/lib/inpage/tokens.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tokens.js","sourceRoot":"","sources":["../../src/inpage/tokens.ts"],"names":[],"mappings":";AAAA,sCAAsC;AACtC,2DAA2D;;;AAkC9C,QAAA,gBAAgB,GAAG,0CAA0C,CAAC;AAC9D,QAAA,qBAAqB,GAAG,yCAAyC,CAAC;AAClE,QAAA,kBAAkB,GAAG,yCAAyC,CAAC"}