monastery 1.28.3 → 1.30.0

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) => {