test: add withDisposable, add tests for ExifRational, ExifSRational

- Add withDisposable to automatically dispose in tests (even if the test fails prematurely)
  - Replace instances when necessary
- Update ExifTagUnified tests to make more logical sense
- Add tests for ExifRational and ExifSRational

Author: jeremy-code

src/__utils__/withDisposable.ts

@@ -0,0 +1,12 @@
+import { onTestFinished } from "vitest";
+
+const withDisposable = <T extends Disposable>(initializer: T | (() => T)) => {
+  const disposable =
+    typeof initializer === "function" ? initializer() : initializer;
+
+  onTestFinished(() => disposable[Symbol.dispose]());
+
+  return disposable;
+};
+
+export { withDisposable };

src/enums/ExifTagUnified.test.ts

@@ -13,11 +13,11 @@ import { ExifTagUnified } from "./ExifTagUnified.ts";
  */
 describe("ExifTagUnified", () => {
   test("should be an object", () => {
-    expect(typeof ExifTagUnified).toBe("object");
+    expect(ExifTagUnified).toBeTypeOf("object");
   });
   test("should have an iterator", () => {
     expect(ExifTagUnified[Symbol.iterator]).toBeDefined();
-    expect(typeof ExifTagUnified[Symbol.iterator]).toBe("function");
+    expect(ExifTagUnified[Symbol.iterator]).toBeTypeOf("function");
     expect(ExifTagUnified[Symbol.iterator]()).toHaveProperty("next");
   });
   test("should have all ExifTag keys with correct values", () => {
@@ -32,21 +32,15 @@ describe("ExifTagUnified", () => {
   });
   test("should have correct entries in order", () => {
     // After the first `ExifTag` entries, the `ExifTagGps` entries are added
-    const exifTagLength = Array.from(ExifTag).length;
-    const exifTagUnifiedEntries = Array.from(ExifTagUnified);
-    expect(exifTagUnifiedEntries.slice(undefined, exifTagLength)).toEqual(
-      Array.from(ExifTag),
+    const exifTagArray = Array.from(ExifTag);
+    const exifTagGpsArray = Array.from(ExifTagGps);
+    const exifTagUnifiedArray = Array.from(ExifTagUnified);
+    expect(exifTagUnifiedArray.slice(undefined, exifTagArray.length)).toEqual(
+      exifTagArray,
     );
-    expect(exifTagUnifiedEntries.slice(exifTagLength)).toEqual(
-      Array.from(ExifTagGps),
+    expect(exifTagUnifiedArray.slice(exifTagArray.length)).toEqual(
+      exifTagGpsArray,
     );
-    expect([...ExifTag, ...ExifTagGps]).toEqual(Array.from(ExifTagUnified));
+    expect([...exifTagArray, ...exifTagGpsArray]).toEqual(exifTagUnifiedArray);
   });
-
-  test.skip.each([...ExifTag, ...ExifTagGps])(
-    "should have value %j for key %j",
-    (key, value) => {
-      expect(ExifTagUnified).toHaveProperty(key, value);
-    },
-  );
 });

src/libexif/ExifContent.test.ts

@@ -1,17 +1,17 @@
-import { describe, expect, onTestFinished, test } from "vitest";
+import { describe, expect, test } from "vitest";
 
 import { ExifContent } from "./ExifContent.ts";
 import { ExifData } from "./ExifData.ts";
 import { ExifEntry } from "./ExifEntry.ts";
 import { getTestFixture } from "../__utils__/getTestFixture.ts";
+import { withDisposable } from "../__utils__/withDisposable.ts";
 import { ExifIfd } from "../enums/ExifIfd.ts";
 import { getEnumKeyFromValue } from "../utils/getEnumKeyFromValue.ts";
 
 describe("ExifContent", () => {
   describe("ExifContent.new()", () => {
     test("should create a new ExifContent instance", () => {
-      const exifContent = ExifContent.new();
-      onTestFinished(() => exifContent.free());
+      const exifContent = withDisposable(ExifContent.new());
       expect(exifContent).toBeInstanceOf(ExifContent);
       expect(exifContent.byteOffset).toBeGreaterThan(0);
       expect(exifContent).toHaveProperty("entriesPtr", 0);
@@ -28,8 +28,9 @@ describe("ExifContent", () => {
       test("should create an array of new ExifContent instances", async () => {
         const testFixture = await getTestFixture(testFixtureFile);
 
-        const exifData = ExifData.newFromData(testFixture.buffer);
-        onTestFinished(() => exifData.free());
+        const exifData = withDisposable(
+          ExifData.newFromData(testFixture.buffer),
+        );
         exifData.ifd.forEach((exifContent, index) => {
           expect(exifContent).toBeInstanceOf(ExifContent);
           expect(exifContent.byteOffset).toBeGreaterThan(0);
@@ -43,12 +44,10 @@ describe("ExifContent", () => {
   );
   describe("exifContent.addEntry()", () => {
     test("should add an entry to ExifContent", () => {
-      const exifContent = ExifContent.new();
-      onTestFinished(() => exifContent.free());
+      const exifContent = withDisposable(ExifContent.new());
       expect(exifContent).toHaveProperty("count", 0);
 
-      const exifEntry = ExifEntry.new();
-      onTestFinished(() => exifEntry.free());
+      const exifEntry = withDisposable(ExifEntry.new());
       exifContent.addEntry(exifEntry);
       expect(exifContent.entriesPtr).toBeGreaterThan(0);
       expect(exifContent).toHaveProperty("count", 1);
@@ -64,26 +63,22 @@ describe("ExifContent", () => {
   });
   describe("exifContent.getEntry()", () => {
     test("should get an entry from ExifContent", () => {
-      const exifContent = ExifContent.new();
-      onTestFinished(() => exifContent.free());
+      const exifContent = withDisposable(ExifContent.new());
+      // withDisposable is not necessary since exifEntry now belongs to exifData
       const exifEntry = ExifEntry.new();
-      onTestFinished(() => exifEntry.free());
       exifEntry.tag = "IMAGE_DESCRIPTION";
       exifContent.addEntry(exifEntry);
       expect(exifContent.getEntry("IMAGE_DESCRIPTION")).toEqual(exifEntry);
     });
     test("should return null if entry not found", () => {
-      const exifContent = ExifContent.new();
-      onTestFinished(() => exifContent.free());
+      const exifContent = withDisposable(ExifContent.new());
       expect(exifContent.getEntry("LATITUDE")).toBeNull();
     });
   });
   describe("exifContent.removeEntry()", () => {
     test("should remove an entry from ExifContent", () => {
-      const exifContent = ExifContent.new();
-      onTestFinished(() => exifContent.free());
-      const exifEntry = ExifEntry.new();
-      onTestFinished(() => exifEntry.free());
+      const exifContent = withDisposable(ExifContent.new());
+      const exifEntry = withDisposable(ExifEntry.new());
       exifEntry.tag = "IMAGE_DESCRIPTION";
       exifContent.addEntry(exifEntry);
       expect(exifContent.getEntry("IMAGE_DESCRIPTION")).toEqual(exifEntry);
@@ -94,11 +89,9 @@ describe("ExifContent", () => {
   });
   describe("exifContent.ifd", () => {
     test("should return correct ifd", () => {
+      // withDisposable is not necessary since exifContent now belongs to exifData
       const exifContent = ExifContent.new();
-      // Not necessary since exifContent now belongs to exifData
-      // onTestFinished(() => exifContent.free());
-      const exifData = ExifData.new();
-      onTestFinished(() => exifData.free());
+      const exifData = withDisposable(ExifData.new());
 
       expect(exifContent).toHaveProperty("ifd", null);
       exifData.ifd[0].free();

src/libexif/ExifData.test.ts

@@ -11,14 +11,15 @@ import {
   type TestFixture,
   getTestFixture,
 } from "../__utils__/getTestFixture.ts";
+import { withDisposable } from "../__utils__/withDisposable.ts";
 import { ExifIfd } from "../enums/ExifIfd.ts";
 import type { Tag } from "../enums/ExifTagUnified.ts";
 import type { Entry } from "../interfaces/utils.ts";
 
 describe("ExifData", () => {
   describe("ExifData.new()", () => {
     test("should create a new ExifData instance", () => {
-      const exifData = ExifData.new();
+      const exifData = withDisposable(ExifData.new());
       expect(exifData).toBeInstanceOf(ExifData);
       expect(exifData.byteOffset).toBeGreaterThan(0);
       expect(exifData.data).toHaveLength(0);
@@ -36,13 +37,13 @@ describe("ExifData", () => {
       expect(exifData.byteOrder).toBe("MOTOROLA");
       expect(exifData.mnoteData).toBeNull();
       expect(exifData.dataType).toBeNull();
-      exifData.free();
     });
   });
   describe("exifData.ifd", () => {
     describe("setter", () => {
       test("should set exifData.ifd", () => {
-        const exifData = ExifData.new();
+        const exifData = withDisposable(ExifData.new());
+        // withDisposable is not necessary since exifContent now belongs to exifData
         const exifContent = ExifContent.new();
 
         exifData.ifd[0].free();
@@ -52,8 +53,6 @@ describe("ExifData", () => {
           "byteOffset",
           exifContent.byteOffset,
         );
-
-        exifData.free();
       });
     });
   });
@@ -62,7 +61,9 @@ describe("ExifData", () => {
     (testFixtureFile) => {
       test("should create a new ExifData instance from data", async () => {
         const testFixture = await getTestFixture(testFixtureFile);
-        const exifData = ExifData.newFromData(testFixture.buffer);
+        const exifData = withDisposable(
+          ExifData.newFromData(testFixture.buffer),
+        );
 
         expect(exifData).not.toBeNull();
         expect(exifData).toBeInstanceOf(ExifData);
@@ -125,34 +126,33 @@ describe("ExifData", () => {
           testFixture.json.mnoteData === null,
         );
         expect(exifData.dataType).toBeNull();
-        exifData.free();
       });
     },
   );
   describe("exifData.setByteOrder()", () => {
     test("should set the byte order", () => {
-      const exifData = ExifData.new();
+      const exifData = withDisposable(ExifData.new());
       expect(exifData.byteOrder).toBe("MOTOROLA");
       exifData.byteOrder = "INTEL";
       expect(exifData.byteOrder).toBe("INTEL");
-      exifData.free();
     });
   });
   describe("exifData.setDataType()", () => {
     test("should set the data type", () => {
-      const exifData = ExifData.new();
+      const exifData = withDisposable(ExifData.new());
       expect(exifData.dataType).toBeNull();
       exifData.dataType = "COMPRESSED";
       expect(exifData.dataType).toBe("COMPRESSED");
-      exifData.free();
     });
   });
   describe.each(["T-45A_Goshawk_03.jpg", "Sumo_Museum.jpg"])(
     "exifData.getEntry(%s)",
     (testFixtureFile) => {
       test("should get an entry by tag", async () => {
         const testFixture = await getTestFixture(testFixtureFile);
-        const exifData = ExifData.newFromData(testFixture.buffer);
+        const exifData = withDisposable(
+          ExifData.newFromData(testFixture.buffer),
+        );
 
         Object.values(testFixture.json.data)
           .flatMap((datum) => Object.entries(datum))
@@ -177,7 +177,6 @@ describe("ExifData", () => {
             );
             expect(exifEntry?.value).toEqual(expectedExifEntry.value);
           });
-        exifData.free();
       });
     },
   );

src/libexif/ExifEntry.test.ts

@@ -3,13 +3,14 @@ import { describe, expect, test } from "vitest";
 import { ExifData } from "./ExifData.ts";
 import { ExifEntry } from "./ExifEntry.ts";
 import { EXIF_SENTINEL_TAG } from "./ExifTag.ts";
+import { withDisposable } from "../__utils__/withDisposable.ts";
 import { ExifIfd } from "../enums/ExifIfd.ts";
 import { intArrayFromString } from "../internal/emscripten.ts";
 
 describe("ExifEntry", () => {
   describe("ExifEntry.new()", () => {
     test("should create a new ExifEntry instance", () => {
-      const exifEntry = ExifEntry.new();
+      const exifEntry = withDisposable(ExifEntry.new());
       // By default, `tagVal` is 0, which is the GPS `VERSION_ID` tag. For this
       // library's convention, `tagVal` is set to `EXIF_SENTINEL_TAG` to indicate
       // that the tag is not set
@@ -25,12 +26,11 @@ describe("ExifEntry", () => {
       expect(exifEntry.data).toHaveLength(0);
       expect(exifEntry.data).toHaveProperty("byteOffset", 0);
       expect(exifEntry.data).toHaveProperty("byteLength", 0);
-      exifEntry.free();
     });
   });
   describe("exifEntry.getValue()", () => {
     test("should return empty string on new entry", () => {
-      const exifEntry = ExifEntry.new();
+      const exifEntry = withDisposable(ExifEntry.new());
       exifEntry.format = "ASCII";
       exifEntry.tag = "MAKE";
       expect(exifEntry).toHaveProperty("format", "ASCII");
@@ -41,7 +41,7 @@ describe("ExifEntry", () => {
     test("should return ASCII value", () => {
       const EXPECTED_ASCII_VALUE = "Canon";
 
-      const exifEntry = ExifEntry.new();
+      const exifEntry = withDisposable(ExifEntry.new());
       exifEntry.format = "ASCII";
       exifEntry.tag = "MAKE";
       const data = Buffer.from(`${EXPECTED_ASCII_VALUE}\0`, "ascii");
@@ -54,46 +54,40 @@ describe("ExifEntry", () => {
        *
        * @see {@link https://github.com/libexif/libexif/blob/master/libexif/exif-entry.c#L884-L885}
        */
-      const exifData = ExifData.new();
+      const exifData = withDisposable(ExifData.new());
       const exifContent = exifData.ifd[ExifIfd.IFD_0];
       exifContent.addEntry(exifEntry);
       expect(exifEntry.value).toBe(EXPECTED_ASCII_VALUE);
       exifContent.removeEntry(exifEntry);
-      exifEntry.free();
-      exifData.free();
     });
     test("should return byte value", () => {
       const EXPECTED_BYTE_VALUE = 0x2a; // 42
-      const exifEntry = ExifEntry.new();
+      const exifEntry = withDisposable(ExifEntry.new());
       exifEntry.format = "BYTE";
       exifEntry.tag = "JPEG_INTERCHANGE_FORMAT";
       exifEntry.components = 1;
       exifEntry.data = new Uint8Array([EXPECTED_BYTE_VALUE]);
-      const exifData = ExifData.new();
+      const exifData = withDisposable(ExifData.new());
       const exifContent = exifData.ifd[ExifIfd.IFD_0];
       exifContent.addEntry(exifEntry);
       expect(exifEntry.value).toBe(`0x${EXPECTED_BYTE_VALUE.toString(16)}`);
       exifContent.removeEntry(exifEntry);
-      exifEntry.free();
-      exifData.free();
     });
   });
   describe("ExifEntry.toTypedArray()", () => {
     test("should return empty array on new entry", () => {
-      const exifEntry = ExifEntry.new();
+      const exifEntry = withDisposable(ExifEntry.new());
       expect(exifEntry.toTypedArray()).toStrictEqual(new Uint8Array([]));
-      exifEntry.free();
     });
     test("should return ASCII uint8array on new entry", () => {
-      const exifEntry = ExifEntry.new();
+      const exifEntry = withDisposable(ExifEntry.new());
       exifEntry.format = "ASCII";
       const asciiIntArray = new Uint8Array(
         intArrayFromString("My Ascii String", false),
       );
       exifEntry.data = asciiIntArray;
       exifEntry.components = asciiIntArray.length;
       expect(exifEntry.toTypedArray()).toStrictEqual(asciiIntArray);
-      exifEntry.free();
     });
   });
 });

src/libexif/ExifLoader.test.ts

@@ -3,6 +3,7 @@ import { describe, expect, test } from "vitest";
 import { ExifData } from "./ExifData.ts";
 import { ExifLoader } from "./ExifLoader.ts";
 import { getTestFixture } from "../__utils__/getTestFixture.ts";
+import { withDisposable } from "../__utils__/withDisposable.ts";
 
 describe("ExifLoader", () => {
   describe("ExifLoader.new()", () => {
@@ -12,7 +13,6 @@ describe("ExifLoader", () => {
       expect(exifLoader.byteOffset).toBeGreaterThan(0);
       expect(exifLoader.getData()).toBeNull();
       expect(exifLoader.getBuf()).toBeNull();
-      exifLoader.unref();
     });
   });
   describe.each(["T-45A_Goshawk_03.jpg", "Sumo_Museum.jpg"])(
@@ -33,16 +33,19 @@ describe("ExifLoader", () => {
         expect(buf).toBeInstanceOf(Uint8Array);
         expect(buf).not.toHaveLength(0);
 
-        const exifData = exifLoader.getData();
-        expect(exifData).not.toBeNull();
+        const exifData = withDisposable(() => {
+          const exifData = exifLoader.getData();
+          if (exifData === null) {
+            throw new Error("exifData is null");
+          }
+          return exifData;
+        });
         expect(exifData).toBeInstanceOf(ExifData);
         expect(exifData?.byteOffset).toBeGreaterThan(0);
 
         exifLoader.reset();
         expect(exifLoader.getBuf()).toBeNull();
         expect(exifLoader.getData()).toBeNull();
-
-        exifData?.free();
         exifLoader.unref();
       });
     },