Add updateProfile, updateEmail, updatePassword

Author: sam-gc

packages-exp/auth-exp/src/core/auth/auth_impl.ts

@@ -81,20 +81,23 @@ export class AuthImpl implements Auth {
       }
 
       this._isInitialized = true;
-      this._notifyStateListeners();
+      this.notifyAuthListeners();
     });
   }
 
   useDeviceLanguage(): void {
     throw new Error('Method not implemented.');
   }
 
-  updateCurrentUser(user: User | null): Promise<void> {
-    return this.queue(() => this.directlySetCurrentUser(user));
+  async updateCurrentUser(user: User | null): Promise<void> {
+    return this.queue(async () => {
+      await this.directlySetCurrentUser(user);
+      this.notifyAuthListeners();
+    });
   }
 
-  signOut(): Promise<void> {
-    return this.queue(() => this.directlySetCurrentUser(null));
+  async signOut(): Promise<void> {
+    return this.updateCurrentUser(null);
   }
 
   setPersistence(persistence: Persistence): Promise<void> {
@@ -129,13 +132,20 @@ export class AuthImpl implements Auth {
     );
   }
 
-  async _persistAndNotifyIfCurrent(user: User): Promise<void> {
+  async _persistUserIfCurrent(user: User): Promise<void> {
     if (user === this.currentUser) {
-      return this.updateCurrentUser(user);
+      return this.queue(async () => this.directlySetCurrentUser(user));
     }
   }
 
-  _notifyStateListeners(): void {
+  /** Notifies listeners only if the user is current */
+  _notifyListenersIfCurrent(user: User): void {
+    if (user === this.currentUser) {
+      this.notifyAuthListeners();
+    }
+  }
+
+  private notifyAuthListeners(): void {
     if (!this._isInitialized) {
       return;
     }
@@ -184,8 +194,6 @@ export class AuthImpl implements Auth {
     } else {
       await this.assertedPersistence.removeCurrentUser();
     }
-
-    this._notifyStateListeners();
   }
 
   private queue(action: AsyncAction): Promise<void> {

packages-exp/auth-exp/src/core/user/account_info.test.ts

@@ -24,13 +24,13 @@ import { UserInfo } from '@firebase/auth-types-exp';
 
 // import { UserInfo } from '@firebase/auth-types-exp';
 import { mockEndpoint } from '../../../test/api/helper';
-import { testUser } from '../../../test/mock_auth';
+import { testPersistence, testUser } from '../../../test/mock_auth';
 import * as fetch from '../../../test/mock_fetch';
 import { Endpoint } from '../../api';
+import { Auth } from '../../model/auth';
 import { User } from '../../model/user';
 import { ProviderId } from '../providers';
-// import { ProviderId } from '../providers';
-import { updateProfile } from './account_info';
+import { updateEmail, updatePassword, updateProfile } from './account_info';
 
 use(chaiAsPromised);
 use(sinonChai);
@@ -49,83 +49,194 @@ describe('core/user/profile', () => {
 
   beforeEach(() => {
     user = testUser('uid', '', true);
+    fetch.setUp();
   });
 
   afterEach(() => {
     sinon.restore();
+    fetch.tearDown();
   });
 
-  beforeEach(fetch.setUp);
-  afterEach(fetch.tearDown);
-
-  it('returns immediately if profile object is empty', async () => {
-    const ep = mockEndpoint(Endpoint.SET_ACCOUNT_INFO, {});
-    await updateProfile(user, {});
-    expect(ep.calls).to.be.empty;
-  });
+  describe('#updateProfile', () => {
+    it('returns immediately if profile object is empty', async () => {
+      const ep = mockEndpoint(Endpoint.SET_ACCOUNT_INFO, {});
+      await updateProfile(user, {});
+      expect(ep.calls).to.be.empty;
+    });
 
-  it('calls the setAccountInfo endpoint', async () => {
-    const ep =mockEndpoint(Endpoint.SET_ACCOUNT_INFO, {});
+    it('calls the setAccountInfo endpoint', async () => {
+      const ep =mockEndpoint(Endpoint.SET_ACCOUNT_INFO, {});
 
-    await updateProfile(user, {displayName: 'displayname', photoURL: 'photo'});
-    expect(ep.calls[0].request).to.eql({
-      idToken: 'access-token',
-      displayName: 'displayname',
-      photoUrl: 'photo',
+      await updateProfile(user, {displayName: 'displayname', photoURL: 'photo'});
+      expect(ep.calls[0].request).to.eql({
+        idToken: 'access-token',
+        displayName: 'displayname',
+        photoUrl: 'photo',
+      });
     });
-  });
 
-  it('sets the fields on the user based on the response', async () => {
-    mockEndpoint(Endpoint.SET_ACCOUNT_INFO, {
-      displayName: 'response-name',
-      photoUrl: 'response-photo',
+    it('sets the fields on the user based on the response', async () => {
+      mockEndpoint(Endpoint.SET_ACCOUNT_INFO, {
+        displayName: 'response-name',
+        photoUrl: 'response-photo',
+      });
+
+      await updateProfile(user, {displayName: 'displayname', photoURL: 'photo'});
+      expect(user.displayName).to.eq('response-name');
+      expect(user.photoURL).to.eq('response-photo');
     });
 
-    await updateProfile(user, {displayName: 'displayname', photoURL: 'photo'});
-    expect(user.displayName).to.eq('response-name');
-    expect(user.photoURL).to.eq('response-photo');
+    it('sets the fields on the password provider', async () => {
+      mockEndpoint(Endpoint.SET_ACCOUNT_INFO, {
+        displayName: 'response-name',
+        photoUrl: 'response-photo',
+      });
+      user.providerData = [{...PASSWORD_PROVIDER}];
+
+      await updateProfile(user, {displayName: 'displayname', photoURL: 'photo'});
+      const provider = user.providerData[0];
+      expect(provider.displayName).to.eq('response-name');
+      expect(provider.photoURL).to.eq('response-photo');
+    });
   });
 
-  it('sets the fields on the passwd provider', async () => {
-    mockEndpoint(Endpoint.SET_ACCOUNT_INFO, {
-      displayName: 'response-name',
-      photoUrl: 'response-photo',
+  describe('#updateEmail', () => {
+    it('calls the setAccountInfo endpoint and reloads the user', async () => {
+      const set = mockEndpoint(Endpoint.SET_ACCOUNT_INFO, {});
+      mockEndpoint(Endpoint.GET_ACCOUNT_INFO, {users: [
+        {localId: 'new-uid-to-prove-refresh-got-called'},
+      ]});
+
+      await updateEmail(user, '[email protected]');
+      expect(set.calls[0].request).to.eql({
+        idToken: 'access-token',
+        email: '[email protected]',
+      });
+
+      expect(user.uid).to.eq('new-uid-to-prove-refresh-got-called');
     });
-    user.providerData = [{...PASSWORD_PROVIDER}];
+  });
+
+  describe('#updatePassword', () => {
+    it('calls the setAccountInfo endpoint and reloads the user', async () => {
+      const set = mockEndpoint(Endpoint.SET_ACCOUNT_INFO, {});
+      mockEndpoint(Endpoint.GET_ACCOUNT_INFO, {users: [
+        {localId: 'new-uid-to-prove-refresh-got-called'},
+      ]});
+
+      await updatePassword(user, 'pass');
+      expect(set.calls[0].request).to.eql({
+        idToken: 'access-token',
+        password: 'pass',
+      });
 
-    await updateProfile(user, {displayName: 'displayname', photoURL: 'photo'});
-    const provider = user.providerData[0];
-    expect(provider.displayName).to.eq('response-name');
-    expect(provider.photoURL).to.eq('response-photo');
+      expect(user.uid).to.eq('new-uid-to-prove-refresh-got-called');
+    });
   });
 
   describe('notifications', () => {
-    beforeEach(() => {
-      user.auth.currentUser = user;
+    let auth: Auth;
+    let idTokenChange: sinon.SinonStub;
+
+    beforeEach(async () => {
+      auth = user.auth;
+      idTokenChange = sinon.stub();
+      auth.onIdTokenChanged(idTokenChange);
+
+      // Flush token change promises which are floating
+      await auth.updateCurrentUser(user);
+      auth._isInitialized = true;
+      idTokenChange.resetHistory();
     });
 
-    it('triggers a token update if necessary', async () => {
-      mockEndpoint(Endpoint.SET_ACCOUNT_INFO, {
-        idToken: 'new-id-token',
-        refreshToken: 'new-refresh-token',
-        expiresIn: 300,
+    describe('#updateProfile', () => {
+      it('triggers a token update if necessary', async () => {
+        mockEndpoint(Endpoint.SET_ACCOUNT_INFO, {
+          idToken: 'new-id-token',
+          refreshToken: 'new-refresh-token',
+          expiresIn: 300,
+        });
+
+        await updateProfile(user, {displayName: 'd'});
+        expect(idTokenChange).to.have.been.called;
+        expect(testPersistence.lastPersistedBlob).to.eql(user.toPlainObject());
       });
 
-      const notifySpy = sinon.stub(user.auth, '_notifyStateListeners');
-      await updateProfile(user, {displayName: 'd'});
-      expect(notifySpy).to.have.been.called;
+      it('does NOT trigger a token update if unnecessary', async () => {
+        mockEndpoint(Endpoint.SET_ACCOUNT_INFO, {
+          idToken: 'access-token',
+          refreshToken: 'refresh-token',
+          expiresIn: 300,
+        });
+
+        await updateProfile(user, {displayName: 'd'});
+        expect(idTokenChange).not.to.have.been.called;
+        expect(testPersistence.lastPersistedBlob).to.eql(user.toPlainObject());
+      });
     });
 
-    it('does NOT trigger a token update if unnecessary', async () => {
-      mockEndpoint(Endpoint.SET_ACCOUNT_INFO, {
-        idToken: 'access-token',
-        refreshToken: 'refresh-token',
-        expiresIn: 300,
+    describe('#updateEmail', () => {
+      beforeEach(() => {
+        // This is necessary because this method calls reload; we don't care about that though,
+        // for these tests we're looking at the change listeners
+        mockEndpoint(Endpoint.GET_ACCOUNT_INFO, {users: [{}]});
       });
 
-      const notifySpy = sinon.stub(user.auth, '_notifyStateListeners');
-      await updateProfile(user, {displayName: 'd'});
-      expect(notifySpy).not.to.have.been.called;
+      it('triggers a token update if necessary', async () => {
+        mockEndpoint(Endpoint.SET_ACCOUNT_INFO, {
+          idToken: 'new-id-token',
+          refreshToken: 'new-refresh-token',
+          expiresIn: 300,
+        });
+
+        await updatePassword(user, '[email protected]');
+        expect(idTokenChange).to.have.been.called;
+        expect(testPersistence.lastPersistedBlob).to.eql(user.toPlainObject());
+      });
+
+      it('does NOT trigger a token update if unnecessary', async () => {
+        mockEndpoint(Endpoint.SET_ACCOUNT_INFO, {
+          idToken: 'access-token',
+          refreshToken: 'refresh-token',
+          expiresIn: 300,
+        });
+
+        await updateEmail(user, '[email protected]');
+        expect(idTokenChange).not.to.have.been.called;
+        expect(testPersistence.lastPersistedBlob).to.eql(user.toPlainObject());
+      });
+    });
+
+    describe('#updatePassword', () => {
+      beforeEach(() => {
+        // This is necessary because this method calls reload; we don't care about that though,
+        // for these tests we're looking at the change listeners
+        mockEndpoint(Endpoint.GET_ACCOUNT_INFO, {users: [{}]});
+      });
+
+      it('triggers a token update if necessary', async () => {
+        mockEndpoint(Endpoint.SET_ACCOUNT_INFO, {
+          idToken: 'new-id-token',
+          refreshToken: 'new-refresh-token',
+          expiresIn: 300,
+        });
+
+        await updatePassword(user, 'pass');
+        expect(idTokenChange).to.have.been.called;
+        expect(testPersistence.lastPersistedBlob).to.eql(user.toPlainObject());
+      });
+
+      it('does NOT trigger a token update if unnecessary', async () => {
+        mockEndpoint(Endpoint.SET_ACCOUNT_INFO, {
+          idToken: 'access-token',
+          refreshToken: 'refresh-token',
+          expiresIn: 300,
+        });
+
+        await updatePassword(user, 'pass');
+        expect(idTokenChange).not.to.have.been.called;
+        expect(testPersistence.lastPersistedBlob).to.eql(user.toPlainObject());
+      });
     });
   });
 });

packages-exp/auth-exp/src/core/user/account_info.ts

@@ -18,7 +18,7 @@
 import * as externs from '@firebase/auth-types-exp';
 
 import {
-    updateEmailPassword as apiUpdateEmailPassword
+    updateEmailPassword as apiUpdateEmailPassword, UpdateEmailPasswordRequest
 } from '../../api/account_management/email_and_password';
 import { updateProfile as apiUpdateProfile } from '../../api/account_management/profile';
 import { User } from '../../model/user';
@@ -36,6 +36,7 @@ export async function updateProfile(externUser: externs.User, {displayName, phot
   }
 
   const user = externUser as User;
+  const {auth} = user;
   const idToken = await user.getIdToken();
   const profileRequest = {idToken, displayName, photoUrl};
   const response = await apiUpdateProfile(user.auth, profileRequest);
@@ -50,18 +51,42 @@ export async function updateProfile(externUser: externs.User, {displayName, phot
     passwordProvider.photoURL = user.photoURL;
   }
 
-  user._updateTokensIfNecessary(response);
-  return user.auth._persistAndNotifyIfCurrent(user);
+  const tokensRefreshed = user._updateTokensIfNecessary(response);
+  await auth._persistUserIfCurrent(user);
+  if (tokensRefreshed) {
+    auth._notifyListenersIfCurrent(user);
+  }
+}
+
+export function updateEmail(externUser: externs.User, newEmail: string): Promise<void> {
+  const user = externUser as User;
+  return updateEmailOrPassword(user, newEmail, null);
 }
 
-export async function updateEmail(externUser: externs.User, newEmail: string): Promise<void> {
+export function updatePassword(externUser: externs.User, newPassword: string): Promise<void> {
   const user = externUser as User;
+  return updateEmailOrPassword(user, null, newPassword);
+}
+
+async function updateEmailOrPassword(user: User, email: string|null, password: string|null): Promise<void> {
   const {auth} = user;
   const idToken = await user.getIdToken();
-  const response = await apiUpdateEmailPassword(auth, {idToken, email: newEmail});
-  user._updateTokensIfNecessary(response);
+  const request: UpdateEmailPasswordRequest = {idToken};
+
+  if (email) {
+    request.email = email;
+  }
+  
+  if (password) {
+    request.password = password;
+  }
 
-  // To update 
+  const response = await apiUpdateEmailPassword(auth, request);
+  
+  const tokensRefreshed = user._updateTokensIfNecessary(response);
   await _reloadWithoutSaving(user);
-  return auth._persistAndNotifyIfCurrent(user);
-}
+  await auth._persistUserIfCurrent(user);
+  if (tokensRefreshed) {
+    auth._notifyListenersIfCurrent(user);
+  }
+}