fix: drop jest (2/4): rewrite assertions

src/__tests__/TransformableString.js

@@ -2,186 +2,224 @@ const TransformableString = require("../TransformableString")
 
 const { it, describe } = require("node:test")
 const assert = require("assert")
-function expect(actual) {
-  return {
-    toBe(expected) {
-      assert.strictEqual(actual, expected)
-    },
-    toEqual(expected) {
-      assert.deepStrictEqual(actual, expected)
-    },
-    toMatch(expected) {
-      assert.match(actual, expected)
-    },
-    toThrow(callback) {
-      let error = null
-      try {
-        callback()
-      } catch (e) {
-        error = e
-      }
-      assert.notStrictEqual(error, null)
-    },
-  }
-}
 
 it("should be a function", () => {
-  expect(typeof TransformableString).toBe("function")
+  assert.strictEqual(typeof TransformableString, "function")
 })
 
 describe("toString", () => {
   it("should return the original string if no transform are made", () => {
     const ts = new TransformableString("foo")
-    expect(ts.toString()).toBe("foo")
+    assert.strictEqual(ts.toString(), "foo")
   })
 })
 
 describe("replace", () => {
   it("should replace a slice", () => {
     const ts = new TransformableString("foo")
     ts.replace(1, 2, "OO")
-    expect(ts.toString()).toBe("fOOo")
+    assert.strictEqual(ts.toString(), "fOOo")
   })
 
   it("should throw if trying to replace the same thing twice", () => {
     const ts = new TransformableString("abcd")
     ts.replace(1, 3, "OO")
-    expect(() => ts.replace(2, 4, "OO")).toThrow()
-    expect(() => ts.replace(0, 2, "OO")).toThrow()
+    assert.throws(() => ts.replace(2, 4, "OO"))
+    assert.throws(() => ts.replace(0, 2, "OO"))
   })
 
   it("should replace adjacent slices", () => {
     const ts = new TransformableString("abcde")
     ts.replace(2, 3, "OO")
     ts.replace(3, 4, "MM")
     ts.replace(1, 2, "NN")
-    expect(ts.toString()).toBe("aNNOOMMe")
+    assert.strictEqual(ts.toString(), "aNNOOMMe")
   })
 })
 
 describe("originalIndex", () => {
   it("should return the same index if nothing changed", () => {
     const ts = new TransformableString("abcde")
-    expect(ts.originalIndex(0)).toBe(0)
-    expect(ts.originalIndex(1)).toBe(1)
-    expect(ts.originalIndex(4)).toBe(4)
+    assert.strictEqual(ts.originalIndex(0), 0)
+    assert.strictEqual(ts.originalIndex(1), 1)
+    assert.strictEqual(ts.originalIndex(4), 4)
   })
 
   it("should throw if the index is invalid", () => {
     const ts = new TransformableString("abcde")
-    expect(() => ts.originalIndex(-1)).toThrow()
-    expect(() => ts.originalIndex(6)).toThrow()
+    assert.throws(() => ts.originalIndex(-1))
+    assert.throws(() => ts.originalIndex(6))
   })
 
   it("should return the original index of a string with removed parts", () => {
     const ts = new TransformableString("abcde")
     ts.replace(1, 2, "")
     ts.replace(3, 4, "")
-    expect(ts.toString()).toBe("ace")
-    expect(ts.originalIndex(0)).toBe(0) // a
-    expect(ts.originalIndex(1)).toBe(2) // c
-    expect(ts.originalIndex(2)).toBe(4) // e
-    expect(ts.originalIndex(3)).toBe(5) // index directly after the end is allowed
-    expect(() => ts.originalIndex(4)).toThrow()
+    assert.strictEqual(ts.toString(), "ace")
+    assert.strictEqual(ts.originalIndex(0), 0) // a
+    assert.strictEqual(ts.originalIndex(1), 2) // c
+    assert.strictEqual(ts.originalIndex(2), 4) // e
+    assert.strictEqual(ts.originalIndex(3), 5) // index directly after the end is allowed
+    assert.throws(() => ts.originalIndex(4))
   })
 
   it("should return the original index of a string with added parts", () => {
     const ts = new TransformableString("ace")
     ts.replace(1, 1, "b")
     ts.replace(2, 2, "d")
-    expect(ts.toString()).toBe("abcde")
-    expect(ts.originalIndex(0)).toBe(0) // a
-    expect(ts.originalIndex(1)).toBe(undefined)
-    expect(ts.originalIndex(2)).toBe(1) // c
-    expect(ts.originalIndex(3)).toBe(undefined)
-    expect(ts.originalIndex(4)).toBe(2) // e
-    expect(ts.originalIndex(5)).toBe(3) // index directly after the end is allowed
-    expect(() => ts.originalIndex(6)).toThrow()
+    assert.strictEqual(ts.toString(), "abcde")
+    assert.strictEqual(ts.originalIndex(0), 0) // a
+    assert.strictEqual(ts.originalIndex(1), undefined)
+    assert.strictEqual(ts.originalIndex(2), 1) // c
+    assert.strictEqual(ts.originalIndex(3), undefined)
+    assert.strictEqual(ts.originalIndex(4), 2) // e
+    assert.strictEqual(ts.originalIndex(5), 3) // index directly after the end is allowed
+    assert.throws(() => ts.originalIndex(6))
   })
 
   it("should return the original index of a string with added parts (2)", () => {
     const ts = new TransformableString("ab")
     ts.replace(1, 1, "XX")
-    expect(ts.toString()).toBe("aXXb")
-    expect(ts.originalIndex(0)).toBe(0) // a
-    expect(ts.originalIndex(1)).toBe(undefined)
-    expect(ts.originalIndex(2)).toBe(undefined)
-    expect(ts.originalIndex(3)).toBe(1) // b
+    assert.strictEqual(ts.toString(), "aXXb")
+    assert.strictEqual(ts.originalIndex(0), 0) // a
+    assert.strictEqual(ts.originalIndex(1), undefined)
+    assert.strictEqual(ts.originalIndex(2), undefined)
+    assert.strictEqual(ts.originalIndex(3), 1) // b
   })
 
   it("should return the last index of the last block if the index is after the end", () => {
     const ts = new TransformableString("abcd")
     ts.replace(2, 4, "X")
-    expect(ts.toString()).toBe("abX")
-    expect(ts.originalIndex(0)).toBe(0) // a
-    expect(ts.originalIndex(1)).toBe(1) // b
-    expect(ts.originalIndex(2)).toBe(undefined)
-    expect(ts.originalIndex(3)).toBe(3) // c
+    assert.strictEqual(ts.toString(), "abX")
+    assert.strictEqual(ts.originalIndex(0), 0) // a
+    assert.strictEqual(ts.originalIndex(1), 1) // b
+    assert.strictEqual(ts.originalIndex(2), undefined)
+    assert.strictEqual(ts.originalIndex(3), 3) // c
   })
 })
 
 describe("originalLocation", () => {
   it("should return the same location if nothing changed", () => {
     const ts = new TransformableString("aaaa\nbbbb\ncccc")
-    expect(ts.originalLocation({ line: 1, column: 1 })).toEqual({
-      line: 1,
-      column: 1,
-    })
-    expect(ts.originalLocation({ line: 1, column: 3 })).toEqual({
-      line: 1,
-      column: 3,
-    })
-    expect(ts.originalLocation({ line: 2, column: 1 })).toEqual({
-      line: 2,
-      column: 1,
-    })
+    assert.deepStrictEqual(
+      ts.originalLocation({
+        line: 1,
+        column: 1,
+      }),
+      {
+        line: 1,
+        column: 1,
+      }
+    )
+    assert.deepStrictEqual(
+      ts.originalLocation({
+        line: 1,
+        column: 3,
+      }),
+      {
+        line: 1,
+        column: 3,
+      }
+    )
+    assert.deepStrictEqual(
+      ts.originalLocation({
+        line: 2,
+        column: 1,
+      }),
+      {
+        line: 2,
+        column: 1,
+      }
+    )
   })
 
   it("should return the original location of a string with removed parts", () => {
     const ts = new TransformableString("aaaa\nbbbb\ncccc")
     ts.replace(3, 6, "")
-    expect(ts.toString()).toBe("aaabbb\ncccc")
-    expect(ts.originalLocation({ line: 1, column: 1 })).toEqual({
-      line: 1,
-      column: 1,
-    })
-    expect(ts.originalLocation({ line: 1, column: 4 })).toEqual({
-      line: 2,
-      column: 2,
-    })
-    expect(ts.originalLocation({ line: 2, column: 1 })).toEqual({
-      line: 3,
-      column: 1,
-    })
+    assert.strictEqual(ts.toString(), "aaabbb\ncccc")
+    assert.deepStrictEqual(
+      ts.originalLocation({
+        line: 1,
+        column: 1,
+      }),
+      {
+        line: 1,
+        column: 1,
+      }
+    )
+    assert.deepStrictEqual(
+      ts.originalLocation({
+        line: 1,
+        column: 4,
+      }),
+      {
+        line: 2,
+        column: 2,
+      }
+    )
+    assert.deepStrictEqual(
+      ts.originalLocation({
+        line: 2,
+        column: 1,
+      }),
+      {
+        line: 3,
+        column: 1,
+      }
+    )
   })
 
   it("should return the original location of a string with added parts", () => {
     const ts = new TransformableString("aaaa\nbbbbcccc")
     ts.replace(9, 9, "X\nX")
-    expect(ts.toString()).toBe("aaaa\nbbbbX\nXcccc")
-    expect(ts.originalLocation({ line: 1, column: 1 })).toEqual({
-      line: 1,
-      column: 1,
-    })
-    expect(ts.originalLocation({ line: 1, column: 4 })).toEqual({
-      line: 1,
-      column: 4,
-    })
-    expect(ts.originalLocation({ line: 2, column: 1 })).toEqual({
-      line: 2,
-      column: 1,
-    })
-    expect(ts.originalLocation({ line: 2, column: 5 })).toEqual(undefined)
+    assert.strictEqual(ts.toString(), "aaaa\nbbbbX\nXcccc")
+    assert.deepStrictEqual(
+      ts.originalLocation({
+        line: 1,
+        column: 1,
+      }),
+      {
+        line: 1,
+        column: 1,
+      }
+    )
+    assert.deepStrictEqual(
+      ts.originalLocation({
+        line: 1,
+        column: 4,
+      }),
+      {
+        line: 1,
+        column: 4,
+      }
+    )
+    assert.deepStrictEqual(
+      ts.originalLocation({
+        line: 2,
+        column: 1,
+      }),
+      {
+        line: 2,
+        column: 1,
+      }
+    )
+    assert.deepStrictEqual(
+      ts.originalLocation({
+        line: 2,
+        column: 5,
+      }),
+      undefined
+    )
   })
 })
 
 describe("getOriginalLine", () => {
   it("returns original lines", () => {
     const ts = new TransformableString("aa\nbb\r\ncc")
-    expect(() => ts.getOriginalLine(0)).toThrow()
-    expect(ts.getOriginalLine(1)).toEqual("aa")
-    expect(ts.getOriginalLine(2)).toEqual("bb")
-    expect(ts.getOriginalLine(3)).toEqual("cc")
-    expect(() => ts.getOriginalLine(4)).toThrow()
+    assert.throws(() => ts.getOriginalLine(0))
+    assert.deepStrictEqual(ts.getOriginalLine(1), "aa")
+    assert.deepStrictEqual(ts.getOriginalLine(2), "bb")
+    assert.deepStrictEqual(ts.getOriginalLine(3), "cc")
+    assert.throws(() => ts.getOriginalLine(4))
   })
 })

src/__tests__/extract.js

@@ -1,38 +1,9 @@
 /*eslint no-sparse-arrays: 0*/
+const { it, describe } = require("node:test")
+const assert = require("assert")
 
 const extract = require("../extract")
 
-const { it, describe, context } = require("node:test")
-const assert = require("assert")
-function expect(actual) {
-  return {
-    toBe(expected) {
-      assert.strictEqual(actual, expected)
-    },
-    toEqual(expected) {
-      assert.deepStrictEqual(actual, expected)
-    },
-    toMatch(expected) {
-      assert.match(actual, expected)
-    },
-    toThrow(callback) {
-      let error = null
-      try {
-        callback()
-      } catch (e) {
-        error = e
-      }
-      assert.notStrictEqual(error, null)
-    },
-    toMatchSnapshot() {
-      console.log(context.name)
-      if (typeof actual !== "string") {
-        throw new Error("toMatchSnapshot() only works with strings")
-      }
-    },
-  }
-}
-
 function dedent(str) {
   if (str[0] === "\n") str = str.slice(1)
 
@@ -56,8 +27,14 @@ function test(params) {
     isJavaScriptMIMEType: params.isJavaScriptMIMEType,
     ignoreTagsWithoutType: params.ignoreTagsWithoutType,
   })
-  expect(infos.code.map((code) => code.toString())).toEqual(params.expected)
-  expect(infos.badIndentationLines).toEqual(params.badIndentationLines || [])
+  assert.deepStrictEqual(
+    infos.code.map((code) => code.toString()),
+    params.expected
+  )
+  assert.deepStrictEqual(
+    infos.badIndentationLines,
+    params.badIndentationLines || []
+  )
 }
 
 it("extract simple javascript", () => {