Merge pull request #209 from kuzzleio/25-document-exists

Add Collection:documentExists & Document:exists methods

Author: Gilles Ballini

src/Collection.js

@@ -249,6 +249,30 @@ Collection.prototype.deleteDocument = function (arg, options, cb) {
   return this;
 };
 
+/**
+ * Returns a boolean indicating whether or not a document with provided ID exists.
+ *
+ * @param {string} documentId - Unique document identifier
+ * @param {object} options [options] - Optional parameters
+ * @param {responseCallback} cb - Handles the query response
+ */
+Collection.prototype.documentExists = function (documentId, options, cb) {
+  var
+    data = {_id: documentId},
+    self = this;
+
+  if (!cb && typeof options === 'function') {
+    cb = options;
+    options = null;
+  }
+
+  self.kuzzle.callbackRequired('Collection.documentExists', cb);
+
+  self.kuzzle.query(this.buildQueryArgs('document', 'exists'), data, options, function (err, res) {
+    cb(err, err ? undefined : res.result);
+  });
+};
+
 /**
  * Retrieve a single stored document using its unique document ID.
  *

src/Document.js

@@ -161,6 +161,30 @@ Document.prototype.delete = function (options, cb) {
   });
 };
 
+/**
+ * Checks if this document exists in Kuzzle.
+ *
+ * @param {object} [options] - Optional parameters
+ * @param {responseCallback} [cb] - Handles the query response
+ * @returns {*} this
+ */
+Document.prototype.exists = function (options, cb) {
+  var self = this;
+
+  if (!cb && typeof options === 'function') {
+    cb = options;
+    options = null;
+  }
+
+  if (!self.id) {
+    throw new Error('Document.exists: cannot check if the document exists if no id has been provided');
+  }
+
+  this.kuzzle.query(this.dataCollection.buildQueryArgs('document', 'exists'), this.serialize(), options, cb && function (err, res) {
+    cb(err, err ? undefined : res.result);
+  });
+};
+
 /**
  * Replaces the current content with the last version of this document stored in Kuzzle.
  *

test/Collection/constructor.test.js

@@ -43,6 +43,7 @@ describe('Collection constructor', function () {
     should.exist(collection.createPromise);
     should.exist(collection.createDocumentPromise);
     should.exist(collection.deleteDocumentPromise);
+    should.exist(collection.documentExistsPromise);
     should.exist(collection.fetchDocumentPromise);
     should.exist(collection.fetchAllDocumentsPromise);
     should.exist(collection.getMappingPromise);

test/Collection/methods.test.js

@@ -470,6 +470,67 @@ describe('Collection methods', function () {
     });
   });
 
+  describe('#documentExists', function () {
+    beforeEach(function () {
+      result = { result: true };
+      expectedQuery = {
+        index: 'bar',
+        collection: 'foo',
+        action: 'exists',
+        controller: 'document'
+      };
+    });
+
+    it('should send the right documentExists query to Kuzzle', function(done) {
+      var options = { queuable: false };
+
+      this.timeout(50);
+
+      collection.documentExists('foo', options, function (err, res) {
+        should(err).be.null();
+        should(res).be.true();
+        done();
+      });
+
+      should(kuzzle.query).be.calledOnce();
+      should(kuzzle.query).calledWith(expectedQuery, {_id: 'foo'}, options, sinon.match.func);
+
+      kuzzle.query.yield(null, result);
+    });
+
+    it('should raise an error if no callback is provided', function () {
+      should(function () { collection.documentExists(); }).throw(Error);
+      should(function () { collection.documentExists({}); }).throw(Error);
+      should(function () { collection.documentExists({}, {}); }).throw(Error);
+      should(kuzzle.query).not.be.called();
+    });
+
+    it('should handle the callback argument correctly', function () {
+      var
+        cb1 = sinon.stub(),
+        cb2 = sinon.stub();
+
+      collection.documentExists({}, cb1);
+      collection.documentExists({}, {}, cb2);
+      should(kuzzle.query).be.calledTwice();
+
+      kuzzle.query.yield(null, result);
+      should(cb1).be.calledOnce();
+      should(cb2).be.calledOnce();
+    });
+
+    it('should call the callback with an error if one occurs', function (done) {
+      this.timeout(50);
+
+      collection.documentExists({}, function (err, res) {
+        should(err).be.exactly('foobar');
+        should(res).be.undefined();
+        done();
+      });
+      kuzzle.query.yield('foobar');
+    });
+  });
+
   describe('#fetchDocument', function () {
     beforeEach(function () {
       result = { result: {_id: 'foobar', _source: {foo: 'bar'} }};

test/Document/constructor.test.js

@@ -70,6 +70,7 @@ describe('Document constructor', function () {
     var document = new Document(collection);
 
     should.exist(document.deletePromise);
+    should.not.exist(document.existsPromise);
     should.not.exist(document.publishPromise);
     should.exist(document.refreshPromise);
     should.exist(document.savePromise);

test/Document/methods.test.js

@@ -134,6 +134,91 @@ describe('Document methods', function () {
     });
   });
 
+  describe('#exists', function () {
+    beforeEach(function () {
+      result = { result: true };
+      expectedQuery = {
+        index: 'bar',
+        collection: 'foo',
+        action: 'exists',
+        controller: 'document'
+      };
+    });
+
+    it('should send the right query to Kuzzle', function () {
+      var
+        options = { queuable: false },
+        document = new Document(collection);
+
+      document.id = 'foo';
+      document.exists(options);
+      should(kuzzle.query).be.calledOnce();
+      should(kuzzle.query).calledWith(expectedQuery, {_id: 'foo', body: {}, meta: {}}, options);
+    });
+
+    it('should handle arguments correctly', function () {
+      var
+        document = new Document(collection),
+        cb1 = sinon.stub(),
+        cb2 = sinon.stub();
+
+      document.id = 'foo';
+
+      document.exists(cb1);
+      document.exists({}, cb2);
+
+      should(kuzzle.query).be.calledTwice();
+
+      kuzzle.query.yield(null, result);
+      should(cb1).be.calledOnce();
+      should(cb2).be.calledOnce();
+
+      kuzzle.query.reset();
+      document.exists();
+      document.exists({});
+
+      should(kuzzle.query).be.calledTwice();
+    });
+
+    it('should throw an error if no ID has been set', function () {
+      should(function () { document.exists(); }).throw(Error);
+      should(function () { document.exists({}); }).throw(Error);
+      should(function () { document.exists(sinon.stub()); }).throw(Error);
+      should(function () { document.exists({}, sinon.stub()); }).throw(Error);
+      should(kuzzle.query).not.be.called();
+    });
+
+    it('should resolve the callback with true as the result', function (done) {
+      var document = new Document(collection);
+
+      this.timeout(50);
+      document.id = 'foo';
+
+      document.exists(function (err, res) {
+        should(err).be.null();
+        should(res).be.true();
+        done();
+      });
+
+      should(kuzzle.query).be.calledOnce();
+      kuzzle.query.yield(null, result);
+    });
+
+    it('should revolve the callback with an error if one occurs', function (done) {
+      var document = new Document(collection);
+
+      this.timeout(50);
+      document.id = 'foo';
+
+      document.exists(function (err, res) {
+        should(err).be.exactly('foobar');
+        should(res).be.undefined();
+        done();
+      });
+      kuzzle.query.yield('foobar');
+    });
+  });
+
   describe('#refresh', function () {
     beforeEach(function () {
       result = { result: {_id: 'foo', _version: 42, _source: {some: 'content'}}};