refactor: extract SingleExecutionResult from ExecutionRecorder

src/core/execute.ts

@@ -2,13 +2,13 @@ import { WASI } from "node:wasi";
 import { promises } from "node:fs";
 import { ensureDirSync } from "fs-extra";
 import { instantiate, Imports as ASImports } from "@assemblyscript/loader";
-import { AssertResult } from "../assertResult.js";
+import { ExecutionResult } from "../executionResult.js";
 import { Imports, ImportsArgument } from "../index.js";
 import { InstrumentResult } from "../interface.js";
 import { mockInstrumentFunc } from "../utils/import.js";
 import { supplyDefaultFunction } from "../utils/index.js";
 import { parseImportFunctionInfo } from "../utils/wasmparser.js";
-import { ExecutionRecorder } from "./executionRecorder.js";
+import { ExecutionRecorder, SingleExecutionResult } from "./executionRecorder.js";
 import { CoverageRecorder } from "./covRecorder.js";
 
 const readFile = promises.readFile;
@@ -17,7 +17,7 @@ async function nodeExecutor(
   instrumentResult: InstrumentResult,
   outFolder: string,
   imports: Imports
-): Promise<ExecutionRecorder> {
+): Promise<SingleExecutionResult> {
   const wasi = new WASI({
     args: ["node", instrumentResult.baseName],
     env: process.env,
@@ -56,20 +56,20 @@ async function nodeExecutor(
     throw new Error("node executor abort.");
   }
   coverageRecorder.outputTrace(instrumentResult.traceFile);
-  return executionRecorder;
+  return executionRecorder.result;
 }
 
 export async function execWasmBinaries(
   outFolder: string,
   instrumentResults: InstrumentResult[],
   imports: Imports
-): Promise<AssertResult> {
-  const assertRes = new AssertResult();
+): Promise<ExecutionResult> {
+  const assertRes = new ExecutionResult();
   ensureDirSync(outFolder);
   await Promise.all<void>(
     instrumentResults.map(async (instrumentResult): Promise<void> => {
-      const recorder: ExecutionRecorder = await nodeExecutor(instrumentResult, outFolder, imports);
-      await assertRes.merge(recorder, instrumentResult.expectInfo);
+      const result: SingleExecutionResult = await nodeExecutor(instrumentResult, outFolder, imports);
+      await assertRes.merge(result, instrumentResult.expectInfo);
     })
   );
   return assertRes;

src/core/executionRecorder.ts

@@ -27,12 +27,16 @@ class LogRecorder {
   }
 }
 
-// to do: split execution environment and recorder
-export class ExecutionRecorder implements IAssertResult, UnitTestFramework {
+export class SingleExecutionResult implements IAssertResult {
   total: number = 0;
   fail: number = 0;
-  failed_info: AssertFailMessage = {};
+  failedInfo: AssertFailMessage = {};
   failedLogMessages: FailedLogMessages = {};
+}
+
+// to do: split execution environment and recorder
+export class ExecutionRecorder implements UnitTestFramework {
+  result = new SingleExecutionResult();
 
   registerFunctions: [string, number][] = [];
   #currentTestDescriptions: string[] = [];
@@ -56,19 +60,21 @@ export class ExecutionRecorder implements IAssertResult, UnitTestFramework {
     const logMessages: string[] | null = this.#logRecorder.onFinishTest();
     if (logMessages !== null) {
       const testCaseFullName = this.#currentTestDescription;
-      this.failedLogMessages[testCaseFullName] = (this.failedLogMessages[testCaseFullName] || []).concat(logMessages);
+      this.result.failedLogMessages[testCaseFullName] = (this.result.failedLogMessages[testCaseFullName] || []).concat(
+        logMessages
+      );
     }
   }
 
   collectCheckResult(result: boolean, codeInfoIndex: number, actualValue: string, expectValue: string): void {
-    this.total++;
+    this.result.total++;
     if (!result) {
       this.#logRecorder.markTestFailed();
-      this.fail++;
+      this.result.fail++;
       const testCaseFullName = this.#currentTestDescription;
       const assertMessage: AssertMessage = [codeInfoIndex.toString(), actualValue, expectValue];
-      this.failed_info[testCaseFullName] = this.failed_info[testCaseFullName] || [];
-      this.failed_info[testCaseFullName].push(assertMessage);
+      this.result.failedInfo[testCaseFullName] = this.result.failedInfo[testCaseFullName] || [];
+      this.result.failedInfo[testCaseFullName].push(assertMessage);
     }
   }
 

src/assertResult.ts → src/executionResult.ts

@@ -5,7 +5,7 @@ import chalk from "chalk";
 
 const readFile = promises.readFile;
 
-export class AssertResult {
+export class ExecutionResult {
   fail = 0;
   total = 0;
   failedInfos: FailedInfoMap = new Map();
@@ -18,7 +18,7 @@ export class AssertResult {
       try {
         const expectContent = await readFile(expectInfoFilePath, { encoding: "utf8" });
         expectInfo = json2map(JSON.parse(expectContent) as ExpectInfo);
-        for (const [testcaseName, value] of json2map<AssertMessage[]>(result.failed_info)) {
+        for (const [testcaseName, value] of json2map<AssertMessage[]>(result.failedInfo)) {
           const errorMsgs: string[] = [];
           for (const msg of value) {
             const [index, actualValue, expectValue] = msg;

src/interface.ts

@@ -79,7 +79,7 @@ export type ExpectInfo = Record<ExpectInfoIndex, ExpectInfoDebugLocation>;
 export interface IAssertResult {
   fail: number;
   total: number;
-  failed_info: AssertFailMessage;
+  failedInfo: AssertFailMessage;
   failedLogMessages: FailedLogMessages;
 }
 

src/utils/projectRoot.ts

@@ -2,4 +2,3 @@ import { join } from "node:path";
 import { fileURLToPath, URL } from "node:url";
 
 export const projectRoot = join(fileURLToPath(new URL(".", import.meta.url)), "..", "..");
-console.log(projectRoot);

tests/ts/test/core/executionRecorder.test.ts

@@ -7,15 +7,15 @@ describe("execution recorder", () => {
       recorder._addDescription("description");
 
       recorder.collectCheckResult(false, 0, "", "");
-      expect(recorder.failed_info).toHaveProperty("description");
+      expect(recorder.result.failedInfo).toHaveProperty("description");
     });
     test("add multiple descriptions", () => {
       const recorder = new ExecutionRecorder();
       recorder._addDescription("description1");
       recorder._addDescription("description2");
 
       recorder.collectCheckResult(false, 0, "", "");
-      expect(recorder.failed_info).toHaveProperty("description1 - description2");
+      expect(recorder.result.failedInfo).toHaveProperty("description1 - description2");
     });
 
     test("remove  descriptions", () => {
@@ -25,7 +25,7 @@ describe("execution recorder", () => {
       recorder._removeDescription();
 
       recorder.collectCheckResult(false, 0, "", "");
-      expect(recorder.failed_info).toHaveProperty("description1");
+      expect(recorder.result.failedInfo).toHaveProperty("description1");
     });
   });
 
@@ -34,23 +34,23 @@ describe("execution recorder", () => {
       const recorder = new ExecutionRecorder();
       recorder.collectCheckResult(false, 0, "actual", "expect");
 
-      expect(recorder.total).toBe(1);
-      expect(recorder.fail).toBe(1);
+      expect(recorder.result.total).toBe(1);
+      expect(recorder.result.fail).toBe(1);
     });
     test("collect true results", () => {
       const recorder = new ExecutionRecorder();
       recorder.collectCheckResult(true, 0, "actual1", "expect1");
 
-      expect(recorder.total).toBe(1);
-      expect(recorder.fail).toBe(0);
+      expect(recorder.result.total).toBe(1);
+      expect(recorder.result.fail).toBe(0);
     });
     test("collect multiple results", () => {
       const recorder = new ExecutionRecorder();
       recorder.collectCheckResult(true, 0, "actual1", "expect1");
       recorder.collectCheckResult(false, 1, "actual2", "expect2");
 
-      expect(recorder.total).toBe(2);
-      expect(recorder.fail).toBe(1);
+      expect(recorder.result.total).toBe(2);
+      expect(recorder.result.fail).toBe(1);
     });
   });
 });

tests/ts/test/assertResult.test.ts → tests/ts/test/executionResult.test.ts

@@ -1,34 +1,34 @@
 import { join } from "node:path";
 import { fileURLToPath, URL } from "node:url";
 import { FailedInfoMap, IAssertResult } from "../../../src/interface.js";
-import { AssertResult } from "../../../src/assertResult.js";
+import { ExecutionResult } from "../../../src/executionResult.js";
 import chalk from "chalk";
 
 const __dirname = fileURLToPath(new URL(".", import.meta.url));
 
-test("no failed_info merge", async () => {
-  const assertResult = new AssertResult();
+test("no failedInfo merge", async () => {
+  const executionResult = new ExecutionResult();
   const testcaseA: IAssertResult = {
     fail: 0,
     total: 28,
-    failed_info: {},
+    failedInfo: {},
     failedLogMessages: {},
   };
   const expectInfoFIlePath = join(__dirname, "..", "fixture", "assertResultTest.expectInfo.json");
-  await assertResult.merge(testcaseA, expectInfoFIlePath);
-  expect(assertResult.fail).toEqual(0);
-  expect(assertResult.total).toEqual(28);
-  expect(assertResult.failedInfos).toEqual(new Map<string, string[]>());
+  await executionResult.merge(testcaseA, expectInfoFIlePath);
+  expect(executionResult.fail).toEqual(0);
+  expect(executionResult.total).toEqual(28);
+  expect(executionResult.failedInfos).toEqual(new Map<string, string[]>());
 });
 
 test("equal failed", async () => {
-  const assertResult = new AssertResult();
-  const actualString = "A long sentence for testing errorMsg.length > 160 in assertResult.ts merge function";
-  const expectString = "= A long sentence for testing errorMsg.length > 160 in assertResult.ts merge function ";
+  const executionResult = new ExecutionResult();
+  const actualString = "A long sentence for testing errorMsg.length > 160 in executionResult.ts merge function";
+  const expectString = "= A long sentence for testing errorMsg.length > 160 in executionResult.ts merge function ";
   const testcaseA: IAssertResult = {
     fail: 1,
     total: 28,
-    failed_info: {
+    failedInfo: {
       A: [
         ["1", "100", "= 200"],
         ["3", "[10]", "= [1]"],
@@ -41,7 +41,7 @@ test("equal failed", async () => {
     },
   };
   const expectInfoFIlePath = join(__dirname, "..", "fixture", "assertResultTest.expectInfo.json");
-  await assertResult.merge(testcaseA, expectInfoFIlePath);
+  await executionResult.merge(testcaseA, expectInfoFIlePath);
   const expectFailedInfo: FailedInfoMap = new Map();
   expectFailedInfo.set("A", {
     assertMessages: [
@@ -52,36 +52,36 @@ test("equal failed", async () => {
     ],
     logMessages: ["log message 1", "log message 2", "log message 3"],
   });
-  expect(assertResult.fail).toEqual(1);
-  expect(assertResult.total).toEqual(28);
-  expect(assertResult.failedInfos).toEqual(expectFailedInfo);
+  expect(executionResult.fail).toEqual(1);
+  expect(executionResult.total).toEqual(28);
+  expect(executionResult.failedInfos).toEqual(expectFailedInfo);
 });
 
 test("print", async () => {
-  const assertResult = new AssertResult();
+  const executionResult = new ExecutionResult();
   const testcaseA: IAssertResult = {
     fail: 1,
     total: 28,
-    failed_info: {
+    failedInfo: {
       A: [["1", "100", "= 200"]],
     },
     failedLogMessages: {
       A: ["log message 1", "log message 2", "log message 3"],
     },
   };
   const expectInfoFIlePath = join(__dirname, "..", "fixture", "assertResultTest.expectInfo.json");
-  await assertResult.merge(testcaseA, expectInfoFIlePath);
+  await executionResult.merge(testcaseA, expectInfoFIlePath);
 
   {
     const outputs: string[] = [];
     chalk.level = 0; // disable color
-    assertResult.print((msg) => outputs.push(msg));
+    executionResult.print((msg) => outputs.push(msg));
     expect(outputs.join("\n")).toMatchSnapshot();
   }
   {
     const outputs: string[] = [];
     chalk.level = 1; // force enable color
-    assertResult.print((msg) => outputs.push(msg));
+    executionResult.print((msg) => outputs.push(msg));
     expect(outputs.join("\n")).toMatchSnapshot();
   }
 });