add more tests for reader package (via #574)

Author: baev

packages/reader/src/xcresult/index.ts

@@ -35,6 +35,15 @@ export const readXcResultBundle = async (visitor: ResultsVisitor, directory: str
   return false;
 };
 
+export const isXcResultToolAvailable = async () => {
+  try {
+    await version();
+    return true;
+  } catch {
+    return false;
+  }
+};
+
 const maybeGetXcResultToolVersion = async () => {
   try {
     return await version();

packages/reader/src/xcresult/xcresulttool/utils.ts

@@ -19,7 +19,7 @@ export const parseWithExportedAttachments = async (
   try {
     attachmentsDir = await mkdtemp(path.join(tmpdir(), "allure-reader-xcresult-"));
     await exportAttachments(xcResultPath, attachmentsDir);
-    await fn(createAttachmentFileFactoryFn(attachmentsDir));
+    await fn(createAttachmentFileFactory(attachmentsDir));
   } finally {
     if (attachmentsDir) {
       try {
@@ -55,7 +55,7 @@ const timestampToString = (timestamp: number) => {
   });
 };
 
-const createAttachmentFileFactoryFn =
+export const createAttachmentFileFactory =
   (attachmentsDir: string): AttachmentFileFactory =>
   async (attachmentUuid, uniqueFileName) => {
     const fileExtension = path.extname(uniqueFileName);

packages/reader/test/attachments.test.ts

@@ -0,0 +1,28 @@
+import { BufferResultFile } from "@allurereport/reader-api";
+import { attachment, step } from "allure-js-commons";
+import { describe, expect, it } from "vitest";
+
+import { attachments } from "../src/attachments/index.js";
+import { mockVisitor } from "./utils.js";
+
+describe("attachments reader", () => {
+  it("should pass attachment files through to the visitor", async () => {
+    const visitor = mockVisitor();
+
+    const resultFile = await step("prepare an attachment result file", async () => {
+      const file = new BufferResultFile(Buffer.from("attachment content", "utf-8"), "example.txt");
+      await attachment("attachment-input.txt", Buffer.from("attachment content", "utf-8"), "text/plain");
+      return file;
+    });
+
+    const read = await step("read the attachment file", async () => {
+      return await attachments.read(visitor, resultFile);
+    });
+
+    await step("verify the attachment was forwarded unchanged", async () => {
+      expect(read).toBe(true);
+      expect(visitor.visitAttachmentFile).toHaveBeenCalledTimes(1);
+      expect(visitor.visitAttachmentFile).toHaveBeenCalledWith(resultFile, { readerId: "attachments" });
+    });
+  });
+});

packages/reader/test/utils.helpers.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it } from "vitest";
+
+import { ensureArray, ensureBoolean, ensureInt, ensureObject, ensureString } from "../src/utils.js";
+
+describe("reader utility helpers", () => {
+  describe("ensureBoolean", () => {
+    it("should keep boolean values and fall back for non-boolean values", () => {
+      expect(ensureBoolean(true)).toBe(true);
+      expect(ensureBoolean(false)).toBe(false);
+      expect(ensureBoolean("true")).toBeUndefined();
+      expect(ensureBoolean("true", true)).toBe(true);
+    });
+  });
+
+  describe("ensureInt", () => {
+    it("should parse numbers and integer-like strings", () => {
+      expect(ensureInt(42)).toBe(42);
+      expect(ensureInt("42")).toBe(42);
+      expect(ensureInt("42px")).toBe(42);
+      expect(ensureInt("nope")).toBeUndefined();
+    });
+  });
+
+  describe("ensureString", () => {
+    it("should keep strings and fall back for non-string values", () => {
+      expect(ensureString("value")).toBe("value");
+      expect(ensureString(42)).toBeUndefined();
+      expect(ensureString(42, "fallback")).toBe("fallback");
+    });
+  });
+
+  describe("ensureArray", () => {
+    it("should keep arrays and fall back for non-array values", () => {
+      expect(ensureArray([1, 2, 3])).toEqual([1, 2, 3]);
+      expect(ensureArray("value")).toBeUndefined();
+      expect(ensureArray("value", ["fallback"])).toEqual(["fallback"]);
+    });
+  });
+
+  describe("ensureObject", () => {
+    it("should keep non-null objects and fall back otherwise", () => {
+      expect(ensureObject({ foo: "bar" })).toEqual({ foo: "bar" });
+      expect(ensureObject(null)).toBeUndefined();
+      expect(ensureObject(["not", "object"])).toEqual(["not", "object"]);
+      expect(ensureObject(undefined, { fallback: true })).toEqual({ fallback: true });
+    });
+  });
+});

packages/reader/test/utils.ts

@@ -40,14 +40,57 @@ export const readResults = async (
   files: Record<string, string> = {},
   result: boolean = true,
 ) => {
-  return step("readResults", async () => {
+  return step(`read ${reader.readerId()} results`, async () => {
     const visitor = mockVisitor();
+
+    await attachment(
+      `${reader.readerId()}-inputs.json`,
+      Buffer.from(
+        JSON.stringify(
+          {
+            readerId: reader.readerId(),
+            expectedResult: result,
+            files: Object.entries(files).map(([resourcePath, originalFileName]) => ({
+              resourcePath,
+              originalFileName,
+            })),
+          },
+          null,
+          2,
+        ),
+        "utf-8",
+      ),
+      "application/json",
+    );
+
     for (const filesKey in files) {
-      const resultFile = await readResourceAsResultFile(filesKey, files[filesKey]);
-      await attachResultFile(resultFile);
-      const read = await reader.read(visitor, resultFile);
-      expect(read).toBe(result);
+      await step(`read ${filesKey}`, async () => {
+        const resultFile = await readResourceAsResultFile(filesKey, files[filesKey]);
+        await attachResultFile(resultFile);
+        const read = await reader.read(visitor, resultFile);
+        expect(read).toBe(result);
+      });
     }
+
+    await attachment(
+      `${reader.readerId()}-visitor-summary.json`,
+      Buffer.from(
+        JSON.stringify(
+          {
+            testResults: visitor.visitTestResult.mock.calls.length,
+            attachmentFiles: visitor.visitAttachmentFile.mock.calls.length,
+            metadata: visitor.visitMetadata.mock.calls.length,
+            fixtures: visitor.visitTestFixtureResult.mock.calls.length,
+            globals: visitor.visitGlobals.mock.calls.length,
+          },
+          null,
+          2,
+        ),
+        "utf-8",
+      ),
+      "application/json",
+    );
+
     return visitor;
   });
 };

packages/reader/test/xcresult.test.ts

@@ -7,13 +7,14 @@ import { step } from "allure-js-commons";
 import { beforeAll, describe, expect, it } from "vitest";
 
 import { IS_MAC } from "../src/xcresult/bundle.js";
-import { readXcResultBundle } from "../src/xcresult/index.js";
+import { isXcResultToolAvailable, readXcResultBundle } from "../src/xcresult/index.js";
 import { attachResultDir, buildResourcePath, mockVisitor } from "./utils.js";
 
 const filenamePatterns = {
   unnamed: /public\.data_\d_[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}/,
   bar: /bar_\d_[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}/,
 };
+const HAS_XCRESULTTOOL = IS_MAC && (await isXcResultToolAvailable());
 
 const readXcResultResource = async (resourcePath: string, expectedResult: boolean = true) => {
   return await step("readXcResultBundle", async () => {
@@ -47,7 +48,16 @@ describe.skipIf(IS_MAC)("Not a MAC machine", () => {
   });
 });
 
-describe.skipIf(!IS_MAC)("A MAC machine", { timeout: 10_000 }, () => {
+describe.skipIf(!IS_MAC || HAS_XCRESULTTOOL)("A MAC machine without xcresulttool", () => {
+  it("should treat xcresult parsing as unsupported instead of failing downstream assertions", async () => {
+    const result = await readXcResultResource("outcomes/passed.xcresult");
+
+    expect(result.visitAttachmentFile).not.toBeCalled();
+    expect(result.visitTestResult).not.toBeCalled();
+  });
+});
+
+describe.skipIf(!HAS_XCRESULTTOOL)("A MAC machine with xcresulttool", { timeout: 10_000 }, () => {
   describe("attachments", () => {
     it("should parse a nameless test attachment", async () => {
       const result = await readXcResultResource("attachments/nameless.xcresult");

packages/reader/test/xcresult.utils.test.ts

@@ -0,0 +1,107 @@
+import console from "node:console";
+import { mkdtemp, mkdir, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { findBundleInfoFile, followsXcResultNaming, isMostProbablyXcResultBundle } from "../src/xcresult/bundle.js";
+import { createAttachmentFileFactory, mapWellKnownAttachmentName } from "../src/xcresult/xcresulttool/utils.js";
+
+describe("xcresult bundle helpers", () => {
+  const tempDirs: string[] = [];
+
+  afterEach(async () => {
+    await Promise.all(
+      tempDirs.map(async (directory) => {
+        await import("node:fs/promises").then(({ rm }) => rm(directory, { recursive: true, force: true }));
+      }),
+    );
+    tempDirs.length = 0;
+  });
+
+  const createTempDir = async (name: string) => {
+    const parent = await mkdtemp(path.join(tmpdir(), "allure-reader-bundle-"));
+    const directory = path.join(parent, name);
+    await mkdir(directory, { recursive: true });
+    tempDirs.push(directory);
+    return directory;
+  };
+
+  it("should detect xcresult bundles by naming convention and bundle metadata", async () => {
+    const namedBundle = await createTempDir("named.xcresult");
+    const bundleWithInfo = await createTempDir("bundle");
+    const plainDirectory = await createTempDir("plain");
+
+    await mkdir(path.join(bundleWithInfo, "Contents"), { recursive: true });
+    await writeFile(path.join(bundleWithInfo, "Contents", "Info.plist"), "plist", "utf-8");
+
+    expect(followsXcResultNaming(namedBundle)).toBe(true);
+    expect(await findBundleInfoFile(bundleWithInfo)).toBe(path.join(bundleWithInfo, "Contents", "Info.plist"));
+    expect(await isMostProbablyXcResultBundle(namedBundle)).toBe(true);
+    expect(await isMostProbablyXcResultBundle(bundleWithInfo)).toBe(true);
+    expect(await isMostProbablyXcResultBundle(plainDirectory)).toBe(false);
+  });
+});
+
+describe("xcresult attachment helpers", () => {
+  const tempDirs: string[] = [];
+
+  afterEach(async () => {
+    await Promise.all(
+      tempDirs.map(async (directory) => {
+        await import("node:fs/promises").then(({ rm }) => rm(directory, { recursive: true, force: true }));
+      }),
+    );
+    tempDirs.length = 0;
+    vi.restoreAllMocks();
+  });
+
+  const createTempDir = async () => {
+    const directory = await mkdtemp(path.join(tmpdir(), "allure-reader-attachments-"));
+    tempDirs.push(directory);
+    return directory;
+  };
+
+  it("should read exported attachments by exact file path and extension fallback", async () => {
+    const attachmentsDir = await createTempDir();
+    const factory = createAttachmentFileFactory(attachmentsDir);
+
+    await writeFile(path.join(attachmentsDir, "uuid-plain"), "plain text", "utf-8");
+    await writeFile(path.join(attachmentsDir, "uuid-image.png"), "png data", "utf-8");
+
+    const plain = await factory("uuid-plain", "plain.txt");
+    const image = await factory("uuid-image", "image.png");
+
+    expect(plain?.getOriginalFileName()).toBe("plain.txt");
+    expect(await plain?.asUtf8String()).toBe("plain text");
+    expect(image?.getOriginalFileName()).toBe("image.png");
+    expect(await image?.asUtf8String()).toBe("png data");
+  });
+
+  it("should return undefined and log an actionable error when an attachment cannot be read", async () => {
+    const attachmentsDir = await createTempDir();
+    const factory = createAttachmentFileFactory(attachmentsDir);
+    const consoleError = vi.spyOn(console, "error").mockImplementation(() => {});
+
+    await expect(factory("missing-uuid", "missing.txt")).resolves.toBeUndefined();
+    expect(consoleError).toHaveBeenCalledWith(
+      "Can't read attachment",
+      "missing-uuid",
+      "in",
+      attachmentsDir,
+      ":",
+      expect.anything(),
+      expect.anything(),
+    );
+  });
+
+  it("should map well-known automatic attachment names to readable titles", () => {
+    expect(mapWellKnownAttachmentName("kXCTAttachmentScreenRecording", undefined)).toBe("Screen Recording");
+    expect(mapWellKnownAttachmentName("kXCTAttachmentLegacyScreenImageData", undefined)).toBe("Screenshot");
+    expect(mapWellKnownAttachmentName("kXCTAttachmentLegacyScreenImageData", 1_717_171_717_171)).toContain(
+      "Screenshot at",
+    );
+    expect(mapWellKnownAttachmentName("Custom Attachment", undefined)).toBe("Custom Attachment");
+  });
+});

packages/reader/test/xml-utils.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  cleanBadXmlCharacters,
+  isBadXmlCharacter,
+  isEmptyElement,
+  isStringAnyRecord,
+  isStringAnyRecordArray,
+} from "../src/xml-utils.js";
+
+describe("xml utility helpers", () => {
+  it("should recognize empty xml elements and plain string-keyed records", () => {
+    expect(isEmptyElement("")).toBe(true);
+    expect(isEmptyElement("not-empty")).toBe(false);
+    expect(isStringAnyRecord({ foo: "bar" })).toBe(true);
+    expect(isStringAnyRecord(["foo"])).toBe(false);
+    expect(isStringAnyRecordArray([{ foo: "bar" }, { bar: "baz" }])).toBe(true);
+    expect(isStringAnyRecordArray([{ foo: "bar" }, ["baz"]])).toBe(false);
+  });
+
+  it("should identify and replace invalid xml characters", () => {
+    expect(isBadXmlCharacter(0)).toBe(true);
+    expect(isBadXmlCharacter(9)).toBe(false);
+    expect(isBadXmlCharacter(10)).toBe(false);
+    expect(isBadXmlCharacter(13)).toBe(false);
+
+    const input = Buffer.from([65, 0, 66, 9, 67, 255]);
+    const cleaned = cleanBadXmlCharacters(Buffer.from(input));
+
+    expect(Array.from(cleaned)).toEqual([65, 32, 66, 9, 67, 255]);
+  });
+});

packages/reader/vitest.config.ts

@@ -1,7 +1,9 @@
 import { createRequire } from "node:module";
+import { env } from "node:process";
 import { defineConfig } from "vitest/config";
 
 const require = createRequire(import.meta.url);
+const resultsDir = env.ALLURE_RESULTS_DIR ?? "./out/allure-results";
 
 export default defineConfig({
   test: {
@@ -12,7 +14,7 @@ export default defineConfig({
       [
         "allure-vitest/reporter",
         {
-          resultsDir: "./out/allure-results",
+          resultsDir,
           globalLabels: [
             { name: "module", value: "reader" },
           ],