Implement onIdTokenChanged and update onAuthStateChanged

Firebase SDK [Version 4.0.0](https://firebase.google.com/support/release-notes/js#version_500_-_may_8_2018)
changed the behavior of `onAuthStateChanged` and added a new event handler
called `onIdTokenChanged`. This patch mocks that change.

onIdTokenChanged now implements the former behavior of onAuthStateChanged.
onAuthStateChanged now signals only when the actual user changes, not when
a new ID token is set for the same user.

Author: dmurvihill

API.md

@@ -175,8 +175,9 @@ Authentication methods for simulating changes to the auth state of a Firebase re
 Changes the active authentication credentials to the `authData` object.
 Before changing the authentication state, `changeAuthState` checks the
 `user` object against the current authentication data.
-`onAuthStateChanged` listeners will only be triggered if the data is not
-deeply equal.
+`onIdTokenChanged` listeners will be triggered if the data is not
+deeply equal. `onAuthStateChanged` listeners will be triggered if the
+data is deeply equal but with different ID token validity.
 
 `user` should be a `MockUser` object or an object with the same fields
 as `MockUser`. To simulate no user being authenticated, pass `null` for
@@ -225,9 +226,13 @@ Finds a user previously created with [`createUser`](https://www.firebase.com/doc
 ##### `updateUser(user)` -> `Promise<MockUser>`
 
 Replace the existing user with a new one, by matching uid. Throws an
-error if no user exists whose uid matches the given user's uid. Resolves
-with the updated user when complete. This operation is queued until the
-next flush.
+error if no user exists whose uid matches the given user's uid.
+Appropriate `onAuthStateChanged` and `onIdTokenChanged` listeners will
+be triggered if the new user has the same `uid` as the current
+authenticated user.
+
+Resolves with the updated user when complete. This operation is queued
+until the next flush.
 
 ## Server Timestamps
 

CHANGELOG.md

@@ -7,8 +7,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 ### Added
 - Changelog
+- mock `auth.Auth.onIdTokenChanged()` method, matching the previous
+  behavior of `onAuthStateChanged()` (see below)
 
 ### Changed
+- (Breaking) Consistent with Firebase SDK
+  [version 4.0.0](https://firebase.google.com/support/release-notes/js#version_500_-_may_8_2018) and later,
+  and later, `onAuthStateChanged` no longer issues an event when a new
+  ID token is issued for the same user. The `onIdTokenChanged` method is
+  now mocked, keeping the previous behavior.
 - `MockStorageFile.download()` now allows omitting the destination arg;
   in that case, it simply resolves the `Promise` with the file contents
   and does not write it anywhere else.

src/firebase-auth.js

@@ -9,6 +9,7 @@ function FirebaseAuth () {
   this.currentUser = null;
   this._auth = {
     listeners: [],
+    idTokenListeners: [],
     completionListeners: [],
     users: [],
     uidCounter: 1
@@ -17,10 +18,10 @@ function FirebaseAuth () {
 
 FirebaseAuth.prototype.changeAuthState = function (userData) {
   this._defer('changeAuthState', _.toArray(arguments), function() {
-    if (!_.isEqual(this.currentUser, userData)) {
-      this.currentUser = _.isObject(userData) ? userData : null;
-      this._triggerAuthEvent();
-    }
+    userData = _.isObject(userData) ? userData : null;
+    const oldUser = _.cloneDeep(this.currentUser);
+    this.currentUser = userData;
+    this._notify_state_listeners(oldUser);
   });
 };
 
@@ -47,6 +48,13 @@ FirebaseAuth.prototype.onAuthStateChanged = function (callback) {
   }
 };
 
+FirebaseAuth.prototype.onIdTokenChanged = function (callback) {
+  const currentUser = this.currentUser;
+  this._auth.idTokenListeners.push({fn: callback});
+  callback.call(null, _.cloneDeep(currentUser));
+  return () => this.offAuth(callback);
+};
+
 FirebaseAuth.prototype.getUserByEmail = function (email, onComplete) {
   var err = this._nextErr('getUserByEmail');
   var self = this;
@@ -100,6 +108,11 @@ FirebaseAuth.prototype.updateUser = function (newUser) {
         reject(new Error('Tried to update a nonexistent user'));
       } else {
         self._auth.users[i] = newUser.clone();
+        if (this.currentUser && this.currentUser.uid === newUser.uid) {
+          const oldUser = this.currentUser.clone();
+          this.currentUser = self._auth.users[i];
+          this._notify_state_listeners(oldUser);
+        }
         resolve(newUser);
       }
     });
@@ -175,7 +188,6 @@ Object.keys(signinMethods)
           self._triggerAuthEvent();
         }, true);
       });
-      return promise;
     };
   });
 
@@ -218,6 +230,15 @@ FirebaseAuth.prototype._triggerAuthEvent = function () {
   listeners.forEach(function (parts) {
     parts.fn.call(parts.context, _.cloneDeep(user));
   });
+  this._triggerIdTokenEvent();
+};
+
+FirebaseAuth.prototype._triggerIdTokenEvent = function () {
+  var user = this.currentUser;
+  var listeners = _.cloneDeep(this._auth.idTokenListeners);
+  listeners.forEach(function (parts) {
+    parts.fn.call(parts.context, _.cloneDeep(user));
+  });
 };
 
 FirebaseAuth.prototype._getUser = function (uid) {
@@ -239,12 +260,11 @@ FirebaseAuth.prototype.onAuth = function (onComplete, context) {
 };
 
 FirebaseAuth.prototype.offAuth = function (onComplete, context) {
-  var index = _.findIndex(this._auth.listeners, function (listener) {
+  function shouldRemove(listener) {
     return listener.fn === onComplete && listener.context === context;
-  });
-  if (index > -1) {
-    this._auth.listeners.splice(index, 1);
   }
+  [this._auth.listeners, this._auth.idTokenListeners]
+    .forEach(event => _.remove(event, shouldRemove));
 };
 
 FirebaseAuth.prototype.unauth = function () {
@@ -502,6 +522,46 @@ FirebaseAuth.prototype.setCustomUserClaims = function (uid, claims) {
   });
 };
 
+FirebaseAuth.prototype._notify_state_listeners = function (previousUser) {
+  const difference = scanDifference(previousUser, this.currentUser);
+  if (difference === 'different_user') {
+    this._triggerAuthEvent();
+  } else if(difference === 'different_token') {
+    this._triggerIdTokenEvent();
+  } else if (difference === 'same') {
+    // do nothing
+  } else {
+    throw new Error('Unexpected result from scanDifference');
+  }
+
+  function scanDifference(oldUser, newUser) {
+    if (_.isObject(oldUser)) {
+      if (_.isObject(newUser)) {
+        if (_.isEqual(oldUser, newUser)) {
+          return 'same';
+        } else {
+          return equalExceptToken(oldUser, newUser) ?
+            'different_token' : 'different_user';
+        }
+      } else {
+        return 'different_user';
+      }
+    } else {
+      return _.isObject(newUser) ? 'different_user' : 'same';
+    }
+  }
+
+  function equalExceptToken(user1, user2) {
+    const u1 = user1.clone();
+    const u2 = user2.clone();
+    delete u1._idtoken;
+    delete u1._tokenValidity;
+    delete u2._idtoken;
+    delete u2._tokenValidity;
+    return _.isEqual(u1, u2);
+  }
+};
+
 FirebaseAuth.prototype._nextUid = function () {
   return 'simplelogin:' + (this._auth.uidCounter++);
 };

test/unit/auth.js

@@ -315,13 +315,9 @@ describe('Auth', function () {
 
   });
 
-  describe('#onAuthStateChanged', function () {
+  function onAuthChangeSharedProperties(it, unsubscribe) {
 
-    beforeEach(() => {
-      ref.onAuthStateChanged(spy);
-    });
-
-    it('is triggered when changeAuthState modifies data', function () {
+    it('is triggered when changeAuthState modifies the user', function () {
       ref.changeAuthState({
         uid: 'kato'
       });
@@ -331,7 +327,7 @@ describe('Auth', function () {
       });
     });
 
-    it('is not triggered if auth state does not change', function () {
+    it('is not triggered when auth state does not change', function () {
       ref.changeAuthState({
         uid: 'kato'
       });
@@ -347,6 +343,117 @@ describe('Auth', function () {
     it('synchronously triggers the callback with the current auth data', function () {
       expect(spy).to.have.been.calledWith(null);
     });
+
+    it('does not trigger after unsubscribe', function () {
+      unsubscribe();
+      spy.reset();
+      ref.changeAuthState(new User(ref, {
+        uid: 'kato',
+      }));
+      ref.flush();
+      expect(spy.callCount).to.equal(0);
+    });
+  }
+
+  describe('#onIdTokenChanged', () => {
+
+    let unsubscribe;
+
+    beforeEach(() => {
+      unsubscribe = ref.onIdTokenChanged(spy);
+    });
+
+    onAuthChangeSharedProperties(it, () => unsubscribe());
+
+    it('is triggered if only ID token changes', () => {
+      const user = new User(ref, {
+        uid: 'kato',
+        email: '[email protected]',
+      });
+      ref.createUser(user);
+      ref.changeAuthState(user);
+      ref.flush();
+      spy.reset();
+      const userWithNewToken = user.clone();
+      userWithNewToken._idtoken = Math.random().toString();
+      ref.changeAuthState(userWithNewToken);
+      ref.flush();
+      expect(spy.called).to.equal(true);
+    });
+
+    it('is triggered on updating current user', () => {
+      const user = new User(ref, {
+        uid: 'kato',
+        email: '[email protected]',
+      });
+      ref.createUser(user);
+      ref.changeAuthState(user);
+      ref.flush();
+      spy.reset();
+      const userWithNewToken = user.clone();
+      userWithNewToken._idtoken = Math.random().toString();
+      ref.updateUser(userWithNewToken);
+      ref.flush();
+      expect(spy.called).to.equal(true);
+    });
+
+    it('is not triggered on updating non-current user', () => {
+      const currentUser = new User(ref, {
+        uid: 'green hornet',
+        email: '[email protected]',
+      });
+      const user = new User(ref, {
+        uid: 'kato',
+        email: '[email protected]',
+      });
+      ref.createUser(user);
+      ref.createUser(currentUser);
+      ref.changeAuthState(currentUser);
+      ref.flush();
+      spy.reset();
+      const userWithNewToken = user.clone();
+      userWithNewToken._idtoken = Math.random().toString();
+      ref.updateUser(userWithNewToken);
+      ref.flush();
+      expect(spy.called).to.equal(false);
+    });
+
+    it('is not triggered on updating current user with the same info', () => {
+      const user = new User(ref, {
+        uid: 'kato',
+        email: '[email protected]',
+      });
+      ref.createUser(user);
+      ref.changeAuthState(user);
+      ref.flush();
+      spy.reset();
+      ref.updateUser(user.clone());
+      ref.flush();
+      expect(spy.called).to.equal(false);
+    });
+  });
+
+  describe('#onAuthStateChanged', function () {
+
+    let unsubscribe;
+
+    beforeEach(() => {
+      unsubscribe = ref.onAuthStateChanged(spy);
+    });
+
+    onAuthChangeSharedProperties(it, () => unsubscribe());
+
+    it('is not triggered if only ID token changes', () => {
+      const user = new User(ref, {
+        uid: 'kato'
+      });
+      ref.changeAuthState(user);
+      ref.flush();
+      spy.reset();
+      ref.autoFlush();
+      return user.getIdToken(true)
+        .then(() => expect(spy.called).to.equal(false));
+    });
   });
 
   describe('#createUser', function () {