add tests for the new API

Author: Feiyang1

packages/app/package.json

@@ -22,7 +22,7 @@
     "type-check": "tsc -p . --noEmit",
     "test:browser": "karma start --single-run",
     "test:browser:debug": "karma start --browsers Chrome --auto-watch",
-    "test:node": "TS_NODE_FILES=true TS_NODE_CACHE=NO TS_NODE_COMPILER_OPTIONS='{\"module\":\"commonjs\"}' nyc --reporter lcovonly -- mocha test/**/*.test.* --opts ../../config/mocha.node.opts",
+    "test:node": "TS_NODE_FILES=true TS_NODE_CACHE=NO TS_NODE_COMPILER_OPTIONS='{\"module\":\"commonjs\"}' nyc --reporter lcovonly -- mocha test/**/*.test.* src/**/*.test.ts --opts ../../config/mocha.node.opts",
     "prepare": "yarn build",
     "compile": "tsc -b ./tsconfig.cjs.json ./tsconfig.esm.json"
   },

packages/app/src/compat/firebaseApp.ts

@@ -27,7 +27,6 @@ import { FirebaseAppInternalNext } from '../next/types';
 import { deleteApp } from '../next';
 import {
   addComponent,
-  removeServiceInstance,
   addOrOverwriteComponent
 } from '../next/internal';
 
@@ -93,9 +92,9 @@ export class FirebaseAppImpl implements FirebaseApp {
 
   /**
    * Remove a service instance from the cache, so we will create a new instance for this service
-   * when people try to get this service again.
+   * when people try to get it again.
    *
-   * NOTE: currently only firestore is using this functionality to support firestore shutdown.
+   * NOTE: currently only firestore uses this functionality to support firestore shutdown.
    *
    * @param name The service name
    * @param instanceIdentifier instance identifier in case multiple instances are allowed
@@ -105,7 +104,8 @@ export class FirebaseAppImpl implements FirebaseApp {
     name: string,
     instanceIdentifier: string = DEFAULT_ENTRY_NAME
   ): void {
-    removeServiceInstance(this.app, name, instanceIdentifier);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    this.app.container.getProvider(name as any).clearInstance(instanceIdentifier);
   }
 
   /**

packages/app/src/next/api.test.ts

@@ -0,0 +1,179 @@
+import { expect } from "chai";
+import { stub } from "sinon";
+import "../../test/setup";
+import { initializeApp, getApps, deleteApp, getApp, registerVersion } from './api';
+import { DEFAULT_ENTRY_NAME } from '../constants';
+import { FirebaseAppInternalNext } from './types';
+import { clearComponents, components, registerComponent } from './internal';
+import { createTestComponent } from '../../test/util';
+
+describe('API tests', () => {
+    afterEach(() => {
+        for (const app of getApps()) {
+            deleteApp(app).catch(() => {});
+        }
+    });
+
+    describe('initializeApp', () => {
+        it('creats DEFAULT App', () => {
+            const app = initializeApp({});
+            expect(app.name).to.equal(DEFAULT_ENTRY_NAME);
+        });
+
+        it('creates named App', () => {
+            const appName = 'MyApp';
+            const app = initializeApp({}, appName);
+            expect(app.name).to.equal(appName);
+        });
+
+        it('creates named and DEFAULT App', () => {
+            const appName = 'MyApp';
+            const app1 = initializeApp({});
+            const app2 = initializeApp({}, appName);
+
+            expect(app1.name).to.equal(DEFAULT_ENTRY_NAME);
+            expect(app2.name).to.equal(appName);
+        });
+
+        it('throws when creating duplicate DEDAULT Apps', () => {
+            initializeApp({});
+            expect(() => initializeApp({})).throws(/\[DEFAULT\].*exists/i);
+        });
+
+        it('throws when creating duplicate named Apps', () => {
+            const appName = 'MyApp';
+            initializeApp({}, appName);
+            expect(() => initializeApp({}, appName)).throws(/'MyApp'.*exists/i);
+        });
+
+        it('takes an object as the second parameter to create named App', () => {
+            const appName = 'MyApp';
+            const app = initializeApp({}, { name: appName });
+            expect(app.name).to.equal(appName);
+        });
+
+        it('takes an object as the second parameter to create named App', () => {
+            const appName = 'MyApp';
+            const app = initializeApp({}, { name: appName });
+            expect(app.name).to.equal(appName);
+        });
+
+        it('sets automaticDataCollectionEnabled', () => {
+            const app = initializeApp({}, { automaticDataCollectionEnabled: true });
+            expect(app.automaticDataCollectionEnabled).to.be.true;
+        });
+
+        it('adds registered components to App', () => {
+            clearComponents();
+            const comp1 = createTestComponent('test1');
+            const comp2 = createTestComponent('test2');
+            registerComponent(comp1);
+            registerComponent(comp2);
+
+            const app = initializeApp({}) as FirebaseAppInternalNext;
+            expect(app.container.getProviders().length).to.equal(components.size);
+        });
+    });
+
+    describe('getApp', () => {
+        it('retrieves DEFAULT App', () => {
+            const app = initializeApp({});
+            expect(getApp()).to.equal(app);
+        });
+
+        it('retrives named App', () => {
+            const appName = 'MyApp';
+            const app = initializeApp({}, appName);
+            expect(getApp(appName)).to.equal(app);
+        });
+
+        it('throws retrieving a non existing App', () => {
+            expect(() => getApp('RandomName')).throws(/No Firebase App 'RandomName'/);
+        });
+    });
+
+    describe('getApps', () => {
+        it('retrives all Apps that have been created', () => {
+            const app1 = initializeApp({});
+            const app2 = initializeApp({}, 'App2');
+
+            const apps = getApps();
+
+            expect(apps.length).to.equal(2);
+            expect(apps[0]).to.equal(app1);
+            expect(apps[1]).to.equal(app2);
+        });
+
+        it('does NOT return deleted Apps', () => {
+            const app1 = initializeApp({});
+            const app2 = initializeApp({}, 'App2');
+
+            deleteApp(app1).catch(() => {});
+
+            const apps = getApps();
+
+            expect(apps.length).to.equal(1);
+            expect(apps[0]).to.equal(app2);
+        });
+    });
+
+    describe('deleteApp', () => {
+        it('marks an App as deleted', () => {
+            const app = initializeApp({});
+            expect((app as FirebaseAppInternalNext).isDeleted).to.be.false;
+
+            deleteApp(app).catch(() => {});
+            expect((app as FirebaseAppInternalNext).isDeleted).to.be.true;
+        });
+
+        it('removes App from the cache', () => {
+            const app = initializeApp({});
+            expect(getApps().length).to.equal(1);
+
+            deleteApp(app).catch(() => {});
+            expect(getApps().length).to.equal(0);
+        });
+    });
+
+    describe('registerVersion', () => {
+    
+        afterEach(() => {
+          clearComponents();
+        });
+    
+        it('will register an official version component without warnings', () => {
+          const warnStub = stub(console, 'warn');
+          const initialSize = components.size;
+    
+          registerVersion('@firebase/analytics', '1.2.3');
+          expect(components.get('fire-analytics-version')).to.exist;
+          expect(components.size).to.equal(initialSize + 1);
+    
+          expect(warnStub.called).to.be.false;
+        });
+    
+        it('will register an arbitrary version component without warnings', () => {
+          const warnStub = stub(console, 'warn');
+          const initialSize = components.size;
+    
+          registerVersion('angularfire', '1.2.3');
+          expect(components.get('angularfire-version')).to.exist;
+          expect(components.size).to.equal(initialSize + 1);
+    
+          expect(warnStub.called).to.be.false;
+        });
+    
+        it('will do nothing if registerVersion() is given illegal characters', () => {
+          const warnStub = stub(console, 'warn');
+          const initialSize = components.size;
+    
+          registerVersion('remote config', '1.2.3');
+          expect(warnStub.args[0][1]).to.include('library name "remote config"');
+          expect(components.size).to.equal(initialSize);
+    
+          registerVersion('remote-config', '1.2/3');
+          expect(warnStub.args[1][1]).to.include('version name "1.2/3"');
+          expect(components.size).to.equal(initialSize);
+        });
+      });
+});

packages/app/src/next/apis.ts renamed to packages/app/src/next/api.ts

@@ -0,0 +1,63 @@
+import { expect } from "chai";
+import "../../test/setup";
+import { FirebaseAppImplNext } from './firebaseApp';
+import { ComponentContainer } from '@firebase/component';
+import { FirebaseAppInternalNext } from './types';
+
+describe('FirebaseAppNext', () => {
+    it('has various accessors', () => {
+        const options = {
+            apiKey: "APIKEY"
+        };
+        const app = new FirebaseAppImplNext(
+            options, 
+            {name: 'test', automaticDataCollectionEnabled: false},
+            new ComponentContainer('test')
+        );
+
+        expect(app.automaticDataCollectionEnabled).to.be.false;
+        expect(app.name).to.equal('test');
+        expect(app.options).to.deep.equal(options);
+    });
+
+    it('deep-copies options', () => {
+        const options = {
+            apiKey: "APIKEY"
+        };
+        const app = new FirebaseAppImplNext(
+            options, 
+            {name: 'test', automaticDataCollectionEnabled: false},
+            new ComponentContainer('test')
+        );
+
+        expect(app.options).to.not.equal(options);
+        expect(app.options).to.deep.equal(options);
+    });
+
+    it('sets automaticDataCollectionEnabled', () => {
+        const app = new FirebaseAppImplNext(
+            {}, 
+            {name: 'test', automaticDataCollectionEnabled: false},
+            new ComponentContainer('test')
+        );
+
+        expect(app.automaticDataCollectionEnabled).to.be.false;
+        app.automaticDataCollectionEnabled = true;
+        expect(app.automaticDataCollectionEnabled).to.be.true;
+    });
+    
+    it('throws accessing any property after being deleted', () => {
+        const app = new FirebaseAppImplNext(
+            {}, 
+            {name: 'test', automaticDataCollectionEnabled: false},
+            new ComponentContainer('test')
+        );
+
+        expect(() => app.name).to.not.throw();
+        (app as unknown as FirebaseAppInternalNext).isDeleted = true;
+
+        expect(() => {app.name;}).throws("Firebase App named 'test' already deleted");
+        expect(() => app.options).throws("Firebase App named 'test' already deleted");
+        expect(() => app.automaticDataCollectionEnabled).throws("Firebase App named 'test' already deleted");
+    });
+});

packages/app/src/next/firebaseApp.test.ts

@@ -1 +1 @@
-export * from './apis';
+export * from './api';

packages/app/src/next/index.ts

@@ -0,0 +1,103 @@
+import { expect } from "chai";
+import { stub } from "sinon";
+import "../../test/setup";
+import { createTestComponent, TestService } from '../../test/util';
+import { initializeApp, getApps, deleteApp } from './api';
+import { addComponent, addOrOverwriteComponent, registerComponent, components, clearComponents } from './internal';
+import { FirebaseAppInternalNext } from './types';
+
+declare module '@firebase/component' {
+    interface NameServiceMapping {
+      'test': TestService;
+    }
+  }
+
+describe('Internal API tests', () => {
+
+    afterEach(() => {
+        for (const app of getApps()) {
+            deleteApp(app).catch(() => {});
+        }
+    });
+
+    describe('addComponent', () => {
+        it('registers component with App', () => {
+            const app = initializeApp({}) as FirebaseAppInternalNext;
+            const testComp = createTestComponent('test');
+
+            addComponent(app, testComp);
+
+            expect(app.container.getProvider('test').getComponent()).to.equal(testComp);
+        });
+        it('does NOT throw registering duplicate components', () => {
+            const app = initializeApp({}) as FirebaseAppInternalNext;
+            const testComp = createTestComponent('test');
+
+            addComponent(app, testComp);
+
+            expect(() => addComponent(app, testComp)).to.not.throw();
+            expect(app.container.getProvider('test').getComponent()).to.equal(testComp);
+        });
+    });
+
+    describe('addOrOverwriteComponent', () => {
+        it('registers component with App', () => {
+            const app = initializeApp({}) as FirebaseAppInternalNext;
+            const testComp = createTestComponent('test');
+
+            addOrOverwriteComponent(app, testComp);
+
+            expect(app.container.getProvider('test').getComponent()).to.equal(testComp);
+        });
+
+        it('overwrites an existing component with the same name', () => {
+            const app = initializeApp({}) as FirebaseAppInternalNext;
+            const testComp1 = createTestComponent('test');
+            const testComp2 = createTestComponent('test');
+
+            addOrOverwriteComponent(app, testComp1);
+            addOrOverwriteComponent(app, testComp2);
+
+            expect(app.container.getProvider('test').getComponent()).to.equal(testComp2);
+        });
+    });
+
+    describe('registerComponent', () => {
+        afterEach(() => {
+            clearComponents();
+        });
+
+        it('caches a component and registers it with all Apps', () => {
+            const app1 = initializeApp({}) as FirebaseAppInternalNext;
+            const app2 = initializeApp({}, 'app2') as FirebaseAppInternalNext;
+
+            const stub1 = stub(app1.container, 'addComponent').callThrough();
+            const stub2 = stub(app2.container, 'addComponent').callThrough();
+
+            const testComp = createTestComponent('test');
+            registerComponent(testComp);
+
+            expect(components.get('test')).to.equal(testComp);
+            expect(stub1).to.have.been.calledWith(testComp);
+            expect(stub2).to.have.been.calledWith(testComp);
+        });
+        
+        it('returns true if registration is successful', () => {
+            const testComp = createTestComponent('test');
+            expect(components.size).to.equal(0);
+            expect(registerComponent(testComp)).to.be.true;
+            expect(components.get('test')).to.equal(testComp);
+        });
+
+        it('does NOT throw when registering duplicate components and returns false', () => {
+            const testComp1 = createTestComponent('test');
+            const testComp2 = createTestComponent('test');
+            expect(components.size).to.equal(0);
+            expect(registerComponent(testComp1)).to.be.true;
+            expect(components.get('test')).to.equal(testComp1);
+            expect(registerComponent(testComp2)).to.be.false;
+            expect(components.get('test')).to.equal(testComp1);
+        });
+    });
+
+});