@elastic/synthetics 1.0.0-beta.21 → 1.0.0-beta.24

package/src/core/gatherer.ts

@@ -25,9 +25,8 @@
 
 import { chromium, ChromiumBrowser, BrowserContext } from 'playwright-chromium';
 import { PluginManager } from '../plugins';
-import { RunOptions } from './runner';
 import { log } from './logger';
-import { Driver } from '../common_types';
+import { Driver, RunOptions } from '../common_types';
 
 /**
  * Purpose of the Gatherer is to set up the necessary browser driver
@@ -43,7 +42,7 @@ export class Gatherer {
     if (Gatherer.browser == null) {
       if (wsEndpoint) {
         log(`Gatherer: connecting to WS endpoint: ${wsEndpoint}`);
-        Gatherer.browser = await chromium.connect({ wsEndpoint });
+        Gatherer.browser = await chromium.connect(wsEndpoint);
       } else {
         Gatherer.browser = await chromium.launch({
           ...playwrightOptions,

package/src/core/index.ts

@@ -25,7 +25,8 @@
 
 import { Journey, JourneyCallback, JourneyOptions } from '../dsl';
 import Runner from './runner';
-import { VoidCallback, HooksCallback } from '../common_types';
+import { VoidCallback, HooksCallback, Location } from '../common_types';
+import { wrapFnWithLocation } from '../helpers';
 import { log } from './logger';
 
 /**
@@ -39,23 +40,28 @@ if (!global[SYNTHETICS_RUNNER]) {
 
 export const runner: Runner = global[SYNTHETICS_RUNNER];
 
-export const journey = (
-  options: JourneyOptions | string,
-  callback: JourneyCallback
-) => {
-  log(`register journey: ${JSON.stringify(options)}`);
-  if (typeof options === 'string') {
-    options = { name: options, id: options };
+export const journey = wrapFnWithLocation(
+  (
+    location: Location,
+    options: JourneyOptions | string,
+    callback: JourneyCallback
+  ) => {
+    log(`register journey: ${JSON.stringify(options)}`);
+    if (typeof options === 'string') {
+      options = { name: options, id: options };
+    }
+    const j = new Journey(options, callback, location);
+    runner.addJourney(j);
+    return j;
   }
-  const j = new Journey(options, callback);
-  runner.addJourney(j);
-  return j;
-};
+);
 
-export const step = (name: string, callback: VoidCallback) => {
-  log(`register step: ${name}`);
-  return runner.currentJourney?.addStep(name, callback);
-};
+export const step = wrapFnWithLocation(
+  (location: Location, name: string, callback: VoidCallback) => {
+    log(`register step: ${name}`);
+    return runner.currentJourney?.addStep(name, callback, location);
+  }
+);
 
 export const beforeAll = (callback: HooksCallback) => {
   runner.addHook('beforeAll', callback);

package/src/core/runner.ts

@@ -28,7 +28,7 @@ import { join } from 'path';
 import { rm } from 'fs/promises';
 import { Journey } from '../dsl/journey';
 import { Step } from '../dsl/step';
-import { reporters, Reporter } from '../reporters';
+import { reporters } from '../reporters';
 import {
   CACHE_PATH,
   monotonicTimeInSeconds,
@@ -44,36 +44,16 @@ import {
   Params,
   NetworkConditions,
   PluginOutput,
-  CliArgs,
   HooksArgs,
-  PlaywrightOptions,
   Driver,
   Screenshot,
+  RunOptions,
 } from '../common_types';
 import { PageMetrics, PluginManager } from '../plugins';
 import { PerformanceManager } from '../plugins';
 import { Gatherer } from './gatherer';
 import { log } from './logger';
 
-export type RunOptions = Omit<
-  CliArgs,
-  | 'debug'
-  | 'pattern'
-  | 'inline'
-  | 'require'
-  | 'reporter'
-  | 'richEvents'
-  | 'capability'
-  | 'sandbox'
-  | 'headless'
-  | 'throttling'
-> & {
-  environment?: string;
-  playwrightOptions?: PlaywrightOptions;
-  networkConditions?: NetworkConditions;
-  reporter?: CliArgs['reporter'] | Reporter;
-};
-
 type HookType = 'beforeAll' | 'afterAll';
 export type SuiteHooks = Record<HookType, Array<HooksCallback>>;
 

package/src/dsl/journey.ts

@@ -26,7 +26,7 @@
 import { Browser, Page, BrowserContext, CDPSession } from 'playwright-chromium';
 import micromatch, { isMatch } from 'micromatch';
 import { Step } from './step';
-import { VoidCallback, HooksCallback, Params } from '../common_types';
+import { VoidCallback, HooksCallback, Params, Location } from '../common_types';
 
 export type JourneyOptions = {
   name: string;
@@ -49,18 +49,24 @@ export class Journey {
   id?: string;
   tags?: string[];
   callback: JourneyCallback;
+  location?: Location;
   steps: Step[] = [];
   hooks: Hooks = { before: [], after: [] };
 
-  constructor(options: JourneyOptions, callback: JourneyCallback) {
+  constructor(
+    options: JourneyOptions,
+    callback: JourneyCallback,
+    location?: Location
+  ) {
     this.name = options.name;
     this.id = options.id || options.name;
     this.tags = options.tags;
     this.callback = callback;
+    this.location = location;
   }
 
-  addStep(name: string, callback: VoidCallback) {
-    const step = new Step(name, this.steps.length + 1, callback);
+  addStep(name: string, callback: VoidCallback, location?: Location) {
+    const step = new Step(name, this.steps.length + 1, callback, location);
     this.steps.push(step);
     return step;
   }

package/src/dsl/step.ts

@@ -23,16 +23,23 @@
  *
  */
 
-import { VoidCallback } from '../common_types';
+import { Location, VoidCallback } from '../common_types';
 
 export class Step {
   name: string;
   index: number;
   callback: VoidCallback;
+  location?: Location;
 
-  constructor(name: string, index: number, callback: VoidCallback) {
+  constructor(
+    name: string,
+    index: number,
+    callback: VoidCallback,
+    location: Location
+  ) {
     this.name = name;
     this.index = index;
     this.callback = callback;
+    this.location = location;
   }
 }

package/src/formatter/javascript.ts

@@ -26,7 +26,14 @@
 import {
   JavaScriptLanguageGenerator,
   JavaScriptFormatter,
-} from 'playwright-chromium/lib/server/supplements/recorder/javascript';
+} from 'playwright-core/lib/server/supplements/recorder/javascript';
+
+export type Step = {
+  actions: ActionInContext[];
+  name?: string;
+};
+
+export type Steps = Step[];
 
 export type ActionInContext = {
   pageAlias: string;
@@ -39,7 +46,7 @@ export type ActionInContext = {
   title?: string;
 };
 
-type Action = {
+export type Action = {
   name: string;
   selector?: string;
   url?: string;
@@ -52,9 +59,11 @@ type Action = {
   value?: string;
   isAssert?: boolean;
   command?: string;
+  files?: string[];
+  options?: string[];
 };
 
-type Signal = {
+export type Signal = {
   name: string;
   url?: string;
   isAsync?: boolean;
@@ -73,8 +82,13 @@ export class SyntheticsGenerator extends JavaScriptLanguageGenerator {
     this.previousContext = undefined;
   }
 
+  /**
+   * Generate code for an action.
+   * @param actionInContext The action to create code for.
+   * @returns the strings generated for the action.
+   */
   generateAction(actionInContext: ActionInContext) {
-    const { action, pageAlias, title } = actionInContext;
+    const { action, pageAlias } = actionInContext;
     if (action.name === 'openPage') {
       return '';
     }
@@ -84,17 +98,9 @@ export class SyntheticsGenerator extends JavaScriptLanguageGenerator {
       return '';
     }
 
-    let formatter = new JavaScriptFormatter(this.isSuite ? 2 : 0);
-    // Check if it's a new step
-    const isNewStep = this.isNewStep(actionInContext);
-    if (isNewStep) {
-      if (this.insideStep) {
-        formatter.add(this.generateStepEnd());
-      }
-      formatter.add(this.generateStepStart(title || actionTitle(action)));
-    } else {
-      formatter = new JavaScriptFormatter(this.isSuite ? 4 : 2);
-    }
+    const stepIndent = this.insideStep ? 2 : 0;
+    const offset = this.isSuite ? 2 + stepIndent : 0 + stepIndent;
+    const formatter = new JavaScriptFormatter(offset);
 
     const subject = actionInContext.isMainFrame
       ? pageAlias
@@ -185,7 +191,9 @@ export class SyntheticsGenerator extends JavaScriptLanguageGenerator {
 
   generateStepStart(name) {
     this.insideStep = true;
-    return `step(${quote(name)}, async () => {`;
+    const formatter = new JavaScriptFormatter(this.isSuite ? 2 : 0);
+    formatter.add(`step(${quote(name)}, async () => {`);
+    return formatter.format();
   }
 
   generateStepEnd() {
@@ -211,19 +219,41 @@ export class SyntheticsGenerator extends JavaScriptLanguageGenerator {
     return `});`;
   }
 
-  generateText(actions: Array<ActionInContext>) {
+  /**
+   * Generates JavaScript code from a custom set of steps and nested actions.
+   *
+   * This function makes no assumptions about where steps should be created,
+   * and instead follows the step definitions the caller has defined.
+   * @param steps IR to use for code generation
+   * @returns a list of the code strings outputted by the generator
+   */
+  generateFromSteps(steps: Steps): string {
     const text = [];
     if (this.isSuite) {
       text.push(this.generateHeader());
     }
-    for (let i = 0; i < actions.length; i++) {
-      text.push(this.generateAction(actions[i]));
-      if (i === actions.length - 1) text.push(this.generateStepEnd());
+    for (const step of steps) {
+      if (step.actions.length === 0)
+        throw Error('Cannot process an empty step');
+      text.push(
+        this.generateStepStart(
+          step.name ??
+            step.actions[0].title ??
+            actionTitle(step.actions[0].action)
+        )
+      );
+
+      for (const action of step.actions) {
+        const actionText = this.generateAction(action);
+        if (actionText.length) text.push(actionText);
+      }
+
+      text.push(this.generateStepEnd());
     }
     if (this.isSuite) {
       text.push(this.generateFooter());
     }
-    return text.filter(t => Boolean(t)).join('\n');
+    return text.filter(s => !!s).join('\n');
   }
 }
 
@@ -297,7 +327,12 @@ function formatObject(value, indent = '  ') {
   return String(value);
 }
 
-function actionTitle(action) {
+/**
+ * Generates an appropriate title string based on the action type/data.
+ * @param action Playwright action IR
+ * @returns title string
+ */
+export function actionTitle(action: Action) {
   switch (action.name) {
     case 'openPage':
       return `Open new page`;
@@ -326,5 +361,7 @@ function actionTitle(action) {
       );
     case 'select':
       return `Select ${action.options.join(', ')}`;
+    case 'assert':
+      return `Assert ${action.selector} ${action.command}`;
   }
 }

package/src/helpers.ts

@@ -29,7 +29,13 @@ import { resolve, join, dirname } from 'path';
 import fs from 'fs';
 import { promisify } from 'util';
 import { performance } from 'perf_hooks';
-import { HooksArgs, HooksCallback, NetworkConditions } from './common_types';
+import sourceMapSupport from '@cspotcode/source-map-support';
+import {
+  HooksArgs,
+  HooksCallback,
+  NetworkConditions,
+  Location,
+} from './common_types';
 
 const lstatAsync = promisify(fs.lstat);
 const readdirAsync = promisify(fs.readdir);
@@ -315,3 +321,36 @@ export function parseNetworkConditions(args: string): NetworkConditions {
 
   return networkConditions;
 }
+
+// default stack trace limit
+const dstackTraceLimit = 10;
+
+// Uses the V8 Stacktrace API to get the function location
+// information - https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+export function wrapFnWithLocation<A extends unknown[], R>(
+  func: (location: Location, ...args: A) => R
+): (...args: A) => R {
+  return (...args) => {
+    const _prepareStackTrace = Error.prepareStackTrace;
+    Error.prepareStackTrace = (_, stackFrames) => {
+      // Deafult CallSite would not map to the original transpiled source
+      // from ts-node properly, So we wrap it with the library that knows
+      // how to retrive those source-map for the transpiled code
+      const frame: NodeJS.CallSite = sourceMapSupport.wrapCallSite(
+        stackFrames[1]
+      );
+      return {
+        file: frame.getFileName(),
+        line: frame.getLineNumber(),
+        column: frame.getColumnNumber(),
+      };
+    };
+    Error.stackTraceLimit = 2;
+    const obj: { stack: Location } = {} as any;
+    Error.captureStackTrace(obj);
+    const location = obj.stack;
+    Error.stackTraceLimit = dstackTraceLimit;
+    Error.prepareStackTrace = _prepareStackTrace;
+    return func(location, ...args);
+  };
+}

package/src/index.ts

@@ -24,23 +24,10 @@
  */
 
 import { runner } from './core';
-import { RunOptions } from './core/runner';
-import sourceMapSupport from 'source-map-support';
+import { RunOptions } from './common_types';
 
 export async function run(options: RunOptions) {
-  /**
-   * Install source map support
-   */
-  sourceMapSupport.install({
-    environment: 'node',
-  });
-
-  try {
-    return await runner.run(options);
-  } catch (e) {
-    console.error('Failed to run the test', e);
-    process.exit(1);
-  }
+  return runner.run(options);
 }
 
 /**
@@ -66,4 +53,11 @@ export type { default as Runner } from './core/runner';
 export type { Reporter, ReporterOptions } from './reporters';
 
 export type { SyntheticsConfig } from './common_types';
-export type { ActionInContext } from './formatter/javascript';
+export type {
+  Action,
+  ActionInContext,
+  Signal,
+  Step,
+  Steps,
+  actionTitle,
+} from './formatter/javascript';

package/src/loader.ts

@@ -0,0 +1,162 @@
+/**
+ * MIT License
+ *
+ * Copyright (c) 2020-present, Elastic NV
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+import { stdin, cwd } from 'process';
+import { resolve } from 'path';
+import { CliArgs } from './common_types';
+import { step, journey } from './core';
+import { log } from './core/logger';
+import { expect } from './core/expect';
+import {
+  isDepInstalled,
+  isDirectory,
+  totalist,
+  findPkgJsonByTraversing,
+} from './helpers';
+
+const resolvedCwd = cwd();
+
+export async function loadTestFiles(options: CliArgs, args: string[]) {
+  /**
+   * Transform `.ts` files out of the box by invoking
+   * the `ts-node` via `transpile-only` mode that compiles
+   * TS files without doing any extensive type checks.
+   *
+   * We must register `ts-node` _before_ loading inline
+   * scripts too because otherwise we will not be able to
+   * require `.ts` configuration files.
+   */
+  /* eslint-disable-next-line @typescript-eslint/no-var-requires */
+  require('ts-node').register({
+    transpileOnly: true,
+    compilerOptions: {
+      esModuleInterop: true,
+      allowJs: true,
+      target: 'es2020',
+    },
+  });
+
+  /**
+   * Preload modules before running the tests
+   */
+  const modules = [].concat(options.require || []).filter(Boolean);
+  for (const name of modules) {
+    if (isDepInstalled(name)) {
+      require(name);
+    } else {
+      throw new Error(`cannot find module '${name}'`);
+    }
+  }
+
+  if (options.inline) {
+    const source = await readStdin();
+    loadInlineScript(source);
+    return;
+  }
+  /**
+   * Handle piped files by reading the STDIN
+   * ex: ls example/suites/*.js | npx @elastic/synthetics
+   */
+  const files =
+    args.length > 0 ? args : (await readStdin()).split('\n').filter(Boolean);
+  const suites = await prepareSuites(files, options);
+  requireSuites(suites);
+}
+
+const loadInlineScript = source => {
+  const scriptFn = new Function(
+    'step',
+    'page',
+    'context',
+    'browser',
+    'params',
+    'expect',
+    source
+  );
+  journey('inline', ({ page, context, browser, params }) => {
+    scriptFn.apply(null, [step, page, context, browser, params, expect]);
+  });
+};
+
+/**
+ * Read the input from STDIN and run it as inline journey
+ */
+async function readStdin() {
+  const chunks = [];
+  stdin.resume();
+  stdin.setEncoding('utf-8');
+  for await (const chunk of stdin) {
+    chunks.push(chunk);
+  }
+  return chunks.join();
+}
+
+function requireSuites(suites: Iterable<string>) {
+  for (const suite of suites) {
+    require(suite);
+  }
+}
+
+/**
+ * Handle both directory and files that are passed through TTY
+ * and add them to suites
+ */
+async function prepareSuites(inputs: string[], cliArgs: CliArgs) {
+  const suites = new Set<string>();
+  const addSuite = absPath => {
+    log(`Processing file: ${absPath}`);
+    suites.add(require.resolve(absPath));
+  };
+  /**
+   * Match all files inside the directory with the
+   * .journey.{mjs|cjs|js|ts) extensions
+   */
+  const pattern = cliArgs.pattern
+    ? new RegExp(cliArgs.pattern, 'i')
+    : /.+\.journey\.([mc]js|[jt]s?)$/;
+  /**
+   * Ignore node_modules by default when running suites
+   */
+  const ignored = /node_modules/i;
+
+  for (const input of inputs) {
+    const absPath = resolve(resolvedCwd, input);
+    /**
+     * Validate for package.json file before running
+     * the suites
+     */
+    findPkgJsonByTraversing(absPath, resolvedCwd);
+    if (isDirectory(absPath)) {
+      await totalist(absPath, (rel, abs) => {
+        if (pattern.test(rel) && !ignored.test(rel)) {
+          addSuite(abs);
+        }
+      });
+    } else {
+      addSuite(absPath);
+    }
+  }
+  return suites.values();
+}