@toa.io/extensions.storages 0.22.0 → 0.23.0-dev.0

package/source/Storage.test.ts

@@ -1,445 +1,468 @@
 import { Readable } from 'node:stream'
-import { match } from '@toa.io/match'
+import { match } from 'matchacho'
 import { buffer } from '@toa.io/generic'
 import { Storage } from './Storage'
-import { cases, open, rnd } from './.test/util'
+import { cases, open, rnd } from './test/util'
 import { type Entry } from './Entry'
 import { providers } from './providers'
+import type { ErrorType } from 'error-value'
 
 let storage: Storage
 let dir: string
 
-describe.each(cases)('%s', (_, url, secrets) => {
-  beforeEach(() => {
-    dir = '/' + rnd()
+const [, url, secrets] = cases[0]
 
-    const Provider = providers[url.protocol]
-    const provider = new Provider(url, secrets)
+beforeEach(() => {
+  dir = '/' + rnd()
 
-    storage = new Storage(provider)
-  })
+  const Provider = providers[url.protocol]
+  const provider = new Provider(url, secrets)
 
-  it('should be', async () => {
-    expect(storage).toBeInstanceOf(Storage)
-  })
+  storage = new Storage(provider)
+})
 
-  it('should return error if entry is not found', async () => {
-    const result = await storage.get('not-found')
+it('should be', async () => {
+  expect(storage).toBeInstanceOf(Storage)
+})
 
-    match(result,
-      Error, (error: Error) => expect(error.message).toBe('NOT_FOUND'))
-  })
+it('should return error if entry is not found', async () => {
+  const result = await storage.get('not-found')
 
-  describe('put', () => {
-    let lenna: Entry
+  if (!(result instanceof Error))
+    throw new Error('Expected error')
 
-    beforeEach(async () => {
-      const stream = await open('lenna.png')
+  expect(result).toMatchObject({ code: 'NOT_FOUND' })
+})
 
-      lenna = await storage.put(dir, stream) as Entry
-    })
+describe('put', () => {
+  let lenna: Entry
+  let startCreation: number
 
-    it('should not return error', async () => {
-      expect(lenna).not.toBeInstanceOf(Error)
-    })
+  beforeEach(async () => {
+    const stream = open('lenna.png')
 
-    it('should return entry id', async () => {
-      expect(lenna.id).toBeDefined()
-    })
+    startCreation = Date.now()
+    lenna = await storage.put(dir, stream) as Entry
+  })
 
-    it('should return id as checksum', async () => {
-      const stream = await open('lenna.png')
-      const dir2 = '/' + rnd()
-      const copy = await storage.put(dir2, stream) as Entry
+  it('should not return error', async () => {
+    expect(lenna).not.toBeInstanceOf(Error)
+  })
 
-      expect(copy.id).toBe(lenna.id)
-    })
+  it('should return entry id', async () => {
+    expect(lenna.id).toBeDefined()
+  })
 
-    it('should detect file type', async () => {
-      expect(lenna.type).toBe('image/png')
-    })
+  it('should return id as checksum', async () => {
+    const stream = open('lenna.png')
+    const dir2 = '/' + rnd()
+    const copy = await storage.put(dir2, stream) as Entry
 
-    it('should count size', async () => {
-      expect(lenna.size).toBe(473831)
+    expect(copy.id).toBe(lenna.id)
+  })
+
+  it('should detect file type', async () => {
+    expect(lenna.type).toBe('image/png')
+  })
+
+  it('should count size', async () => {
+    expect(lenna.size).toBe(473831)
+  })
+
+  it('should return entry', async () => {
+    expect(lenna).toMatchObject({
+      id: lenna.id,
+      type: 'image/png',
+      variants: [],
+      meta: {}
     })
+  })
 
-    it('should return entry', async () => {
-      expect(lenna).toMatchObject({
+  it('should create entry', async () => {
+    const entry = await storage.get(`${dir}/${lenna.id}`)
+
+    match(entry,
+      {
         id: lenna.id,
         type: 'image/png',
         variants: [],
         meta: {}
-      })
-    })
+      }, undefined)
+  })
 
-    it('should create entry', async () => {
-      const entry = await storage.get(`${dir}/${lenna.id}`)
+  it('should set timestamp', async () => {
+    const now = Date.now()
+    const entry = await storage.get(`${dir}/${lenna.id}`) as Entry
 
-      match(entry,
-        {
-          id: lenna.id,
-          type: 'image/png',
-          variants: [],
-          meta: {}
-        }, undefined)
-    })
+    expect(entry.created).toBeLessThanOrEqual(now)
+    expect(entry.created).toBeGreaterThanOrEqual(startCreation)
+  })
 
-    it('should set timestamp', async () => {
-      const now = Date.now()
-      const entry = await storage.get(`${dir}/${lenna.id}`) as Entry
+  describe('existing entry', () => {
+    it('should unhide existing', async () => {
+      const stream = open('lenna.png')
+      const path = `${dir}/${lenna.id}`
 
-      expect(entry.created).toBeLessThanOrEqual(now)
-      expect(entry.created).toBeGreaterThan(now - 100)
-    })
+      await storage.conceal(path)
+      await storage.put(dir, stream)
+
+      const list = await storage.list(dir)
 
-    describe('existing entry', () => {
-      it('should unhide existing', async () => {
-        const stream = await open('lenna.png')
-        const path = `${dir}/${lenna.id}`
+      expect(list).toContainEqual(lenna.id)
+    })
 
-        await storage.conceal(path)
-        await storage.put(dir, stream)
+    it('should preserve meta', async () => {
+      const path = `${dir}/${lenna.id}`
+      const stream = open('lenna.png')
 
-        const list = await storage.list(dir)
+      await storage.annotate(path, 'foo', 'bar')
+      await storage.put(dir, stream)
 
-        expect(list).toContainEqual(lenna.id)
-      })
+      const entry = await storage.get(path) as Entry
 
-      it('should preserve meta', async () => {
-        const path = `${dir}/${lenna.id}`
-        const stream = await open('lenna.png')
+      expect(entry.meta).toMatchObject({ foo: 'bar' })
+    })
+  })
+})
 
-        await storage.annotate(path, 'foo', 'bar')
-        await storage.put(dir, stream)
+describe('list', () => {
+  let albert: Entry
+  let lenna: Entry
 
-        const entry = await storage.get(path) as Entry
+  beforeEach(async () => {
+    const stream0 = open('albert.jpg')
+    const stream1 = open('lenna.png')
 
-        expect(entry.meta).toMatchObject({ foo: 'bar' })
-      })
-    })
+    albert = await storage.put(dir, stream0) as Entry
+    lenna = await storage.put(dir, stream1) as Entry
   })
 
-  describe('list', () => {
-    let albert: Entry
-    let lenna: Entry
+  it('should list entries', async () => {
+    const list = await storage.list(dir)
 
-    beforeEach(async () => {
-      const stream0 = await open('albert.jpg')
-      const stream1 = await open('lenna.png')
+    expect(list).toMatchObject([albert.id, lenna.id])
+  })
 
-      albert = await storage.put(dir, stream0) as Entry
-      lenna = await storage.put(dir, stream1) as Entry
-    })
+  it('should permutate', async () => {
+    const error = await storage.permute(dir, [lenna.id, albert.id])
 
-    it('should list entries', async () => {
-      const list = await storage.list(dir)
+    expect(error).toBeUndefined()
 
-      expect(list).toMatchObject([albert.id, lenna.id])
-    })
+    const list = await storage.list(dir)
 
-    it('should permutate', async () => {
-      const error = await storage.reorder(dir, [lenna.id, albert.id])
+    expect(list).toMatchObject([lenna.id, albert.id])
+  })
 
-      expect(error).toBeUndefined()
+  it('should return PERMUTATION_MISMATCH', async () => {
+    const cases = [
+      [lenna.id],
+      [albert.id, lenna.id, 'unknown'],
+      [lenna.id, lenna.id],
+      [lenna.id, lenna.id, albert.id]
+    ]
 
-      const list = await storage.list(dir)
+    for (const permutation of cases) {
+      const error = await storage.permute(dir, permutation)
 
-      expect(list).toMatchObject([lenna.id, albert.id])
-    })
+      expect(error).toBeInstanceOf(Error)
+      expect(error).toMatchObject({ code: 'PERMUTATION_MISMATCH' })
+    }
+  })
 
-    it('should return PERMUTATION_MISMATCH', async () => {
-      const cases = [
-        [lenna.id],
-        [albert.id, lenna.id, 'unknown'],
-        [lenna.id, lenna.id],
-        [lenna.id, lenna.id, albert.id]
-      ]
+  it('should exclude concealed', async () => {
+    const path = `${dir}/${lenna.id}`
 
-      for (const permutation of cases) {
-        const error = await storage.reorder(dir, permutation)
+    await storage.conceal(path)
 
-        expect(error).toBeInstanceOf(Error)
-        expect(error).toMatchObject({ message: 'PERMUTATION_MISMATCH' })
-      }
-    })
+    const entries = await storage.list(dir)
 
-    it('should exclude concealed', async () => {
-      const path = `${dir}/${lenna.id}`
+    expect(entries).toMatchObject([albert.id])
+  })
 
-      await storage.conceal(path)
+  it('should reveal', async () => {
+    const path = `${dir}/${lenna.id}`
 
-      const entries = await storage.list(dir)
+    await storage.conceal(path)
+    await storage.reveal(path)
+    await storage.reveal(path) // test that no duplicates are created
 
-      expect(entries).toMatchObject([albert.id])
-    })
+    const entries = await storage.list(dir)
 
-    it('should reveal', async () => {
-      const path = `${dir}/${lenna.id}`
+    expect(entries).toMatchObject([albert.id, lenna.id])
+  })
 
-      await storage.conceal(path)
-      await storage.reveal(path)
-      await storage.reveal(path) // test that no duplicates are created
+  it('should return ERR_NOT_FOOUD if entry doesnt exist', async () => {
+    const path = `${dir}/oopsie`
 
-      const entries = await storage.list(dir)
+    const methods: Array<'reveal' | 'conceal'> = ['reveal', 'conceal']
 
-      expect(entries).toMatchObject([albert.id, lenna.id])
-    })
+    for (const method of methods) {
+      const error = await storage[method](path)
 
-    it('should return ERR_NOT_FOOUD if entry doesnt exist', async () => {
-      const path = `${dir}/oopsie`
+      expect(error).toBeInstanceOf(Error)
+      expect(error).toMatchObject({ code: 'NOT_FOUND' })
+    }
+  })
+})
 
-      const methods: Array<'reveal' | 'conceal'> = ['reveal', 'conceal']
+describe('annotate', () => {
+  let lenna: Entry
 
-      for (const method of methods) {
-        const error = await storage[method](path)
+  beforeEach(async () => {
+    const stream = open('lenna.png')
 
-        expect(error).toBeInstanceOf(Error)
-        expect(error).toMatchObject({ message: 'NOT_FOUND' })
-      }
-    })
+    lenna = await storage.put(dir, stream) as Entry
   })
 
-  describe('annotate', () => {
-    let lenna: Entry
+  it('should set meta', async () => {
+    const path = `${dir}/${lenna.id}`
 
-    beforeEach(async () => {
-      const stream = await open('lenna.png')
+    await storage.annotate(path, 'foo', 'bar')
 
-      lenna = await storage.put(dir, stream) as Entry
-    })
+    const state0 = await storage.get(path) as Entry
 
-    it('should set meta', async () => {
-      const path = `${dir}/${lenna.id}`
+    expect(state0.meta).toMatchObject({ foo: 'bar' })
 
-      await storage.annotate(path, 'foo', 'bar')
+    await storage.annotate(path, 'foo')
 
-      const state0 = await storage.get(path) as Entry
+    const state1 = await storage.get(path) as Entry
 
-      expect(state0.meta).toMatchObject({ foo: 'bar' })
+    expect('foo' in state1.meta).toBe(false)
+  })
+})
 
-      await storage.annotate(path, 'foo')
+describe('variants', () => {
+  let lenna: Entry
 
-      const state1 = await storage.get(path) as Entry
+  beforeEach(async () => {
+    const stream = open('lenna.png')
 
-      expect('foo' in state1.meta).toBe(false)
-    })
+    lenna = await storage.put(dir, stream) as Entry
   })
 
-  describe('variants', () => {
-    let lenna: Entry
+  it('should add variant', async () => {
+    const stream = open('sample.jpeg')
 
-    beforeEach(async () => {
-      const stream = await open('lenna.png')
+    const path = `${dir}/${lenna.id}`
 
-      lenna = await storage.put(dir, stream) as Entry
-    })
+    await storage.diversify(path, 'foo', stream)
 
-    it('should add variant', async () => {
-      const stream = await open('sample.jpeg')
+    const state = await storage.get(path) as Entry
 
-      const path = `${dir}/${lenna.id}`
+    expect(state.variants).toMatchObject([{ name: 'foo', size: 73444, type: 'image/jpeg' }])
+  })
 
-      await storage.diversify(path, 'foo', stream)
+  it('should replace variant', async () => {
+    const stream0 = open('sample.jpeg')
+    const stream1 = open('sample.webp')
+    const path = `${dir}/${lenna.id}`
 
-      const state = await storage.get(path) as Entry
+    await storage.diversify(path, 'foo', stream0)
+    await storage.diversify(path, 'foo', stream1)
 
-      expect(state.variants).toMatchObject([{ name: 'foo', size: 73444, type: 'image/jpeg' }])
-    })
+    const state = await storage.get(path) as Entry
 
-    it('should replace variant', async () => {
-      const stream0 = await open('sample.jpeg')
-      const stream1 = await open('sample.webp')
-      const path = `${dir}/${lenna.id}`
+    expect(state.variants).toMatchObject([{ name: 'foo', type: 'image/webp' }])
+  })
+})
 
-      await storage.diversify(path, 'foo', stream0)
-      await storage.diversify(path, 'foo', stream1)
+describe('fetch', () => {
+  let lenna: Entry
 
-      const state = await storage.get(path) as Entry
+  beforeEach(async () => {
+    const stream = open('lenna.png')
 
-      expect(state.variants).toMatchObject([{ name: 'foo', type: 'image/webp' }])
-    })
+    lenna = await storage.put(dir, stream) as Entry
   })
 
-  describe('fetch', () => {
-    let lenna: Entry
+  it('should fetch', async () => {
+    const path = `${dir}/${lenna.id}`
+    const stream = await storage.fetch(path)
 
-    beforeEach(async () => {
-      const stream = await open('lenna.png')
+    const stored: Buffer = await match(stream,
+      Readable, async (stream: Readable) => await buffer(stream))
 
-      lenna = await storage.put(dir, stream) as Entry
-    })
+    const buf = await buffer(open('lenna.png'))
 
-    it('should fetch', async () => {
-      const path = `${dir}/${lenna.id}`
-      const stream = await storage.fetch(path)
+    expect(stored.compare(buf)).toBe(0)
+  })
 
-      const stored: Buffer = await match(stream,
-        Readable, async (stream: Readable) => await buffer(stream))
+  it('should fetch blob by id', async () => {
+    const stream = open('lenna.ascii')
+    const entry = await storage.put(dir, stream) as Entry
+    const stored = await storage.fetch(entry.id)
 
-      const buf = await buffer(await open('lenna.png'))
+    if (stored instanceof Error)
+      throw stored
 
-      expect(stored.compare(buf)).toBe(0)
-    })
+    const buf = await buffer(stored)
+    const expected = await buffer(open('lenna.ascii'))
 
-    it('should fetch blob by id', async () => {
-      const stream = await open('lenna.ascii')
-      const entry = await storage.put(dir, stream) as Entry
-      const stored = await storage.fetch(entry.id)
+    expect(buf.compare(expected)).toBe(0)
+  })
 
-      if (stored instanceof Error)
-        throw stored
+  it('should fetch variant', async () => {
+    const stream = open('sample.jpeg')
 
-      const buf = await buffer(stored)
-      const expected = await buffer(await open('lenna.ascii'))
+    const buf = await buffer(stream)
+    const path = `${dir}/${lenna.id}`
 
-      expect(buf.compare(expected)).toBe(0)
-    })
+    await storage.diversify(path, '100x100.jpeg', Readable.from(buf))
 
-    it('should fetch variant', async () => {
-      const stream = await open('sample.jpeg')
+    const variant = await storage.fetch(`${path}.100x100.jpeg`)
 
-      const buf = await buffer(stream)
-      const path = `${dir}/${lenna.id}`
+    const stored = await match<Promise<Buffer>>(variant,
+      Readable, async (stream: Readable) => await buffer(stream))
 
-      await storage.diversify(path, '100x100.jpeg', Readable.from(buf))
+    expect(stored.compare(buf)).toBe(0)
+  })
 
-      const variant = await storage.fetch(`${path}.100x100.jpeg`)
+  it('should not fetch blob by id and fake path', async () => {
+    const stored = await storage.fetch(`fake/${lenna.id}`)
 
-      const stored = await match(variant,
-        Readable, async (stream: Readable) => await buffer(stream))
+    match(stored,
+      Error, (error: ErrorType) => expect(error.code).toBe('NOT_FOUND'))
+  })
+})
 
-      expect(stored.compare(buf)).toBe(0)
-    })
+describe('delete', () => {
+  let lenna: Entry
 
-    it('should not fetch blob by id and fake path', async () => {
-      const stored = await storage.fetch(`fake/${lenna.id}`)
+  beforeEach(async () => {
+    const stream = open('lenna.png')
 
-      match(stored,
-        Error, (error: Error) => expect(error.message).toBe('NOT_FOUND'))
-    })
+    lenna = await storage.put(dir, stream) as Entry
   })
 
-  describe('delete', () => {
-    let lenna: Entry
+  it('should remove from the list', async () => {
+    await storage.delete(`${dir}/${lenna.id}`)
 
-    beforeEach(async () => {
-      const stream = await open('lenna.png')
+    const list = await storage.list(dir)
 
-      lenna = await storage.put(dir, stream) as Entry
-    })
+    expect(list).not.toContain(lenna.id)
+  })
 
-    it('should remove from the list', async () => {
-      await storage.delete(`${dir}/${lenna.id}`)
+  it('should delete entry', async () => {
+    await storage.delete(`${dir}/${lenna.id}`)
 
-      const list = await storage.list(dir)
+    const result = await storage.get(`${dir}/${lenna.id}`)
 
-      expect(list).not.toContain(lenna.id)
-    })
+    match(result,
+      Error, (error: ErrorType) => expect(error.code).toBe('NOT_FOUND'))
+  })
 
-    it('should delete entry', async () => {
-      await storage.delete(`${dir}/${lenna.id}`)
+  it('should delete variants', async () => {
+    const stream = open('sample.jpeg')
 
-      const result = await storage.get(`${dir}/${lenna.id}`)
+    const path = `${dir}/${lenna.id}`
 
-      match(result,
-        Error, (error: Error) => expect(error.message).toBe('NOT_FOUND'))
-    })
+    await storage.diversify(path, 'foo', stream)
+    await storage.delete(`${dir}/${lenna.id}`)
 
-    it('should delete variants', async () => {
-      const stream = await open('sample.jpeg')
+    const variant = await storage.fetch(`${path}.foo`)
 
-      const path = `${dir}/${lenna.id}`
+    match(variant,
+      Error, (error: ErrorType) => expect(error.code).toBe('NOT_FOUND'))
 
-      await storage.diversify(path, 'foo', stream)
-      await storage.delete(`${dir}/${lenna.id}`)
+    stream.destroy()
+  })
 
-      const variant = await storage.fetch(`${path}.foo`)
+  it('should throw if path is not an entry', async () => {
+    const result = await storage.delete(dir)
 
-      match(variant,
-        Error, (error: Error) => expect(error.message).toBe('NOT_FOUND'))
+    expect(result).toBeInstanceOf(Error)
+    expect(result).toMatchObject({ code: 'NOT_FOUND' })
+  })
+})
 
-      stream.destroy()
-    })
+describe('signatures', () => {
+  it.each(['jpeg', 'gif', 'webp', 'heic', 'jxl', 'avif'])('should detect image/%s',
+    async (type) => {
+      const stream = open('sample.' + type)
 
-    it('should throw if path is not an entry', async () => {
-      const result = await storage.delete(dir)
+      const entry = await storage.put(dir, stream) as Entry
 
-      expect(result).toBeInstanceOf(Error)
-      expect(result).toMatchObject({ message: 'NOT_FOUND' })
+      expect(entry.type).toBe('image/' + type)
     })
-  })
+})
 
-  describe('signatures', () => {
-    it.each(['jpeg', 'gif', 'webp', 'heic', 'jxl', 'avif'])('should detect image/%s',
-      async (type) => {
-        const stream = await open('sample.' + type)
+it('should return error if type doesnt match', async () => {
+  const stream = open('sample.jpeg')
 
-        const entry = await storage.put(dir, stream) as Entry
+  const result = await storage.put(dir, stream, { claim: 'image/png' })
 
-        expect(entry.type).toBe('image/' + type)
-      })
-  })
+  match(result,
+    Error, (error: ErrorType) => expect(error.code).toBe('TYPE_MISMATCH'))
+})
 
-  it('should return error if type doesnt match', async () => {
-    const stream = await open('sample.jpeg')
+it('should trust unknown types', async () => {
+  const stream = open('lenna.ascii')
 
-    const result = await storage.put(dir, stream, 'image/png')
+  const result = await storage.put(dir, stream, { claim: 'text/plain' })
 
-    match(result,
-      Error, (error: Error) => expect(error.message).toBe('TYPE_MISMATCH'))
-  })
+  expect(result).not.toBeInstanceOf(Error)
+  expect(result).toMatchObject({ type: 'text/plain' })
+})
 
-  it('should trust unknown types', async () => {
-    const stream = await open('lenna.ascii')
+it('should return error if type is identifiable', async () => {
+  const stream = open('lenna.ascii')
 
-    const result = await storage.put(dir, stream, 'text/plain')
+  const result = await storage.put(dir, stream, { claim: 'image/jpeg' })
 
-    expect(result).not.toBeInstanceOf(Error)
-    expect(result).toMatchObject({ type: 'text/plain' })
-  })
+  expect(result).toBeInstanceOf(Error)
+  expect(result).toMatchObject({ code: 'TYPE_MISMATCH' })
+})
 
-  it('should return error if type is identifiable', async () => {
-    const stream = await open('lenna.ascii')
+it('should not return error if type application/octet-stream', async () => {
+  const stream = open('sample.jpeg')
 
-    const result = await storage.put(dir, stream, 'image/jpeg')
+  const result = await storage.put(dir, stream, { claim: 'application/octet-stream' })
 
-    expect(result).toBeInstanceOf(Error)
-    expect(result).toMatchObject({ message: 'TYPE_MISMATCH' })
-  })
+  expect(result).not.toBeInstanceOf(Error)
+  expect(result).toMatchObject({ type: 'image/jpeg' })
+})
 
-  it('should not return error if type application/octet-stream', async () => {
-    const stream = await open('sample.jpeg')
+it('should return error if type is not acceptable', async () => {
+  const stream = open('sample.jpeg')
 
-    const result = await storage.put(dir, stream, 'application/octet-stream')
+  const result = await storage.put(dir, stream, { accept: 'image/png' })
 
-    expect(result).not.toBeInstanceOf(Error)
-    expect(result).toMatchObject({ type: 'image/jpeg' })
-  })
+  match(result,
+    Error, (error: ErrorType) => expect(error.code).toBe('NOT_ACCEPTABLE'))
+})
 
-  it('should handle root entries', async () => {
-    const stream = await open('sample.jpeg')
+it('should accept wildcard types', async () => {
+  const stream = open('sample.jpeg')
 
-    const result = await storage.put('hello', stream) as Entry
+  const result = await storage.put(dir, stream, { accept: 'image/*' })
 
-    expect(result).not.toBeInstanceOf(Error)
+  expect(result).not.toBeInstanceOf(Error)
+  expect(result).toMatchObject({ type: 'image/jpeg' })
+})
 
-    const stored = await storage.fetch(result.id)
+it('should handle root entries', async () => {
+  const stream = open('sample.jpeg')
 
-    expect(stored).not.toBeInstanceOf(Error)
-  })
+  const result = await storage.put('hello', stream) as Entry
 
-  it('should store empty file', async () => {
-    const stream = await open('empty.txt')
-    const result = await storage.put('empty', stream) as Entry
+  expect(result).not.toBeInstanceOf(Error)
 
-    expect(result.size).toBe(0)
+  const stored = await storage.fetch(result.id)
 
-    const stored = await storage.fetch(result.id) as Readable
+  expect(stored).not.toBeInstanceOf(Error)
+})
 
-    expect(stored).not.toBeInstanceOf(Error)
+it('should store empty file', async () => {
+  const stream = open('empty.txt')
+  const result = await storage.put('empty', stream) as Entry
 
-    const buf = await buffer(stored)
+  expect(result.size).toBe(0)
 
-    expect(buf.length).toBe(0)
-  })
+  const stored = await storage.fetch(result.id) as Readable
+
+  expect(stored).not.toBeInstanceOf(Error)
+
+  const buf = await buffer(stored)
+
+  expect(buf.length).toBe(0)
 })