monastery 1.28.4 → 1.30.1

package/test/plugin-images.js

@@ -2,7 +2,7 @@ module.exports = function(monastery, opendb) {
 
   // Data no images doesn't throw error
 
-  test('images no initialisation', async (done) => {
+  test('images no initialisation', async () => {
     let db = (await opendb(null)).db
     db.model('company', {
       fields: {
@@ -15,7 +15,7 @@ module.exports = function(monastery, opendb) {
       }
     })
     let company = await db.company.insert({ data: {
-      logo: { bucket: "corex-dev", date: 1598481616 }
+      logo: { bucket: 'corex-dev', date: 1598481616 }
     }})
     let user = await db.user.insert({ data: {
       company: company._id
@@ -31,13 +31,13 @@ module.exports = function(monastery, opendb) {
     expect(db.company.fields.logo).toEqual({
       image: true,
       isAny: true,
-      type: "any"
+      type: 'any'
     })
 
     // found company
     expect(foundCompany).toEqual({
       _id: company._id,
-      logo: { bucket: "corex-dev", date: 1598481616 },
+      logo: { bucket: 'corex-dev', date: 1598481616 },
     })
 
     // found user
@@ -45,15 +45,14 @@ module.exports = function(monastery, opendb) {
       _id: user._id,
       company: {
         _id: company._id,
-        logo: { bucket: "corex-dev", date: 1598481616 }
+        logo: { bucket: 'corex-dev', date: 1598481616 }
       }
     })
 
     db.close()
-    done()
   })
 
-  test('images initialisation', async (done) => {
+  test('images initialisation', async () => {
     let db = (await opendb(null, {
       timestamps: false,
       serverSelectionTimeoutMS: 2000,
@@ -75,7 +74,10 @@ module.exports = function(monastery, opendb) {
       filename: { type: 'string', isString: true },
       filesize: { type: 'number', isNumber: true },
       path: { type: 'string', isString: true },
-      schema: { type: 'object', isObject: true, image: true, nullObject: true, default: undefined, isImageObject: true },
+      schema: {
+        type: 'object', isObject: true, image: true, nullObject: true, default: undefined,
+        isImageObject: true
+      },
       uid: { type: 'string', isString: true }
     }
 
@@ -85,17 +87,16 @@ module.exports = function(monastery, opendb) {
     expect(user.fields.users[0].logo).toEqual(expected)
 
     db.close()
-    done()
   })
 
-  test('images addImages helper functions', async (done) => {
+  test('images addImages helper functions', async () => {
     let db = (await opendb(null, {
       timestamps: false,
       serverSelectionTimeoutMS: 2000,
       imagePlugin: { awsBucket: 'fake', awsAccessKeyId: 'fake', awsSecretAccessKey: 'fake' }
     })).db
     let plugin = db.imagePluginFile
-    let user = db.model('user', { fields: {
+    db.model('user', { fields: {
       logo: { type: 'image' },
       logos: [{ type: 'image' }],
       users: [{ logo: { type: 'image' } }]
@@ -137,209 +138,424 @@ module.exports = function(monastery, opendb) {
       .toEqual({ user: { a: { b: { c: { logo: image }}}}})
 
     db.close()
-    done()
   })
 
-  test('images addImages', async (done) => {
-    let db = (await opendb(null, {
-      timestamps: false,
-      serverSelectionTimeoutMS: 2000,
-      imagePlugin: { awsBucket: 'fake', awsAccessKeyId: 'fake', awsSecretAccessKey: 'fake' }
-    })).db
-
-    let user = db.model('user', { fields: {
-      logo: { type: 'image' },
-      logos: [{ type: 'image' }],
-      users: [{ logo: { type: 'image' } }]
-    }})
-
-    let plugin = db.imagePluginFile
-    let supertest = require('supertest')
-    let express = require('express')
-    let upload = require('express-fileupload')
-    let app = express()
-    app.use(upload({ limits: { fileSize: 1 * 1000 * 1000, files: 10 }}))
-
-    app.post('/', function(req, res) {
-      // Files exist
-      expect(req.files.logo).toEqual(expect.any(Object))
-      plugin._findValidImages(req.files, user)
-        .then(validFiles => {
-          // Valid file count
-          expect(validFiles).toEqual([
-            expect.any(Array),
-            expect.any(Array),
-            expect.any(Array),
-            expect.any(Array)
-          ])
-          // Valid imageField
-          expect(validFiles[0].imageField).toEqual(expect.any(Object))
-          expect(validFiles[1].imageField).toEqual(expect.any(Object))
-          expect(validFiles[2].imageField).toEqual(expect.any(Object))
-          expect(validFiles[3].imageField).toEqual(expect.any(Object))
-          // Valid inputPath
-          expect(validFiles[0].inputPath).toEqual('logo')
-          expect(validFiles[1].inputPath).toEqual('logos.0')
-          expect(validFiles[2].inputPath).toEqual('users.0.logo')
-          expect(validFiles[3].inputPath).toEqual('users.2.logo')
-          // Valid type
-          expect(validFiles[0][0].format).toEqual('png')
-          expect(validFiles[1][0].format).toEqual('png')
-          expect(validFiles[2][0].format).toEqual('png')
-          expect(validFiles[3][0].format).toEqual('png')
-
-          return plugin.addImages({ model: user, files: req.files, query: { _id: 1234 }}, req.body, true)
-        })
-        .then(res => {
-          expect(res[0]).toEqual({
-            name: 'my awesome avatar',
-            logo: {
-              bucket: 'fake',
-              date: expect.any(Number),
-              filename: 'logo.png',
-              filesize: expect.any(Number),
-              path: expect.any(String),
-              uid: expect.any(String)
-            },
-            logos: [ expect.any(Object) ],
-            users: [
-              {
-                logo: {
-                  bucket: 'fake',
-                  date: expect.any(Number),
-                  filename: 'logo2.png',
-                  filesize: expect.any(Number),
-                  path: expect.any(String),
-                  uid: expect.any(String)
-                }
+  test('images addImages', (done) => {
+    (async function run () {
+      let db = (await opendb(null, {
+        timestamps: false,
+        serverSelectionTimeoutMS: 2000,
+        imagePlugin: { awsBucket: 'fake', awsAccessKeyId: 'fake', awsSecretAccessKey: 'fake' }
+      })).db
+
+      let user = db.model('user', { fields: {
+        logo: { type: 'image' },
+        logos: [{ type: 'image' }],
+        users: [{ logo: { type: 'image' } }]
+      }})
+
+      let plugin = db.imagePluginFile
+      let supertest = require('supertest')
+      let express = require('express')
+      let upload = require('express-fileupload')
+      let app = express()
+      app.use(upload({ limits: { fileSize: 1 * 1000 * 1000, files: 10 }}))
+
+      app.post('/', function(req, res) {
+        // Files exist
+        expect(req.files.logo).toEqual(expect.any(Object))
+        plugin._findValidImages(req.files, user)
+          .then(validFiles => {
+            // Valid file count
+            expect(validFiles).toEqual([
+              expect.any(Array),
+              expect.any(Array),
+              expect.any(Array),
+              expect.any(Array)
+            ])
+            // Valid imageField
+            expect(validFiles[0].imageField).toEqual(expect.any(Object))
+            expect(validFiles[1].imageField).toEqual(expect.any(Object))
+            expect(validFiles[2].imageField).toEqual(expect.any(Object))
+            expect(validFiles[3].imageField).toEqual(expect.any(Object))
+            // Valid inputPath
+            expect(validFiles[0].inputPath).toEqual('logo')
+            expect(validFiles[1].inputPath).toEqual('logos.0')
+            expect(validFiles[2].inputPath).toEqual('users.0.logo')
+            expect(validFiles[3].inputPath).toEqual('users.2.logo')
+            // Valid type
+            expect(validFiles[0][0].format).toEqual('png')
+            expect(validFiles[1][0].format).toEqual('png')
+            expect(validFiles[2][0].format).toEqual('png')
+            expect(validFiles[3][0].format).toEqual('png')
+
+            return plugin.addImages({ model: user, files: req.files, query: { _id: 1234 }}, req.body, true)
+          })
+          .then(res => {
+            expect(res[0]).toEqual({
+              name: 'my awesome avatar',
+              logo: {
+                bucket: 'fake',
+                date: expect.any(Number),
+                filename: 'logo.png',
+                filesize: expect.any(Number),
+                path: expect.any(String),
+                uid: expect.any(String)
               },
-              undefined, // !this will be converted to null on insert/update
-              {
-                logo: {
-                  bucket: 'fake',
-                  date: expect.any(Number),
-                  filename: 'logo2.png',
-                  filesize: expect.any(Number),
-                  path: expect.any(String),
-                  uid: expect.any(String)
+              logos: [ expect.any(Object) ],
+              users: [
+                {
+                  logo: {
+                    bucket: 'fake',
+                    date: expect.any(Number),
+                    filename: 'logo2.png',
+                    filesize: expect.any(Number),
+                    path: expect.any(String),
+                    uid: expect.any(String)
+                  }
+                },
+                undefined, // !this will be converted to null on insert/update
+                {
+                  logo: {
+                    bucket: 'fake',
+                    date: expect.any(Number),
+                    filename: 'logo2.png',
+                    filesize: expect.any(Number),
+                    path: expect.any(String),
+                    uid: expect.any(String)
+                  }
                 }
-              }
-            ]
+              ]
+            })
           })
-        })
-        .finally(() => {
-          res.json()
-          db.close()
-          done()
-        })
-    })
+          .finally(() => {
+            res.json()
+            db.close()
+            done()
+          })
+      })
 
-    // Start tests
-    supertest(app)
-      .post('/')
-      .field('name', 'my awesome avatar')
-      .attach('logo', `${__dirname}/assets/logo.png`)
-      .attach('logos.0', `${__dirname}/assets/logo2.png`)
-      .attach('users.0.logo', `${__dirname}/assets/logo2.png`)
-      .attach('users.2.logo', `${__dirname}/assets/logo2.png`)
-      .expect(200)
-      .end((err, res) => { if (err) console.log(err) })
+      // Start tests
+      supertest(app)
+        .post('/')
+        .field('name', 'my awesome avatar')
+        .attach('logo', `${__dirname}/assets/logo.png`)
+        .attach('logos.0', `${__dirname}/assets/logo2.png`)
+        .attach('users.0.logo', `${__dirname}/assets/logo2.png`)
+        .attach('users.2.logo', `${__dirname}/assets/logo2.png`)
+        .expect(200)
+        .end((err, res) => { if (err) console.log(err) })
+    })()
   })
 
-  test('images removeImages', async (done) => {
-    let db = (await opendb(null, {
-      timestamps: false,
-      serverSelectionTimeoutMS: 2000,
-      imagePlugin: { awsBucket: 'fake', awsAccessKeyId: 'fake', awsSecretAccessKey: 'fake' }
-    })).db
+  test('images removeImages', (done) => {
+    (async function run () {
+      let db = (await opendb(null, {
+        timestamps: false,
+        serverSelectionTimeoutMS: 2000,
+        imagePlugin: { awsBucket: 'fake', awsAccessKeyId: 'fake', awsSecretAccessKey: 'fake' }
+      })).db
+
+      let user = db.model('user', { fields: {
+        logo: { type: 'image' },
+        logos: [{ type: 'image' }],
+        users: [{ userlogo: { type: 'image' } }],
+        deep: { logo: { type: 'image' }}
+      }})
+
+      let image = {
+        bucket: 'test',
+        date: 1234,
+        filename: 'test.png',
+        filesize: 1234,
+        path: 'test/test123'
+      }
+      let user1 = await db.user._insert({
+        logo: { ...image, uid: 'test1', path: 'dir/test1.png' },
+        logos: [
+          { ...image, uid: 'test2', path: 'dir/test2.png' },
+          { ...image, uid: 'test3', path: 'dir/test3.png' }
+        ],
+        users: [
+          { userlogo: { ...image, uid: 'test4', path: 'dir/test4.png' }},
+          null,
+          { userlogo: { ...image, uid: 'test4', path: 'dir/test4.png' }},
+          { userlogo: { ...image, uid: 'test4', path: 'dir/test4.png' }}
+        ],
+        deep: {}
+      })
 
-    let user = db.model('user', { fields: {
-      logo: { type: 'image' },
-      logos: [{ type: 'image' }],
-      users: [{ userlogo: { type: 'image' } }],
-      deep: { logo: { type: 'image' }}
-    }})
+      let plugin = db.imagePluginFile
+      let supertest = require('supertest')
+      let express = require('express')
+      let upload = require('express-fileupload')
+      let app = express()
+      app.use(upload({ limits: { fileSize: 1 * 1000 * 1000, files: 10 }}))
 
-    let image = {
-      bucket: 'test',
-      date: 1234,
-      filename: 'test.png',
-      filesize: 1234,
-      path: 'test/test123'
-    }
-    let user1 = await db.user._insert({
-      logo: { ...image, uid: 'test1', path: 'dir/test1.png' },
-      logos: [
-        { ...image, uid: 'test2', path: 'dir/test2.png' },
-        { ...image, uid: 'test3', path: 'dir/test3.png' }
-      ],
-      users: [
-        { userlogo: { ...image, uid: 'test4', path: 'dir/test4.png' }},
-        null,
-        { userlogo: { ...image, uid: 'test4', path: 'dir/test4.png' }},
-        { userlogo: { ...image, uid: 'test4', path: 'dir/test4.png' }}
-      ],
-      deep: {}
-    })
+      app.post('/', function(req, res) {
+        req.body.logos = JSON.parse(req.body.logos)
+        req.body.users = JSON.parse(req.body.users)
+        let options = { files: req.files, model: user, query: { _id: user1._id }}
 
-    let plugin = db.imagePluginFile
-    let supertest = require('supertest')
-    let express = require('express')
-    let upload = require('express-fileupload')
-    let app = express()
-    app.use(upload({ limits: { fileSize: 1 * 1000 * 1000, files: 10 }}))
+        plugin.removeImages(options, req.body, true)
+          .then(res => {
+            expect(res[0]).toEqual({ test1: 1, test2: 0, test3: 1, test4: 0 })
+            expect(res[1]).toEqual([
+              { Key: 'dir/test2.png' },
+              { Key: 'small/test2.jpg' },
+              { Key: 'medium/test2.jpg' },
+              { Key: 'large/test2.jpg' },
+
+              { Key: 'dir/test4.png' },
+              { Key: 'small/test4.jpg' },
+              { Key: 'medium/test4.jpg' },
+              { Key: 'large/test4.jpg' }
+            ])
+          })
+          .finally(() => {
+            res.json()
+            db.close()
+            done()
+          })
+      })
 
-    app.post('/', function(req, res) {
-      req.body.logos = JSON.parse(req.body.logos)
-      req.body.users = JSON.parse(req.body.users)
-      let options = { files: req.files, model: user, query: { _id: user1._id }}
+      // Start tests
+      supertest(app)
+        .post('/')
+        .field('name', 'my awesome avatar')
+        .field('logos', JSON.stringify([ null, { ...image, uid: 'test3', path: 'dir/test3.png' } ]))
+        .field('users', JSON.stringify([
+          { userlogo: { ...image, uid: 'test1', path: 'dir/test1.png' }},
+          null,
+          null,
+          //null // undefined
+        ]))
+        .attach('logo', `${__dirname}/assets/logo.png`)
+        .attach('logos.0', `${__dirname}/assets/logo2.png`)
+        .expect(200)
+        .end((err, res) => { if (err) console.log(err) })
+    })()
+  })
 
-      plugin.removeImages(options, req.body, true)
-        .then(res => {
-          expect(res[0]).toEqual({ test1: 0, test2: -1, test3: 1, test4: 0 })
-          expect(res[1]).toEqual([
-            { Key: 'dir/test1.png' },
-            { Key: 'small/test1.jpg' },
-            { Key: 'medium/test1.jpg' },
-            { Key: 'large/test1.jpg' },
-
-            { Key: 'dir/test2.png' },
-            { Key: 'small/test2.jpg' },
-            { Key: 'medium/test2.jpg' },
-            { Key: 'large/test2.jpg' },
-
-            { Key: 'dir/test4.png' },
-            { Key: 'small/test4.jpg' },
-            { Key: 'medium/test4.jpg' },
-            { Key: 'large/test4.jpg' }
-          ])
+  test('images removeImages with no data', (done) => {
+    (async function run () {
+      // NOTE: Redundent, leaving for now (test was needed to fix a project issue)
+      let db = (await opendb(null, {
+        timestamps: false,
+        serverSelectionTimeoutMS: 2000,
+        imagePlugin: { awsBucket: 'fake', awsAccessKeyId: 'fake', awsSecretAccessKey: 'fake' }
+      })).db
+
+      let user = db.model('user', { fields: {
+        logo: { type: 'image' }
+      }})
+
+      // let image = {
+      //   bucket: 'test',
+      //   date: 1234,
+      //   filename: 'test.png',
+      //   filesize: 1234,
+      //   path: 'test/test123'
+      // }
+      let user1 = await db.user._insert({
+        logo: null
+      })
+
+      let plugin = db.imagePluginFile
+      let supertest = require('supertest')
+      let express = require('express')
+      let upload = require('express-fileupload')
+      let app = express()
+      app.use(upload({ limits: { fileSize: 1 * 1000 * 1000, files: 10 }}))
+
+      app.post('/', function(req, res) {
+        try {
+          let options = { files: req.files, model: user, query: { _id: user1._id }}
+          plugin.removeImages(options, req.body, true)
+            .then(res => {
+              expect(res[0]).toEqual({})
+              expect(res[1]).toEqual([])
+            })
+            .finally(() => {
+              res.json()
+              db.close()
+              done()
+            })
+        } catch(e) {
+          console.log(e)
+          res.error(e)
+        }
+      })
+
+      // Start tests
+      supertest(app)
+        .post('/')
+        .attach('logo', `${__dirname}/assets/logo.png`)
+        .expect(200)
+        .end((err, res) => { if (err) console.log(err, res.text) })
+    })()
+  })
+
+  test('images addImages formats & filesizes', (done) => {
+    (async function run () {
+      let db = (await opendb(null, {
+        timestamps: false,
+        serverSelectionTimeoutMS: 2000,
+        imagePlugin: {
+          awsBucket: 'fake',
+          awsAccessKeyId: 'fake',
+          awsSecretAccessKey: 'fake',
+          formats: ['jpg', 'jpeg', 'png', 'ico']
+        }
+      })).db
+
+      let user = db.model('user', { fields: {
+        imageIco:     { type: 'image' },
+        imageWebp:    { type: 'image', formats: ['webp'] },
+        imageSvgBad:  { type: 'image' },
+        imageSvgGood: { type: 'image', formats: ['svg'] },
+        imageSvgAny:  { type: 'image', formats: ['any'] },
+        imageSize1:   { type: 'image', fileSize: 1000 * 100 },
+        imageSize2:   { type: 'image' },
+      }})
+
+      let plugin = db.imagePluginFile
+      let supertest = require('supertest')
+      let express = require('express')
+      let upload = require('express-fileupload')
+      let app = express()
+      app.use(upload({ limits: { fileSize: 1000 * 200, files: 10 }}))
+
+      app.post('/', async (req, res) => {
+        let imageSvgBad = { imageSvgBad: req.files.imageSvgBad }
+        let imageSize1 = { imageSize1: req.files.imageSize1 }
+        let imageSize2 = { imageSize2: req.files.imageSize2 }
+        delete req.files.imageSvgBad
+        delete req.files.imageSize1
+        delete req.files.imageSize2
+        // Ico, Webp, and imageSvgGood will throw an error first if it's not a valid type
+        await expect(plugin._findValidImages(req.files, user)).resolves.toEqual(expect.any(Array))
+        await expect(plugin._findValidImages(imageSvgBad, user)).rejects.toEqual({
+          title: 'imageSvgBad',
+          detail: 'The file format \'svg\' for \'bad.svg\' is not supported'
+        })
+        await expect(plugin._findValidImages(imageSize1, user)).rejects.toEqual({
+          title: 'imageSize1',
+          detail: 'The file size for \'lion1.png\' is bigger than 0.1MB.'
         })
-        .finally(() => {
-          res.json()
+        await expect(plugin._findValidImages(imageSize2, user)).rejects.toEqual({
+          title: 'imageSize2',
+          detail: 'The file size for \'lion2.jpg\' is too big.'
+        })
+        res.json()
+      })
+
+      // Start tests
+      supertest(app)
+        .post('/')
+        .attach('imageIco', `${__dirname}/assets/image.ico`)
+        .attach('imageWebp', `${__dirname}/assets/image.webp`)
+        .attach('imageSvgBad', `${__dirname}/assets/bad.svg`)
+        .attach('imageSvgGood', `${__dirname}/assets/bad.svg`)
+        .attach('imageSvgAny', `${__dirname}/assets/bad.svg`)
+        .attach('imageSize1', `${__dirname}/assets/lion1.png`)
+        .attach('imageSize2', `${__dirname}/assets/lion2.jpg`)
+        .expect(200)
+        .end((err, res) => {
+          if (err) console.log(err)
           db.close()
           done()
         })
-    })
+    })()
+  })
 
-    // Start tests
-    supertest(app)
-      .post('/')
-      .field('name', 'my awesome avatar')
-      .field('logos', JSON.stringify([ null, { ...image, uid: 'test3', path: 'dir/test3.png' } ]))
-      .field('users', JSON.stringify([
-        { userlogo: { ...image, uid: 'test1', path: 'dir/test1.png' }},
-        null,
-        null,
-        //null // undefined
-      ]))
-      .attach('logo', `${__dirname}/assets/logo.png`)
-      .attach('logos.0', `${__dirname}/assets/logo2.png`)
-      .expect(200)
-      .end((err, res) => { if (err) console.log(err) })
+  test('images addImages bad file objects', (done) => {
+    (async function run () {
+      //// latest supertrace setup
+      let db = (await opendb(null, {
+        timestamps: false,
+        serverSelectionTimeoutMS: 2000,
+        imagePlugin: { awsBucket: 'fake', awsAccessKeyId: 'fake', awsSecretAccessKey: 'fake' }
+      })).db
+
+      db.model('user', { fields: {
+        logo: { type: 'image' },
+        logos: [{ type: 'image' }],
+        users: [{ logo: { type: 'image' } }]
+      }})
+
+      let imageObjectMock = {
+        bucket: 'temp',
+        date: 1234,
+        filename: 'temp.png',
+        filesize: 1234,
+        path: 'temp',
+        uid: 'temp'
+      }
+      let detailLongMock = 'Image fields need to either be null, undefined, file, or an object containing the '
+        + 'following fields \'{ bucket, date, filename, filesize, path, uid }\''
+
+      let supertest = require('supertest')
+      let express = require('express')
+      let app = express()
+      let bodyParser = require('body-parser')
+
+      app.use(bodyParser.json())
+      app.use(bodyParser.urlencoded({ extended: true }))
+      app.post('/', async function(req, res) {
+        try {
+          await db.user.validate(req.body)
+          res.send()
+        } catch (err) {
+          res.status(500).send(err)
+        }
+      })
+
+      // Start tests
+      supertest(app)
+        .post('/')
+        .send({
+          logo: null,//ok
+          logos: [undefined, imageObjectMock, {}],//0,1=ok
+          users: [
+            { logo: {} },
+            { logo: { bucket: '' }},
+            { logo: imageObjectMock },//ok
+            { logo: null },//ok
+          ]
+        })
+        .expect(500)
+        .then(res => {
+          // console.log(res.body)
+          expect(res.body).toEqual([
+            {
+              detail: 'Invalid image value',
+              meta: { rule: 'isImageObject', model: 'user', field: '2', detailLong: detailLongMock },
+              status: '400',
+              title: 'logos.2'
+            }, {
+              detail: 'Invalid image value',
+              meta: { rule: 'isImageObject', model: 'user', field: 'logo', detailLong: detailLongMock },
+              status: '400',
+              title: 'users.0.logo'
+            }, {
+              detail: 'Invalid image value',
+              meta: { rule: 'isImageObject', model: 'user', field: 'logo', detailLong: detailLongMock },
+              status: '400',
+              title: 'users.1.logo'
+            }
+          ])
+          db.close()
+          done()
+        })
+        .catch(err => {
+          db.close()
+          done(err)
+        })
+    })()
   })
 
-  test('images removeImages with no data', async (done) => {
-    // NOTE: Redundent, leaving for now (test was needed to fix a project issue)
+  test('images reorder', async () => {
     let db = (await opendb(null, {
       timestamps: false,
       serverSelectionTimeoutMS: 2000,
@@ -347,18 +563,20 @@ module.exports = function(monastery, opendb) {
     })).db
 
     let user = db.model('user', { fields: {
-      logo: { type: 'image' }
+      logos: [{ type: 'image' }],
     }})
 
     let image = {
       bucket: 'test',
       date: 1234,
-      filename: 'test.png',
+      filename: 'lion1.png',
       filesize: 1234,
-      path: 'test/test123'
+      path: 'test/lion1.png',
+      uid: 'lion1'
     }
+
     let user1 = await db.user._insert({
-      logo: null
+      logos: [image],
     })
 
     let plugin = db.imagePluginFile
@@ -366,108 +584,32 @@ module.exports = function(monastery, opendb) {
     let express = require('express')
     let upload = require('express-fileupload')
     let app = express()
-    app.use(upload({ limits: { fileSize: 1 * 1000 * 1000, files: 10 }}))
+    app.use(upload())
 
-    app.post('/', function(req, res) {
+    // Reorder
+    app.post('/', async function(req, res) {
       try {
-        let options = { files: req.files, model: user, query: { _id: user1._id }}
-        plugin.removeImages(options, req.body, true)
-          .then(res => {
-            expect(res[0]).toEqual({})
-            expect(res[1]).toEqual([])
-          })
-          .finally(() => {
-            res.json()
-            db.close()
-            done()
-          })
-      } catch(e) {
-        console.log(e)
-        res.error(e)
+        req.body.logos = JSON.parse(req.body.logos)
+        let options = { files: req.files, model: user, query: { _id: user1._id } }
+        let response = await plugin.removeImages(options, req.body, true)
+        expect(response[0]).toEqual({ lion1: 1 })
+        expect(response[1]).toEqual([])
+        res.send()
+      } catch (e) {
+        console.log(e.message || e)
+        res.status(500).send()
       }
     })
-
-    // Start tests
-    supertest(app)
+    await supertest(app)
       .post('/')
-      .attach('logo', `${__dirname}/assets/logo.png`)
+      .field('logos', JSON.stringify([ null, image ]))
       .expect(200)
-      .end((err, res) => { if (err) console.log(err, res.text) })
-  })
-
-  test('images addImages formats & filesizes', async (done) => {
-    let db = (await opendb(null, {
-      timestamps: false,
-      serverSelectionTimeoutMS: 2000,
-      imagePlugin: {
-        awsBucket: 'fake',
-        awsAccessKeyId: 'fake',
-        awsSecretAccessKey: 'fake',
-        formats: ['jpg', 'jpeg', 'png', 'ico']
-      }
-    })).db
-
-    let user = db.model('user', { fields: {
-      imageIco:     { type: 'image' },
-      imageWebp:    { type: 'image', formats: ['webp'] },
-      imageSvgBad:  { type: 'image' },
-      imageSvgGood: { type: 'image', formats: ['svg'] },
-      imageSvgAny:  { type: 'image', formats: ['any'] },
-      imageSize1:   { type: 'image', fileSize: 1000 * 100 },
-      imageSize2:   { type: 'image' },
-    }})
-
-    let plugin = db.imagePluginFile
-    let supertest = require('supertest')
-    let express = require('express')
-    let upload = require('express-fileupload')
-    let app = express()
-    app.use(upload({ limits: { fileSize: 1000 * 200, files: 10 }}))
-
-    app.post('/', async (req, res) => {
-      let imageSvgBad = { imageSvgBad: req.files.imageSvgBad }
-      let imageSize1 = { imageSize1: req.files.imageSize1 }
-      let imageSize2 = { imageSize2: req.files.imageSize2 }
-      delete req.files.imageSvgBad
-      delete req.files.imageSize1
-      delete req.files.imageSize2
-      // Ico, Webp, and imageSvgGood will throw an error first if it's not a valid type
-      await expect(plugin._findValidImages(req.files, user)).resolves.toEqual(expect.any(Array))
-      await expect(plugin._findValidImages(imageSvgBad, user)).rejects.toEqual({
-        title: 'imageSvgBad',
-        detail: 'The file format \'svg\' for \'bad.svg\' is not supported'
-      })
-      await expect(plugin._findValidImages(imageSize1, user)).rejects.toEqual({
-        title: 'imageSize1',
-        detail: 'The file size for \'lion1.png\' is bigger than 0.1MB.'
-      })
-      await expect(plugin._findValidImages(imageSize2, user)).rejects.toEqual({
-        title: 'imageSize2',
-        detail: 'The file size for \'lion2.jpg\' is too big.'
-      })
-      res.json()
-    })
 
-    // Start tests
-    supertest(app)
-      .post('/')
-      .attach('imageIco', `${__dirname}/assets/image.ico`)
-      .attach('imageWebp', `${__dirname}/assets/image.webp`)
-      .attach('imageSvgBad', `${__dirname}/assets/bad.svg`)
-      .attach('imageSvgGood', `${__dirname}/assets/bad.svg`)
-      .attach('imageSvgAny', `${__dirname}/assets/bad.svg`)
-      .attach('imageSize1', `${__dirname}/assets/lion1.png`)
-      .attach('imageSize2', `${__dirname}/assets/lion2.jpg`)
-      .expect(200)
-      .end((err, res) => {
-        if (err) console.log(err)
-        db.close()
-        done()
-      })
+    db.close()
   })
 
-  test('images addImages bad file objects', async (done) => {
-    //// latest supertrace setup
+  test('images reorder and added image', async () => {
+    // latest (2022.02)
     let db = (await opendb(null, {
       timestamps: false,
       serverSelectionTimeoutMS: 2000,
@@ -475,79 +617,77 @@ module.exports = function(monastery, opendb) {
     })).db
 
     let user = db.model('user', { fields: {
-      logo: { type: 'image' },
       logos: [{ type: 'image' }],
-      users: [{ logo: { type: 'image' } }]
     }})
 
-    let imageObjectMock = {
-      bucket: 'temp',
+    let image = {
+      bucket: 'test',
       date: 1234,
-      filename: 'temp.png',
+      filename: 'lion1.png',
       filesize: 1234,
-      path: 'temp',
-      uid: 'temp'
+      path: 'test/lion1.png',
+      uid: 'lion1'
     }
-    let detailLongMock = 'Image fields need to either be null, undefined, file, or an object containing the '
-      + 'following fields \'{ bucket, date, filename, filesize, path, uid }\''
 
+    let user1 = await db.user._insert({
+      logos: [image],
+    })
+
+    let plugin = db.imagePluginFile
     let supertest = require('supertest')
     let express = require('express')
+    let upload = require('express-fileupload')
     let app = express()
-    let bodyParser = require('body-parser')
+    app.use(upload())
 
-    app.use(bodyParser.json())
-    app.use(bodyParser.urlencoded({ extended: true }))
     app.post('/', async function(req, res) {
       try {
-        let result = await db.user.validate(req.body)
+        req.body.logos = JSON.parse(req.body.logos)
+        let options = { files: req.files, model: user, query: { _id: user1._id } }
+
+        // Remove images
+        let response = await plugin.removeImages(options, req.body, true)
+        expect(response[0]).toEqual({ lion1: 1 }) // useCount
+        expect(response[1]).toEqual([]) // unused
+
+        // File exists
+        let validFiles = await plugin._findValidImages(req.files, user)
+        expect(((validFiles||[])[0]||{}).inputPath).toEqual('logos.0') // Valid inputPath
+
+        // Add images
+        response = await plugin.addImages(options, req.body, true)
+        expect(response[0]).toEqual({
+          logos: [{
+            bucket: 'fake',
+            date: expect.any(Number),
+            filename: 'lion2.jpg',
+            filesize: expect.any(Number),
+            path: expect.any(String),
+            uid: expect.any(String)
+          }, {
+            bucket: 'test', // still the same image-object reference (nothing new)
+            date: expect.any(Number),
+            filename: 'lion1.png',
+            filesize: expect.any(Number),
+            path: expect.any(String),
+            uid: expect.any(String)
+          },],
+        })
+
         res.send()
-      } catch (err) {
-        res.status(500).send(err)
+      } catch (e) {
+        console.log(e.message || e)
+        res.status(500).send()
       }
     })
 
-    // Start tests
-    supertest(app)
+    await supertest(app)
       .post('/')
-      .send({
-        logo: null,//ok
-        logos: [undefined, imageObjectMock, {}],//0,1=ok
-        users: [
-          { logo: {} },
-          { logo: { bucket: "" }},
-          { logo: imageObjectMock },//ok
-          { logo: null },//ok
-        ]
-      })
-      .expect(500)
-      .then(res => {
-        // console.log(res.body)
-        expect(res.body).toEqual([
-          {
-            detail: 'Invalid image value',
-            meta: { rule: 'isImageObject', model: 'user', field: '2', detailLong: detailLongMock },
-            status: '400',
-            title: 'logos.2'
-          }, {
-            detail: 'Invalid image value',
-            meta: { rule: 'isImageObject', model: 'user', field: 'logo', detailLong: detailLongMock },
-            status: '400',
-            title: 'users.0.logo'
-          }, {
-            detail: 'Invalid image value',
-            meta: { rule: 'isImageObject', model: 'user', field: 'logo', detailLong: detailLongMock },
-            status: '400',
-            title: 'users.1.logo'
-          }
-        ])
-        db.close()
-        done()
-      })
-      .catch(err => {
-        db.close()
-        done(err)
-      })
+      .field('logos', JSON.stringify([ null, image ]))
+      .attach('logos.0', `${__dirname}/assets/lion2.jpg`)
+      .expect(200)
+
+    db.close()
   })
 
 }