monastery 1.28.3 → 1.30.0

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,121 @@ 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 })).rejects.toContainEqual({
+    // 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',
       detail: 'This field is required.',
@@ -214,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)
   })
@@ -233,7 +277,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 +361,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 +458,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 +476,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 +524,7 @@ module.exports = function(monastery, opendb) {
         name: { type: 'string', bigName: 8 },
         animals: [{
           name: { type: 'string', bigName: 8 }
-        }]
+        }],
       },
       rules: {
         bigName: function(value, ruleArg) {
@@ -483,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' })
@@ -494,13 +558,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({  }, { 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 () => {
@@ -524,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' })
@@ -548,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' } })
 
@@ -588,11 +697,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 +726,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 +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 = {
@@ -686,14 +799,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 +823,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 +840,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 +905,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 +925,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 +958,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 +975,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()
   })
 
 }