Consolidate checking into one function

Author: hsubox76

packages/analytics/index.test.ts

@@ -35,6 +35,7 @@ import { findGtagScriptOnPage } from './src/helpers';
 import { removeGtagScript } from './testing/gtag-script-util';
 import { Deferred } from '@firebase/util';
 import { AnalyticsError } from './src/errors';
+import { FirebaseInstallations } from '@firebase/installations-types';
 
 let analyticsInstance: FirebaseAnalytics = {} as FirebaseAnalytics;
 const fakeMeasurementId = 'abcd-efgh';
@@ -104,51 +105,6 @@ describe('FirebaseAnalytics instance tests', () => {
       );
       warnStub.restore();
     });
-    it('Warns if cookies are not enabled', () => {
-      const warnStub = stub(console, 'warn');
-      const cookieStub = stub(navigator, 'cookieEnabled').value(false);
-      const app = getFakeApp({
-        appId: fakeAppParams.appId,
-        apiKey: fakeAppParams.apiKey
-      });
-      const installations = getFakeInstallations();
-      analyticsFactory(app, installations);
-      expect(warnStub.args[0][1]).to.include(
-        AnalyticsError.COOKIES_NOT_ENABLED
-      );
-      warnStub.restore();
-      cookieStub.restore();
-    });
-    it('Warns if browser extension environment', () => {
-      const warnStub = stub(console, 'warn');
-      window.chrome = { runtime: { id: 'blah' } };
-      const app = getFakeApp({
-        appId: fakeAppParams.appId,
-        apiKey: fakeAppParams.apiKey
-      });
-      const installations = getFakeInstallations();
-      analyticsFactory(app, installations);
-      expect(warnStub.args[0][1]).to.include(
-        AnalyticsError.INVALID_ANALYTICS_CONTEXT
-      );
-      warnStub.restore();
-      window.chrome = undefined;
-    });
-    it('Warns if indexedDB does not exist', () => {
-      const warnStub = stub(console, 'warn');
-      const idbStub = stub(window, 'indexedDB').value(undefined);
-      const app = getFakeApp({
-        appId: fakeAppParams.appId,
-        apiKey: fakeAppParams.apiKey
-      });
-      const installations = getFakeInstallations();
-      analyticsFactory(app, installations);
-      expect(warnStub.args[0][1]).to.include(
-        AnalyticsError.INDEXED_DB_UNSUPPORTED
-      );
-      warnStub.restore();
-      idbStub.restore();
-    });
     it('Throws if creating an instance with already-used appId', () => {
       const app = getFakeApp(fakeAppParams);
       const installations = getFakeInstallations();
@@ -230,45 +186,98 @@ describe('FirebaseAnalytics instance tests', () => {
     });
   });
 
-  describe('Standard app, indexedDB.open not available', () => {
+  describe('Standard app, mismatched environment', () => {
     let app: FirebaseApp = {} as FirebaseApp;
-    let fidDeferred: Deferred<void>;
+    let installations: FirebaseInstallations = {} as FirebaseInstallations;
     const gtagStub: SinonStub = stub();
+    let fidDeferred: Deferred<void>;
     let warnStub: SinonStub;
-    before(() => {
+    let cookieStub: SinonStub;
+    beforeEach(() => {
       clock = useFakeTimers();
       resetGlobalVars();
       app = getFakeApp(fakeAppParams);
       fidDeferred = new Deferred<void>();
-      const installations = getFakeInstallations('fid-1234', () =>
+      installations = getFakeInstallations('fid-1234', () =>
         fidDeferred.resolve()
       );
       window['gtag'] = gtagStub;
       window['dataLayer'] = [];
       stubFetch(200, { measurementId: fakeMeasurementId });
       warnStub = stub(console, 'warn');
-      idbOpenStub = stub(indexedDB, 'open').throws('idb open error');
-      analyticsInstance = analyticsFactory(app, installations);
+      stubIdbOpen();
     });
-    after(() => {
+    afterEach(() => {
       delete window['gtag'];
       delete window['dataLayer'];
-      removeGtagScript();
       fetchStub.restore();
       clock.restore();
-      idbOpenStub.restore();
       warnStub.restore();
+      idbOpenStub.restore();
     });
-    it('Does not call gtag on logEvent but does not throw', async () => {
+    it('Warns on logEvent if cookies not available', async () => {
+      cookieStub = stub(navigator, 'cookieEnabled').value(false);
+      analyticsInstance = analyticsFactory(app, installations);
       analyticsInstance.logEvent(EventName.ADD_PAYMENT_INFO, {
         currency: 'USD'
       });
+      // Successfully resolves fake IDB open request.
+      fakeRequest.onsuccess();
       // Clear promise chain started by logEvent.
       await clock.runAllAsync();
       expect(gtagStub).to.not.have.been.called;
       expect(warnStub.args[0][1]).to.include(
-        AnalyticsError.INVALID_INDEXED_DB_CONTEXT
+        AnalyticsError.INVALID_ANALYTICS_CONTEXT
+      );
+      expect(warnStub.args[0][1]).to.include('Cookies');
+      cookieStub.restore();
+    });
+    it('Warns on logEvent if in browser extension', async () => {
+      window.chrome = { runtime: { id: 'blah' } };
+      analyticsInstance = analyticsFactory(app, installations);
+      analyticsInstance.logEvent(EventName.ADD_PAYMENT_INFO, {
+        currency: 'USD'
+      });
+      // Successfully resolves fake IDB open request.
+      fakeRequest.onsuccess();
+      // Clear promise chain started by logEvent.
+      await clock.runAllAsync();
+      expect(gtagStub).to.not.have.been.called;
+      expect(warnStub.args[0][1]).to.include(
+        AnalyticsError.INVALID_ANALYTICS_CONTEXT
+      );
+      expect(warnStub.args[0][1]).to.include('browser extension');
+      window.chrome = undefined;
+    });
+    it('Warns on logEvent if indexedDB API not available', async () => {
+      const idbStub = stub(window, 'indexedDB').value(undefined);
+      analyticsInstance = analyticsFactory(app, installations);
+      analyticsInstance.logEvent(EventName.ADD_PAYMENT_INFO, {
+        currency: 'USD'
+      });
+      // Clear promise chain started by logEvent.
+      await clock.runAllAsync();
+      expect(gtagStub).to.not.have.been.called;
+      expect(warnStub.args[0][1]).to.include(
+        AnalyticsError.INVALID_ANALYTICS_CONTEXT
+      );
+      expect(warnStub.args[0][1]).to.include('IndexedDB is not available');
+      idbStub.restore();
+    });
+    it('Warns on logEvent if indexedDB.open() not allowed', async () => {
+      idbOpenStub.restore();
+      idbOpenStub = stub(indexedDB, 'open').throws('idb open error test');
+      analyticsInstance = analyticsFactory(app, installations);
+      analyticsInstance.logEvent(EventName.ADD_PAYMENT_INFO, {
+        currency: 'USD'
+      });
+      // Clear promise chain started by logEvent.
+      await clock.runAllAsync();
+      expect(gtagStub).to.not.have.been.called;
+      expect(warnStub.args[0][1]).to.include(
+        AnalyticsError.INVALID_ANALYTICS_CONTEXT
       );
+      expect(warnStub.args[0][1]).to.include('idb open error test');
     });
   });
 

packages/analytics/src/errors.ts

@@ -25,10 +25,7 @@ export const enum AnalyticsError {
   FETCH_THROTTLE = 'fetch-throttle',
   CONFIG_FETCH_FAILED = 'config-fetch-failed',
   NO_API_KEY = 'no-api-key',
-  NO_APP_ID = 'no-app-id',
-  INDEXED_DB_UNSUPPORTED = 'indexedDB-unsupported',
-  INVALID_INDEXED_DB_CONTEXT = 'invalid-indexedDB-context',
-  COOKIES_NOT_ENABLED = 'cookies-not-enabled'
+  NO_APP_ID = 'no-app-id'
 }
 
 const ERRORS: ErrorMap<AnalyticsError> = {
@@ -42,16 +39,10 @@ const ERRORS: ErrorMap<AnalyticsError> = {
     'or it will have no effect.',
   [AnalyticsError.INTEROP_COMPONENT_REG_FAILED]:
     'Firebase Analytics Interop Component failed to instantiate: {$reason}',
-  [AnalyticsError.INDEXED_DB_UNSUPPORTED]:
-    'IndexedDB is not supported by current browser',
-  [AnalyticsError.INVALID_INDEXED_DB_CONTEXT]:
-    "Environment doesn't support IndexedDB: {$errorInfo}. " +
-    'Wrap initialization of analytics in analytics.isSupported() ' +
-    'to prevent initialization in unsupported environments',
-  [AnalyticsError.COOKIES_NOT_ENABLED]:
-    'Cookies are not enabled in this browser environment. Analytics requires cookies to be enabled.',
   [AnalyticsError.INVALID_ANALYTICS_CONTEXT]:
-    'Firebase Analytics is not supported in browser extensions.',
+    'Firebase Analytics is not supported in this environment. ' +
+    'Wrap initialization of analytics in analytics.isSupported() ' +
+    'to prevent initialization in unsupported environments. Details: {$errorInfo}',
   [AnalyticsError.FETCH_THROTTLE]:
     'The config fetch request timed out while in an exponential backoff state.' +
     ' Unix timestamp in milliseconds when fetch request throttling ends: {$throttleEndTimeMillis}.',
@@ -73,7 +64,7 @@ interface ErrorParams {
     httpStatus: number;
     responseMessage: string;
   };
-  [AnalyticsError.INVALID_INDEXED_DB_CONTEXT]: { errorInfo: string };
+  [AnalyticsError.INVALID_ANALYTICS_CONTEXT]: { errorInfo: string };
 }
 
 export const ERROR_FACTORY = new ErrorFactory<AnalyticsError, ErrorParams>(

packages/analytics/src/factory.ts

@@ -153,44 +153,45 @@ export function settings(options: SettingsOptions): void {
   }
 }
 
-function logWarningFromCode(errorCode: AnalyticsError): void {
-  const error = ERROR_FACTORY.create(errorCode);
-  logger.warn(error.message);
-}
-
-export function factory(
-  app: FirebaseApp,
-  installations: FirebaseInstallations
-): FirebaseAnalytics {
-  const emptyAnalyticsInstance: FirebaseAnalyticsInternal = {
-    app,
-    // Public methods return void for API simplicity and to better match gtag,
-    // while internal implementations return promises.
-    logEvent: () => {},
-    setCurrentScreen: () => {},
-    setUserId: () => {},
-    setUserProperties: () => {},
-    setAnalyticsCollectionEnabled: () => {},
-    INTERNAL: {
-      delete: (): Promise<void> => {
-        return Promise.resolve();
-      }
-    }
-  };
-
+/**
+ * Returns true if no environment mismatch is found.
+ * If environment mismatches are found, throws an INVALID_ANALYTICS_CONTEXT
+ * error that also lists details for each mismatch found.
+ */
+async function validateBrowserContext(): Promise<boolean> {
+  const mismatchedEnvMessages = [];
   if (isBrowserExtension()) {
-    logWarningFromCode(AnalyticsError.INVALID_ANALYTICS_CONTEXT);
-    return emptyAnalyticsInstance;
+    mismatchedEnvMessages.push('This is a browser extension environment.');
   }
   if (!areCookiesEnabled()) {
-    logWarningFromCode(AnalyticsError.COOKIES_NOT_ENABLED);
-    return emptyAnalyticsInstance;
+    mismatchedEnvMessages.push('Cookies are not available.');
   }
   if (!isIndexedDBAvailable()) {
-    logWarningFromCode(AnalyticsError.INDEXED_DB_UNSUPPORTED);
-    return emptyAnalyticsInstance;
+    mismatchedEnvMessages.push(
+      'IndexedDB is not available in this environment.'
+    );
+  } else {
+    try {
+      await validateIndexedDBOpenable();
+    } catch (e) {
+      mismatchedEnvMessages.push(e);
+    }
+  }
+  if (mismatchedEnvMessages.length > 0) {
+    const details = mismatchedEnvMessages
+      .map((message, index) => `(${index + 1}) ${message}`)
+      .join(' ');
+    throw ERROR_FACTORY.create(AnalyticsError.INVALID_ANALYTICS_CONTEXT, {
+      errorInfo: details
+    });
   }
+  return true;
+}
 
+export function factory(
+  app: FirebaseApp,
+  installations: FirebaseInstallations
+): FirebaseAnalytics {
   const appId = app.options.appId;
   if (!appId) {
     throw ERROR_FACTORY.create(AnalyticsError.NO_APP_ID);
@@ -236,21 +237,15 @@ export function factory(
   }
   // Async but non-blocking.
   // This map reflects the completion state of all promises for each appId.
-  initializationPromisesMap[appId] = validateIndexedDBOpenable()
-    .then(() =>
-      initializeIds(
-        app,
-        dynamicConfigPromisesList,
-        measurementIdToAppId,
-        installations,
-        gtagCoreFunction
-      )
+  initializationPromisesMap[appId] = validateBrowserContext().then(() =>
+    initializeIds(
+      app,
+      dynamicConfigPromisesList,
+      measurementIdToAppId,
+      installations,
+      gtagCoreFunction
     )
-    .catch(e => {
-      throw ERROR_FACTORY.create(AnalyticsError.INVALID_INDEXED_DB_CONTEXT, {
-        errorInfo: e
-      });
-    });
+  );
 
   const analyticsInstance: FirebaseAnalyticsInternal = {
     app,

packages/analytics/src/functions.ts

@@ -32,7 +32,7 @@ async function handleInitializationPromiseErrors(
   try {
     return await initializationPromise;
   } catch (e) {
-    if (e.message.includes(AnalyticsError.INVALID_INDEXED_DB_CONTEXT)) {
+    if (e.message.includes(AnalyticsError.INVALID_ANALYTICS_CONTEXT)) {
       logger.warn(e.message);
       return null;
     }

packages/analytics/src/helpers.ts

@@ -98,7 +98,7 @@ async function gtagOnConfig(
   } catch (e) {
     // Thrown by an initializeIds promise in initializationPromisesMap before
     // making any fetches if indexedDB.open() is unavailable in the environment.
-    if (e.message.includes(AnalyticsError.INVALID_INDEXED_DB_CONTEXT)) {
+    if (e.message.includes(AnalyticsError.INVALID_ANALYTICS_CONTEXT)) {
       logger.warn(e.message);
       return;
     }
@@ -175,7 +175,7 @@ async function gtagOnEvent(
   } catch (e) {
     // Thrown by an initializeIds promise in initializationPromisesMap before
     // making any fetches if indexedDB.open() is unavailable in the environment.
-    if (e.message.includes(AnalyticsError.INVALID_INDEXED_DB_CONTEXT)) {
+    if (e.message.includes(AnalyticsError.INVALID_ANALYTICS_CONTEXT)) {
       logger.warn(e.message);
       return;
     }