@valkey/valkey-glide-darwin-arm64 1.3.2 → 1.3.3-rc0

package/rust-client/node_modules/save/test/count.js

@@ -1,78 +0,0 @@
-var async = require('async')
-
-module.exports = function(idProperty, getEngine) {
-  describe('#count()', function() {
-    it('should return 0 count if no objects match query', function(done) {
-      getEngine(function(ignoreError, engine) {
-        engine.count({}, function(ignoreError, count) {
-          count.should.equal(0)
-          done()
-        })
-      })
-    })
-
-    it("should emit a 'count' event", function(done) {
-      getEngine(function(ignoreError, engine) {
-        engine.on('count', function(entity) {
-          entity.should.eql({ a: 1 })
-          done()
-        })
-
-        engine.count({ a: 1 }, function() {})
-      })
-    })
-
-    it("should emit a 'received' event", function(done) {
-      getEngine(function(ignoreError, engine) {
-        engine.on('received', function(data) {
-          data.should.eql(0)
-          done()
-        })
-
-        engine.count({ a: 1 }, function(error) {
-          if (error) return done(error)
-        })
-      })
-    })
-
-    it('should return correct count if objects match query', function(done) {
-      getEngine(function(ignoreError, engine) {
-        async.mapSeries(
-          [{ a: 3 }, { a: 1 }, { a: 2, b: 1 }, { a: 2, b: 2 }, { a: 2, b: 3 }],
-          engine.create,
-          function(error) {
-            if (error) return done(error)
-            engine.find({ a: 2 }, function(ignoreError, results) {
-              if (results.length > 3) {
-                console.log('count', results)
-                return done(new Error('Wrong number'))
-              }
-              engine.count({ a: 2 }, function(error, count) {
-                if (error) return done(error)
-                count.should.equal(3)
-                done()
-              })
-            })
-          }
-        )
-      })
-    })
-
-    it('should return total count with a {} query', function(done) {
-      getEngine(function(ignoreError, engine) {
-        async.mapSeries(
-          [{ a: 3 }, { a: 1 }, { a: 2, c: 1 }, { a: 2, c: 2 }],
-          engine.create,
-          function(error) {
-            if (error) return done(error)
-            engine.count({}, function(error, count) {
-              if (error) return done(error)
-              count.should.equal(4)
-              done()
-            })
-          }
-        )
-      })
-    })
-  })
-}

package/rust-client/node_modules/save/test/create-or-update.js

@@ -1,72 +0,0 @@
-var should = require('should')
-
-module.exports = function(idProperty, getEngine) {
-  describe('#createOrUpdate', function() {
-    it('should create a new object when no id is specified', function(done) {
-      getEngine(function(ignoreError, engine) {
-        engine.createOrUpdate({ a: 1 }, function(err, object) {
-          should.not.exist(err)
-          object.should.have.property('a')
-          object.should.have.property('_id')
-          done()
-        })
-      })
-    })
-
-    it('should return a clone of the object', function(done) {
-      var object = { a: 1 }
-      getEngine(function(ignoreError, engine) {
-        engine.createOrUpdate(object, function(err, newObject) {
-          should.not.exist(err)
-          newObject.newProperty = true
-          object.should.not.have.property('newProperty')
-          done()
-        })
-      })
-    })
-
-    it("should emit a 'create' event when a new object is created", function(done) {
-      getEngine(function(ignoreError, engine) {
-        engine.on('create', function(entity) {
-          entity.should.eql({ a: 3 })
-          done()
-        })
-
-        engine.createOrUpdate({ a: 3 }, function() {})
-      })
-    })
-
-    it('should update the entity when it has already been saved', function(done) {
-      getEngine(function(ignoreError, engine) {
-        engine.createOrUpdate({ a: 5 }, function(err, object) {
-          var previousId = object._id
-          should.not.exist(err)
-          engine.createOrUpdate({ _id: previousId, a: 7 }, function(
-            err,
-            object
-          ) {
-            should.not.exist(err)
-            object._id.should.eql(previousId)
-            object.a.should.eql(7)
-            done()
-          })
-        })
-      })
-    })
-
-    it("should emit the 'update' event when a object is updated", function(done) {
-      getEngine(function(ignoreError, engine) {
-        engine.on('update', function(object) {
-          object.a.should.eql(7)
-          done()
-        })
-
-        engine.createOrUpdate({ a: 5 }, function(err, object) {
-          var previousId = object._id
-          should.not.exist(err)
-          engine.createOrUpdate({ _id: previousId, a: 7 }, function() {})
-        })
-      })
-    })
-  })
-}

package/rust-client/node_modules/save/test/create.js

@@ -1,181 +0,0 @@
-var _ = require('lodash')
-var async = require('async')
-var should = require('should')
-
-module.exports = function(idProperty, getEngine) {
-  describe('#create()', function() {
-    it('should return the inserted entity with a new id', function(done) {
-      getEngine(function(ignoreError, engine) {
-        engine.create({ a: 1 }, function(ignoreError, entity) {
-          entity.should.have.property(idProperty)
-          done()
-        })
-      })
-    })
-
-    it('should correctly insert an entity with a nested object', function(done) {
-      var testObject = { a: 1, b: { a: 2, b: 2 } }
-
-      getEngine(function(ignoreError, engine) {
-        engine.create(testObject, function(ignoreError, entity) {
-          entity.b.should.have.property('a')
-          entity.b.a.should.eql(2)
-          done()
-        })
-      })
-    })
-
-    it("should emit a 'create' event", function(done) {
-      getEngine(function(ignoreError, engine) {
-        engine.on('create', function(entity) {
-          entity.should.eql({ a: 1 })
-          done()
-        })
-        engine.create({ a: 1 })
-      })
-    })
-
-    it("should emit a 'afterCreate' event", function(done) {
-      getEngine(function(ignoreError, engine) {
-        engine.on('afterCreate', function(entity) {
-          entity.should.eql({ _id: '1' })
-          done()
-        })
-        engine.create({ _id: 1 })
-      })
-    })
-
-    it('unique id should always be a string', function(done) {
-      getEngine(function(ignoreError, engine) {
-        var fixtures = [{ a: 1 }, { _id: 6, a: 1 }, { _id: '7', a: 1 }]
-
-        async.map(fixtures, engine.create, function(error, objects) {
-          should.not.exist(error)
-
-          _.forEach(objects, function(object) {
-            object.should.have.property(idProperty)
-            should.strictEqual(typeof object[idProperty], 'string')
-          })
-
-          done()
-        })
-      })
-    })
-
-    it('should always create a unique id', function(done) {
-      var n = 15
-      var c = 1
-      var ids = []
-
-      function cb(error, entity) {
-        should.not.exist(error)
-        if (c >= n) {
-          _.uniq(ids).should.eql(ids)
-          done()
-        } else {
-          should.exist(entity[idProperty])
-          ids.push(entity[idProperty])
-        }
-
-        c += 1
-      }
-
-      getEngine(function(ignoreError, engine) {
-        var item = { a: 1 }
-        for (var i = 0; i < n; i += 1) {
-          engine.create(item, cb)
-        }
-      })
-    })
-
-    it('should return the same object besides the id', function(done) {
-      var original = { a: 1 }
-
-      getEngine(function(ignoreError, engine) {
-        engine.create(original, function(ignoreError, entity) {
-          delete entity[idProperty]
-
-          original.should.eql(entity)
-
-          done()
-        })
-      })
-    })
-
-    it('should retrieve ids as strings', function(done) {
-      var original = { a: 1 }
-
-      getEngine(function(ignoreError, engine) {
-        engine.create(original, function(ignoreError, entity) {
-          entity[idProperty].should.be.type('string')
-
-          done()
-        })
-      })
-    })
-
-    it('should allow idProperty to be defined', function(done) {
-      var original = { a: 1 }
-      original[idProperty] = '0'
-
-      getEngine(function(ignoreError, engine) {
-        engine.create(original, function(error, entity) {
-          should.not.exist(error)
-          entity._id.should.equal('0')
-          done()
-        })
-      })
-    })
-
-    it('should not count falsy values as being a defined id', function(done) {
-      function checkFalsy(falsy, cb) {
-        var original = {}
-        original[idProperty] = falsy
-
-        getEngine(function(error, engine) {
-          should.not.exist(error)
-          engine.create(original, function(ignoreError, entity) {
-            should.notEqual(entity[idProperty], falsy)
-            cb()
-          })
-        })
-      }
-
-      async.forEach([null, undefined, '', false, 0, NaN], checkFalsy, done)
-    })
-
-    it('should not retain reference to original object', function(done) {
-      var item = { a: 1 }
-
-      getEngine(function(ignoreError, engine) {
-        async.map([item, item], engine.create, function(error) {
-          should.not.exist(error)
-          engine.find({}, {}, function(ignoreError, objects) {
-            objects[0].a = 2
-            objects[1].a.should.equal(1)
-            done()
-          })
-        })
-      })
-    })
-
-    it('should return a new object', function(done) {
-      var data = { a: 1 }
-      var dataClone = _.clone(data)
-      var engine = require('../lib/memory-engine')()
-
-      engine.create(data, function(ignoreError, object) {
-        delete object.a
-
-        object.should.not.eql(dataClone)
-        data.should.have.property('a')
-
-        engine.read(object._id, function(ignoreError, item) {
-          item.should.have.property('a')
-          item.should.have.property('_id')
-          done()
-        })
-      })
-    })
-  })
-}

package/rust-client/node_modules/save/test/delete-many.js

@@ -1,71 +0,0 @@
-var async = require('async')
-var should = require('should')
-
-module.exports = function(idProperty, getEngine) {
-  describe('#deleteMany()', function() {
-    it('should delete the entity if the delete query matches', function(done) {
-      getEngine(function(ignoreError, engine) {
-        var objectToDelete = { a: 1 }
-        async.map(
-          [objectToDelete, objectToDelete, { a: 2 }, { b: 1 }],
-          engine.create,
-          function() {
-            engine.deleteMany(objectToDelete, function(error) {
-              should.not.exist(error)
-
-              engine.find({}, {}, function(ignoreError, objects) {
-                // Assert items have been deleted
-                objects.length.should.equal(2)
-
-                // Assert items returned arent deleted ones
-                objects.forEach(function(object) {
-                  object.should.not.equal(objectToDelete)
-                })
-                done()
-              })
-            })
-          }
-        )
-      })
-    })
-
-    it("should emit a 'deleteMany' event", function(done) {
-      getEngine(function(ignoreError, engine) {
-        engine.create({ a: 1 }, function(ignoreError, insertedObject) {
-          engine.on('deleteMany', function(entity) {
-            entity.should.eql(insertedObject)
-            done()
-          })
-          engine.deleteMany(insertedObject)
-        })
-      })
-    })
-
-    it("should emit a 'afterDeleteMany' event", function(done) {
-      getEngine(function(ignoreError, engine) {
-        engine.create({ a: 1 }, function(ignoreError, insertedObject) {
-          engine.on('afterDeleteMany', function(entity) {
-            entity.should.eql(insertedObject)
-            done()
-          })
-          engine.deleteMany(insertedObject)
-        })
-      })
-    })
-
-    it('should not error if there are no objects to delete', function(done) {
-      getEngine(function(ignoreError, engine) {
-        async.map(
-          [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 4 }],
-          engine.create,
-          function() {
-            engine.deleteMany({ a: 5 }, function(error) {
-              should.not.exist(error)
-              done()
-            })
-          }
-        )
-      })
-    })
-  })
-}

package/rust-client/node_modules/save/test/delete.js

@@ -1,41 +0,0 @@
-module.exports = function(idProperty, getEngine) {
-  describe('#delete()', function() {
-    it('should delete the entity', function(done) {
-      getEngine(function(ignoreError, engine) {
-        engine.create({ a: 1 }, function(ignoreError, insertedObject) {
-          engine.delete(insertedObject[idProperty], function(error) {
-            ;(error === undefined).should.equal(true)
-            engine.find(insertedObject, {}, function(ignoreError, objects) {
-              objects.length.should.eql(0)
-              done()
-            })
-          })
-        })
-      })
-    })
-
-    it("should emit a 'delete' event", function(done) {
-      getEngine(function(ignoreError, engine) {
-        engine.create({ a: 1 }, function(ignoreError, insertedObject) {
-          engine.on('delete', function(entity) {
-            entity.should.eql(insertedObject[idProperty])
-            done()
-          })
-          engine.delete(insertedObject[idProperty])
-        })
-      })
-    })
-
-    it("should emit a 'afterDelete' event", function(done) {
-      getEngine(function(ignoreError, engine) {
-        engine.create({ a: 1 }, function(ignoreError, insertedObject) {
-          engine.on('afterDelete', function(entity) {
-            entity.should.eql(insertedObject[idProperty])
-            done()
-          })
-          engine.delete(insertedObject[idProperty])
-        })
-      })
-    })
-  })
-}

package/rust-client/node_modules/save/test/engine.tests.js

@@ -1,38 +0,0 @@
-module.exports = function(
-  idProperty,
-  getEngine,
-  beforeCallback,
-  afterCallback
-) {
-  describe('engine', function() {
-    before(function(done) {
-      if (typeof beforeCallback === 'function') {
-        beforeCallback(done)
-      } else {
-        done()
-      }
-    })
-
-    after(function() {
-      if (typeof afterCallback === 'function') {
-        afterCallback()
-      }
-    })
-    ;[
-      './id-property',
-      './create',
-      './read',
-      './update',
-      './update-many',
-      './delete',
-      './delete-many',
-      './find',
-      './find-one',
-      './count',
-      './create-or-update',
-      './streaming'
-    ].map(function(testFile) {
-      require(testFile)(idProperty, getEngine)
-    })
-  })
-}

package/rust-client/node_modules/save/test/find-one.js

@@ -1,75 +0,0 @@
-var async = require('async')
-var should = require('should')
-
-module.exports = function(idProperty, getEngine) {
-  describe('#findOne()', function() {
-    it('should return undefined when no data matches query ', function(done) {
-      getEngine(function(ignoreError, engine) {
-        engine.findOne({ a: 1 }, function(ignoreError, object) {
-          should.not.exist(object)
-          done()
-        })
-      })
-    })
-
-    it("should emit a 'findOne' event", function(done) {
-      getEngine(function(ignoreError, engine) {
-        engine.on('findOne', function(entity) {
-          entity.should.eql({ a: 1 })
-          done()
-        })
-
-        engine.findOne({ a: 1 }, function() {})
-      })
-    })
-
-    it('should return id of type string', function(done) {
-      getEngine(function(ignoreError, engine) {
-        async.map([{ a: 3 }], engine.create, function() {
-          engine.findOne({}, function(ignoreError, object) {
-            object[idProperty].should.be.type('string')
-            done()
-          })
-        })
-      })
-    })
-
-    it('should return a clone of the object', function(done) {
-      var object = { a: 3 }
-      getEngine(function(ignoreError, engine) {
-        async.map([object], engine.create, function() {
-          engine.findOne({}, function(ignoreError, newObject) {
-            newObject.newProperty = true
-            object.should.not.have.property('newProperty')
-            done()
-          })
-        })
-      })
-    })
-
-    it('should return an object for a single clause query that matches an existing object ', function(done) {
-      getEngine(function(ignoreError, engine) {
-        async.map([{ a: 1 }], engine.create, function() {
-          engine.findOne({ a: 1 }, function(ignoreError, object) {
-            object.a.should.equal(1)
-            done()
-          })
-        })
-      })
-    })
-
-    it('should use options to shape results', function(done) {
-      getEngine(function(ignoreError, engine) {
-        async.map([{ a: 3 }, { a: 1 }, { a: 2 }], engine.create, function(
-          error
-        ) {
-          if (error) return done(error)
-          engine.findOne({}, { sort: { a: 1 } }, function(ignoreError, object) {
-            object.a.should.equal(1)
-            done()
-          })
-        })
-      })
-    })
-  })
-}