@altano/vitest-plugins 0.0.2 → 0.1.0

package/.turbo/turbo-lint.log

@@ -1,5 +1,5 @@
 
-> @altano/vitest-plugins@0.0.2 lint /home/runner/work/npm-packages/npm-packages/packages/vitest-plugins
+> @altano/vitest-plugins@0.1.0 lint /home/runner/work/npm-packages/npm-packages/packages/vitest-plugins
 > eslint package.json src/**/*.ts*
 
 Warning: React version was set to "detect" in eslint-plugin-react settings, but the "react" package is not installed. Assuming latest React version for linting.

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @altano/vitest-plugins
 
+## 0.1.0
+
+### Minor Changes
+
+- f2dda42: new filesystem matchers
+
 ## 0.0.2
 
 ### Patch Changes

package/README.md

@@ -90,7 +90,7 @@ If you want to assert anything more complicated (e.g. an error contains some sub
 
 ### toMatchError
 
-Assert on any part of an error object (e.g. the stack):
+Verify any part of an error object (e.g. the stack):
 
 ```ts
 expect(new Error("face")).toMatchError(
@@ -102,7 +102,7 @@ expect(new Error("face")).toMatchError(
 
 ### toThrowErrorMatching
 
-Assert on any part of a _thrown_ error object (e.g. the stack):
+Verify any part of a _thrown_ error object (e.g. the stack):
 
 ```ts
 expect(() => {
@@ -113,3 +113,35 @@ expect(() => {
   }),
 );
 ```
+
+### toBePath
+
+Verify the realpath (canonical path) of expected. More lenient than a string check when dealing with logical paths, symlinks, etc.
+
+```ts
+expect("/private/some/path").toBePath("/some/path");
+```
+
+### toBeFile
+
+Verify a file exists
+
+```ts
+expect(import.meta.filename).toBeFile();
+```
+
+### toBeDirectory
+
+Verify a directory exists
+
+```ts
+expect("/").toBeDirectory();
+```
+
+### toEqualFile
+
+Verify that the given path matches the contents of another file
+
+```ts
+expect("/some/file.txt").toEqualFile("/other/file.txt");
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@altano/vitest-plugins",
-  "version": "0.0.2",
+  "version": "0.1.0",
   "description": "Custom matchers and snapshot serializers to enhance vitest",
   "type": "module",
   "sideEffects": false,
@@ -38,6 +38,7 @@
     "typescript": "^5.4.2",
     "unified": "^10.1.2",
     "vfile": "^5.3.7",
+    "vite": "^5.2.8",
     "vitest": "^1.4.0",
     "@altano/tsconfig": "0.0.0",
     "eslint-config-altano": "0.0.0"

package/src/matchers/setup.ts

@@ -1,9 +1,17 @@
 import { expect } from "vitest";
 
+import toBePath from "./toBePath";
+import toBeFile from "./toBeFile";
+import toBeDirectory from "./toBeDirectory";
+import toEqualFile from "./toEqualFile";
 import toMatchError from "./toMatchError";
 import toThrowErrorMatching from "./toThrowErrorMatching";
 
 expect.extend({
+  toBePath,
+  toBeFile,
+  toBeDirectory,
+  toEqualFile,
   toMatchError,
   toThrowErrorMatching,
 });

package/src/matchers/toBeDirectory.ts

@@ -0,0 +1,21 @@
+import type { Matcher } from "./matcher";
+import fs from "node:fs";
+
+function directoryExists(path: string): boolean {
+  try {
+    const stats = fs.statSync(path);
+    return stats.isDirectory();
+  } catch (e) {
+    return false;
+  }
+}
+
+const toBeDirectory: Matcher = function (path: string) {
+  return {
+    message: () =>
+      `Received is not a directory (or cannot be accessed by the current user)`,
+    pass: directoryExists(path),
+  };
+};
+
+export default toBeDirectory;

package/src/matchers/toBeFile.ts

@@ -0,0 +1,22 @@
+import type { Matcher } from "./matcher";
+import fs from "node:fs";
+
+function fileExists(path: string): boolean {
+  try {
+    const stats = fs.statSync(path);
+    return stats.isFile();
+  } catch (e) {
+    return false;
+  }
+}
+
+const toBeFile: Matcher = function (path: string) {
+  return {
+    message: () =>
+      `${path} is not a file (or cannot be accessed by the current user)`,
+    pass: fileExists(path),
+    actual: path,
+  };
+};
+
+export default toBeFile;

package/src/matchers/toBePath.ts

@@ -0,0 +1,27 @@
+import type { Matcher } from "./matcher";
+import { realpathSync } from "node:fs";
+
+function getRealpath(path: string): string | null {
+  try {
+    return realpathSync(path);
+  } catch (_e) {
+    return null;
+  }
+}
+
+const toBePath: Matcher = function (received: string, expected: string) {
+  const receivedRealpath = getRealpath(received);
+  const expectedRealpath = getRealpath(expected);
+
+  return {
+    message: () =>
+      receivedRealpath == null || expectedRealpath == null
+        ? `One of the paths wasn't an accessible file on disk and couldn't be compared`
+        : `The realpath of the received path did not match the expected one`,
+    pass: this.equals(receivedRealpath, expectedRealpath),
+    actual: receivedRealpath,
+    expected: expectedRealpath,
+  };
+};
+
+export default toBePath;

package/src/matchers/toEqualFile.ts

@@ -0,0 +1,26 @@
+import type { Matcher } from "./matcher";
+import fs from "node:fs";
+import crypto from "node:crypto";
+
+function getChecksum(filepath: string): string {
+  const hash = crypto.createHash("md5");
+  hash.update(fs.readFileSync(filepath));
+  return hash.digest("hex");
+}
+
+const toEqualFile: Matcher = function (
+  receivedPathOfFile: string,
+  pathOfFileWithExpectedContents: string,
+) {
+  const receivedChecksum = getChecksum(receivedPathOfFile);
+  const expectedChecksum = getChecksum(pathOfFileWithExpectedContents);
+  return {
+    message: () =>
+      `The checksum of the file contents of the files do not match`,
+    pass: this.equals(receivedChecksum, expectedChecksum),
+    actual: `Checksum = ${receivedChecksum}`,
+    expected: `Checksum = ${expectedChecksum}`,
+  };
+};
+
+export default toEqualFile;

package/src/matchers/types.d.ts

@@ -3,6 +3,13 @@
 import type { Assertion, AsymmetricMatchersContaining } from "vitest";
 
 interface CustomMatchers<R = unknown> {
+  /**
+   * compare the realpath (canonical path) of expected/received
+   */
+  toBePath(expected: string): R;
+  toBeFile(): R;
+  toBeDirectory(): R;
+  toEqualFile(pathOfFileWithExpectedContents: string): R;
   toMatchError(expected: unknown): R;
   toThrowErrorMatching(expected: unknown): R;
 }

package/tests/unit/matchers/toBeDirectory.spec.ts

@@ -0,0 +1,31 @@
+import os from "node:os";
+import { describe, expect, it } from "vitest";
+import "../../../src/matchers/setup";
+
+describe("matchers", () => {
+  describe("toBeDirectory", () => {
+    it("should recognize the root", () => {
+      expect("/").toBeDirectory();
+    });
+    it("should recognize the home directory", () => {
+      expect(os.homedir()).toBeDirectory();
+    });
+    it("should recognize this test's directory", () => {
+      expect(import.meta.dirname).toBeDirectory();
+    });
+    it("should not match on garbage", () => {
+      expect("fucking garbage").not.toBeDirectory();
+    });
+    it("should not match on a made up dir", () => {
+      expect("/some/plausible/horseshit").not.toBeDirectory();
+    });
+    it("should NOT recognize this test file as a directory", () => {
+      expect(import.meta.filename).not.toBeDirectory();
+    });
+    it("should throw an error when not a directory", () => {
+      expect(() => {
+        expect("face").toBeDirectory();
+      }).toThrowErrorMatchingInlineSnapshot(`[Error: Received is not a directory (or cannot be accessed by the current user)]`);
+    });
+  });
+});

package/tests/unit/matchers/toBeFile.spec.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from "vitest";
+import "../../../src/matchers/setup";
+
+describe("matchers", () => {
+  describe("toBeFile", () => {
+    it("should recognize this test file as a file", () => {
+      expect(import.meta.filename).toBeFile();
+    });
+    it("should NOT recognize this test directory as a file", () => {
+      expect(import.meta.dirname).not.toBeFile();
+    });
+    it("should throw an error when not a file", () => {
+      expect(() => {
+        expect("face").toBeFile();
+      }).toThrowErrorMatchingInlineSnapshot(
+        `[Error: face is not a file (or cannot be accessed by the current user)]`,
+      );
+    });
+  });
+});

package/tests/unit/matchers/toBePath.spec.ts

@@ -0,0 +1,30 @@
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import "../../../src/matchers/setup";
+
+describe("matchers", () => {
+  describe("toBePath", () => {
+    it("should recognize this test file as a file", () => {
+      const weirdPath = path.join(
+        import.meta.dirname,
+        "..",
+        path.basename(import.meta.dirname),
+      );
+      expect(import.meta.dirname).toBePath(weirdPath);
+    });
+    it("should throw an error for a non-matching path", () => {
+      const wrongPath = path.join(import.meta.dirname, "..");
+      expect(() => {
+        expect(import.meta.dirname).toBePath(wrongPath);
+      }).toThrowErrorMatchingInlineSnapshot(`[Error: The realpath of the received path did not match the expected one]`);
+    });
+    it("should throw an error for a path that isn't accessible", () => {
+      const nonExistentPath = path.join(import.meta.dirname, "face");
+      expect(() => {
+        expect(import.meta.dirname).toBePath(nonExistentPath);
+      }).toThrowErrorMatchingInlineSnapshot(
+        `[Error: One of the paths wasn't an accessible file on disk and couldn't be compared]`,
+      );
+    });
+  });
+});

package/tests/unit/matchers/toEqualFile.spec.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from "vitest";
+import "../../../src/matchers/setup";
+import path from "node:path";
+
+describe("matchers", () => {
+  describe("toEqualFile", () => {
+    // Okay this is a silly test but *shrug*
+    it("should produce a hash of this test file", () => {
+      expect(import.meta.filename).toEqualFile(import.meta.filename);
+    });
+    it("should fail when given two differing files", async () => {
+      expect(() => {
+        expect(import.meta.filename).toEqualFile(
+          path.join(import.meta.dirname, "toBePath.spec.ts"),
+        );
+      }).toThrowErrorMatchingInlineSnapshot(
+        `[Error: The checksum of the file contents of the files do not match]`,
+      );
+    });
+    it("should fail when given a non-existent file", async () => {
+      expect(() => {
+        expect("faaaaaaaaaace").toEqualFile("khaaaaaaaaan");
+      }).toThrowErrorMatchingInlineSnapshot(`[Error: ENOENT: no such file or directory, open 'faaaaaaaaaace']`);
+    });
+  });
+});