remove some uses of mutate-fs

That module is not future-proof for ESM, or TS compatible.

Author: isaacs

src/pack.ts

@@ -33,7 +33,7 @@ export class PackJob {
 import { Minipass } from 'minipass'
 import * as zlib from 'minizlib'
 import { Yallist } from 'yallist'
-import { ReadEntry } from './read-entry.js'
+import type { ReadEntry } from './read-entry.js'
 import type { WarnEvent } from './warn-method.js'
 import { warnMethod, type WarnData, type Warner } from './warn-method.js'
 
@@ -227,10 +227,10 @@ export class Pack
       throw new Error('write after end')
     }
 
-    if (path instanceof ReadEntry) {
-      this[ADDTARENTRY](path)
-    } else {
+    if (typeof path === 'string') {
       this[ADDFSENTRY](path)
+    } else {
+      this[ADDTARENTRY](path)
     }
     return this.flowing
   }

test/extract.ts

@@ -17,8 +17,6 @@ const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
 const extractdir = path.resolve(__dirname, 'fixtures/extract')
 const tars = path.resolve(__dirname, 'fixtures/tars')
-//@ts-ignore
-import mutateFS from 'mutate-fs'
 
 const tnock = (t: Test, host: string, opts?: nock.Options) => {
   nock.disableNetConnect()
@@ -355,15 +353,22 @@ t.test('nonexistent', async t => {
   await t.rejects(x({ file: 'does not exist' }))
 })
 
-t.test('read fail', t => {
+t.test('read fail', async t => {
   const poop = new Error('poop')
-  t.teardown(mutateFS.fail('read', poop))
+  const { extract } = await t.mockImport<
+    typeof import('../src/extract.js')
+  >('../src/extract.js', {
+    fs: t.createMock(fs, {
+      readSync: () => {
+        throw poop
+      },
+    }),
+  })
 
   t.throws(
-    () => x({ maxReadSize: 10, sync: true, file: __filename }),
+    () => extract({ maxReadSize: 10, sync: true, file: __filename }),
     poop,
   )
-  t.end()
 })
 
 t.test('sync gzip error edge case test', async t => {

test/list.ts

@@ -1,7 +1,6 @@
 import type { Stats } from 'fs'
 import fs, { readFileSync } from 'fs'
-//@ts-ignore
-import mutateFS from 'mutate-fs'
+import fsp from 'fs/promises'
 import { dirname, resolve } from 'path'
 import type { Test } from 'tap'
 import t from 'tap'
@@ -14,6 +13,14 @@ import { makeTar } from './fixtures/make-tar.js'
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)
 
+const poop = new Error('poop')
+const cbFail = (...args: any[]) =>
+  (args[args.length - 1] as Function)(poop)
+const syncFail = () => {
+  throw poop
+}
+const asyncFail = async () => syncFail()
+
 const lp = JSON.parse(
   readFileSync(__dirname + '/fixtures/parse/long-paths.json', 'utf8'),
 ) as (
@@ -181,9 +188,28 @@ t.test('bad args', t => {
   t.end()
 })
 
-t.test('stat fails', t => {
-  const poop = new Error('poop')
-  t.teardown(mutateFS.statFail(poop))
+t.test('stat fails', async t => {
+  const { list } = await t.mockImport<typeof import('../src/list.js')>(
+    '../src/list.js',
+    {
+      fs: t.createMock(fs, {
+        open: cbFail,
+        stat: cbFail,
+        lstat: cbFail,
+        fstat: cbFail,
+        openSync: syncFail,
+        statSync: syncFail,
+        lstatSync: syncFail,
+        fstatSync: syncFail,
+      }),
+      'fs/promises': t.createMock(fsp, {
+        open: asyncFail,
+        stat: asyncFail,
+        lstat: asyncFail,
+        fstat: asyncFail,
+      }),
+    },
+  )
   t.test('sync', t => {
     t.plan(1)
     t.throws(() => list({ file: __filename, sync: true }), poop)
@@ -200,9 +226,19 @@ t.test('stat fails', t => {
 })
 
 t.test('read fail', t => {
-  t.test('sync', t => {
-    const poop = new Error('poop')
-    t.teardown(mutateFS.fail('read', poop))
+  t.test('sync', async t => {
+    const { list } = await t.mockImport<typeof import('../src/list.js')>(
+      '../src/list.js',
+      {
+        fs: t.createMock(fs, {
+          read: cbFail,
+          readSync: syncFail,
+        }),
+        'fs/promises': t.createMock(fsp, {
+          read: asyncFail,
+        }),
+      },
+    )
     t.plan(1)
     t.throws(
       () =>
@@ -214,17 +250,39 @@ t.test('read fail', t => {
       poop,
     )
   })
-  t.test('cb', t => {
-    const poop = new Error('poop')
-    t.teardown(mutateFS.fail('read', poop))
+
+  t.test('cb', async t => {
+    const { list } = await t.mockImport<typeof import('../src/list.js')>(
+      '../src/list.js',
+      {
+        fs: t.createMock(fs, {
+          read: cbFail,
+          readSync: syncFail,
+        }),
+        'fs/promises': t.createMock(fsp, {
+          read: asyncFail,
+        }),
+      },
+    )
     t.plan(1)
-    list({ file: __filename }, er => t.equal(er, poop))
+    await list({ file: __filename }, er => t.equal(er, poop))
   })
-  t.test('promise', t => {
-    const poop = new Error('poop')
-    t.teardown(mutateFS.fail('read', poop))
+
+  t.test('promise', async t => {
+    const { list } = await t.mockImport<typeof import('../src/list.js')>(
+      '../src/list.js',
+      {
+        fs: t.createMock(fs, {
+          read: cbFail,
+          readSync: syncFail,
+        }),
+        'fs/promises': t.createMock(fsp, {
+          read: asyncFail,
+        }),
+      },
+    )
     t.plan(1)
-    list({ file: __filename }).catch(er => t.equal(er, poop))
+    await list({ file: __filename }).catch(er => t.equal(er, poop))
   })
   t.end()
 })