monastery 1.28.1 → 1.28.5

package/test/populate.js

@@ -1,6 +1,6 @@
 module.exports = function(monastery, opendb) {
 
-  test('Model populate', async (done) => {
+  test('Model populate', async () => {
     // Setup
     let db = (await opendb(null)).db
     let bird = db.model('bird', { fields: {
@@ -30,7 +30,7 @@ module.exports = function(monastery, opendb) {
       name: 'Martin Luther',
       myBird: {
         _id: bird1._id,
-        name: "ponyo"
+        name: 'ponyo'
       },
       pets: {
         myBird: bird1._id
@@ -46,7 +46,7 @@ module.exports = function(monastery, opendb) {
       pets: {
         myBird: {
           _id: bird1._id,
-          name: "ponyo"
+          name: 'ponyo'
         },
       }
     })
@@ -62,7 +62,7 @@ module.exports = function(monastery, opendb) {
       name: 'Martin Luther',
       myBird: {
         _id: bird1._id,
-        name: "ponyo"
+        name: 'ponyo'
       },
       pets: {
         myBird: bird1._id
@@ -72,7 +72,7 @@ module.exports = function(monastery, opendb) {
       name: 'Martin Luther2',
       myBird: {
         _id: bird1._id,
-        name: "ponyo"
+        name: 'ponyo'
       },
       pets: {
         myBird: bird1._id
@@ -80,10 +80,9 @@ module.exports = function(monastery, opendb) {
     }])
 
     db.close()
-    done()
   })
 
-  test('Model populate type=any', async (done) => {
+  test('Model populate type=any', async () => {
     let db = (await opendb(null)).db
     db.model('company', { fields: {
       address: { type: 'any' }
@@ -131,10 +130,9 @@ module.exports = function(monastery, opendb) {
     })
 
     db.close()
-    done()
   })
 
-  test('Model populate/blacklisting via $lookup', async (done) => {
+  test('Model populate/blacklisting via $lookup', async () => {
     // Setup
     let db = (await opendb(null)).db
     let user = db.model('user', {
@@ -167,10 +165,10 @@ module.exports = function(monastery, opendb) {
     let find1 = await user.findOne({
       query: user1._id,
       populate: [{
-        "as": "birds",
-        "from": "bird",
-        "let": { id: "$_id" },
-        "pipeline": [
+        'as': 'birds',
+        'from': 'bird',
+        'let': { id: '$_id' },
+        'pipeline': [
           { $match: { $expr: { $eq: ['$owner', '$$id'] }}}
         ]
       }]
@@ -193,10 +191,10 @@ module.exports = function(monastery, opendb) {
     let find2 = await user.findOne({
       query: user1._id,
       populate: [{
-        "as": "anyModel",
-        "from": "bird",
-        "let": { id: "$_id" },
-        "pipeline": [
+        'as': 'anyModel',
+        'from': 'bird',
+        'let': { id: '$_id' },
+        'pipeline': [
           { $match: { $expr: { $eq: ['$owner', '$$id'] }}}
         ]
       }]
@@ -217,7 +215,6 @@ module.exports = function(monastery, opendb) {
     })
 
     db.close()
-    done()
   })
 
 }

package/test/util.js

@@ -10,10 +10,10 @@ module.exports = function(monastery, opendb) {
       'deep[companyLogos][0]': 'b',
       'deep[companyLogos2][0][logo]':'c',
       'deep[companyLogos2][1][logo]': '',
-      "users[0][first]": "Martin",
-      "users[0][last]": "Luther",
-      "users[1][first]": "Bruce",
-      "users[1][last]": "Lee",
+      'users[0][first]': 'Martin',
+      'users[0][last]': 'Luther',
+      'users[1][first]': 'Bruce',
+      'users[1][last]': 'Lee',
     })).toEqual({
       name: 'Martin',
       pets: expect.any(Array),
@@ -23,12 +23,12 @@ module.exports = function(monastery, opendb) {
         companyLogos2: [{ logo: 'c' }, { logo: '' }]
       },
       users: [
-        { "first": "Martin", "last": "Luther" },
-        { "first": "Bruce", "last": "Lee" },
+        { 'first': 'Martin', 'last': 'Luther' },
+        { 'first': 'Bruce', 'last': 'Lee' },
       ]
     })
-    expect(util.parseFormData({ "users[]['name']": 'Martin' })).rejects
-      .toEqual(`Array items in bracket notation need array indexes "users[]['name']", e.g. users[0][name]`)
+    expect(util.parseFormData({ 'users[][\'name\']': 'Martin' })).rejects
+      .toEqual('Array items in bracket notation need array indexes "users[][\'name\']", e.g. users[0][name]')
   })
 
   test('Utilities: isId', async () => {

package/test/validate.js

@@ -157,7 +157,8 @@ module.exports = function(monastery, opendb) {
     })
 
     // Required subdocument property (defined with ignoreUndefined)
-    await expect(user.validate({ animals: { cat: '' }}, { update: true, ignoreUndefined: true })).rejects.toContainEqual({
+    await expect(user.validate({ animals: { cat: '' }}, { update: true, ignoreUndefined: true }))
+    .rejects.toContainEqual({
       status: '400',
       title: 'animals.cat',
       detail: 'This field is required.',
@@ -233,7 +234,6 @@ module.exports = function(monastery, opendb) {
     let fn = validate._getMostSpecificKeyMatchingPath
     let mock = {
       'cats.name': true,
-      'cats.name': true,
 
       'dogs.name': true,
       'dogs.$.name': true,
@@ -318,7 +318,7 @@ module.exports = function(monastery, opendb) {
     // Setup
     // Todo: Setup testing for array array subdocument field messages
     let db = (await opendb(false)).db
-    let arrayWithSchema = (array, schema) => { array.schema = schema; return array }
+    // let arrayWithSchema = (array, schema) => { array.schema = schema; return array }
     let user = db.model('user', {
       fields: {
         name: { type: 'string', minLength: 4 },
@@ -415,14 +415,16 @@ module.exports = function(monastery, opendb) {
       meta: { rule: 'minLength', model: 'user', field: 'name' }
     })
     // array-subdocument-1-field error
-    await expect(user.validate({ catNames: [{ name: 'carla' }, { name: 'ben' }] })).rejects.toContainEqual({
+    await expect(user.validate({ catNames: [{ name: 'carla' }, { name: 'ben' }] }))
+    .rejects.toContainEqual({
       status: '400',
       title: 'catNames.1.name',
       detail: 'min length error (1)',
       meta: { rule: 'minLength', model: 'user', field: 'name' }
     })
     // array-subdocument-2-field error
-    await expect(user.validate({ catNames: [{ name: 'carla' }, { name: 'carla' }, { name: 'ben' }] })).rejects.toContainEqual({
+    await expect(user.validate({ catNames: [{ name: 'carla' }, { name: 'carla' }, { name: 'ben' }] }))
+    .rejects.toContainEqual({
       status: '400',
       title: 'catNames.2.name',
       detail: 'min length error (2)',
@@ -431,28 +433,32 @@ module.exports = function(monastery, opendb) {
 
 
     // array-subdocument-field error (loose $ match)
-    await expect(user.validate({ pigNames: [[{ name: 'ben' }]] })).rejects.toContainEqual({
+    await expect(user.validate({ pigNames: [[{ name: 'ben' }]] }))
+    .rejects.toContainEqual({
       status: '400',
       title: 'pigNames.0.0.name',
       detail: 'min length error ($)',
       meta: { rule: 'minLength', model: 'user', field: 'name' }
     })
     // array-subdocument-1-field error
-    await expect(user.validate({ pigNames: [[{ name: 'carla' }, { name: 'ben' }]] })).rejects.toContainEqual({
+    await expect(user.validate({ pigNames: [[{ name: 'carla' }, { name: 'ben' }]] }))
+    .rejects.toContainEqual({
       status: '400',
       title: 'pigNames.0.1.name',
       detail: 'min length error (1)',
       meta: { rule: 'minLength', model: 'user', field: 'name' }
     })
     // array-subdocument-0-2-field error
-    await expect(user.validate({ pigNames: [[{ name: 'carla' }, { name: 'carla' }, { name: 'ben' }]] })).rejects.toContainEqual({
+    await expect(user.validate({ pigNames: [[{ name: 'carla' }, { name: 'carla' }, { name: 'ben' }]] }))
+    .rejects.toContainEqual({
       status: '400',
       title: 'pigNames.0.2.name',
       detail: 'min length error (deep 0 2)',
       meta: { rule: 'minLength', model: 'user', field: 'name' }
     })
     // array-subdocument-2-0-field error (fallback)
-    await expect(user.validate({ pigNames: [[],[],[{ name: 'carla' },{ name: 'carla' },{ name: 'ben' }]] })).rejects.toContainEqual({
+    await expect(user.validate({ pigNames: [[],[],[{ name: 'carla' },{ name: 'carla' },{ name: 'ben' }]] }))
+    .rejects.toContainEqual({
       status: '400',
       title: 'pigNames.2.2.name',
       detail: 'min length error (deep $ 2)',
@@ -494,7 +500,9 @@ module.exports = function(monastery, opendb) {
     })
 
     // subdocument in an array
-    await expect(user.validate({ animals: [{ name: 'benjamin' }] })).resolves.toEqual({ animals: [{ name: 'benjamin' }] })
+    await expect(user.validate({ animals: [{ name: 'benjamin' }] })).resolves.toEqual({
+      animals: [{ name: 'benjamin' }]
+    })
     await expect(user.validate({ animals: [{ name: 'ben' }] })).rejects.toContainEqual({
       status: '400',
       title: 'animals.0.name',
@@ -588,11 +596,11 @@ module.exports = function(monastery, opendb) {
 
     // Index, mongodb connection error
     await expect(user3._setupIndexes({ name: { type: 'string', index: 'text' }})).rejects
-      .toEqual({ type: "info", detail: "Skipping createIndex on the 'user3' model, no mongodb connection found." })
+      .toEqual({ type: 'info', detail: 'Skipping createIndex on the \'user3\' model, no mongodb connection found.' })
 
     // Model id (Monk ObjectId)
-    let data = await user4.validate({ name: "5d4356299d0f010017602f6b" })
-    await expect(data.name.toString()).toEqual(db.id("5d4356299d0f010017602f6b").toString())
+    let data = await user4.validate({ name: '5d4356299d0f010017602f6b' })
+    await expect(data.name.toString()).toEqual(db.id('5d4356299d0f010017602f6b').toString())
     await expect(data.name).toEqual(expect.any(Object))
 
     // Bad model id (Monk ObjectId)
@@ -617,7 +625,6 @@ module.exports = function(monastery, opendb) {
       amount: { type: 'number', required: true },
     }})
 
-
     // MinLength
     await expect(user.validate({ name: 'Martin Luther' })).resolves.toEqual({name: 'Martin Luther'})
     await expect(user.validate({ name: 'Carl' })).rejects.toContainEqual({
@@ -686,14 +693,14 @@ module.exports = function(monastery, opendb) {
     await expect(user.validate({ amount: 'bad' })).rejects.toContainEqual(mock2)
   })
 
-  test('Schema default objects', async (done) => {
+  test('Schema default objects', async () => {
     let db = (await opendb(null, {
       timestamps: false,
       defaultObjects: true,
       serverSelectionTimeoutMS: 2000
     })).db
 
-    let base = { names: [], animals: { dogs: [] }}
+    // let base = { names: [], animals: { dogs: [] }}
     let user = db.model('user', { fields: {
       name: { type: 'string' },
       names: [{ type: 'string' }],
@@ -710,10 +717,9 @@ module.exports = function(monastery, opendb) {
     })
 
     db.close()
-    done()
   })
 
-  test('Schema nullObjects', async (done) => {
+  test('Schema nullObjects', async () => {
     let db = (await opendb(null, {
       timestamps: false,
       nullObjects: true,
@@ -731,7 +737,6 @@ module.exports = function(monastery, opendb) {
     await expect(user.validate({ animals: '', names: null })).resolves.toEqual({ animals: null, names: null })
 
     db.close()
-    done()
   })
 
   test('Validation options', async () => {
@@ -788,13 +793,13 @@ module.exports = function(monastery, opendb) {
       { people2: [{ people3: [{}, {}] }] },
       { skipValidation: ['people2.$.people3.0.name'] }
     )).rejects.toContainEqual({
-      detail: "This field is required.",
-      status: "400",
-      title: "people2.0.people3.1.name",
+      detail: 'This field is required.',
+      status: '400',
+      title: 'people2.0.people3.1.name',
       meta: {
-        field: "name",
-        model: "user3",
-        rule: "required"
+        field: 'name',
+        model: 'user3',
+        rule: 'required'
       }
     })
 
@@ -808,18 +813,18 @@ module.exports = function(monastery, opendb) {
 
     // Non existing validation field entries
     await expect(user3.validate({ people: [{}] }, { skipValidation: ['people.badField'] })).rejects.toContainEqual({
-      detail: "This field is required.",
-      status: "400",
-      title: "people.0.name",
+      detail: 'This field is required.',
+      status: '400',
+      title: 'people.0.name',
       meta: {
-        model: "user3",
-        field: "name",
-        rule: "required"
+        model: 'user3',
+        field: 'name',
+        rule: 'required'
       }
     })
   })
 
-  test('Validation hooks', async (done) => {
+  test('Validation hooks', async () => {
     let db = (await opendb(null)).db
     let user = db.model('user', {
       fields: {
@@ -841,16 +846,16 @@ module.exports = function(monastery, opendb) {
     let userDoc = await user.insert({ data: { first: 'Martin', last: 'Luther' }})
 
     // Catch validate (a)synchronous errors thrown in function or through `next(err)`
-    await expect(user.validate({ first: '' })).rejects.toThrow(`beforeValidate error 1..`)
-    await expect(user.validate({ first: 'Martin' })).rejects.toThrow(`beforeValidate error 2..`)
+    await expect(user.validate({ first: '' })).rejects.toThrow('beforeValidate error 1..')
+    await expect(user.validate({ first: 'Martin' })).rejects.toThrow('beforeValidate error 2..')
     await expect(user.validate({ first: 'Martin', last: 'Luther' })).resolves.toEqual({
       first: 'Martin',
       last: 'Luther'
     })
 
     // Catch insert (a)synchronous errors thrown in function or through `next(err)`
-    await expect(user.insert({ data: { first: '' } })).rejects.toThrow(`beforeValidate error 1..`)
-    await expect(user.insert({ data: { first: 'Martin' } })).rejects.toThrow(`beforeValidate error 2..`)
+    await expect(user.insert({ data: { first: '' } })).rejects.toThrow('beforeValidate error 1..')
+    await expect(user.insert({ data: { first: 'Martin' } })).rejects.toThrow('beforeValidate error 2..')
     await expect(user.insert({ data: { first: 'Martin', last: 'Luther' } })).resolves.toEqual({
       _id: expect.any(Object),
       first: 'Martin',
@@ -858,15 +863,17 @@ module.exports = function(monastery, opendb) {
     })
 
     // Catch update (a)synchronous errors thrown in function or through `next(err)`
-    await expect(user.update({ query: userDoc._id, data: { first: '' } })).rejects.toThrow(`beforeValidate error 1..`)
-    await expect(user.update({ query: userDoc._id, data: { first: 'Martin' } })).rejects.toThrow(`beforeValidate error 2..`)
-    await expect(user.update({ query: userDoc._id, data: { first: 'Martin', last: 'Luther' } })).resolves.toEqual({
-      first: 'Martin',
-      last: 'Luther'
-    })
+    await expect(user.update({ query: userDoc._id, data: { first: '' } }))
+      .rejects.toThrow('beforeValidate error 1..')
+    await expect(user.update({ query: userDoc._id, data: { first: 'Martin' } }))
+      .rejects.toThrow('beforeValidate error 2..')
+    await expect(user.update({ query: userDoc._id, data: { first: 'Martin', last: 'Luther' } }))
+      .resolves.toEqual({
+        first: 'Martin',
+        last: 'Luther'
+      })
 
     db.close()
-    done()
   })
 
 }

package/test/virtuals.js

@@ -1,6 +1,6 @@
 module.exports = function(monastery, opendb) {
 
-  test('Virtuals', async (done) => {
+  test('Virtuals', async () => {
     // Setup
     let db = (await opendb(null)).db
     // Test model setup
@@ -145,10 +145,9 @@ module.exports = function(monastery, opendb) {
     })
 
     db.close()
-    done()
   })
 
-  test('Insert/update virtuals (validate)', async (done) => {
+  test('Insert/update virtuals (validate)', async () => {
     // Setup
     let db = (await opendb(null)).db
     let user = db.model('user', {
@@ -246,7 +245,6 @@ module.exports = function(monastery, opendb) {
       }
     })
     db.close()
-    done()
   })
 
 }