@lvce-editor/test-worker 14.15.0 → 14.17.0

package/dist/testWorkerMain.js

@@ -533,7 +533,7 @@ const execute$2 = (command, ...args) => {
 
 const Two$1 = '2.0';
 const callbacks$1 = Object.create(null);
-const get$2 = id => {
+const get$3 = id => {
   return callbacks$1[id];
 };
 const remove$2 = id => {
@@ -682,7 +682,7 @@ const warn = (...args) => {
   console.warn(...args);
 };
 const resolve$1 = (id, response) => {
-  const fn = get$2(id);
+  const fn = get$3(id);
   if (!fn) {
     console.log(response);
     warn(`callback ${id} may already be disposed`);
@@ -1091,10 +1091,10 @@ const createMockRpc = ({
 };
 
 const rpcs = Object.create(null);
-const set$4 = (id, rpc) => {
+const set$5 = (id, rpc) => {
   rpcs[id] = rpc;
 };
-const get$1 = id => {
+const get$2 = id => {
   return rpcs[id];
 };
 const remove$1 = id => {
@@ -1105,18 +1105,18 @@ const remove$1 = id => {
 const create = rpcId => {
   return {
     async dispose() {
-      const rpc = get$1(rpcId);
+      const rpc = get$2(rpcId);
       await rpc.dispose();
     },
     // @ts-ignore
     invoke(method, ...params) {
-      const rpc = get$1(rpcId);
+      const rpc = get$2(rpcId);
       // @ts-ignore
       return rpc.invoke(method, ...params);
     },
     // @ts-ignore
     invokeAndTransfer(method, ...params) {
-      const rpc = get$1(rpcId);
+      const rpc = get$2(rpcId);
       // @ts-ignore
       return rpc.invokeAndTransfer(method, ...params);
     },
@@ -1124,7 +1124,7 @@ const create = rpcId => {
       const mockRpc = createMockRpc({
         commandMap
       });
-      set$4(rpcId, mockRpc);
+      set$5(rpcId, mockRpc);
       // @ts-ignore
       mockRpc[Symbol.dispose] = () => {
         remove$1(rpcId);
@@ -1133,7 +1133,7 @@ const create = rpcId => {
       return mockRpc;
     },
     set(rpc) {
-      set$4(rpcId, rpc);
+      set$5(rpcId, rpc);
     }
   };
 };
@@ -1152,18 +1152,18 @@ const TestWorker = 9001;
 
 const {
   invoke: invoke$2,
-  set: set$3
+  set: set$4
 } = create(EditorWorker);
 
 const {
   invoke: invoke$1,
-  set: set$2
+  set: set$3
 } = create(OpenerWorker);
 
 const {
   invoke,
   invokeAndTransfer,
-  set: set$1
+  set: set$2
 } = create(RendererWorker);
 const sendMessagePortToEditorWorker = async (port, rpcId) => {
   const command = 'HandleMessagePort.handleMessagePort';
@@ -1188,7 +1188,7 @@ const initializeEditorWorker = async () => {
     commandMap: {},
     send: send$1
   });
-  set$3(rpc);
+  set$4(rpc);
 };
 
 const send = async port => {
@@ -1199,7 +1199,18 @@ const initializeOpenerWorker = async () => {
     commandMap: {},
     send
   });
-  set$2(rpc);
+  set$3(rpc);
+};
+
+let autoFixError;
+const get$1 = () => {
+  return autoFixError;
+};
+const set$1 = value => {
+  autoFixError = value;
+};
+const clear$3 = () => {
+  autoFixError = undefined;
 };
 
 class AssertionError extends Error {
@@ -3527,7 +3538,7 @@ const ExtensionSearch = {
 
 const Memfs = 'memfs';
 
-const toFileUrl = url => {
+const toFileUrl$1 = url => {
   const urlObject = new URL(url);
   const pathName = urlObject.pathname;
   if (!pathName.startsWith('/remote')) {
@@ -3551,7 +3562,7 @@ const getDirents = async fileUrl => {
   return allDirents;
 };
 const getFileMapNode = async url => {
-  const fileUrl = toFileUrl(url);
+  const fileUrl = toFileUrl$1(url);
   const allFiles = await getDirents(fileUrl);
   const fileMap = Object.create(null);
   const contents = await Promise.all(allFiles.map(filePath => {
@@ -4879,6 +4890,22 @@ const formatDuration = duration => {
 const Fail = 'fail';
 const Pass = 'pass';
 
+const getAutoFixProperties = error => {
+  const isChatDebugPayloadError = error instanceof ChatDebugShouldHavePayloadError && error.actualPayload !== undefined;
+  const autoFixProperties = isChatDebugPayloadError ? {
+    autoFixError: {
+      actualPayload: error.actualPayload,
+      code: error.code,
+      expectedPayload: error.expectedPayload
+    },
+    overlayActions: [{
+      command: 'Test.tryAutoFix',
+      id: 'chat-debug-should-have-payload-autofix',
+      label: 'Autofix'
+    }]
+  } : {};
+  return autoFixProperties;
+};
 const executeTest2 = async (name, fn, globals, timestampGenerator) => {
   const getTimestamp = timestampGenerator;
   const start = getTimestamp();
@@ -4887,6 +4914,7 @@ const executeTest2 = async (name, fn, globals, timestampGenerator) => {
   const duration = end - start;
   const formattedDuration = formatDuration(duration);
   if (error) {
+    const autoFixProperties = getAutoFixProperties(error);
     return {
       background: 'red',
       duration,
@@ -4894,6 +4922,7 @@ const executeTest2 = async (name, fn, globals, timestampGenerator) => {
       error,
       formattedDuration,
       name,
+      ...autoFixProperties,
       start,
       text: `test failed: ${error}`,
       type: Fail
@@ -4931,18 +4960,25 @@ const now = () => {
 
 const executeTest = async (name, fn, globals = {}) => {
   const {
+    autoFixError,
     background,
     error,
     formattedDuration,
+    overlayActions,
     text,
     type
   } = await executeTest2(name, fn, globals, now);
+  set$1(autoFixError);
   if (error) {
     await printTestError(error);
   } else {
     // eslint-disable-next-line no-console
     console.info(`PASS ${name} in ${formattedDuration}`);
   }
+  if (overlayActions && overlayActions.length > 0) {
+    await invoke('TestFrameWork.showOverlay', type, background, text, overlayActions);
+    return;
+  }
   await invoke('TestFrameWork.showOverlay', type, background, text);
 };
 
@@ -5034,6 +5070,7 @@ const execute = async (href, platform, assetDir) => {
     }
     // TODO maybe setup file watcher earlier, to not miss events?
   } catch (error) {
+    clear$3();
     await printTestError(error);
     await invoke('TestFrameWork.showOverlay', Fail, 'red', `test failed: ${error}`);
     return;
@@ -5118,17 +5155,152 @@ const handleFileWatcherEvent = async event => {
   await hotReloadTest(lastItem, locationHref, time);
 };
 
+const whitespaceRegex = /\s+/g;
+const shouldHavePayloadRegex = /shouldHavePayload\(([^)]*)\)/gs;
+const normalizeWhitespace = value => {
+  return value.replaceAll(whitespaceRegex, '');
+};
+const trySerialize = value => {
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return undefined;
+  }
+};
+const replaceMatch = (fileContent, index, length, replacement) => {
+  const before = fileContent.slice(0, index);
+  const after = fileContent.slice(index + length);
+  return `${before}${replacement}${after}`;
+};
+const replaceShouldHavePayload = (fileContent, expectedPayload, actualPayload) => {
+  const serializedActual = trySerialize(actualPayload);
+  if (!serializedActual) {
+    return undefined;
+  }
+  const matches = [...fileContent.matchAll(shouldHavePayloadRegex)];
+  if (matches.length === 0) {
+    return undefined;
+  }
+  if (matches.length === 1) {
+    const [match] = matches;
+    if (typeof match.index !== 'number') {
+      return undefined;
+    }
+    return replaceMatch(fileContent, match.index, match[0].length, `shouldHavePayload(${serializedActual})`);
+  }
+  const serializedExpected = trySerialize(expectedPayload);
+  if (!serializedExpected) {
+    return undefined;
+  }
+  const normalizedExpected = normalizeWhitespace(serializedExpected);
+  const matchingCandidates = [];
+  for (const match of matches) {
+    const currentArgument = match[1];
+    if (normalizeWhitespace(currentArgument) === normalizedExpected) {
+      matchingCandidates.push(match);
+    }
+  }
+  if (matchingCandidates.length !== 1) {
+    return undefined;
+  }
+  const [candidate] = matchingCandidates;
+  if (typeof candidate.index !== 'number') {
+    return undefined;
+  }
+  return replaceMatch(fileContent, candidate.index, candidate[0].length, `shouldHavePayload(${serializedActual})`);
+};
+const getFileUrlFromRemotePath = rawPathName => {
+  if (!rawPathName.startsWith('/remote')) {
+    return undefined;
+  }
+  const rest = rawPathName.slice('/remote'.length);
+  return `file://${rest}`;
+};
+const toFileUrl = (url, locationHref) => {
+  const parsedUrl = new URL(url, locationHref);
+  if (parsedUrl.protocol === 'file:') {
+    parsedUrl.hash = '';
+    parsedUrl.search = '';
+    return parsedUrl.toString();
+  }
+  return getFileUrlFromRemotePath(parsedUrl.pathname);
+};
+const isAutoFixError = value => {
+  if (!value) {
+    return false;
+  }
+  return value.code === 'chat-debug.should-have-payload';
+};
+const defaultDependencies = {
+  getAutoFixError() {
+    return get$1();
+  },
+  getLatestTestInfo() {
+    return maybeLast();
+  },
+  getLocationHref() {
+    return location.href;
+  },
+  now: Date.now,
+  readFile(uri) {
+    return readFile(uri);
+  },
+  rerun(url, platform, assetDir) {
+    return execute(url, platform, assetDir);
+  },
+  setAutoFixError(value) {
+    set$1(value);
+  },
+  writeFile(uri, content) {
+    return writeFile(uri, content);
+  }
+};
+const tryAutoFixWith = async dependencies => {
+  const latestTestInfo = dependencies.getLatestTestInfo();
+  if (!latestTestInfo) {
+    return;
+  }
+  if (latestTestInfo.inProgress) {
+    return;
+  }
+  const autoFixError = dependencies.getAutoFixError();
+  if (!isAutoFixError(autoFixError)) {
+    return;
+  }
+  if (autoFixError.actualPayload === undefined) {
+    return;
+  }
+  const locationHref = dependencies.getLocationHref();
+  const fileUrl = toFileUrl(latestTestInfo.url, locationHref);
+  if (!fileUrl) {
+    return;
+  }
+  const fileContent = await dependencies.readFile(fileUrl);
+  const updatedFileContent = replaceShouldHavePayload(fileContent, autoFixError.expectedPayload, autoFixError.actualPayload);
+  if (!updatedFileContent || updatedFileContent === fileContent) {
+    return;
+  }
+  await dependencies.writeFile(fileUrl, updatedFileContent);
+  dependencies.setAutoFixError(undefined);
+  const rerunUrl = createUrlWithQueryParameter(latestTestInfo.url, locationHref, dependencies.now());
+  await dependencies.rerun(rerunUrl, latestTestInfo.platform, latestTestInfo.assetDir);
+};
+const tryAutoFix = async () => {
+  await tryAutoFixWith(defaultDependencies);
+};
+
 const commandMap = {
   'FileWatcher.handleEvent': handleFileWatcherEvent,
   'Test.execute': execute,
-  'Test.executeMock': executeMock
+  'Test.executeMock': executeMock,
+  'Test.tryAutoFix': tryAutoFix
 };
 
 const initializeRendererWorker = async () => {
   const rpc = await create$1({
     commandMap: commandMap
   });
-  set$1(rpc);
+  set$2(rpc);
 };
 
 const listen = async () => {

package/package.json

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