monastery 1.34.0 → 1.36.1

package/test/blacklisting.js

@@ -1,104 +1,25 @@
+let bird = require('./mock/blacklisting').bird
+let user = require('./mock/blacklisting').user
+let util = require('../lib/util')
+
 module.exports = function(monastery, opendb) {
 
-  test('find blacklisting', async () => {
+  test('find blacklisting basic', async () => {
     // Setup
     let db = (await opendb(null)).db
-    let bird = db.model('bird', {
-      fields: {
-        name: { type: 'string' },
-      }
-    })
-    let user = db.model('user', {
-      fields: {
-        list: [{ type: 'number' }],
-        dog: { type: 'string' },
-        pet: { type: 'string' },
-        pets: [{
-          name: { type: 'string'},
-          age: { type: 'number'}
-        }],
-        animals: {
-          cat: { type: 'string' },
-          dog: { type: 'string' }
-        },
-        hiddenPets: [{
-          name: { type: 'string'}
-        }],
-        hiddenList: [{ type: 'number'}],
-        deep: {
-          deep2: {
-            deep3: {
-              deep4: { type: 'string' }
-            }
-          }
-        },
-        deeper: {
-          deeper2: {
-            deeper3: {
-              deeper4: { type: 'string' }
-            }
-          }
-        },
-        deepModel: {
-          myBird: { model: 'bird' }
-        },
-        hiddenDeepModel: {
-          myBird: { model: 'bird' }
-        }
-      },
-      findBL: [
-        'dog',
-        'animals.cat',
-        'pets.age',
-        'hiddenPets',
-        'hiddenList',
-        'deep.deep2.deep3',
-        'deeper',
-        'hiddenDeepModel'
-      ],
-    })
-    let bird1 = await bird.insert({ data: { name: 'ponyo' }})
-    let user1 = await user.insert({ data: {
-      list: [44, 54],
-      dog: 'Bruce',
-      pet: 'Freddy',
-      pets: [{ name: 'Pluto', age: 5 }, { name: 'Milo', age: 4 }],
-      animals: {
-        cat: 'Ginger',
-        dog: 'Max'
-      },
-      hiddenPets: [{
-        name: 'secretPet'
-      }],
-      hiddenList: [12, 23],
-      deep: {
-        deep2: {
-          deep3: {
-            deep4: 'hideme'
-          }
-        }
-      },
-      deeper: {
-        deeper2: {
-          deeper3: {
-            deeper4: 'hideme'
-          }
-        }
-      },
-      deepModel: {
-        myBird: bird1._id
-      },
-      hiddenDeepModel: {
-        myBird: bird1._id
-      }
-    }})
+    db.model('bird', bird.schema())
+    db.model('user', user.schema())
 
-    // Test initial blacklist
-    let find1 = await user.findOne({
+    let bird1 = await db.bird.insert({ data: bird.mock() })
+    let user1 = await db.user.insert({ data: user.mock(bird1) })
+
+    // initial blacklist
+    let find1 = await db.user.findOne({
       query: user1._id
     })
     expect(find1).toEqual({
       _id: user1._id,
+      bird: bird1._id,
       list: [44, 54],
       pet: 'Freddy',
       pets: [{ name: 'Pluto' }, { name: 'Milo' }],
@@ -107,117 +28,100 @@ module.exports = function(monastery, opendb) {
       deepModel: { myBird: bird1._id }
     })
 
-    // Test augmented blacklist
-    let find2 = await user.findOne({
+    // augmented blacklist
+    let find2 = await db.user.findOne({
       query: user1._id,
       blacklist: ['pet', 'pet', 'deep', 'deepModel', '-dog', '-animals.cat']
     })
-    expect(find2).toEqual({
+    let customBlacklist
+    expect(find2).toEqual((customBlacklist = {
       _id: user1._id,
+      bird: bird1._id,
       dog: 'Bruce',
       list: [44, 54],
       pets: [{ name: 'Pluto' }, { name: 'Milo' }],
       animals: { dog: 'Max', cat: 'Ginger' }
+    }))
+
+    // blacklist string
+    let find3 = await db.user.findOne({
+      query: user1._id,
+      blacklist: 'pet pet deep deepModel -dog -animals.cat'
     })
+    expect(find3).toEqual(customBlacklist)
+
+    // blacklist removal
+    let find4 = await db.user.findOne({ query: user1._id, blacklist: false })
+    expect(find4).toEqual(user1)
 
     db.close()
   })
 
   test('find blacklisting population', async () => {
-    // inprogresss
     // Setup
-    let db = monastery('localhost/monastery', {
-      timestamps: false,
-      serverSelectionTimeoutMS: 2000,
-    })
-    let bird = db.model('bird', {
-      fields: {
-        color: { type: 'string', default: 'red' },
-        height: { type: 'number' },
-        name: { type: 'string' },
-        sub: {
-          color: { type: 'string', default: 'red' },
-        },
-        subs: [{
-          color: { type: 'string', default: 'red'},
-        }],
-        wing: {
-          size: { type: 'number' },
-          sizes: {
-            one: { type: 'number' },
-            two: { type: 'number' },
-          }
-        },
-      },
-      findBL: ['wing']
-    })
-    let user = db.model('user', {
+    let db = (await opendb(null)).db
+    db.model('bird', bird.schema())
+    db.model('user', {
       fields: {
         dog: { type: 'string' },
-        bird1: { model: 'bird' },
-        bird2: { model: 'bird' },
-        bird3: { model: 'bird' },
-        bird4: { model: 'bird' },
-        bird5: { model: 'bird' },
+        bird: { model: 'bird' },
       },
-      findBL: [
-        'bird1.name',                                 // bird1.name & bird1.wing blacklisted
-        '-bird2', 'bird2.name',                       // bird2.name blacklisted
-        'bird3.name', '-bird3', 'bird3.height',       // bird3.height blacklisted
-        '-bird4.wing.sizes.one', '-bird4.wing.size',  // ignored
-        // bird4.wing.sizes.two blacklisted (expand in future verion)
-        '-bird5.wing.sizes.one',                      // bird5.wing.sizes.one ignored, wing blacklisted
-        // bird5.wing.sizes.two, wing.size blacklisted (expand in future verion)
-      ]
     })
-    let bird1 = await bird.insert({
-      data: {
-        name: 'ponyo',
-        height: 40,
-        sub: {},
-        wing: { size: 1, sizes: { one: 1, two: 1 }}
-      }
-    })
-    let userData = {
+
+    let bird1 = await db.bird.insert({ data: bird.mock() })
+    let user1 = await db.user.insert({ data: {
       dog: 'Bruce',
-      bird1: bird1._id,
-      bird2: bird1._id,
-      bird3: bird1._id,
-      bird4: bird1._id,
-      bird5: bird1._id
+      bird: bird1._id,
+    }})
+
+    let bird1Base = {
+      _id: bird1._id,
+      color: 'red',
+      sub: { color: 'red' }
     }
-    let user1 = await user.insert({ data: userData })
-    let bird1Base = { _id: bird1._id, color: 'red', sub: { color: 'red' }}
 
-    // Test bird1
-    expect(await user.findOne({ query: user1._id, populate: ['bird1'] })).toEqual({
-      ...userData,
-      _id: user1._id,
-      bird1: { ...bird1Base, height: 40 },
-    })
-    // Test bird2
-    expect(await user.findOne({ query: user1._id, populate: ['bird2'] })).toEqual({
-      ...userData,
-      _id: user1._id,
-      bird2: { ...bird1Base, height: 40, wing: { size: 1, sizes: { one: 1, two: 1 }} },
-    })
-    // Test bird3
-    expect(await user.findOne({ query: user1._id, populate: ['bird3'] })).toEqual({
-      ...userData,
-      _id: user1._id,
-      bird3: { ...bird1Base, name: 'ponyo', wing: { size: 1, sizes: { one: 1, two: 1 }} },
-    })
-    // Test bird4
-    expect(await user.findOne({ query: user1._id, populate: ['bird4'] })).toEqual({
-      ...userData,
-      _id: user1._id,
-      bird4: { ...bird1Base, name: 'ponyo', height: 40 },
-    })
-    // Test bird5
-    expect(await user.findOne({ query: user1._id, populate: ['bird5'] })).toEqual({
-      ...userData,
-      _id: user1._id,
-      bird5: { ...bird1Base, name: 'ponyo', height: 40 },
+    // 'bird1.name',                                 // bird1.name & bird1.wing blacklisted
+    // '-bird2', 'bird2.name',                       // bird2.name blacklisted
+    // 'bird3.name', '-bird3', 'bird3.height',       // bird3.height blacklisted
+    // '-bird4.wing.sizes.one', '-bird4.wing.size',  // ignored
+    //        bird4.wing.sizes.two blacklisted (expand in future verion)
+    // '-bird5.wing.sizes.one',                      // bird5.wing.sizes.one ignored, wing blacklisted
+    //        bird5.wing.sizes.two, wing.size blacklisted (expand in future verion)
+
+    // test 1
+    db.user.findBL = ['bird.name']
+    expect(await db.user.findOne({ query: user1._id, populate: ['bird'] })).toEqual({
+      ...user1,
+      bird: { ...bird1Base, height: 12 },
+    })
+    // test 2
+    db.user.findBL = ['-bird', 'bird.name']
+    expect(await db.user.findOne({ query: user1._id, populate: ['bird'] })).toEqual({
+      ...user1,
+      bird: { ...bird1Base, height: 12, wing: { size: 1, sizes: { one: 1, two: 1 }} },
+    })
+    // test 3
+    db.user.findBL = ['bird.name', '-bird', 'bird.height']
+    expect(await db.user.findOne({ query: user1._id, populate: ['bird'] })).toEqual({
+      ...user1,
+      bird: { ...bird1Base, name: 'Ponyo', wing: { size: 1, sizes: { one: 1, two: 1 }} },
+    })
+    // test 4
+    db.user.findBL = ['-bird.wing.sizes.one', '-bird.wing.size']
+    expect(await db.user.findOne({ query: user1._id, populate: ['bird'] })).toEqual({
+      ...user1,
+      bird: { ...bird1Base, name: 'Ponyo', height: 12 },
+    })
+    // test 5
+    db.user.findBL = ['-bird.wing.sizes.one']
+    expect(await db.user.findOne({ query: user1._id, populate: ['bird'] })).toEqual({
+      ...user1,
+      bird: { ...bird1Base, name: 'Ponyo', height: 12 },
+    })
+    // blacklist removal
+    expect(await db.user.findOne({ query: user1._id, blacklist: false, populate: ['bird'] })).toEqual({
+      ...user1,
+      bird: { ...bird1Base, height: 12, name: 'Ponyo', wing: { size: 1, sizes: { one: 1, two: 1 }} },
     })
 
     db.close()
@@ -243,13 +147,13 @@ module.exports = function(monastery, opendb) {
       },
     })
     // default
-    expect(db.user._getBlacklistProjection('find')).toEqual({
+    expect(db.user._getProjectionFromBlacklist('find')).toEqual({
       'bird1.wing': 0,
       'bird1.age': 0,
       'password': 0,
     })
     // blacklist /w invalid field (which goes through)
-    expect(db.user._getBlacklistProjection('find', ['name', 'invalidfield'])).toEqual({
+    expect(db.user._getProjectionFromBlacklist('find', ['name', 'invalidfield'])).toEqual({
       'bird1.wing': 0,
       'bird1.age': 0,
       'invalidfield': 0,
@@ -257,38 +161,38 @@ module.exports = function(monastery, opendb) {
       'password': 0,
     })
     // whitelist
-    expect(db.user._getBlacklistProjection('find', ['-password', '-bird1.age'])).toEqual({
+    expect(db.user._getProjectionFromBlacklist('find', ['-password', '-bird1.age'])).toEqual({
       'bird1.wing': 0,
     })
     // whitelist parent
-    expect(db.user._getBlacklistProjection('find', ['-bird1'])).toEqual({
+    expect(db.user._getProjectionFromBlacklist('find', ['-bird1'])).toEqual({
       'password': 0,
     })
     // whitelist parent, then blacklist child
-    expect(db.user._getBlacklistProjection('find', ['-bird1', 'bird1.name'])).toEqual({
+    expect(db.user._getProjectionFromBlacklist('find', ['-bird1', 'bird1.name'])).toEqual({
       'password': 0,
       'bird1.name': 0,
     })
     // the model's blacklists are applied after deep model's
     db.user.findBL = ['-bird1.age']
-    expect(db.user._getBlacklistProjection('find')).toEqual({
+    expect(db.user._getProjectionFromBlacklist('find')).toEqual({
       'bird1.wing': 0,
     })
     // custom blacklists are applied after the model's, which are after deep model's
     db.user.findBL = ['-bird1.age']
-    expect(db.user._getBlacklistProjection('find', ['bird1'])).toEqual({
+    expect(db.user._getProjectionFromBlacklist('find', ['bird1'])).toEqual({
       'bird1': 0,
     })
     // blacklisted parent with a blacklisted child
-    expect(db.user._getBlacklistProjection('find', ['bird1', 'bird1.wing'])).toEqual({
+    expect(db.user._getProjectionFromBlacklist('find', ['bird1', 'bird1.wing'])).toEqual({
       'bird1': 0,
     })
     // A mess of things
-    expect(db.user._getBlacklistProjection('find', ['-bird1', 'bird1.wing', '-bird1.wing','bird1.wing.size'])).toEqual({
+    expect(db.user._getProjectionFromBlacklist('find', ['-bird1', 'bird1.wing', '-bird1.wing','bird1.wing.size'])).toEqual({
       'bird1.wing.size': 0,
     })
     // blacklisted parent with a whitelisted child (expect blacklist expansion in future version?)
-    // expect(db.user._getBlacklistProjection('find', ['bird1', '-bird1.wing'])).toEqual({
+    // expect(db.user._getProjectionFromBlacklist('find', ['bird1', '-bird1.wing'])).toEqual({
     //   'bird1.age': 0,
     //   'bird1.name': 0,
     // })
@@ -296,7 +200,7 @@ module.exports = function(monastery, opendb) {
     db.close()
   })
 
-  test('find project', async () => {
+  test('find project basic', async () => {
     // Test mongodb native project option
     // Setup
     let db = (await opendb(null)).db
@@ -370,14 +274,14 @@ module.exports = function(monastery, opendb) {
           color: { type: 'string', default: 'red' },
         }
       },
-      findBL: ['age']
+      findBL: ['age'],
     })
     let user = db.model('user', {
       fields: {
         dog: { type: 'string' },
         bird: { model: 'bird' },
         bird2: { model: 'bird' },
-        bird3: { model: 'bird' }
+        bird3: { model: 'bird' },
       },
       findBL: [
         // allll these should be ignored.....?/////
@@ -390,38 +294,47 @@ module.exports = function(monastery, opendb) {
       name: 'ponyo',
       age: 3,
       height: 40,
-      sub: {}
+      sub: {},
     }})
     let user1 = await user.insert({ data: {
       dog: 'Bruce',
       bird: bird1._id,
       bird2: bird1._id,
-      bird3: bird1._id
+      bird3: bird1._id,
     }})
 
-    // Test project
+    // project
     let find1 = await user.findOne({
       query: user1._id,
       populate: ['bird', 'bird2'],
-      project: ['bird.age', 'bird2']
+      project: ['bird.age', 'bird2'],
     })
     expect(find1).toEqual({
       _id: user1._id,
       bird: { age: 3 },
-      bird2: { _id: bird1._id, age: 3, name: 'ponyo', height: 40, color: 'red', sub: { color: 'red' }}
+      bird2: { _id: bird1._id, age: 3, name: 'ponyo', height: 40, color: 'red', sub: { color: 'red' }},
     })
 
-    // Test project (different project details)
+    // project (different project details)
     let find2 = await user.findOne({
       query: user1._id,
       populate: ['bird', 'bird2'],
-      project: ['bird', 'bird2.height']
+      project: ['bird', 'bird2.height'],
     })
-    expect(find2).toEqual({
+    let customProject
+    expect(find2).toEqual((customProject={
       _id: user1._id,
       bird: { _id: bird1._id, age: 3, name: 'ponyo', height: 40, color: 'red', sub: { color: 'red' }},
       bird2: { height: 40 },
+    }))
+
+    // project string
+    let find3 = await user.findOne({
+      query: user1._id,
+      populate: ['bird', 'bird2'],
+      project: 'bird bird2.height',
     })
+    expect(find3).toEqual(customProject)
 
     db.close()
   })
@@ -506,7 +419,8 @@ module.exports = function(monastery, opendb) {
         '-deep' // blacklist a parent
       ],
     })
-    expect(user2).toEqual({
+    let customBlacklist
+    expect(user2).toEqual((customBlacklist = {
       list: [44, 54],
       dog: 'Bruce',
       pet: 'Freddy',
@@ -522,7 +436,105 @@ module.exports = function(monastery, opendb) {
           }
         }
       }
+    }))
+
+    // Blacklist string
+    let user3 = await user.validate(doc1, {
+      blacklist: '-dog -animals.dog pets.name -hiddenList -deep'
     })
+    expect(user3).toEqual(customBlacklist)
+
+    // Blacklist removal
+    let user4 = await user.validate(doc1, { blacklist: false })
+    expect(user4).toEqual(doc1)
+
+    // Project whitelist
+    let user5 = await user.validate(doc1, {
+      project: [
+        'dog',
+        'pets.name',
+        'deep'
+      ],
+    })
+    expect(user5).toEqual({
+      dog: 'Bruce',
+      pets: [ {name: 'Pluto'}, {name: 'Milo'} ],
+      deep: {
+        deep2: {
+          deep3: {
+            deep4: 'hideme'
+          }
+        }
+      }
+    })
+    db.close()
+  })
+
+  test('findOneAndUpdate blacklisting general', async () => {
+    // todo: test all findOneAndUpdate options
+    // todo: test find & update hooks
+    let db = (await opendb(null)).db
+    db.model('bird', bird.schema())
+    db.model('user', user.schema())
+
+    let bird1 = await db.bird.insert({ data: bird.mock() })
+    let user1 = await db.user.insert({ data: user.mock(bird1) })
+
+    // augmented blacklist
+    let find2 = await db.user.findOneAndUpdate({
+      query: user1._id,
+      data: { dog: 'Bruce2', pet: 'Freddy2' }, // pet shouldn't update
+      blacklist: ['pet', 'deep', 'deepModel', '-dog', '-animals.cat'],
+    })
+    expect(find2).toEqual({
+      _id: user1._id,
+      bird: bird1._id,
+      dog: 'Bruce2',
+      list: [44, 54],
+      pets: [{ name: 'Pluto' }, { name: 'Milo' }],
+      animals: { dog: 'Max', cat: 'Ginger' },
+    })
+    expect(await db.user.findOne({ query: user1._id, project: ['pet'] })).toEqual({
+      _id: user1._id,
+      pet: 'Freddy',
+    })
+
+    db.close()
+  })
+
+  test('findOneAndUpdate blacklisting populate', async () => {
+    let db = (await opendb(null)).db
+    db.model('bird', bird.schema())
+    db.model('user', user.schema())
+
+    let bird1 = await db.bird.insert({ data: bird.mock() })
+    let user1 = await db.user.insert({ data: user.mock(bird1) })
+
+    // augmented blacklist
+    let find2 = await db.user.findOneAndUpdate({
+      query: user1._id,
+      data: { dog: 'Bruce2', pet: 'Freddy2' }, // pet shouldn't update
+      blacklist: [
+        'pet', 'deep', 'deepModel', '-dog', '-animals.cat',
+        'bird.name', '-bird', 'bird.height' // <- populated model
+      ],
+      populate: ['bird'],
+    })
+    expect(find2).toEqual({
+      _id: user1._id,
+      bird: {
+        ...util.omit(bird1, ['height']),
+      },
+      dog: 'Bruce2',
+      list: [44, 54],
+      pets: [{ name: 'Pluto' }, { name: 'Milo' }],
+      animals: { dog: 'Max', cat: 'Ginger' },
+    })
+    expect(await db.user.findOne({ query: user1._id, project: ['pet'] })).toEqual({
+      _id: user1._id,
+      pet: 'Freddy',
+    })
+
     db.close()
   })
 

package/test/crud.js

@@ -145,7 +145,7 @@ module.exports = function(monastery, opendb) {
     db2.close()
   })
 
-  test('update basics', async () => {
+  test('update general', async () => {
     let db = (await opendb(null)).db
     let user = db.model('user', {
       fields: {
@@ -423,14 +423,72 @@ module.exports = function(monastery, opendb) {
     db.close()
   })
 
-  test('remove basics', async () => {
+  test('findOneAndUpdate general', async () => {
+    // todo: test all findOneAndUpdate options
+    // todo: test find & update hooks
     let db = (await opendb(null)).db
+    let dog = db.model('dog', {
+      fields: {
+        name: { type: 'string', default: 'Scruff' },
+      }
+    })
     let user = db.model('user', {
+      fields: {
+        name: { type: 'string', default: 'Martin' },
+        dog: { model: 'dog' },
+      }
+    })
+
+    // Returns omitted field after update, i.e. dog
+    let dog1 = await dog.insert({ data: {} })
+    let user1 = await user.insert({ data: { dog: dog1._id }})
+    expect(await user.findOneAndUpdate({ query: { _id: user1._id }, data: { name: 'Martin2' }})).toEqual({
+      _id: user1._id,
+      name: 'Martin2',
+      dog: dog1._id,
+    })
+
+    // Returns omitted field requiring population after update, i.e. dog
+    expect(await user.findOneAndUpdate({
+      query: { _id: user1._id },
+      data: { name: 'Martin2' },
+      populate: ['dog'],
+    })).toEqual({
+      _id: user1._id,
+      name: 'Martin2',
+      dog: {
+        _id: dog1._id,
+        name: 'Scruff'
+      },
+    })
+
+    // Error finding document to update
+    expect(await user.findOneAndUpdate({
+      query: { _id: db.id() },
+      data: { name: 'Martin2' },
+    })).toEqual(null)
+
+    // Error finding document to update (populate)
+    expect(await user.findOneAndUpdate({
+      query: { _id: db.id() },
+      data: { name: 'Martin2' },
+      populate: ['dog'],
+    })).toEqual(null)
+
+    db.close()
+  })
+
+  test('remove general', async () => {
+    let db = (await opendb(null)).db
+    let user = db.model('userRemove', {
       fields: {
         name: { type: 'string' },
       },
     })
 
+    // Clear (incase of failed a test)
+    user._remove({}, { multi: true })
+
     // Insert multiple
     let inserted2 = await user.insert({ data: [{ name: 'Martin' }, { name: 'Martin' }, { name: 'Martin' }]})
     expect(inserted2).toEqual([