@toa.io/extensions.storages 1.0.0-alpha.21 → 1.0.0-alpha.219

package/source/Storage.test.ts

@@ -1,4 +1,3 @@
-import { Readable } from 'node:stream'
 import { randomUUID } from 'node:crypto'
 import { buffer } from 'node:stream/consumers'
 import { createReadStream } from 'node:fs'
@@ -6,28 +5,22 @@ import path from 'node:path'
 import assert from 'node:assert'
 import { Storage } from './Storage'
 import { suites } from './test/util'
-import { type Entry } from './Entry'
 import { providers } from './providers'
-import type { ProviderConstructor } from './Provider'
+import type { Entry, Metadata, Stream } from './Entry'
+import type { Constructor } from './Provider'
 
-let storage: Storage
-let dir: string
+jest.setTimeout(15_000)
 
 const suite = suites[0]
+const Provider: Constructor = providers[suite.provider]
+const provider = new Provider(suite.options, suite.secrets)
+const storage = new Storage(provider)
+const dir = '/' + randomUUID()
 
 beforeAll(async () => {
   process.chdir(path.join(__dirname, 'test'))
 })
 
-beforeEach(() => {
-  dir = '/' + randomUUID()
-
-  const Provider: ProviderConstructor = providers[suite.provider]
-  const provider = new Provider(suite.options)
-
-  storage = new Storage(provider)
-})
-
 it('should be', async () => {
   expect(storage).toBeInstanceOf(Storage)
 })
@@ -40,6 +33,7 @@ it('should return error if entry is not found', async () => {
 })
 
 describe('put', () => {
+  let path: string
   let lenna: Entry
   let startCreation: number
 
@@ -47,7 +41,10 @@ describe('put', () => {
     const stream = createReadStream('lenna.png')
 
     startCreation = Date.now()
-    lenna = (await storage.put(dir, stream)) as Entry
+    lenna = await storage.put(dir, stream) as Entry
+    path = `${dir}/${lenna.id}`
+
+    assert(!(lenna instanceof Error))
   })
 
   it('should not return error', async () => {
@@ -56,14 +53,7 @@ describe('put', () => {
 
   it('should return entry id', async () => {
     expect(lenna.id).toBeDefined()
-  })
-
-  it('should return id as checksum', async () => {
-    const stream = createReadStream('lenna.png')
-    const dir2 = '/' + randomUUID()
-    const copy = (await storage.put(dir2, stream)) as Entry
-
-    expect(copy).toHaveProperty('id', lenna.id)
+    expect(lenna.id).toHaveLength(32)
   })
 
   it('should detect file type', async () => {
@@ -78,257 +68,96 @@ describe('put', () => {
     expect(lenna).toMatchObject({
       id: lenna.id,
       type: 'image/png',
-      variants: [],
-      meta: {}
-    })
+      size: 473831,
+      checksum: lenna.checksum,
+      created: expect.any(String),
+      attributes: {}
+    } satisfies Entry)
   })
 
-  it('should create entry', async () => {
-    const entry = await storage.get(`${dir}/${lenna.id}`)
+  it('should create metadata', async () => {
+    const entry = await storage.head(path) as Entry
 
     expect(entry).toMatchObject({
-      id: lenna.id,
       type: 'image/png',
-      variants: [],
-      meta: {}
-    })
+      size: 473831,
+      checksum: lenna.checksum,
+      created: expect.any(String),
+      attributes: {}
+    } satisfies Metadata)
   })
 
   it('should set timestamp', async () => {
-    const now = Date.now()
-    const entry = (await storage.get(`${dir}/${lenna.id}`)) as Entry
-
-    expect(entry.created).toBeLessThanOrEqual(now)
-    expect(entry.created).toBeGreaterThanOrEqual(startCreation)
-  })
-
-  describe('existing entry', () => {
-    it('should unhide existing', async () => {
-      const stream = createReadStream('lenna.png')
-      const path = `${dir}/${lenna.id}`
-
-      await storage.conceal(path)
-      await storage.put(dir, stream)
-
-      const list = await storage.list(dir)
-
-      expect(list).toContainEqual(lenna.id)
-    })
-
-    it('should preserve meta', async () => {
-      const path = `${dir}/${lenna.id}`
-      const stream = createReadStream('lenna.png')
-
-      await storage.annotate(path, 'foo', 'bar')
-      await storage.put(dir, stream)
-
-      const entry = await storage.get(path)
-
-      expect(entry).toHaveProperty('meta', expect.objectContaining({ foo: 'bar' }))
-    })
-  })
-})
-
-describe('list', () => {
-  let albert: Entry
-  let lenna: Entry
-
-  beforeEach(async () => {
-    const stream0 = createReadStream('albert.jpg')
-    const stream1 = createReadStream('lenna.png')
-
-    albert = (await storage.put(dir, stream0)) as Entry
-    lenna = (await storage.put(dir, stream1)) as Entry
-  })
-
-  it('should list entries', async () => {
-    const list = await storage.list(dir)
-
-    expect(list).toEqual([albert.id, lenna.id])
-  })
+    const now = Date.now() + 1000 // Cloudinary has 1s resolution
+    const entry = await storage.get(path) as Stream
+    const created = new Date(entry.created).getTime()
 
-  it('should permutate', async () => {
-    const error = await storage.permute(dir, [lenna.id, albert.id])
-
-    expect(error).toBeUndefined()
-
-    const list = await storage.list(dir)
-
-    expect(list).toEqual([lenna.id, albert.id])
-  })
-
-  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]
-    ]
-
-    for (const permutation of cases) {
-      const error = await storage.permute(dir, permutation)
-
-      expect(error).toBeInstanceOf(Error)
-      expect(error).toHaveProperty('code', 'PERMUTATION_MISMATCH')
-    }
-  })
-
-  it('should exclude concealed', async () => {
-    const path = `${dir}/${lenna.id}`
-
-    await storage.conceal(path)
-
-    const entries = await storage.list(dir)
-
-    expect(entries).toEqual([albert.id])
+    expect(created).toBeLessThanOrEqual(now)
+    expect(created).toBeGreaterThanOrEqual(startCreation)
   })
 
-  it('should reveal', async () => {
-    const path = `${dir}/${lenna.id}`
-
-    await storage.conceal(path)
-    await storage.reveal(path)
-    await storage.reveal(path) // test that no duplicates are created
-
-    const entries = await storage.list(dir)
-
-    expect(entries).toEqual([albert.id, lenna.id])
-  })
-
-  it('should return ERR_NOT_FOOUD if entry doesnt exist', async () => {
-    const path = `${dir}/oopsie`
-
-    const methods: Array<'reveal' | 'conceal'> = ['reveal', 'conceal']
-
-    for (const method of methods) {
-      const error = await storage[method](path)
-
-      expect(error).toBeInstanceOf(Error)
-      expect(error).toHaveProperty('code', 'NOT_FOUND')
-    }
-  })
-})
-
-describe('annotate', () => {
-  let lenna: Entry
-
-  beforeEach(async () => {
+  it('should store with given id', async () => {
     const stream = createReadStream('lenna.png')
+    const id = Math.random().toString(36).slice(2)
 
-    lenna = (await storage.put(dir, stream)) as Entry
-  })
+    const entry = await storage.put(dir, stream, { id }) as Entry
 
-  it('should set meta', async () => {
-    const path = `${dir}/${lenna.id}`
+    expect(entry.id).toBe(id)
 
-    await storage.annotate(path, 'foo', 'bar')
+    const check = await storage.head(`${dir}/${id}`)
 
-    const state0 = (await storage.get(path)) as Entry
+    if (check instanceof Error)
+      throw check
 
-    expect(state0).toHaveProperty('meta.foo', 'bar')
-
-    await storage.annotate(path, 'foo')
-
-    const state1 = (await storage.get(path)) as Entry
-
-    expect(state1.meta).not.toHaveProperty('foo')
+    expect(check.id).toBe(id)
   })
 })
 
-describe('variants', () => {
+describe('get, head', () => {
   let lenna: Entry
+  let path: string
 
   beforeEach(async () => {
     const stream = createReadStream('lenna.png')
 
-    lenna = (await storage.put(dir, stream)) as Entry
-  })
-
-  it('should add variant', async () => {
-    const stream = createReadStream('sample.jpeg')
-
-    const path = `${dir}/${lenna.id}`
-
-    await storage.diversify(path, 'foo', stream)
+    lenna = await storage.put(dir, stream) as Entry
 
-    const state = (await storage.get(path)) as Entry
-
-    expect(state).toHaveProperty('variants',
-      expect.arrayContaining([{ name: 'foo', size: 73444, type: 'image/jpeg' }]))
-  })
-
-  it('should replace variant', async () => {
-    const stream0 = createReadStream('sample.jpeg')
-    const stream1 = createReadStream('sample.webp')
-    const path = `${dir}/${lenna.id}`
-
-    await storage.diversify(path, 'foo', stream0)
-    await storage.diversify(path, 'foo', stream1)
-
-    const state = (await storage.get(path)) as Entry
-
-    expect(state).toHaveProperty('variants',
-      expect.arrayContaining([expect.objectContaining({ name: 'foo', type: 'image/webp' })]))
-  })
-})
-
-describe('fetch', () => {
-  let lenna: Entry
-
-  beforeEach(async () => {
-    const stream = createReadStream('lenna.png')
-
-    lenna = (await storage.put(dir, stream)) as Entry
+    path = `${dir}/${lenna.id}`
   })
 
-  it('should fetch', async () => {
-    const path = `${dir}/${lenna.id}`
-    const stream = await storage.fetch(path)
-
-    assert.ok(stream instanceof Readable)
-
-    const stored = await buffer(stream)
+  it('should get', async () => {
+    const entry = await storage.get(path) as Stream
+    const stored = await buffer(entry.stream)
     const buf = await buffer(createReadStream('lenna.png'))
 
-    expect(stored.compare(buf)).toBe(0)
+    expect(stored.compare(new Uint8Array(buf.buffer))).toBe(0)
   })
 
-  it('should fetch blob by id', async () => {
-    const stream = createReadStream('lenna.ascii')
-    const entry = (await storage.put(dir, stream)) as Entry
-    const stored = await storage.fetch(entry.id)
-
-    if (stored instanceof Error) throw stored
+  it('should get entry', async () => {
+    const entry = await storage.head(path) as Entry
 
-    const buf = await buffer(stored)
-    const expected = await buffer(createReadStream('lenna.ascii'))
-
-    expect(buf.compare(expected)).toBe(0)
+    expect(entry.id).toBe(lenna.id)
   })
 
-  it('should fetch variant', async () => {
-    const stream = createReadStream('sample.jpeg')
-
-    const buf = await buffer(stream)
-    const path = `${dir}/${lenna.id}`
-
-    await storage.diversify(path, '100x100.jpeg', Readable.from(buf))
-
-    const variant = await storage.fetch(`${path}.100x100.jpeg`)
+  if (suite.provider === 'cloudinary') {
+    it('should return cloudinary url', async () => {
+      const entry = await storage.head(`${path}.jpeg`) as Entry
 
-    assert.ok(variant instanceof Readable)
+      expect(entry.attributes.url).toMatch(/^https:\/\//)
+    })
 
-    const stored = await buffer(variant)
+    it('should support conditions', async () => {
+      const entry = await storage.head(`${path}.vertical.jpeg`) as Entry
 
-    expect(stored.compare(buf)).toBe(0)
-  })
+      expect(entry.attributes.url.includes('/if_w_gt_h/a_90/if_end/')).toBe(true)
+    })
 
-  it('should not fetch blob by id and fake path', async () => {
-    const stored = await storage.fetch(`fake/${lenna.id}`)
+    it('should return entry id when requested with extensions', async () => {
+      const entry = await storage.head(`${path}.jpeg`) as Entry
 
-    expect(stored).toBeInstanceOf(Error)
-    expect(stored).toHaveProperty('code', 'NOT_FOUND')
-  })
+      expect(entry.id).toBe(lenna.id)
+    })
+  }
 })
 
 describe('delete', () => {
@@ -337,46 +166,26 @@ describe('delete', () => {
   beforeEach(async () => {
     const stream = createReadStream('lenna.png')
 
-    lenna = (await storage.put(dir, stream)) as Entry
-  })
-
-  it('should remove from the list', async () => {
-    await storage.delete(`${dir}/${lenna.id}`)
-
-    const list = await storage.list(dir)
-
-    expect(list).not.toContain(lenna.id)
+    lenna = await storage.put(dir, stream) as Entry
   })
 
   it('should delete entry', async () => {
     await storage.delete(`${dir}/${lenna.id}`)
 
+    // Cloudinary needs some time to invalidate the cache
+    if (suite.provider === 'cloudinary')
+      await new Promise((resolve) => setTimeout(resolve, 10_000))
+
     const result = await storage.get(`${dir}/${lenna.id}`)
 
     expect(result).toBeInstanceOf(Error)
     expect(result).toHaveProperty('code', 'NOT_FOUND')
   })
 
-  it('should delete variants', async () => {
-    const stream = createReadStream('sample.jpeg')
-
-    const path = `${dir}/${lenna.id}`
-
-    await storage.diversify(path, 'foo', stream)
-    await storage.delete(`${dir}/${lenna.id}`)
-    stream.destroy()
-
-    const variant = await storage.fetch(`${path}.foo`)
-
-    expect(variant).toBeInstanceOf(Error)
-    expect(variant).toHaveProperty('code', 'NOT_FOUND')
-  })
-
-  it('should throw if path is not an entry', async () => {
+  it('should not return error', async () => {
     const result = await storage.delete(dir)
 
-    expect(result).toBeInstanceOf(Error)
-    expect(result).toMatchObject({ code: 'NOT_FOUND' })
+    expect(result).toBeUndefined()
   })
 })
 
@@ -384,14 +193,36 @@ describe('signatures', () => {
   it.each(['jpeg', 'gif', 'webp', 'heic', 'jxl', 'avif'])('should detect image/%s',
     async (type) => {
       const stream = createReadStream('sample.' + type)
+      const entry = await storage.put(dir, stream) as Entry
+
+      expect(entry).toHaveProperty('type', 'image/' + type)
+    })
+
+  it.each(['avi'])('should detect video/%s',
+    async (type) => {
+      const stream = createReadStream('sample.' + type)
+      const entry = await storage.put(dir, stream) as Entry
+
+      expect(entry).toHaveProperty('type', 'video/' + type)
+    })
 
+  it.each(['wav'])('should detect audio/%s',
+    async (type) => {
+      const stream = createReadStream('sample.' + type)
       const entry = (await storage.put(dir, stream)) as Entry
 
-      expect(entry).toHaveProperty('type', 'image/' + type)
+      expect(entry).toHaveProperty('type', 'audio/' + type)
     })
+
+  it('should be ok with Arny', async () => {
+    const stream = createReadStream('arny.jpg')
+    const entry = (await storage.put(dir, stream)) as Entry
+
+    expect(entry).toHaveProperty('type', 'image/jpeg')
+  })
 })
 
-it("should return error if type doesn't match", async () => {
+it('should return error if type doesn\'t match', async () => {
   const stream = createReadStream('sample.jpeg')
 
   const result = await storage.put(dir, stream, { claim: 'image/png' })
@@ -447,27 +278,40 @@ it('should accept wildcard types', async () => {
 
 it('should handle root entries', async () => {
   const stream = createReadStream('sample.jpeg')
-
-  const result = (await storage.put('hello', stream)) as Entry
+  const result = await storage.put('/', stream) as Entry
 
   expect(result).not.toBeInstanceOf(Error)
 
-  const stored = await storage.fetch(result.id)
+  const stored = await storage.get(result.id)
 
   expect(stored).not.toBeInstanceOf(Error)
 })
 
-it('should store empty file', async () => {
-  const stream = createReadStream('empty.txt')
-  const result = (await storage.put('empty', stream)) as Entry
+it('should return error of stream size limit exceeded', async () => {
+  const stream = createReadStream('sample.jpeg')
+  const result = await storage.put(dir, stream, { limit: 1024 })
 
-  expect(result).toHaveProperty('size', 0)
+  expect(result).toBeInstanceOf(Error)
+  expect(result).toHaveProperty('code', 'LIMIT_EXCEEDED')
+})
 
-  const stored = (await storage.fetch(result.id)) as Readable
+if (suite.provider !== 'cloudinary')
+  it('should add origin attribute', async () => {
+    const origin = 'https://example.com/image.jpeg'
+    const stream = createReadStream('sample.jpeg')
+    const result = await storage.put('/origins', stream, { origin }) as Entry
 
-  expect(stored).not.toBeInstanceOf(Error)
+    assert.ok(!(result instanceof Error))
+
+    const entry = await storage.get('/origins/' + result.id)
+
+    assert.ok(!(entry instanceof Error))
+
+    expect(entry.attributes.origin).toBe(origin)
+  })
 
-  const buf = await buffer(stored)
+it('should expose path', () => {
+  const path = storage.path()
 
-  expect(buf).toHaveLength(0)
+  expect(typeof path === 'string' || path === null)
 })