monastery 1.28.4 → 1.30.1

package/test/blacklisting.js

@@ -1,6 +1,6 @@
 module.exports = function(monastery, opendb) {
 
-  test('Find blacklisting', async (done) => {
+  test('Find blacklisting', async () => {
     // Setup
     let db = (await opendb(null)).db
     let bird = db.model('bird', {
@@ -150,10 +150,9 @@ module.exports = function(monastery, opendb) {
     })
 
     db.close()
-    done()
   })
 
-  test('Find blacklisting (default fields)', async (done) => {
+  test('Find blacklisting (default fields)', async () => {
     // Setup
     let db = (await opendb(null)).db
     let user = db.model('user', {
@@ -222,10 +221,9 @@ module.exports = function(monastery, opendb) {
     })
 
     db.close()
-    done()
   })
 
-  test('Find blacklisting (populate)', async (done) => {
+  test('Find blacklisting (populate)', async () => {
     // Setup
     let db = (await opendb(null)).db
     let bird = db.model('bird', {
@@ -305,10 +303,9 @@ module.exports = function(monastery, opendb) {
     })
 
     db.close()
-    done()
   })
 
-  test('Insert/update blacklisting (validate)', async (done) => {
+  test('Insert/update blacklisting (validate)', async () => {
     // Setup
     let db = (await opendb(null)).db
     let user = db.model('user', {
@@ -406,7 +403,6 @@ module.exports = function(monastery, opendb) {
       }
     })
     db.close()
-    done()
   })
 
 }

package/test/crud.js

@@ -1,8 +1,8 @@
-let util = require('../lib/util')
+// let util = require('../lib/util')
 
 module.exports = function(monastery, opendb) {
 
-  test('Basic operator calls', async (done) => {
+  test('Basic operator calls', async () => {
     let db = (await opendb(null)).db
     let user = db.model('user', {
       fields: { name: { type: 'string' }},
@@ -53,13 +53,14 @@ module.exports = function(monastery, opendb) {
     expect(find6).toEqual({ _id: inserted2[0]._id, name: 'Martin Luther1' })
 
     // Missing parameters
-    await expect(user.find()).rejects.toThrow(`Please pass an object or MongoId to options.query`)
-    await expect(user.find(undefined)).rejects.toThrow(`Please pass an object or MongoId to options.query`)
-    await expect(user.find({})).rejects.toThrow(`Please pass an object or MongoId to options.query`)
-    await expect(user.find({ query: null })).rejects.toThrow(`Please pass an object or MongoId to options.query`)
-    await expect(user.find({ query: undefined })).rejects.toThrow(`Please pass an object or MongoId to options.query`)
-    await expect(user.find({ query: { _id: undefined }})).rejects.toThrow(`Please pass an object or MongoId to options.query`)
-    await expect(user.find(1)).rejects.toThrow(`Please pass an object or MongoId to options.query`)
+    await expect(user.find()).rejects.toThrow('Please pass an object or MongoId to options.query')
+    await expect(user.find(undefined)).rejects.toThrow('Please pass an object or MongoId to options.query')
+    await expect(user.find({})).rejects.toThrow('Please pass an object or MongoId to options.query')
+    await expect(user.find({ query: null })).rejects.toThrow('Please pass an object or MongoId to options.query')
+    await expect(user.find({ query: undefined })).rejects.toThrow('Please pass an object or MongoId to options.query')
+    await expect(user.find({ query: { _id: undefined }}))
+      .rejects.toThrow('Please pass an object or MongoId to options.query')
+    await expect(user.find(1)).rejects.toThrow('Please pass an object or MongoId to options.query')
 
     // Bad MongoID
     await expect(user.find({ query: '' })).resolves.toEqual(null)
@@ -89,10 +90,10 @@ module.exports = function(monastery, opendb) {
 
     // Update (no/empty data object)
     await expect(user.update({ query: inserted._id, data: {}}))
-      .rejects.toThrow(`No valid data passed to user.update()`)
+      .rejects.toThrow('No valid data passed to user.update()')
 
     await expect(user.update({ query: inserted._id }))
-      .rejects.toThrow(`No valid data passed to user.update()`)
+      .rejects.toThrow('No valid data passed to user.update()')
 
     // Update (no/empty data object, but has update operators
     await expect(user.update({ query: inserted._id, $set: { name: 'bruce' }}))
@@ -114,7 +115,7 @@ module.exports = function(monastery, opendb) {
     expect(beforeValidateHookCalled).toEqual(false)
 
     // Update multiple
-    let updated2 = await user.update({
+    await user.update({
       query: { _id: { $in: [inserted2[0]._id, inserted2[1]._id] }},
       data: { name: 'Martin Luther3' },
       multi: true
@@ -137,10 +138,9 @@ module.exports = function(monastery, opendb) {
     expect(remove.result).toEqual({ n: 1, ok: 1 })
 
     db.close()
-    done()
   })
 
-  test('Insert defaults', async (done) => {
+  test('Insert defaults', async () => {
     let db = (await opendb(null, { defaultObjects: true, serverSelectionTimeoutMS: 2000 })).db
     let db2 = (await opendb(null, { useMilliseconds: true, serverSelectionTimeoutMS: 2000 })).db
     let user = db.model('user', { fields: {
@@ -192,10 +192,9 @@ module.exports = function(monastery, opendb) {
 
     db.close()
     db2.close()
-    done()
   })
 
-  test('update defaults', async (done) => {
+  test('update defaults', async () => {
     let db = (await opendb(null, { useMilliseconds: true, serverSelectionTimeoutMS: 2000 })).db
     let user = db.model('user', {
       fields: {
@@ -236,7 +235,7 @@ module.exports = function(monastery, opendb) {
       query: inserted._id,
       data: {},
       timestamps: false
-    })).rejects.toThrow(`No valid data passed to user.update()`)
+    })).rejects.toThrow('No valid data passed to user.update()')
 
     // UpdatedAt override (wont work)
     let updated4 = await user.update({
@@ -254,12 +253,11 @@ module.exports = function(monastery, opendb) {
     expect(updated5.updatedAt).toEqual(1)
 
     db.close()
-    done()
   })
 
-  test('Insert with id casting', async (done) => {
+  test('Insert with id casting', async () => {
     let db = (await opendb(null)).db
-    let company = db.model('company', { fields: {
+    db.model('company', { fields: {
       name: { type: 'string' }
     }})
     let user = db.model('user', { fields: {
@@ -279,10 +277,9 @@ module.exports = function(monastery, opendb) {
     })
 
     db.close()
-    done()
   })
 
-  test('Find default field population', async (done) => {
+  test('Find default field population', async () => {
     let db = (await opendb(null)).db
     let user = db.model('user', {
       fields: {
@@ -308,7 +305,7 @@ module.exports = function(monastery, opendb) {
       ],
       pet: { dog: inserted._id }
     }})
-    let updated = await dog.update({
+    await dog.update({
       query: inserted._id,
       data: { user: inserted2._id }
     })
@@ -370,10 +367,9 @@ module.exports = function(monastery, opendb) {
     })
 
     db.close()
-    done()
   })
 
-  test('Hooks', async (done) => {
+  test('Hooks', async () => {
     let db = (await opendb(null)).db
     let user = db.model('user', {
       fields: {
@@ -412,8 +408,8 @@ module.exports = function(monastery, opendb) {
     let userDoc = await user.insert({ data: { first: 'Martin', last: 'Luther' }})
 
     // Catch insert (a)synchronous errors thrown in function or through `next(err)`
-    await expect(user.insert({ data: { first: '' } })).rejects.toThrow(`beforeInsert error 1..`)
-    await expect(user.insert({ data: { first: 'Martin' } })).rejects.toThrow(`beforeInsert error 2..`)
+    await expect(user.insert({ data: { first: '' } })).rejects.toThrow('beforeInsert error 1..')
+    await expect(user.insert({ data: { first: 'Martin' } })).rejects.toThrow('beforeInsert error 2..')
     await expect(user.insert({ data: { first: 'Martin', last: 'Luther' } })).resolves.toEqual({
       _id: expect.any(Object),
       first: 'Martin',
@@ -421,15 +417,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(`beforeUpdate error 1..`)
-    await expect(user.update({ query: userDoc._id, data: { first: 'Martin' } })).rejects.toThrow(`beforeUpdate error 2..`)
+    await expect(user.update({ query: userDoc._id, data: { first: '' } }))
+      .rejects.toThrow('beforeUpdate error 1..')
+    await expect(user.update({ query: userDoc._id, data: { first: 'Martin' } }))
+      .rejects.toThrow('beforeUpdate error 2..')
     await expect(user.update({ query: userDoc._id, data: { first: 'Martin', last: 'Luther' } })).resolves.toEqual({
       first: 'Martin',
       last: 'Luther'
     })
 
     // Catch remove synchronous errors through `next(err)`
-    await expect(user.remove({ query: userDoc._id })).rejects.toThrow(`beforeRemove error..`)
+    await expect(user.remove({ query: userDoc._id })).rejects.toThrow('beforeRemove error..')
 
     // After find continues series
     await expect(user.find({ query: userDoc._id })).resolves.toEqual({
@@ -439,7 +437,6 @@ module.exports = function(monastery, opendb) {
     })
 
     db.close()
-    done()
   })
 
 }

package/test/model.js

@@ -19,13 +19,13 @@ module.exports = function(monastery, opendb) {
          insertOnly: true,
          isInteger: true,
          timestampField: true,
-         type: "integer",
+         type: 'integer',
        },
        updatedAt: {
          default: expect.any(Function),
          isInteger: true,
          timestampField: true,
-         type: "integer",
+         type: 'integer',
        },
     })
 
@@ -79,13 +79,13 @@ module.exports = function(monastery, opendb) {
         insertOnly: true,
         isInteger: true,
         timestampField: true,
-        type: "integer"
+        type: 'integer'
       },
       updatedAt: {
         default: expect.any(Function),
         isInteger: true,
         timestampField: true,
-        type: "integer"
+        type: 'integer'
       }
     })
   })
@@ -115,11 +115,10 @@ module.exports = function(monastery, opendb) {
     })
   })
 
-  test('Model indexes', async (done) => {
-    // Need to test different types of indexes
+  test('Model indexes', async () => {
+    // Setup: Need to test different types of indexes
     let db = (await opendb(null)).db
-
-    // Drop previously tested collections
+    // Setup: Drop previously tested collections
     if ((await db._db.listCollections().toArray()).find(o => o.name == 'userIndexRaw')) {
       await db._db.collection('userIndexRaw').drop()
     }
@@ -129,10 +128,10 @@ module.exports = function(monastery, opendb) {
 
     // Unique & text index (after model initialisation, in serial)
     let userIndexRawModel = db.model('userIndexRaw', {})
-    let setupIndex1 = await userIndexRawModel._setupIndexes({
+    await userIndexRawModel._setupIndexes({
       email: { type: 'string', index: 'unique' },
     })
-    let setupIndex2 = await userIndexRawModel._setupIndexes({
+    await userIndexRawModel._setupIndexes({
       name: { type: 'string', index: 'text' },
     })
     let indexes = await db._db.collection('userIndexRaw').indexes()
@@ -170,28 +169,117 @@ module.exports = function(monastery, opendb) {
       textIndexVersion: 3
     })
 
-    // No text index change error, i.e. new Error("Index with name: text already exists with different options")
+    // No text index change error, i.e. new Error('Index with name: text already exists with different options')
     await expect(userIndexModel._setupIndexes({
       name: { type: 'string', index: 'text' },
       name2: { type: 'string', index: 'text' }
     })).resolves.toEqual([{
-      "key": { "name": "text", "name2": "text" },
-      "name": "text",
+      'key': { 'name': 'text', 'name2': 'text' },
+      'name': 'text',
     }])
 
     // Text index on a different model
     await expect(userIndexRawModel._setupIndexes({
       name2: { type: 'string', index: 'text' }
     })).resolves.toEqual([{
-      "key": {"name2": "text"},
-      "name": "text",
+      'key': {'name2': 'text'},
+      'name': 'text',
+    }])
+
+    db.close()
+  })
+
+  test('Model subdocument indexes', async () => {
+    // Setup: Need to test different types of indexes
+    let db = (await opendb(null)).db
+    // Setup: Drop previously tested collections
+    if ((await db._db.listCollections().toArray()).find(o => o.name == 'userIndexSubdoc')) {
+      await db._db.collection('userIndexSubdoc').drop()
+    }
+    // Run
+    let userModel = await db.model('userIndexSubdoc', {
+      fields: {}
+    })
+    await expect(userModel._setupIndexes(
+      {
+        animals: {
+          name: { type: 'string', index: 'unique' },
+        },
+        animals2: {
+          names: {
+            name: { type: 'string', index: 'unique' },
+          },
+        },
+        animals3: {
+          names: {
+            name: { type: 'string', index: 'text' },
+          },
+        },
+      }, {
+        dryRun: true
+      }
+    )).resolves.toEqual([{
+      'key': { 'animals.name': 1 },
+      'name': 'animals.name_1',
+      'unique': true,
+    }, {
+      'key': { 'animals2.names.name': 1 },
+      'name': 'animals2.names.name_1',
+      'unique': true,
+    }, {
+      'key': { 'animals3.names.name': 'text' },
+      'name': 'text',
     }])
 
     db.close()
-    done()
   })
 
-  test('Model 2dsphere indexes', async (done) => {
+  test('Model array indexes', async () => {
+    // Setup: Need to test different types of indexes
+    let db = (await opendb(null)).db
+    // Setup: Drop previously tested collections
+    if ((await db._db.listCollections().toArray()).find(o => o.name == 'userIndexArray')) {
+      await db._db.collection('userIndexArray').drop()
+    }
+    // Run
+    let userModel = await db.model('userIndexArray', {
+      fields: {}
+    })
+    await expect(userModel._setupIndexes(
+      {
+        animals: [{
+          name: { type: 'string', index: 'unique' },
+        }],
+        animals2: [{ type: 'string', index: true }],
+        animals3: [[{ type: 'string', index: true }]],
+        animals4: [{
+          names: [{
+            name: { type: 'string', index: 'unique' },
+          }],
+        }],
+      }, {
+        dryRun: true
+      }
+    )).resolves.toEqual([{
+      'key': { 'animals.name': 1 },
+      'name': 'animals.name_1',
+      'unique': true,
+    }, {
+      'key': { 'animals2': 1 },
+      'name': 'animals2_1',
+    }, {
+      'key': { 'animals3.0': 1 },
+      'name': 'animals3.0_1',
+    }, {
+      'key': { 'animals4.names.name': 1 },
+      'name': 'animals4.names.name_1',
+      'unique': true,
+    }])
+
+    db.close()
+  })
+
+  test('Model 2dsphere indexes', async () => {
     // Setup. The tested model needs to be unique as race condition issue arises when the same model
     // with text indexes are setup at the same time
     let db = (await opendb(null)).db
@@ -217,10 +305,10 @@ module.exports = function(monastery, opendb) {
       coordinates: expect.any(Array),
       schema: {
         default: undefined,
-        index: "2dsphere",
+        index: '2dsphere',
         isObject: true,
         nullObject: undefined,
-        type: "object"
+        type: 'object'
       }
     })
     expect(db.user3.fields.location2).toEqual({
@@ -228,10 +316,10 @@ module.exports = function(monastery, opendb) {
       coordinates: expect.any(Array),
       schema: {
         default: undefined,
-        index: { type: "2dsphere" },
+        index: { type: '2dsphere' },
         isObject: true,
         nullObject: undefined,
-        type: "object"
+        type: 'object'
       }
     })
 
@@ -244,17 +332,16 @@ module.exports = function(monastery, opendb) {
        _id: expect.any(Object),
        location: {
          coordinates: [172.5880385, -43.3311608],
-         type: "Point"
+         type: 'Point'
        },
     })
 
     db.close()
-    done()
   })
 
-  test('Model findBL, findBLProject', async (done) => {
+  test('Model findBL, findBLProject', async () => {
     let db = (await opendb(null)).db
-    let bird = db.model('bird', { fields: {
+    db.model('bird', { fields: {
       name: { type: 'string' }
     }})
     let user = db.model('user', {
@@ -355,8 +442,8 @@ module.exports = function(monastery, opendb) {
       'hiddenDeepModel': 0,
       'hiddenDeepModels': 0,
       // Deep model blacklists
-      "deepModel.myBird.password": 0,
-      "deepModel2.myBird.password": 0
+      'deepModel.myBird.password': 0,
+      'deepModel2.myBird.password': 0
     })
 
     // Test whitelisting
@@ -415,7 +502,6 @@ module.exports = function(monastery, opendb) {
     })
 
     db.close()
-    done()
   })
 
 }

package/test/monk.js

@@ -1,10 +1,10 @@
 module.exports = function(monastery, opendb) {
 
-  test('Monk confilicts', async (done) => {
+  test('Monk confilicts', async () => {
     // Setup
     let db = (await opendb(false)).db
     let monkdb = require('monk')(':badconnection', () => {})
-    let user = db.model('user', {})
+    db.model('user', {})
     let modelNamedConnected = db.model('connected', {})
 
     // Any of our monastery properties already exist on the manager?
@@ -19,8 +19,8 @@ module.exports = function(monastery, opendb) {
     expect(db.connected).toEqual(db.connected)
     expect(db.model.connected).toEqual(modelNamedConnected)
 
-    // Close test since monk(uri) awaits upoin a connection
-    done()
+    // Close test since monk(uri) awaits upoin a connection (Update, done not needed in latest jest)
+    // done()
   })
 
   test('Monastery connect with promise', (done) => {