monastery 1.28.5 → 1.30.2

package/test/validate.js

@@ -19,7 +19,7 @@ module.exports = function(monastery, opendb) {
       detail: 'This field is required.',
       meta: { rule: 'required', model: 'user', field: 'name' }
     })
-    await expect(user.validate({ name : '' }, { ignoreUndefined: true })).rejects.toContainEqual({
+    await expect(user.validate({ name : '' }, { validateUndefined: false })).rejects.toContainEqual({
       status: '400',
       title: 'name',
       detail: 'This field is required.',
@@ -27,8 +27,8 @@ module.exports = function(monastery, opendb) {
     })
 
     // Required error (insert, and with ignoreRequired)
-    await expect(user.validate({}, { ignoreUndefined: true })).resolves.toEqual({})
-    await expect(user.validate({}, { ignoreUndefined: true, update: true })).resolves.toEqual({})
+    await expect(user.validate({}, { validateUndefined: false })).resolves.toEqual({})
+    await expect(user.validate({}, { validateUndefined: false, update: true })).resolves.toEqual({})
 
     // No required error (update)
     await expect(user.validate({}, { update: true })).resolves.toEqual({})
@@ -87,77 +87,120 @@ module.exports = function(monastery, opendb) {
     let db = (await opendb(false)).db
     let user = db.model('user', { fields: {
       animals: {
-        cat: { type: 'string', required: true },
+        cat: { type: 'string', required: true }, // {} = required on insert
         dog: {
           name:  { type: 'string' },
-          color: { type: 'string', required: true }
+          color: { type: 'string', required: true } // {} = required on insert
         }
       }
     }})
 
-    // Invalid subdocument type
-    await expect(user.validate({ animals: { dog: 1 }})).rejects.toContainEqual({
-      status: '400',
-      title: 'animals.dog',
-      detail: 'Value was not an object.',
-      meta: { rule: 'isObject', model: 'user', field: 'dog' }
-    })
+    // Insert: Required subdocument properties
+    await expect(user.validate({})).rejects.toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          status: '400',
+          title: 'animals.cat',
+          detail: 'This field is required.',
+          meta: { rule: 'required', model: 'user', field: 'cat' }
+        }),
+        expect.objectContaining({
+          status: '400',
+          title: 'animals.dog.color',
+          detail: 'This field is required.',
+          meta: { rule: 'required', model: 'user', field: 'color' }
+        }),
+      ])
+    )
 
-    // Required subdocument property (required on insert)
-    await expect(user.validate({})).rejects.toContainEqual({
-      status: '400',
-      title: 'animals.cat',
-      detail: 'This field is required.',
-      meta: { rule: 'required', model: 'user', field: 'cat' }
-    })
+    // Insert: Required subdocument properties
+    await expect(user.validate({ animals: {} })).rejects.toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          status: '400',
+          title: 'animals.cat',
+          detail: 'This field is required.',
+          meta: { rule: 'required', model: 'user', field: 'cat' }
+        }),
+        expect.objectContaining({
+          status: '400',
+          title: 'animals.dog.color',
+          detail: 'This field is required.',
+          meta: { rule: 'required', model: 'user', field: 'color' }
+        }),
+      ])
+    )
 
-    // Required subdocument property (required on insert)
-    await expect(user.validate({})).rejects.toContainEqual({
-      status: '400',
-      title: 'animals.dog.color',
-      detail: 'This field is required.',
-      meta: { rule: 'required', model: 'user', field: 'color' }
-    })
+    // Insert: Invalid subdocument type
+    await expect(user.validate({ animals: { dog: 1 }})).rejects.toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          status: '400',
+          title: 'animals.cat',
+          detail: 'This field is required.',
+          meta: { rule: 'required', model: 'user', field: 'cat' }
+        }),
+        expect.objectContaining({
+          status: '400',
+          title: 'animals.dog',
+          detail: 'Value was not an object.',
+          meta: { rule: 'isObject', model: 'user', field: 'dog' }
+        }),
+      ])
+    )
 
-    // Required subdocument property (required on update when a parent is specified)
-    await expect(user.validate({ animals: {} }, { update: true })).rejects.toContainEqual({
-      status: '400',
-      title: 'animals.cat',
-      detail: 'This field is required.',
-      meta: { rule: 'required', model: 'user', field: 'cat' }
+    // Insert: Ignore required subdocument property with a defined parent
+    await expect(user.validate({ animals: {} }, { validateUndefined: false })).resolves.toEqual({
+      animals: {}
     })
 
-    // Required subdocument property (required on update when a parent is specified)
-    await expect(user.validate({ animals: { dog: {}} }, { update: true })).rejects.toContainEqual({
-      status: '400',
-      title: 'animals.dog.color',
-      detail: 'This field is required.',
-      meta: { rule: 'required', model: 'user', field: 'color' }
-    })
+    // Update: Required subdocument property when a parent/grandparent is specified
+    await expect(user.validate({ animals: {} }, { update: true })).rejects.toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          status: '400',
+          title: 'animals.cat',
+          detail: 'This field is required.',
+          meta: { rule: 'required', model: 'user', field: 'cat' }
+        }),
+        expect.objectContaining({
+          status: '400',
+          title: 'animals.dog.color',
+          detail: 'This field is required.',
+          meta: { rule: 'required', model: 'user', field: 'color' }
+        }),
+      ])
+    )
 
-    // Required subdocument property (required on update when a grand-parent is specified)
-    await expect(user.validate({ animals: {} }, { update: true })).rejects.toContainEqual({
-      status: '400',
-      title: 'animals.dog.color',
-      detail: 'This field is required.',
-      meta: { rule: 'required', model: 'user', field: 'color' }
-    })
+    // Update: Required subdocument property when a parent is specified
+    await expect(user.validate({ animals: { dog: {}} }, { update: true })).rejects.toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          status: '400',
+          title: 'animals.cat',
+          detail: 'This field is required.',
+          meta: { rule: 'required', model: 'user', field: 'cat' }
+        }),
+        expect.objectContaining({
+          status: '400',
+          title: 'animals.dog.color',
+          detail: 'This field is required.',
+          meta: { rule: 'required', model: 'user', field: 'color' }
+        }),
+      ])
+    )
 
-    // Ignore required subdocument property (not required on update)
+    // Update: Ignore required subdocument property when root parent is undefined
     await expect(user.validate({}, { update: true })).resolves.toEqual({})
 
-    // Ignore required subdocument property with a defined parent (update) (not required if ignoreUndefined set)
-    await expect(user.validate({ animals: {} }, { ignoreUndefined: true })).resolves.toEqual({
-      animals: {}
-    })
 
-    // Ignore required subdocument property with a defined parent (not required if ignoreUndefined set)
-    await expect(user.validate({ animals: {} }, { update: true, ignoreUndefined: true })).resolves.toEqual({
+    // Update: Ignore required subdocument property with a defined parent when validateUndefined = false
+    await expect(user.validate({ animals: {} }, { update: true, validateUndefined: false })).resolves.toEqual({
       animals: {}
     })
 
-    // Required subdocument property (defined with ignoreUndefined)
-    await expect(user.validate({ animals: { cat: '' }}, { update: true, ignoreUndefined: true }))
+    // Update: Required defined subdocument property when validateUndefined = false
+    await expect(user.validate({ animals: { cat: '' }}, { update: true, validateUndefined: false }))
     .rejects.toContainEqual({
       status: '400',
       title: 'animals.cat',
@@ -215,17 +258,17 @@ module.exports = function(monastery, opendb) {
     await expect(user.validate({ animals: { dogs: [] }}))
       .resolves.toEqual({ animals: { dogs: [] }})
 
-    // No undefined item errors with ignoreUndefined
+    // No undefined item errors with validateUndefined=false
     await expect(user.validate(
       { animals: { dogs: [{ name: 'sparky' }] }},
-      { update: true, ignoreUndefined: true }
+      { update: true, validateUndefined: false }
     ))
       .resolves.toEqual({ animals: { dogs: [{ name: 'sparky' }] }})
 
-    // Requried error within an array subdocument (even during update when parent defined && ignoreUndefined = true)
+    // Requried error within an array subdocument (even during update when parent defined && validateUndefined = false)
     await expect(user.validate(
       { animals: { dogs: [{ name: 'sparky', color: '' }] }},
-      { update: true, ignoreUndefined: true }
+      { update: true, validateUndefined: false }
     ))
       .rejects.toContainEqual(error)
   })
@@ -481,7 +524,7 @@ module.exports = function(monastery, opendb) {
         name: { type: 'string', bigName: 8 },
         animals: [{
           name: { type: 'string', bigName: 8 }
-        }]
+        }],
       },
       rules: {
         bigName: function(value, ruleArg) {
@@ -489,6 +532,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: {
+          validateUndefined: true,
+          fn: function(value, ruleArg) {
+            return value || this.name
+          }
+        }
+      }
+    })
 
     // Basic field
     await expect(user.validate({ name: 'benjamin' })).resolves.toEqual({ name: 'benjamin' })
@@ -509,6 +567,39 @@ module.exports = function(monastery, opendb) {
       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({  }, { validateUndefined: false })).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 () => {
@@ -532,8 +623,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' })
@@ -556,9 +652,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' } })
 
@@ -668,7 +769,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 = {
@@ -734,6 +840,12 @@ 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()