reuse files when generate report within hardlinks(#545)

Author: todti

packages/core/src/plugin.ts

@@ -1,4 +1,5 @@
-import { mkdir, writeFile } from "node:fs/promises";
+import { createHash, randomUUID } from "node:crypto";
+import { link, mkdir, rename, rm, writeFile } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { join as joinPosix } from "node:path/posix";
 
@@ -56,6 +57,8 @@ export class InMemoryReportFiles implements ReportFiles {
 
 export class FileSystemReportFiles implements ReportFiles {
   readonly #output: string;
+  readonly #contentHashToPath = new Map<string, string>();
+  readonly #pathToContentHash = new Map<string, string>();
 
   constructor(output: string) {
     this.#output = resolve(output);
@@ -64,10 +67,68 @@ export class FileSystemReportFiles implements ReportFiles {
   addFile = async (path: string, data: Buffer): Promise<string> => {
     const targetPath = resolve(this.#output, path);
     const targetDirPath = dirname(targetPath);
+    const contentHash = createHash("sha256").update(data).digest("hex");
+    const targetPathHash = this.#pathToContentHash.get(targetPath);
+    const canonicalPath = this.#contentHashToPath.get(contentHash);
 
     await mkdir(targetDirPath, { recursive: true });
-    await writeFile(targetPath, data, { encoding: "utf-8" });
+
+    if (targetPathHash === contentHash) {
+      return targetPath;
+    }
+
+    if (canonicalPath && canonicalPath !== targetPath) {
+      try {
+        await this.#replaceWithHardlink(canonicalPath, targetPath);
+        this.#pathToContentHash.set(targetPath, contentHash);
+        return targetPath;
+      } catch (error) {
+        if (!this.#isRecoverableHardlinkError(error)) {
+          throw error;
+        }
+      }
+    }
+
+    await this.#replaceWithFile(targetPath, data);
+    this.#contentHashToPath.set(contentHash, targetPath);
+    this.#pathToContentHash.set(targetPath, contentHash);
 
     return targetPath;
   };
+
+  #replaceWithFile = async (targetPath: string, data: Buffer): Promise<void> => {
+    const tempPath = `${targetPath}.${randomUUID()}.tmp`;
+
+    try {
+      await writeFile(tempPath, data, { encoding: "utf-8" });
+      await rename(tempPath, targetPath);
+    } finally {
+      await rm(tempPath, { force: true });
+    }
+  };
+
+  #replaceWithHardlink = async (canonicalPath: string, targetPath: string): Promise<void> => {
+    const tempPath = `${targetPath}.${randomUUID()}.tmp`;
+
+    try {
+      await link(canonicalPath, tempPath);
+      await rename(tempPath, targetPath);
+    } finally {
+      await rm(tempPath, { force: true });
+    }
+  };
+
+  #isRecoverableHardlinkError = (error: unknown): boolean => {
+    if (!error || typeof error !== "object" || !("code" in error)) {
+      return false;
+    }
+
+    return (
+      error.code === "EXDEV" ||
+      error.code === "EPERM" ||
+      error.code === "EEXIST" ||
+      error.code === "ENOENT" ||
+      error.code === "EACCES"
+    );
+  };
 }

packages/e2e/test/commons/output.test.ts

@@ -1,4 +1,5 @@
-import { readdir } from "node:fs/promises";
+import { readFile, readdir, stat } from "node:fs/promises";
+import { resolve } from "node:path";
 
 import AwesomePlugin from "@allurereport/plugin-awesome";
 import { expect, test } from "@playwright/test";
@@ -130,4 +131,67 @@ test.describe("output", () => {
     expect(reportDirFiles.find((dirent) => dirent.name === "awesome1" && !dirent.isFile())).not.toBeUndefined();
     expect(reportDirFiles.find((dirent) => dirent.name === "awesome2" && !dirent.isFile())).not.toBeUndefined();
   });
+
+  test("should keep attachment and static assets accessible for every awesome report without duplicating inode", async () => {
+    bootstrap = await bootstrapReport({
+      reportConfig: {
+        name: "Sample allure report",
+        appendHistory: false,
+        knownIssuesPath: undefined,
+        plugins: [
+          {
+            id: "awesome1",
+            enabled: true,
+            plugin: new AwesomePlugin({}),
+            options: {},
+          },
+          {
+            id: "awesome2",
+            enabled: true,
+            plugin: new AwesomePlugin({}),
+            options: {},
+          },
+        ],
+      },
+      testResults: [
+        {
+          name: "0 sample passed test",
+          fullName: "sample.js#0 sample passed test",
+          status: Status.PASSED,
+          stage: Stage.FINISHED,
+          start: 1000,
+        },
+      ],
+      globals: {
+        attachments: {
+          "global-shared.txt": Buffer.from("global-shared-content", "utf8"),
+        },
+      },
+    });
+
+    const reportOneAssets = await readdir(resolve(bootstrap.reportDir, "awesome1"));
+    const reportTwoAssets = await readdir(resolve(bootstrap.reportDir, "awesome2"));
+    const reportOneAttachmentFiles = await readdir(resolve(bootstrap.reportDir, "awesome1", "data", "attachments"));
+    const reportTwoAttachmentFiles = await readdir(resolve(bootstrap.reportDir, "awesome2", "data", "attachments"));
+    const staticAssets = reportOneAssets.filter((assetName) => assetName.endsWith(".js") || assetName.endsWith(".css"));
+
+    expect(staticAssets.length).toBeGreaterThan(0);
+    expect(reportTwoAssets).toEqual(expect.arrayContaining(staticAssets));
+    expect(reportOneAttachmentFiles).toHaveLength(1);
+    expect(reportTwoAttachmentFiles).toHaveLength(1);
+    expect(reportOneAttachmentFiles[0]).toBe(reportTwoAttachmentFiles[0]);
+
+    const reportOneAttachmentPath = resolve(bootstrap.reportDir, "awesome1", "data", "attachments", reportOneAttachmentFiles[0]);
+    const reportTwoAttachmentPath = resolve(bootstrap.reportDir, "awesome2", "data", "attachments", reportTwoAttachmentFiles[0]);
+
+    expect(await readFile(reportOneAttachmentPath, "utf8")).toBe("global-shared-content");
+    expect(await readFile(reportTwoAttachmentPath, "utf8")).toBe("global-shared-content");
+
+    if (process.platform !== "win32") {
+      const firstAttachmentStat = await stat(reportOneAttachmentPath);
+      const secondAttachmentStat = await stat(reportTwoAttachmentPath);
+
+      expect(firstAttachmentStat.ino).toBe(secondAttachmentStat.ino);
+    }
+  });
 });