monastery 1.28.2 → 1.29.0

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)',
@@ -475,7 +481,7 @@ module.exports = function(monastery, opendb) {
         name: { type: 'string', bigName: 8 },
         animals: [{
           name: { type: 'string', bigName: 8 }
-        }]
+        }],
       },
       rules: {
         bigName: function(value, ruleArg) {
@@ -483,6 +489,21 @@ module.exports = function(monastery, opendb) {
         }
       }
     })
+    let user2 = db.model('user2', {
+      fields: {
+        name: { type: 'string' },
+        nickname: { type: 'string', requiredIfNoName: true },
+        age: { type: 'number', required: true },
+      },
+      rules: {
+        requiredIfNoName: {
+          ignoreUndefined: false,
+          fn: function(value, ruleArg) {
+            return value || this.name
+          }
+        }
+      }
+    })
 
     // Basic field
     await expect(user.validate({ name: 'benjamin' })).resolves.toEqual({ name: 'benjamin' })
@@ -494,13 +515,48 @@ 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',
       detail: 'Invalid data property for rule "bigName".',
       meta: { rule: 'bigName', model: 'user', field: 'name' }
     })
+
+    // Required rule based off another field (create)
+    await expect(user2.validate({ name: 'benjamin', age: 12 })).resolves.toEqual({
+      name: 'benjamin',
+      age: 12
+    })
+    await expect(user2.validate({ nickname: 'benny', age: 12 })).resolves.toEqual({
+      nickname: 'benny',
+      age: 12
+    })
+    await expect(user2.validate({ })).rejects.toEqual([
+      {
+        'detail': 'Invalid data property for rule "requiredIfNoName".',
+        'meta': { 'field': 'nickname', 'model': 'user2', 'rule': 'requiredIfNoName'},
+        'status': '400',
+        'title': 'nickname'
+      }, {
+        'detail': 'This field is required.',
+        'meta': { 'field': 'age', 'model': 'user2', 'rule': 'required'},
+        'status': '400',
+        'title': 'age'
+      }
+    ])
+    await expect(user2.validate({  }, { ignoreUndefined: true })).resolves.toEqual({})
+
+    // Required rule based off another field (update)
+    await expect(user2.validate({ }, { update: true })).resolves.toEqual({})
+    await expect(user2.validate({ nickname: '' }, { update: true })).rejects.toEqual([{
+      'detail': 'Invalid data property for rule "requiredIfNoName".',
+      'meta': { 'field': 'nickname', 'model': 'user2', 'rule': 'requiredIfNoName'},
+      'status': '400',
+      'title': 'nickname'
+    }])
   })
 
   test('Validated data', async () => {
@@ -524,8 +580,13 @@ module.exports = function(monastery, opendb) {
     // Ignores invalid data
     await expect(user.validate({ badprop: true, schema: {} })).resolves.toEqual({})
 
-    // Allows null data
-    await expect(user.validate({ name: null })).resolves.toEqual({ name: null })
+    // Rejects null for non object/array fields
+    await expect(user.validate({ name: null })).rejects.toEqual([{
+      'detail': 'Value was not a string.',
+      'meta': {'detailLong': undefined, 'field': 'name', 'model': 'user', 'rule': 'isString'},
+      'status':'400',
+      'title': 'name'
+    }])
 
     // String data
     await expect(user.validate({ name: 'Martin Luther' })).resolves.toEqual({ name: 'Martin Luther' })
@@ -548,9 +609,14 @@ module.exports = function(monastery, opendb) {
 
     // Subdocument property data (null)
     await expect(user.validate({ animals: { dog: null }}))
-      .resolves.toEqual({ animals: { dog: null }})
-
-    // Subdocument property data (bad data)
+      .rejects.toEqual([{
+        'detail': 'Value was not a string.',
+        'meta': {'detailLong': undefined, 'field': 'dog', 'model': 'user', 'rule': 'isString'},
+        'status': '400',
+        'title': 'animals.dog',
+      }])
+
+    // Subdocument property data (unknown data)
     await expect(user.validate({ animals: { dog: 'sparky', cat: 'grumpy' } }))
       .resolves.toEqual({ animals: { dog: 'sparky' } })
 
@@ -588,11 +654,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 +683,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({
@@ -661,7 +726,12 @@ module.exports = function(monastery, opendb) {
     await expect(user2.validate({ amount: 0 })).resolves.toEqual({ amount: 0 }) // required
     await expect(user.validate({ amount: '0' })).resolves.toEqual({ amount: 0 }) // required
     await expect(user.validate({ amount: undefined })).resolves.toEqual({})  // not required
-    await expect(user.validate({ amount: null })).resolves.toEqual({ amount: null }) // not required
+    await expect(user.validate({ amount: null })).rejects.toEqual([{ // type error
+      'detail': 'Value was not a number.',
+      'meta': { 'field': 'amount', 'model': 'user', 'rule': 'isNumber'},
+      'status': '400',
+      'title': 'amount'
+    }])
 
     // Number required
     let mock1 = {
@@ -686,14 +756,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 +780,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,
@@ -728,10 +797,15 @@ module.exports = function(monastery, opendb) {
     }})
 
     // Subdocument data (null/string)
+    await expect(user.validate({ animals: 'notAnObject' })).rejects.toEqual([{
+      'detail': 'Value was not an object.',
+      'meta': {'detailLong': undefined, 'field': 'animals', 'model': 'user', 'rule': 'isObject'},
+      'status': '400',
+      'title': 'animals'
+    }])
     await expect(user.validate({ animals: '', names: null })).resolves.toEqual({ animals: null, names: null })
 
     db.close()
-    done()
   })
 
   test('Validation options', async () => {
@@ -788,13 +862,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 +882,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 +915,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 +932,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()
   })
 
 }