Port 3P token API to app-check-exp

common/api-review/app-check-exp.api.md

@@ -5,6 +5,8 @@
 ```ts
 
 import { FirebaseApp } from '@firebase/app-exp';
+import { PartialObserver } from '@firebase/util';
+import { Unsubscribe } from '@firebase/util';
 
 // @public
 export interface AppCheck {
@@ -30,6 +32,14 @@ export interface AppCheckToken {
     readonly token: string;
 }
 
+// @public
+export type AppCheckTokenListener = (token: AppCheckTokenResult) => void;
+
+// @public
+export interface AppCheckTokenResult {
+    readonly token: string;
+}
+
 // Warning: (ae-forgotten-export) The symbol "AppCheckProvider" needs to be exported by the entry point index.d.ts
 //
 // @public
@@ -48,9 +58,18 @@ export interface CustomProviderOptions {
     getToken: () => Promise<AppCheckToken>;
 }
 
+// @public
+export function getToken(appCheckInstance: AppCheck, forceRefresh?: boolean): Promise<AppCheckTokenResult>;
+
 // @public
 export function initializeAppCheck(app: FirebaseApp | undefined, options: AppCheckOptions): AppCheck;
 
+// @public
+export function onTokenChanged(appCheckInstance: AppCheck, observer: PartialObserver<AppCheckTokenResult>): Unsubscribe;
+
+// @public
+export function onTokenChanged(appCheckInstance: AppCheck, onNext: (tokenResult: AppCheckTokenResult) => void, onError?: (error: Error) => void, onCompletion?: () => void): Unsubscribe;
+
 // @public
 export class ReCaptchaV3Provider implements AppCheckProvider {
     constructor(_siteKey: string);
@@ -61,7 +80,7 @@ export class ReCaptchaV3Provider implements AppCheckProvider {
     }
 
 // @public
-export function setTokenAutoRefreshEnabled(app: FirebaseApp, isTokenAutoRefreshEnabled: boolean): void;
+export function setTokenAutoRefreshEnabled(appCheckInstance: AppCheck, isTokenAutoRefreshEnabled: boolean): void;
 
 
 // (No @packageDocumentation comment for this package)

packages-exp/app-check-exp/src/api.test.ts

@@ -16,11 +16,29 @@
  */
 import '../test/setup';
 import { expect } from 'chai';
-import { stub } from 'sinon';
-import { setTokenAutoRefreshEnabled, initializeAppCheck } from './api';
-import { FAKE_SITE_KEY, getFullApp, getFakeApp } from '../test/util';
-import { getState } from './state';
+import { match, spy, stub } from 'sinon';
+import {
+  setTokenAutoRefreshEnabled,
+  initializeAppCheck,
+  getToken,
+  onTokenChanged
+} from './api';
+import {
+  FAKE_SITE_KEY,
+  getFullApp,
+  getFakeApp,
+  getFakeGreCAPTCHA,
+  getFakeAppCheck,
+  getFakePlatformLoggingProvider,
+  removegreCAPTCHAScriptsOnPage
+} from '../test/util';
+import { clearState, getState } from './state';
 import * as reCAPTCHA from './recaptcha';
+import * as util from './util';
+import * as logger from './logger';
+import * as client from './client';
+import * as storage from './storage';
+import * as internalApi from './internal-api';
 import { deleteApp, FirebaseApp } from '@firebase/app-exp';
 import { ReCaptchaV3Provider } from './providers';
 
@@ -29,9 +47,12 @@ describe('api', () => {
 
   beforeEach(() => {
     app = getFullApp();
+    stub(util, 'getRecaptcha').returns(getFakeGreCAPTCHA());
   });
 
   afterEach(() => {
+    clearState();
+    removegreCAPTCHAScriptsOnPage();
     return deleteApp(app);
   });
 
@@ -88,8 +109,167 @@ describe('api', () => {
   describe('setTokenAutoRefreshEnabled()', () => {
     it('sets isTokenAutoRefreshEnabled correctly', () => {
       const app = getFakeApp({ automaticDataCollectionEnabled: false });
-      setTokenAutoRefreshEnabled(app, true);
+      const appCheck = getFakeAppCheck(app);
+      setTokenAutoRefreshEnabled(appCheck, true);
       expect(getState(app).isTokenAutoRefreshEnabled).to.equal(true);
     });
   });
+  describe('getToken()', () => {
+    it('getToken() calls the internal getToken() function', async () => {
+      const app = getFakeApp({ automaticDataCollectionEnabled: true });
+      const appCheck = getFakeAppCheck(app);
+      const internalGetToken = stub(internalApi, 'getToken').resolves({
+        token: 'a-token-string'
+      });
+      await getToken(appCheck, true);
+      expect(internalGetToken).to.be.calledWith(
+        appCheck.app,
+        match.any, // platformLoggerProvider
+        true
+      );
+    });
+    it('getToken() throws errors returned with token', async () => {
+      const app = getFakeApp({ automaticDataCollectionEnabled: true });
+      const appCheck = getFakeAppCheck(app);
+      // If getToken() errors, it returns a dummy token with an error field
+      // instead of throwing.
+      stub(internalApi, 'getToken').resolves({
+        token: 'a-dummy-token',
+        error: Error('there was an error')
+      });
+      await expect(getToken(appCheck, true)).to.be.rejectedWith(
+        'there was an error'
+      );
+    });
+  });
+  describe('onTokenChanged()', () => {
+    it('Listeners work when using top-level parameters pattern', async () => {
+      const appCheck = initializeAppCheck(app, {
+        provider: new ReCaptchaV3Provider(FAKE_SITE_KEY),
+        isTokenAutoRefreshEnabled: true
+      });
+      const fakeRecaptchaToken = 'fake-recaptcha-token';
+      const fakeRecaptchaAppCheckToken = {
+        token: 'fake-recaptcha-app-check-token',
+        expireTimeMillis: 123,
+        issuedAtTimeMillis: 0
+      };
+      stub(reCAPTCHA, 'getToken').returns(Promise.resolve(fakeRecaptchaToken));
+      stub(client, 'exchangeToken').returns(
+        Promise.resolve(fakeRecaptchaAppCheckToken)
+      );
+      stub(storage, 'writeTokenToStorage').returns(Promise.resolve(undefined));
+
+      const listener1 = (): void => {
+        throw new Error();
+      };
+      const listener2 = spy();
+
+      const errorFn1 = spy();
+      const errorFn2 = spy();
+
+      const unsubscribe1 = onTokenChanged(appCheck, listener1, errorFn1);
+      const unsubscribe2 = onTokenChanged(appCheck, listener2, errorFn2);
+
+      expect(getState(app).tokenObservers.length).to.equal(2);
+
+      await internalApi.getToken(
+        appCheck.app,
+        getFakePlatformLoggingProvider()
+      );
+
+      expect(listener2).to.be.calledWith({
+        token: fakeRecaptchaAppCheckToken.token
+      });
+      // onError should not be called on listener errors.
+      expect(errorFn1).to.not.be.called;
+      expect(errorFn2).to.not.be.called;
+      unsubscribe1();
+      unsubscribe2();
+      expect(getState(app).tokenObservers.length).to.equal(0);
+    });
+
+    it('Listeners work when using Observer pattern', async () => {
+      const appCheck = initializeAppCheck(app, {
+        provider: new ReCaptchaV3Provider(FAKE_SITE_KEY),
+        isTokenAutoRefreshEnabled: true
+      });
+      const fakePlatformLoggingProvider = getFakePlatformLoggingProvider();
+      const fakeRecaptchaToken = 'fake-recaptcha-token';
+      const fakeRecaptchaAppCheckToken = {
+        token: 'fake-recaptcha-app-check-token',
+        expireTimeMillis: 123,
+        issuedAtTimeMillis: 0
+      };
+      stub(reCAPTCHA, 'getToken').returns(Promise.resolve(fakeRecaptchaToken));
+      stub(client, 'exchangeToken').returns(
+        Promise.resolve(fakeRecaptchaAppCheckToken)
+      );
+      stub(storage, 'writeTokenToStorage').returns(Promise.resolve(undefined));
+
+      const listener1 = (): void => {
+        throw new Error();
+      };
+      const listener2 = spy();
+
+      const errorFn1 = spy();
+      const errorFn2 = spy();
+
+      /**
+       * Reverse the order of adding the failed and successful handler, for extra
+       * testing.
+       */
+      const unsubscribe2 = onTokenChanged(appCheck, {
+        next: listener2,
+        error: errorFn2
+      });
+      const unsubscribe1 = onTokenChanged(appCheck, {
+        next: listener1,
+        error: errorFn1
+      });
+
+      expect(getState(app).tokenObservers.length).to.equal(2);
+
+      await internalApi.getToken(appCheck.app, fakePlatformLoggingProvider);
+
+      expect(listener2).to.be.calledWith({
+        token: fakeRecaptchaAppCheckToken.token
+      });
+      // onError should not be called on listener errors.
+      expect(errorFn1).to.not.be.called;
+      expect(errorFn2).to.not.be.called;
+      unsubscribe1();
+      unsubscribe2();
+      expect(getState(app).tokenObservers.length).to.equal(0);
+    });
+
+    it('onError() catches token errors', async () => {
+      stub(logger.logger, 'error');
+      const appCheck = initializeAppCheck(app, {
+        provider: new ReCaptchaV3Provider(FAKE_SITE_KEY),
+        isTokenAutoRefreshEnabled: false
+      });
+      const fakePlatformLoggingProvider = getFakePlatformLoggingProvider();
+      const fakeRecaptchaToken = 'fake-recaptcha-token';
+      stub(reCAPTCHA, 'getToken').returns(Promise.resolve(fakeRecaptchaToken));
+      stub(client, 'exchangeToken').rejects('exchange error');
+      stub(storage, 'writeTokenToStorage').returns(Promise.resolve(undefined));
+
+      const listener1 = spy();
+
+      const errorFn1 = spy();
+
+      const unsubscribe1 = onTokenChanged(appCheck, listener1, errorFn1);
+
+      await internalApi.getToken(app, fakePlatformLoggingProvider);
+
+      expect(getState(app).tokenObservers.length).to.equal(1);
+
+      expect(errorFn1).to.be.calledOnce;
+      expect(errorFn1.args[0][0].name).to.include('exchange error');
+
+      unsubscribe1();
+      expect(getState(app).tokenObservers.length).to.equal(0);
+    });
+  });
 });