test: adapter tests and fixes

Author: TillaTheHun0

adapter.js

@@ -5,7 +5,7 @@ import { Namespaced } from './lib/namespaced.js'
 import { checkName, handleHyperErr, minioClientSchema } from './lib/utils.js'
 
 const { Async } = crocks
-const { prop, map, always } = R
+const { prop, map, always, identity } = R
 
 export const HYPER_BUCKET_PREFIX = 'hyper-storage-namespaced'
 
@@ -190,7 +190,7 @@ export default function (config) {
    * @returns {Promise<ResponseObjects>}
    */
   function listObjects({ bucket, prefix }) {
-    return Async.all([checkBucket(bucket), checkName(object)])
+    return Async.all([checkBucket(bucket), checkName(prefix)])
       .chain(() => client.listObjects({ bucket, prefix }))
       .bimap(
         identity,

adapter.test.js

@@ -0,0 +1,164 @@
+import { assertEquals, assertObjectMatch } from './dev_deps.js'
+import { ReadableWebToNodeStream } from './deps.js'
+
+import adapter from './adapter.js'
+
+Deno.test('adapter', async (t) => {
+  const happyMinio = {
+    makeBucket: (name) => {
+      if (name === 'test-exists') return Promise.reject({ code: 'BucketAlreadyExists' })
+      return Promise.resolve()
+    },
+    removeBucket: () => Promise.resolve(),
+    bucketExists: () => Promise.resolve(true),
+    listBuckets: () =>
+      Promise.resolve([
+        { name: 'test-foo' },
+        { name: 'test-bar' },
+      ]),
+    getObject: () => {
+      return Promise.resolve(
+        new ReadableWebToNodeStream(new Response(JSON.stringify({ fizz: 'buzz' })).body),
+      )
+    },
+    putObject: () => Promise.resolve(),
+    removeObject: () => {
+      return Promise.resolve()
+    },
+    removeObjects: (bucket, keys) => {
+      if (bucket === 'test-removeBucketTest') {
+        assertEquals(keys, ['foo', 'bar'])
+      }
+      return Promise.resolve()
+    },
+    listObjects: () => {
+      // Mock stream
+      return {
+        on: (event, fn) => {
+          switch (event) {
+            case 'data': {
+              fn({ name: 'foo' })
+              fn({ name: 'bar' })
+              break
+            }
+            case 'end': {
+              return fn('foo')
+            }
+          }
+        },
+      }
+    },
+    presignedUrl: () => {
+      return Promise.resolve('http://presigned')
+    },
+  }
+
+  const a = adapter({
+    minio: happyMinio,
+    bucketPrefix: 'test',
+    useNamespacedBucket: false,
+  })
+
+  await t.step('makeBucket', async (t) => {
+    await t.step('should return whether the bucket was created successfully', () => {
+      return a.makeBucket('foo')
+        .then((res) => assertEquals(res, { ok: true }))
+    })
+
+    await t.step('should return a HyperErr if the bucket already exists', () => {
+      return a.makeBucket('exists')
+        .then((res) => assertObjectMatch(res, { ok: false, status: 409 }))
+    })
+  })
+
+  await t.step('removeBucket', async (t) => {
+    await t.step('should return whether the bucket was removed successfully', () => {
+      return a.removeBucket('foo')
+        .then((res) => assertEquals(res, { ok: true }))
+    })
+
+    await t.step('should remove all objects in the bucket before removing', () => {
+      return a.removeBucket('removeBucketTest')
+        .then((res) => assertEquals(res, { ok: true }))
+    })
+  })
+
+  await t.step('listBuckets', async (t) => {
+    await t.step('should return the names of the buckets', () => {
+      return a.listBuckets()
+        .then((res) =>
+          assertObjectMatch(res, {
+            ok: true,
+            buckets: [
+              'test-foo',
+              'test-bar',
+            ],
+          })
+        )
+    })
+  })
+
+  await t.step('putObject', async (t) => {
+    await t.step('should return that the object was put successfully', () => {
+      return a.putObject({
+        bucket: 'foo',
+        object: 'bar.png',
+        stream: new Response(JSON.stringify({ foo: 'bar' })).body,
+      })
+        .then((res) => assertEquals(res, { ok: true }))
+    })
+
+    await t.step('should return the presigned url', () => {
+      return a.putObject({
+        bucket: 'foo',
+        object: 'bar.png',
+        useSignedUrl: true,
+      })
+        .then((res) => assertEquals(res, { ok: true, url: 'http://presigned' }))
+    })
+  })
+
+  await t.step('removeObject', async (t) => {
+    await t.step('should return that the object was removed successfully', () => {
+      return a.removeObject({
+        bucket: 'foo',
+        object: 'bar.png',
+      })
+        .then((res) => assertEquals(res, { ok: true }))
+    })
+  })
+
+  await t.step('getObject', async (t) => {
+    await t.step('should return the stream of the object', () => {
+      return a.getObject({
+        bucket: 'foo',
+        object: 'bar.png',
+      })
+        .then(async (res) => {
+          const object = await (new Response(res).json())
+          assertEquals(object, { fizz: 'buzz' })
+        })
+    })
+
+    await t.step('should return the presigned url', () => {
+      return a.getObject({
+        bucket: 'foo',
+        object: 'bar.png',
+        useSignedUrl: true,
+      })
+        .then((res) => assertEquals(res, { ok: true, url: 'http://presigned' }))
+    })
+  })
+
+  await t.step('listObjects', async (t) => {
+    await t.step('should return names of objects in the bucket', () => {
+      return a.listObjects({
+        bucket: 'foo',
+        prefix: 'fizz',
+      })
+        .then((res) => {
+          assertEquals(res, { ok: true, objects: ['foo', 'bar'] })
+        })
+    })
+  })
+})

lib/utils.js

@@ -31,6 +31,11 @@ export const minioClientSchema = z.object({
       bucket: z.string(),
       key: z.string(),
     })),
+  removeObjects: z.function()
+    .args(z.object({
+      bucket: z.string(),
+      keys: z.array(z.string()),
+    })),
   getObject: z.function()
     .args(z.object({
       bucket: z.string(),