auth.validateMyCredentials

Author: jenow

src/Auth.js

@@ -197,6 +197,19 @@ class Auth {
 			.then(res => res.result);
 	}
 
+	/**
+	 * Validate credentials of the specified <strategy> for the current user.
+	 *
+	 * @param strategy
+	 * @param credentials
+	 * @param options
+	 * @returns {Promise|*|PromiseLike<T>|Promise<T>}
+	 */
+	validateMyCredentials (strategy, credentials, options) {
+		return this.kuzzle.query({controller: 'auth', action: 'validateMyCredentials'}, {strategy, body: credentials}, options)
+			.then(res => res.result);
+	}
+
 }
 
 module.exports = Auth;

src/Kuzzle.js

@@ -441,27 +441,6 @@ class Kuzzle extends KuzzleEventEmitter {
     return this.jwt;
   }
 
-  /**
-   * Validate credentials of the specified <strategy> for the current user.
-   *
-   * @param strategy
-   * @param credentials
-   * @param options
-   * @param cb
-   */
-  validateMyCredentials (strategy, credentials, options, cb) {
-    if (!cb && typeof options === 'function') {
-      cb = options;
-      options = null;
-    }
-
-    this.query({controller: 'auth', action: 'validateMyCredentials'}, {strategy, body: credentials}, options, (err, res) => {
-      if (typeof cb === 'function') {
-        cb(err, err ? undefined : res.result);
-      }
-    });
-  }
-
   /**
    * Create a kuzzle index
    *

test/Auth/methods.test.js

@@ -422,4 +422,26 @@ describe.only('Kuzzle Auth controller', function () {
 				});
 		});
 	});
+
+	describe('#validateMyCredentials', function () {
+		const expectedQuery = {
+				controller: 'auth',
+				action: 'validateMyCredentials'
+			},
+			result = {
+				result: true
+			};
+
+		it('should call query with the right arguments and return Promise which resolves a boolean', () => {
+			kuzzle.query.resolves(result);
+
+			return auth.validateMyCredentials('strategy', {username: 'foo'})
+				.then(res => {
+					should(kuzzle.query).be.calledOnce();
+					should(kuzzle.query).be.calledWith(expectedQuery, {strategy: 'strategy', body: { username: 'foo'}}, undefined);
+					should(res).be.eql(result.result);
+				});
+		});
+	});
+
 });

test/kuzzle/constructor.test.js

@@ -53,7 +53,6 @@ describe('Kuzzle constructor', function () {
     should(kuzzle.startQueuing).be.a.Function();
     should(kuzzle.stopQueuing).be.a.Function();
     should(kuzzle.unsetJwt).be.a.Function();
-    should(kuzzle.validateMyCredentials).be.a.Function();
   });
 
   it('should expose the documented writable properties', function () {
@@ -285,6 +284,5 @@ describe('Kuzzle constructor', function () {
     should(kuzzle.startQueuingPromise).be.undefined();
     should(kuzzle.stopQueuingPromise).be.undefined();
     should(kuzzle.unsetJwtPromise).be.undefined();
-    should(kuzzle.validateMyCredentialsPromise).be.a.Function();
   });
 });

test/kuzzle/methods.test.js

@@ -840,92 +840,4 @@ describe('Kuzzle methods', function () {
     });
   });
 
-  describe('#updateSelf', function () {
-    var expectedQuery = {
-      action: 'updateSelf',
-      controller: 'auth'
-    };
-
-    beforeEach(function () {
-      sandbox.stub(kuzzle, 'query').callsFake(queryStub);
-      result = {
-        result: {
-          _id: 'foobar',
-          _source: {
-            name: {
-              first: 'John',
-              last: 'Doe'
-            }
-          }
-        }
-      };
-    });
-
-    it('should send the right query to Kuzzle even without callback', function () {
-      kuzzle.updateSelf({foo: 'bar'});
-      should(kuzzle.query).be.calledOnce();
-      should(kuzzle.query).be.calledWith(expectedQuery, {body: {foo: 'bar'}});
-    });
-
-    it('should send the right query to Kuzzle', function () {
-      var cb = sinon.stub();
-
-      kuzzle.updateSelf({foo: 'bar'}, cb);
-      should(kuzzle.query).be.calledOnce();
-      should(kuzzle.query).be.calledWith(expectedQuery, {body: {foo: 'bar'}});
-      should(cb).be.calledOnce();
-      should(cb).be.calledWithExactly(null, result.result);
-
-    });
-
-    it('should execute the callback with an error if an error occurs', function () {
-      var cb = sinon.stub();
-
-      error = 'foobar';
-      kuzzle.updateSelf({foo: 'bar'}, cb);
-      should(cb).be.calledOnce();
-      should(cb).be.calledWithExactly('foobar', undefined);
-    });
-  });
-
-  describe('#validateMyCredentials', function() {
-    it('should trigger callback with an error', function (done) {
-      var
-        cberror = {message: 'i am an error'},
-        spy = sandbox.stub(kuzzle, 'query').yields(cberror),
-        args;
-
-      kuzzle.validateMyCredentials('strategy', {username: 'foo'}, function (err) {
-        should(err).be.exactly(cberror);
-        args = spy.firstCall.args;
-
-        should(spy).be.calledOnce();
-
-        should(args[0].controller).be.exactly('auth');
-        should(args[0].action).be.exactly('validateMyCredentials');
-        should(args[2]).be.exactly(null);
-        done();
-      });
-    });
-
-    it('should call query with right arguments', function (done) {
-      var
-        doc = {username: 'foo'},
-        spy = sandbox.stub(kuzzle, 'query').yields(null, {result: true}),
-        args;
-
-      kuzzle.validateMyCredentials('strategy', doc, function (err, res) {
-        should(res).be.exactly(true);
-        args = spy.firstCall.args;
-
-        should(spy).be.calledOnce();
-
-        should(args[0].controller).be.exactly('auth');
-        should(args[0].action).be.exactly('validateMyCredentials');
-        should(args[2]).be.exactly(null);
-        done();
-      });
-    });
-  });
-
 });