@lvce-editor/test-worker 4.14.0 → 4.16.0

package/dist/testWorkerMain.js

@@ -54,12 +54,12 @@ class VError extends Error {
   }
 }
 
-class AssertionError extends Error {
+let AssertionError$1 = class AssertionError extends Error {
   constructor(message) {
     super(message);
     this.name = 'AssertionError';
   }
-}
+};
 const getType = value => {
   switch (typeof value) {
     case 'number':
@@ -85,13 +85,13 @@ const getType = value => {
 const object = value => {
   const type = getType(value);
   if (type !== 'object') {
-    throw new AssertionError('expected value to be of type object');
+    throw new AssertionError$1('expected value to be of type object');
   }
 };
-const string = value => {
+const string$1 = value => {
   const type = getType(value);
   if (type !== 'string') {
-    throw new AssertionError('expected value to be of type string');
+    throw new AssertionError$1('expected value to be of type string');
   }
 };
 
@@ -960,6 +960,10 @@ const WebWorkerRpcClient = {
   create: create$1
 };
 
+const formatDuration = duration => {
+  return duration.toFixed(2) + 'ms';
+};
+
 const RendererWorker = 1;
 
 const rpcs = Object.create(null);
@@ -985,13 +989,6 @@ const Rpc = {
   invokeAndTransfer
 };
 
-const Fail = 'fail';
-const Pass = 'pass';
-
-const now = () => {
-  return performance.now();
-};
-
 const printError = error => {
   if (error && error.constructor.name === 'AssertionError') {
     console.error(error.message);
@@ -999,6 +996,7 @@ const printError = error => {
     console.error(error);
   }
 };
+
 const stringifyError = error => {
   if (!error) {
     return `${error}`;
@@ -1008,9 +1006,14 @@ const stringifyError = error => {
   }
   return `${error.message}`;
 };
-const formatDuration = duration => {
-  return duration.toFixed(2) + 'ms';
+
+const Fail = 'fail';
+const Pass = 'pass';
+
+const now = () => {
+  return performance.now();
 };
+
 const executeTest = async (name, fn, globals = {}) => {
   let _error;
   let _start;
@@ -1031,12 +1034,10 @@ const executeTest = async (name, fn, globals = {}) => {
       console.error(error);
       return;
     }
-    // @ts-ignore
     _error = stringifyError(error);
     if (!(error instanceof VError)) {
       error = new VError(error, `Test failed: ${name}`);
     }
-    // @ts-ignore
     printError(error);
   }
   let state;
@@ -1073,6 +1074,13 @@ const importTest = async url => {
   }
 };
 
+class AssertionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'AssertionError';
+  }
+}
+
 const webViews = Object.create(null);
 const set = (id, webView) => {
   webViews[id] = webView;
@@ -1088,29 +1096,181 @@ const getLocatorRpc = locator => {
   return Rpc;
 };
 
-const Assert = {
-  string(value, message) {
-    if (typeof value !== 'string') {
-      throw new TypeError(message);
-    }
-  },
-  number(value, message) {
-    if (typeof value !== 'number' || Number.isNaN(value)) {
-      throw new TypeError(message);
-    }
-  }
-};
-const expect$1 = locator => {
+const locatorInvoke = (locator, method, ...params) => {
+  object(locator);
+  string$1(method);
   const {
     invoke
   } = getLocatorRpc(locator);
+  return invoke(method, ...params);
+};
+
+const printLocator = locator => {
+  if (locator._nth !== -1) {
+    return `${locator._selector}:nth(${locator._nth})`;
+  }
+  if (locator._hasText) {
+    return `${locator._selector} "${locator._hasText}"`;
+  }
+  return `${locator._selector}`;
+};
+
+const toBeVisible = locator => {
+  return `expected selector to be visible ${locator._selector}`;
+};
+const toHaveValue = (locator, {
+  value
+}) => {
+  return `expected selector ${locator._selector} to have value ${value}`;
+};
+const toHaveText = async (locator, options) => {
+  const locatorString = printLocator(locator);
+  const {
+    wasFound,
+    actual
+  } = await locatorInvoke(locator, 'TestFrameWork.checkConditionError', 'toHaveText', locator, options);
+  const {
+    text
+  } = options;
+  if (!wasFound) {
+    return `expected selector ${locatorString} to have text "${text}" element was not found`;
+  }
+  return `expected selector ${locatorString} to have text "${text}" but was "${actual}"`;
+};
+const toHaveAttribute = async (locator, options) => {
+  const locatorString = printLocator(locator);
+  const {
+    wasFound,
+    actual
+  } = await locatorInvoke(locator, 'TestFrameWork.checkConditionError', 'toHaveAttribute', locator, options);
+  const {
+    key,
+    value
+  } = options;
+  if (!wasFound) {
+    return `expected ${locatorString} to have attribute ${key} ${value} but element was not found`;
+  }
+  return `expected ${locatorString} to have attribute ${key} ${value} but was ${actual}`;
+};
+const toHaveCount = async (locator, {
+  count
+}) => {
+  const locatorString = printLocator(locator);
+  const {
+    actual
+  } = await locatorInvoke(locator, 'TestFrameWork.checkConditionError', 'toHaveCount', locator);
+  return `expected ${locatorString} to have count ${count} but was ${actual}`;
+};
+const toBeFocused = async locator => {
+  const locatorString = printLocator(locator);
+  const {
+    actual
+  } = await locatorInvoke(locator, 'TestFrameWork.checkConditionError', 'toBeFocused', locator);
+  return `expected ${locatorString} to be focused but active element is ${actual}`;
+};
+const toHaveClass = async (locator, options) => {
+  const locatorString = printLocator(locator);
+  const {
+    wasFound
+  } = await locatorInvoke(locator, 'TestFrameWork.checkConditionError', 'toHaveClass', locator, options);
+  const {
+    className
+  } = options;
+  if (!wasFound) {
+    return `expected ${locatorString} to have class ${className} but element was not found`;
+  }
+  return `expected ${locatorString} to have class ${className}`;
+};
+const toHaveId = async (locator, options) => {
+  const {
+    wasFound,
+    actual
+  } = await locatorInvoke(locator, 'TestFrameWork.checkConditionError', 'toHaveId', locator, options);
+  const locatorString = printLocator(locator);
+  const {
+    id
+  } = options;
+  if (!wasFound) {
+    return `expected ${locatorString} to have id ${id} but element was not found`;
+  }
+  return `expected ${locatorString} to have id ${id} but was ${actual}`;
+};
+const toBeHidden = locator => {
+  const locatorString = printLocator(locator);
+  return `expected ${locatorString} to be hidden`;
+};
+const toHaveCss = async (locator, options) => {
+  const {
+    wasFound,
+    actual
+  } = await locatorInvoke(locator, 'TestFrameWork.checkConditionError', 'toHaveCss', locator, options);
+  const locatorString = printLocator(locator);
+  const {
+    key,
+    value
+  } = options;
+  if (!wasFound) {
+    return `expected ${locatorString} to have css ${key} ${value} but element was not found`;
+  }
+  return `expected ${locatorString} to have css ${key} ${value} but was ${actual}`;
+};
+
+const getFunction = fnName => {
+  switch (fnName) {
+    case 'toBeVisible':
+      return toBeVisible;
+    case 'toHaveValue':
+      return toHaveValue;
+    case 'toHaveText':
+      return toHaveText;
+    case 'toHaveAttribute':
+      return toHaveAttribute;
+    case 'toHaveCount':
+      return toHaveCount;
+    case 'toBeFocused':
+      return toBeFocused;
+    case 'toHaveId':
+      return toHaveId;
+    case 'toBeHidden':
+      return toBeHidden;
+    case 'toHaveCss':
+      return toHaveCss;
+    case 'toHaveClass':
+      return toHaveClass;
+    default:
+      throw new Error(`unexpected function name ${fnName}`);
+  }
+};
+
+const string = (value, message) => {
+  if (typeof value !== 'string') {
+    throw new TypeError(message);
+  }
+};
+const number = (value, message) => {
+  if (typeof value !== 'number' || Number.isNaN(value)) {
+    throw new TypeError(message);
+  }
+};
+
+const expect$1 = locator => {
   return {
     async checkSingleElementCondition(fnName, options) {
       // TODO add rpcId property to locator instead
-      return invoke('TestFrameWork.checkSingleElementCondition', locator, fnName, options);
+      const result = await locatorInvoke(locator, 'TestFrameWork.checkSingleElementCondition', locator, fnName, options);
+      if (result && result.error) {
+        const fn = getFunction(fnName);
+        const errorInfo = await fn(locator, options);
+        throw new AssertionError(errorInfo);
+      }
     },
     async checkMultiElementCondition(fnName, options) {
-      return invoke('TestFrameWork.checkMultiElementCondition', locator, fnName, options);
+      const result = await locatorInvoke(locator, 'TestFrameWork.checkMultiElementCondition', locator, fnName, options);
+      if (result && result.error) {
+        const fn = getFunction(fnName);
+        const errorInfo = await fn(locator, options);
+        throw new AssertionError(errorInfo);
+      }
     },
     async toBeVisible() {
       if (this.negated) {
@@ -1119,19 +1279,19 @@ const expect$1 = locator => {
       return this.checkSingleElementCondition('toBeVisible', {});
     },
     async toHaveText(text) {
-      Assert.string(text, 'text must be of type string');
+      string(text, 'text must be of type string');
       return this.checkSingleElementCondition('toHaveText', {
         text
       });
     },
     async toContainText(text) {
-      Assert.string(text, 'text must be of type string');
+      string(text, 'text must be of type string');
       return this.checkSingleElementCondition('toContainText', {
         text
       });
     },
     async toHaveValue(value) {
-      Assert.string(value, 'value must be of type string');
+      string(value, 'value must be of type string');
       return this.checkSingleElementCondition('toHaveValue', {
         value
       });
@@ -1146,7 +1306,7 @@ const expect$1 = locator => {
       });
     },
     async toHaveAttribute(key, value) {
-      Assert.string(key, 'key must be of type string');
+      string(key, 'key must be of type string');
       // Assert.string(value, 'value must be of type string')
       return this.checkSingleElementCondition('toHaveAttribute', {
         key,
@@ -1154,19 +1314,19 @@ const expect$1 = locator => {
       });
     },
     async toHaveClass(className) {
-      Assert.string(className, 'className must be of type string');
+      string(className, 'className must be of type string');
       return this.checkSingleElementCondition('toHaveClass', {
         className
       });
     },
     async toHaveId(id) {
-      Assert.string(id, 'id must be of type string');
+      string(id, 'id must be of type string');
       return this.checkSingleElementCondition('toHaveId', {
         id
       });
     },
     async toHaveCount(count) {
-      Assert.number(count, 'count must be of type number');
+      number(count, 'count must be of type number');
       return this.checkMultiElementCondition('toHaveCount', {
         count
       });
@@ -1214,7 +1374,7 @@ const getTests = () => {
 };
 const setMockRpc = mockRpc => {
   object(mockRpc);
-  string(mockRpc.name);
+  string$1(mockRpc.name);
   state.mockRpcs[mockRpc.name] = mockRpc;
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/test-worker",
-  "version": "4.14.0",
+  "version": "4.16.0",
   "description": "Test Worker",
   "repository": {
     "type": "git",