@deot/dev-test 1.1.1 → 2.0.1

package/dist/index.cjs.js

@@ -1,124 +1,427 @@
 'use strict';
 
-var devShared = require('@deot/dev-shared');
-var childProcess = require('child_process');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const devShared = require('@deot/dev-shared');
+const childProcess = require('child_process');
+const puppeteer = require('puppeteer');
 
 function _interopNamespaceDefault(e) {
-    var n = Object.create(null);
-    if (e) {
-        Object.keys(e).forEach(function (k) {
-            if (k !== 'default') {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () { return e[k]; }
-                });
-            }
-        });
-    }
-    n.default = e;
-    return Object.freeze(n);
+	const n = Object.create(null, { [Symbol.toStringTag]: { value: 'Module' } });
+	if (e) {
+		for (const k in e) {
+			if (k !== 'default') {
+				const d = Object.getOwnPropertyDescriptor(e, k);
+				Object.defineProperty(n, k, d.get ? d : {
+					enumerable: true,
+					get: () => e[k]
+				});
+			}
+		}
+	}
+	n.default = e;
+	return Object.freeze(n);
 }
 
-var childProcess__namespace = /*#__PURE__*/_interopNamespaceDefault(childProcess);
+const childProcess__namespace = /*#__PURE__*/_interopNamespaceDefault(childProcess);
 
 const { LOCAL_COMMAND_MAP } = devShared.Shell;
 const KEY_MAP = {
-    DOWN: '\x1b\x5b\x42',
-    UP: '\x1b\x5b\x41',
-    ENTER: '\x0d',
-    SPACE: '\x7f'
+  DOWN: "\x1B[B",
+  UP: "\x1B[A",
+  ENTER: "\r",
+  // return;
+  SPACE: ""
 };
 class Command {
-    target;
-    code;
-    error;
-    resolve;
-    reject;
-    stdout;
-    stderr;
-    emitter;
-    isClose;
-    schedule;
-    constructor(command, args) {
-        this.target = new Promise((resolve, reject) => {
-            this.resolve = this._handleEnd(resolve);
-            this.reject = this._handleEnd(reject);
-        });
-        this.code = null;
-        this.error = null;
-        this.stdout = '';
-        this.stderr = '';
-        this.emitter = this.start(command, args);
-        this.isClose = false;
-        this.schedule = {
-            target: Promise.resolve(),
-            complete: () => { }
-        };
-    }
-    _handleEnd(fn) {
-        return (e) => {
-            this.isClose = true;
-            const { code, error } = e;
-            this.code = code;
-            this.error = error;
-            fn({
-                ...e,
-                stdout: this.stdout,
-                stderr: this.stderr
-            });
-        };
+  target;
+  code;
+  error;
+  resolve;
+  reject;
+  stdout;
+  stderr;
+  emitter;
+  isClose;
+  schedule;
+  constructor(command, args) {
+    this.target = new Promise((resolve, reject) => {
+      this.resolve = this._handleEnd(resolve);
+      this.reject = this._handleEnd(reject);
+    });
+    this.code = null;
+    this.error = null;
+    this.stdout = "";
+    this.stderr = "";
+    this.emitter = this.start(command, args);
+    this.isClose = false;
+    this.schedule = {
+      target: Promise.resolve(),
+      complete: (
+        /* istanbul ignore next */
+        () => {
+        }
+      )
+    };
+  }
+  _handleEnd(fn) {
+    return (e) => {
+      this.isClose = true;
+      const { code, error } = e;
+      this.code = code;
+      this.error = error;
+      fn({
+        ...e,
+        stdout: this.stdout,
+        stderr: this.stderr
+      });
+    };
+  }
+  start(command, args) {
+    const SPACE = " ";
+    const [command$, ...args$] = (command + SPACE + args.join(SPACE)).replace(/\s+/g, SPACE).split(SPACE).filter((i) => !!i).map((i) => LOCAL_COMMAND_MAP[i] || i);
+    const emitter = childProcess__namespace.spawn(command$, args$, {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    emitter.on("close", (code) => {
+      if (code !== 0) {
+        this.reject({ code });
+      } else {
+        this.resolve({ code });
+      }
+    });
+    emitter.on(
+      "error",
+      /* istanbul ignore next */
+      (error) => {
+        !process.exitCode && (process.exitCode = 1);
+        this.reject({ code: process.exitCode, error });
+      }
+    );
+    emitter.stdout.on("data", (e) => {
+      this.stdout += e.toString();
+      this.schedule.complete();
+    });
+    emitter.stderr.on(
+      "data",
+      /* istanbul ignore next */
+      (e) => this.stderr += e.toString()
+    );
+    return emitter;
+  }
+  async stop() {
+    await this.schedule.target;
+    if (!this.isClose) {
+      this.emitter.stdin.end();
+      this.isClose = true;
     }
-    start(command, args) {
-        const SPACE = ' ';
-        const [command$, ...args$] = (command + SPACE + args.join(SPACE))
-            .replace(/\s+/g, SPACE)
-            .split(SPACE)
-            .filter(i => !!i)
-            .map(i => LOCAL_COMMAND_MAP[i] || i);
-        const emitter = childProcess__namespace.spawn(command$, args$, {
-            stdio: ['pipe', 'pipe', 'pipe']
-        });
-        emitter.on('close', (code) => {
-            if (code !== 0) {
-                this.reject({ code });
-            }
-            else {
-                this.resolve({ code });
-            }
-        });
-        emitter.on('error', (error) => {
-            !process.exitCode && (process.exitCode = 1);
-            this.reject({ code: process.exitCode, error });
+    const response = await this.target;
+    return response;
+  }
+  async press(key, timeout = 200) {
+    if (!key || this.isClose)
+      return;
+    await this.schedule.target;
+    this.schedule.target = new Promise((resolve) => {
+      this.schedule.complete = resolve;
+    });
+    await new Promise((resolve) => {
+      this.emitter.stdin.write(
+        KEY_MAP[key.toUpperCase()] || key,
+        "utf8",
+        resolve
+      );
+    });
+    await new Promise((_) => setTimeout(_, timeout));
+  }
+}
+
+class Operater {
+  page;
+  constructor(v) {
+    this.page = v;
+  }
+  /**
+   * @param {string} selector ~
+   * @param {ClickOptions} options ~
+   */
+  async click(selector, options) {
+    await this.page.click(selector, options);
+  }
+  /**
+   * @param {string} selector ~
+   * @returns {number} ~
+   */
+  async count(selector) {
+    return (await this.page.$$(selector)).length;
+  }
+  /**
+   * @param {string} selector ~
+   * @returns {Promise<string>} ~
+   */
+  async text(selector) {
+    return await this.page.$eval(selector, (node) => node.textContent);
+  }
+  /**
+   * @param {string} selector ~
+   * @returns {Promise<string>} ~
+   */
+  async value(selector) {
+    return await this.page.$eval(selector, (node) => node.value);
+  }
+  /**
+   * @param {string} selector ~
+   * @returns {Promise<string>} ~
+   */
+  async html(selector) {
+    return await this.page.$eval(selector, (node) => node.innerHTML);
+  }
+  /**
+   * @param {string} selector ~
+   * @returns {Promise<string[]>} ~
+   */
+  async classList(selector) {
+    return await this.page.$eval(selector, (node) => [...node.classList]);
+  }
+  /**
+   * @param {string} selector ~
+   * @returns {Promise<HTMLElement[]>} ~
+   */
+  async children(selector) {
+    return await this.page.$eval(selector, (node) => [...node.children]);
+  }
+  /**
+   * @param {string} selector ~
+   * @returns {Promise<boolean>} ~
+   */
+  async isVisible(selector) {
+    const display = await this.page.$eval(selector, (node) => {
+      return window.getComputedStyle(node).display;
+    });
+    return display !== "none";
+  }
+  /**
+   *
+   * @param {string} selector ~
+   * @returns {Promise<boolean>} ~
+   */
+  async isChecked(selector) {
+    return await this.page.$eval(
+      selector,
+      (node) => node.checked
+    );
+  }
+  /**
+   *
+   * @param {string} selector ~
+   * @returns {Promise<boolean>} ~
+   */
+  async isFocused(selector) {
+    return await this.page.$eval(selector, (node) => node === document.activeElement);
+  }
+  /**
+   * @param {string} selector ~
+   * @param {string} value$ ~
+   * @returns {Promise<void>} ~
+   */
+  async setValue(selector, value$) {
+    await this.page.$eval(
+      selector,
+      (node, value$$) => {
+        node.value = value$$;
+        node.dispatchEvent(new Event("input"));
+      },
+      value$
+    );
+  }
+  /**
+   * @param {string} selector ~
+   * @param {string} value$ ~
+   * @returns {Promise<void>} ~
+   */
+  async typeValue(selector, value$) {
+    const el = await this.page.$(selector);
+    await el.evaluate((node) => node.value = "");
+    await el.type(value$);
+  }
+  /**
+   * @param {string} selector ~
+   * @param {string} value$ ~
+   * @returns {Promise<void>} ~
+   */
+  async enterValue(selector, value$) {
+    const el = await this.page.$(selector);
+    await el.evaluate((node) => node.value = "");
+    await el.type(value$);
+    await el.press("Enter");
+  }
+  /**
+   * @param {string} selector ~
+   * @returns {Promise<void>} ~
+   */
+  async clearValue(selector) {
+    return await this.page.$eval(
+      selector,
+      (node) => {
+        node.value = "";
+      }
+    );
+  }
+  /**
+   *
+   * @param {number} time ~
+   * @returns {Promise<any>} ~
+   */
+  sleep(time) {
+    return this.page.evaluate((time$) => {
+      return new Promise((r) => {
+        setTimeout(r, time$);
+      });
+    }, time);
+  }
+  nextFrame() {
+    return this.page.evaluate(() => {
+      return new Promise((resolve) => {
+        requestAnimationFrame(() => {
+          requestAnimationFrame(resolve);
         });
-        emitter.stdout.on('data', e => {
-            this.stdout += e.toString();
-            this.schedule.complete();
+      });
+    });
+  }
+}
+
+class Launch {
+  browser;
+  page;
+  operater;
+  _browser;
+  _page;
+  options;
+  constructor() {
+    this.operater = new Proxy({}, {
+      get: () => {
+        throw new Error("operater is not defined. create* invote first");
+      }
+    });
+    this.browser = new Proxy({}, {
+      get: () => {
+        throw new Error("browser is not defined. createBrowser invote first");
+      }
+    });
+    this.page = new Proxy({}, {
+      get: () => {
+        throw new Error("page is not defined. createPage invote first");
+      }
+    });
+    this.options = process.env.CI ? (
+      /* istanbul ignore next */
+      { args: ["--no-sandbox", "--disable-setuid-sandbox"] }
+    ) : {};
+  }
+  createBrowser(force) {
+    if (force || !this._browser) {
+      if (force && this._browser) {
+        this._browser.then((browser) => {
+          browser.isConnected() && browser.close();
         });
-        emitter.stderr.on('data', e => this.stderr += e.toString());
-        return emitter;
-    }
-    async stop() {
-        await this.schedule.target;
-        if (!this.isClose) {
-            this.emitter.stdin.end();
-            this.isClose = true;
-        }
-        const response = await this.target;
-        return response;
+      }
+      this._browser = puppeteer.launch({
+        ...this.options,
+        headless: "new"
+      });
+      this._browser.then((browser) => {
+        this.browser = browser;
+      });
     }
-    async press(key, timeout = 200) {
-        if (!key || this.isClose)
-            return;
-        await this.schedule.target;
-        this.schedule.target = new Promise(resolve => {
-            this.schedule.complete = resolve;
+    return this._browser;
+  }
+  async createPage(force) {
+    await this.createBrowser();
+    if (force || !this._page) {
+      if (force && this._page) {
+        this._page.then((page) => {
+          !page.isClosed() && page.close();
         });
-        await new Promise(resolve => {
-            this.emitter.stdin.write(KEY_MAP[key.toUpperCase()] || key, 'utf8', resolve);
-        });
-        await new Promise(_ => setTimeout(_, timeout));
+      }
+      this._page = this.browser.newPage();
+      this._page.then((page) => {
+        this.page = page;
+        this.operater = new Operater(page);
+        page.evaluateOnNewDocument(
+          /* istanbul ignore next */
+          () => {
+            localStorage.clear();
+          }
+        );
+        page.on(
+          "console",
+          /* istanbul ignore next */
+          (e) => {
+            if (e.type() === "error") {
+              const err = e.args()[0];
+              console.error(
+                `Error from Puppeteer-loaded page:
+`,
+                err.remoteObject().description
+              );
+            }
+          }
+        );
+      });
     }
+    return this._page;
+  }
 }
 
+const TIME_OUT = 30 * 1e3;
+const impl = () => {
+  let launch = new Launch();
+  beforeAll(async () => {
+    await launch.createBrowser();
+  }, 2e4);
+  beforeEach(async () => {
+    await launch.createPage(true);
+  });
+  afterEach(async () => {
+    await launch.page.close();
+  });
+  afterAll(async () => {
+    await launch.browser.close();
+  });
+  return launch;
+};
+
+const e2e = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+	__proto__: null,
+	TIME_OUT,
+	impl
+}, Symbol.toStringTag, { value: 'Module' }));
+
+const sleep = (s) => new Promise((_) => {
+  setTimeout(_, s || 0);
+});
+const expectByPolling = async (poll, expected, options) => {
+  const { maxTries = 30, interval = 50, to } = options || {};
+  for (let tries = 0; tries < maxTries; tries++) {
+    const actual = await poll();
+    const allowMatch = (!to || to === "toMatch") && typeof expected === "string" && typeof actual === "string";
+    if (allowMatch && actual.indexOf(expected) > -1 || actual === expected || tries === maxTries - 1) {
+      allowMatch ? expect(actual).toMatch(expected) : expect(actual)[to || "toBe"](expected);
+      break;
+    } else {
+      await sleep(interval);
+    }
+  }
+};
+
+const utils = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+	__proto__: null,
+	expectByPolling,
+	sleep
+}, Symbol.toStringTag, { value: 'Module' }));
+
 exports.Command = Command;
+exports.E2E = e2e;
+exports.Launch = Launch;
+exports.Operater = Operater;
+exports.Utils = utils;

package/dist/index.d.ts

@@ -1,7 +1,11 @@
 /// <reference types="node" />
 
+import type { Browser } from 'puppeteer';
 import * as childProcess from 'child_process';
+import type { ClickOptions } from 'puppeteer';
 import type { Nullable } from '@deot/dev-shared';
+import type { Page } from 'puppeteer';
+import type { PuppeteerLaunchOptions } from 'puppeteer';
 
 export declare class Command {
     target: Promise<any>;
@@ -24,4 +28,67 @@ export declare class Command {
     press(key: string, timeout?: number): Promise<void>;
 }
 
+declare namespace E2E {
+    export {
+        TIME_OUT,
+        impl
+    }
+}
+export { E2E }
+
+declare const expectByPolling: (poll: () => Promise<any> | any, expected: any, options?: ExpectByPollingOptions) => Promise<void>;
+
+declare interface ExpectByPollingOptions {
+    interval?: number;
+    maxTries?: number;
+    to?: string;
+}
+
+declare const impl: () => Launch;
+
+export declare class Launch {
+    browser: Browser;
+    page: Page;
+    operater: Operater;
+    private _browser;
+    private _page;
+    options: PuppeteerLaunchOptions;
+    constructor();
+    createBrowser(force?: boolean): Promise<Browser>;
+    createPage(force?: boolean): Promise<Page>;
+}
+
+export declare class Operater {
+    page: Page;
+    constructor(v: Page);
+    click(selector: string, options?: ClickOptions): Promise<void>;
+    count(selector: string): Promise<number>;
+    text(selector: string): Promise<string>;
+    value(selector: string): Promise<string>;
+    html(selector: string): Promise<string>;
+    classList(selector: string): Promise<string[]>;
+    children(selector: string): Promise<HTMLElement[]>;
+    isVisible(selector: string): Promise<boolean>;
+    isChecked(selector: string): Promise<boolean>;
+    isFocused(selector: string): Promise<boolean>;
+    setValue(selector: string, value$: string): Promise<void>;
+    typeValue(selector: string, value$: string): Promise<void>;
+    enterValue(selector: string, value$: string): Promise<void>;
+    clearValue(selector: string): Promise<void>;
+    sleep(time: number): Promise<any>;
+    nextFrame(): Promise<unknown>;
+}
+
+declare const sleep: (s?: number) => Promise<unknown>;
+
+declare const TIME_OUT: number;
+
+declare namespace Utils {
+    export {
+        sleep,
+        expectByPolling
+    }
+}
+export { Utils }
+
 export { }

package/dist/index.es.js

@@ -1,103 +1,400 @@
 import { Shell } from '@deot/dev-shared';
 import * as childProcess from 'child_process';
+import puppeteer from 'puppeteer';
 
 const { LOCAL_COMMAND_MAP } = Shell;
 const KEY_MAP = {
-    DOWN: '\x1b\x5b\x42',
-    UP: '\x1b\x5b\x41',
-    ENTER: '\x0d',
-    SPACE: '\x7f'
+  DOWN: "\x1B[B",
+  UP: "\x1B[A",
+  ENTER: "\r",
+  // return;
+  SPACE: ""
 };
 class Command {
-    target;
-    code;
-    error;
-    resolve;
-    reject;
-    stdout;
-    stderr;
-    emitter;
-    isClose;
-    schedule;
-    constructor(command, args) {
-        this.target = new Promise((resolve, reject) => {
-            this.resolve = this._handleEnd(resolve);
-            this.reject = this._handleEnd(reject);
-        });
-        this.code = null;
-        this.error = null;
-        this.stdout = '';
-        this.stderr = '';
-        this.emitter = this.start(command, args);
-        this.isClose = false;
-        this.schedule = {
-            target: Promise.resolve(),
-            complete: () => { }
-        };
-    }
-    _handleEnd(fn) {
-        return (e) => {
-            this.isClose = true;
-            const { code, error } = e;
-            this.code = code;
-            this.error = error;
-            fn({
-                ...e,
-                stdout: this.stdout,
-                stderr: this.stderr
-            });
-        };
+  target;
+  code;
+  error;
+  resolve;
+  reject;
+  stdout;
+  stderr;
+  emitter;
+  isClose;
+  schedule;
+  constructor(command, args) {
+    this.target = new Promise((resolve, reject) => {
+      this.resolve = this._handleEnd(resolve);
+      this.reject = this._handleEnd(reject);
+    });
+    this.code = null;
+    this.error = null;
+    this.stdout = "";
+    this.stderr = "";
+    this.emitter = this.start(command, args);
+    this.isClose = false;
+    this.schedule = {
+      target: Promise.resolve(),
+      complete: (
+        /* istanbul ignore next */
+        () => {
+        }
+      )
+    };
+  }
+  _handleEnd(fn) {
+    return (e) => {
+      this.isClose = true;
+      const { code, error } = e;
+      this.code = code;
+      this.error = error;
+      fn({
+        ...e,
+        stdout: this.stdout,
+        stderr: this.stderr
+      });
+    };
+  }
+  start(command, args) {
+    const SPACE = " ";
+    const [command$, ...args$] = (command + SPACE + args.join(SPACE)).replace(/\s+/g, SPACE).split(SPACE).filter((i) => !!i).map((i) => LOCAL_COMMAND_MAP[i] || i);
+    const emitter = childProcess.spawn(command$, args$, {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    emitter.on("close", (code) => {
+      if (code !== 0) {
+        this.reject({ code });
+      } else {
+        this.resolve({ code });
+      }
+    });
+    emitter.on(
+      "error",
+      /* istanbul ignore next */
+      (error) => {
+        !process.exitCode && (process.exitCode = 1);
+        this.reject({ code: process.exitCode, error });
+      }
+    );
+    emitter.stdout.on("data", (e) => {
+      this.stdout += e.toString();
+      this.schedule.complete();
+    });
+    emitter.stderr.on(
+      "data",
+      /* istanbul ignore next */
+      (e) => this.stderr += e.toString()
+    );
+    return emitter;
+  }
+  async stop() {
+    await this.schedule.target;
+    if (!this.isClose) {
+      this.emitter.stdin.end();
+      this.isClose = true;
     }
-    start(command, args) {
-        const SPACE = ' ';
-        const [command$, ...args$] = (command + SPACE + args.join(SPACE))
-            .replace(/\s+/g, SPACE)
-            .split(SPACE)
-            .filter(i => !!i)
-            .map(i => LOCAL_COMMAND_MAP[i] || i);
-        const emitter = childProcess.spawn(command$, args$, {
-            stdio: ['pipe', 'pipe', 'pipe']
-        });
-        emitter.on('close', (code) => {
-            if (code !== 0) {
-                this.reject({ code });
-            }
-            else {
-                this.resolve({ code });
-            }
-        });
-        emitter.on('error', (error) => {
-            !process.exitCode && (process.exitCode = 1);
-            this.reject({ code: process.exitCode, error });
+    const response = await this.target;
+    return response;
+  }
+  async press(key, timeout = 200) {
+    if (!key || this.isClose)
+      return;
+    await this.schedule.target;
+    this.schedule.target = new Promise((resolve) => {
+      this.schedule.complete = resolve;
+    });
+    await new Promise((resolve) => {
+      this.emitter.stdin.write(
+        KEY_MAP[key.toUpperCase()] || key,
+        "utf8",
+        resolve
+      );
+    });
+    await new Promise((_) => setTimeout(_, timeout));
+  }
+}
+
+class Operater {
+  page;
+  constructor(v) {
+    this.page = v;
+  }
+  /**
+   * @param {string} selector ~
+   * @param {ClickOptions} options ~
+   */
+  async click(selector, options) {
+    await this.page.click(selector, options);
+  }
+  /**
+   * @param {string} selector ~
+   * @returns {number} ~
+   */
+  async count(selector) {
+    return (await this.page.$$(selector)).length;
+  }
+  /**
+   * @param {string} selector ~
+   * @returns {Promise<string>} ~
+   */
+  async text(selector) {
+    return await this.page.$eval(selector, (node) => node.textContent);
+  }
+  /**
+   * @param {string} selector ~
+   * @returns {Promise<string>} ~
+   */
+  async value(selector) {
+    return await this.page.$eval(selector, (node) => node.value);
+  }
+  /**
+   * @param {string} selector ~
+   * @returns {Promise<string>} ~
+   */
+  async html(selector) {
+    return await this.page.$eval(selector, (node) => node.innerHTML);
+  }
+  /**
+   * @param {string} selector ~
+   * @returns {Promise<string[]>} ~
+   */
+  async classList(selector) {
+    return await this.page.$eval(selector, (node) => [...node.classList]);
+  }
+  /**
+   * @param {string} selector ~
+   * @returns {Promise<HTMLElement[]>} ~
+   */
+  async children(selector) {
+    return await this.page.$eval(selector, (node) => [...node.children]);
+  }
+  /**
+   * @param {string} selector ~
+   * @returns {Promise<boolean>} ~
+   */
+  async isVisible(selector) {
+    const display = await this.page.$eval(selector, (node) => {
+      return window.getComputedStyle(node).display;
+    });
+    return display !== "none";
+  }
+  /**
+   *
+   * @param {string} selector ~
+   * @returns {Promise<boolean>} ~
+   */
+  async isChecked(selector) {
+    return await this.page.$eval(
+      selector,
+      (node) => node.checked
+    );
+  }
+  /**
+   *
+   * @param {string} selector ~
+   * @returns {Promise<boolean>} ~
+   */
+  async isFocused(selector) {
+    return await this.page.$eval(selector, (node) => node === document.activeElement);
+  }
+  /**
+   * @param {string} selector ~
+   * @param {string} value$ ~
+   * @returns {Promise<void>} ~
+   */
+  async setValue(selector, value$) {
+    await this.page.$eval(
+      selector,
+      (node, value$$) => {
+        node.value = value$$;
+        node.dispatchEvent(new Event("input"));
+      },
+      value$
+    );
+  }
+  /**
+   * @param {string} selector ~
+   * @param {string} value$ ~
+   * @returns {Promise<void>} ~
+   */
+  async typeValue(selector, value$) {
+    const el = await this.page.$(selector);
+    await el.evaluate((node) => node.value = "");
+    await el.type(value$);
+  }
+  /**
+   * @param {string} selector ~
+   * @param {string} value$ ~
+   * @returns {Promise<void>} ~
+   */
+  async enterValue(selector, value$) {
+    const el = await this.page.$(selector);
+    await el.evaluate((node) => node.value = "");
+    await el.type(value$);
+    await el.press("Enter");
+  }
+  /**
+   * @param {string} selector ~
+   * @returns {Promise<void>} ~
+   */
+  async clearValue(selector) {
+    return await this.page.$eval(
+      selector,
+      (node) => {
+        node.value = "";
+      }
+    );
+  }
+  /**
+   *
+   * @param {number} time ~
+   * @returns {Promise<any>} ~
+   */
+  sleep(time) {
+    return this.page.evaluate((time$) => {
+      return new Promise((r) => {
+        setTimeout(r, time$);
+      });
+    }, time);
+  }
+  nextFrame() {
+    return this.page.evaluate(() => {
+      return new Promise((resolve) => {
+        requestAnimationFrame(() => {
+          requestAnimationFrame(resolve);
         });
-        emitter.stdout.on('data', e => {
-            this.stdout += e.toString();
-            this.schedule.complete();
+      });
+    });
+  }
+}
+
+class Launch {
+  browser;
+  page;
+  operater;
+  _browser;
+  _page;
+  options;
+  constructor() {
+    this.operater = new Proxy({}, {
+      get: () => {
+        throw new Error("operater is not defined. create* invote first");
+      }
+    });
+    this.browser = new Proxy({}, {
+      get: () => {
+        throw new Error("browser is not defined. createBrowser invote first");
+      }
+    });
+    this.page = new Proxy({}, {
+      get: () => {
+        throw new Error("page is not defined. createPage invote first");
+      }
+    });
+    this.options = process.env.CI ? (
+      /* istanbul ignore next */
+      { args: ["--no-sandbox", "--disable-setuid-sandbox"] }
+    ) : {};
+  }
+  createBrowser(force) {
+    if (force || !this._browser) {
+      if (force && this._browser) {
+        this._browser.then((browser) => {
+          browser.isConnected() && browser.close();
         });
-        emitter.stderr.on('data', e => this.stderr += e.toString());
-        return emitter;
+      }
+      this._browser = puppeteer.launch({
+        ...this.options,
+        headless: "new"
+      });
+      this._browser.then((browser) => {
+        this.browser = browser;
+      });
     }
-    async stop() {
-        await this.schedule.target;
-        if (!this.isClose) {
-            this.emitter.stdin.end();
-            this.isClose = true;
-        }
-        const response = await this.target;
-        return response;
-    }
-    async press(key, timeout = 200) {
-        if (!key || this.isClose)
-            return;
-        await this.schedule.target;
-        this.schedule.target = new Promise(resolve => {
-            this.schedule.complete = resolve;
-        });
-        await new Promise(resolve => {
-            this.emitter.stdin.write(KEY_MAP[key.toUpperCase()] || key, 'utf8', resolve);
+    return this._browser;
+  }
+  async createPage(force) {
+    await this.createBrowser();
+    if (force || !this._page) {
+      if (force && this._page) {
+        this._page.then((page) => {
+          !page.isClosed() && page.close();
         });
-        await new Promise(_ => setTimeout(_, timeout));
+      }
+      this._page = this.browser.newPage();
+      this._page.then((page) => {
+        this.page = page;
+        this.operater = new Operater(page);
+        page.evaluateOnNewDocument(
+          /* istanbul ignore next */
+          () => {
+            localStorage.clear();
+          }
+        );
+        page.on(
+          "console",
+          /* istanbul ignore next */
+          (e) => {
+            if (e.type() === "error") {
+              const err = e.args()[0];
+              console.error(
+                `Error from Puppeteer-loaded page:
+`,
+                err.remoteObject().description
+              );
+            }
+          }
+        );
+      });
     }
+    return this._page;
+  }
 }
 
-export { Command };
+const TIME_OUT = 30 * 1e3;
+const impl = () => {
+  let launch = new Launch();
+  beforeAll(async () => {
+    await launch.createBrowser();
+  }, 2e4);
+  beforeEach(async () => {
+    await launch.createPage(true);
+  });
+  afterEach(async () => {
+    await launch.page.close();
+  });
+  afterAll(async () => {
+    await launch.browser.close();
+  });
+  return launch;
+};
+
+const e2e = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+	__proto__: null,
+	TIME_OUT,
+	impl
+}, Symbol.toStringTag, { value: 'Module' }));
+
+const sleep = (s) => new Promise((_) => {
+  setTimeout(_, s || 0);
+});
+const expectByPolling = async (poll, expected, options) => {
+  const { maxTries = 30, interval = 50, to } = options || {};
+  for (let tries = 0; tries < maxTries; tries++) {
+    const actual = await poll();
+    const allowMatch = (!to || to === "toMatch") && typeof expected === "string" && typeof actual === "string";
+    if (allowMatch && actual.indexOf(expected) > -1 || actual === expected || tries === maxTries - 1) {
+      allowMatch ? expect(actual).toMatch(expected) : expect(actual)[to || "toBe"](expected);
+      break;
+    } else {
+      await sleep(interval);
+    }
+  }
+};
+
+const utils = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+	__proto__: null,
+	expectByPolling,
+	sleep
+}, Symbol.toStringTag, { value: 'Module' }));
+
+export { Command, e2e as E2E, Launch, Operater, utils as Utils };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deot/dev-test",
-  "version": "1.1.1",
+  "version": "2.0.1",
   "main": "dist/index.es.js",
   "types": "dist/index.d.ts",
   "type": "module",
@@ -12,6 +12,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@deot/dev-shared": "^1.1.1"
+    "@deot/dev-shared": "^2.0.0",
+    "puppeteer": "^20.7.3"
   }
 }