Add prettier to repo

.prettierrc

@@ -0,0 +1,5 @@
+{
+  "arrowParens": "always",
+  "singleQuote": true,
+  "trailingComma": "es5",
+}

.travis.yml

@@ -1,6 +1,6 @@
 language: node_js
 node_js:
-- '8'
-- '10'
-- stable
+  - '8'
+  - '10'
+  - stable
 sudo: false

package.json

@@ -10,7 +10,9 @@
     "lint": "node_modules/.bin/tslint src/{**/*,*}.ts spec/{**/*,*}.ts",
     "pretest": "node_modules/.bin/tsc",
     "test": "mocha .tmp/spec/index.spec.js",
-    "posttest": "npm run lint && rm -rf .tmp"
+    "posttest": "npm run lint && rm -rf .tmp",
+    "format": "prettier --check '**/*.{json,ts,yml,yaml}'",
+    "format:fix": "prettier --write '**/*.{json,ts,yml,yaml}'"
   },
   "repository": {
     "type": "git",
@@ -40,6 +42,7 @@
     "firebase-admin": "~8.9.0",
     "firebase-functions": "^3.3.0",
     "mocha": "^6.2.2",
+    "prettier": "^1.19.1",
     "sinon": "^7.5.0",
     "tslint": "^5.20.0",
     "typescript": "^3.6.4"

spec/index.spec.ts

@@ -25,7 +25,10 @@ import { expect } from 'chai';
 
 describe('index', () => {
   /* tslint:disable-next-line:no-var-requires */
-  const indexExport = require('../src')({projectId: 'fakeProject'}, 'fakeServiceAccount');
+  const indexExport = require('../src')(
+    { projectId: 'fakeProject' },
+    'fakeServiceAccount'
+  );
   after(() => {
     // Call cleanup (handles case of cleanup function not existing)
     indexExport.cleanup && indexExport.cleanup();
@@ -48,8 +51,12 @@ describe('index', () => {
   });
 
   it('should set env variables based parameters SDK was initialized with', () => {
-    expect(process.env.FIREBASE_CONFIG).to.equal(JSON.stringify({projectId: 'fakeProject'}));
-    expect(process.env.GOOGLE_APPLICATION_CREDENTIALS).to.equal('fakeServiceAccount');
+    expect(process.env.FIREBASE_CONFIG).to.equal(
+      JSON.stringify({ projectId: 'fakeProject' })
+    );
+    expect(process.env.GOOGLE_APPLICATION_CREDENTIALS).to.equal(
+      'fakeServiceAccount'
+    );
   });
 
   it('should clean up env variables once cleanup is called', () => {

spec/lifecycle.spec.ts

@@ -40,11 +40,13 @@ describe('lifecycle', () => {
 
     it('sets env variables appropriately if SDK initialized without parameters', () => {
       test.init();
-      expect(process.env.FIREBASE_CONFIG).to.equal(JSON.stringify({
-        databaseURL: 'https://not-a-project.firebaseio.com',
-        storageBucket: 'not-a-project.appspot.com',
-        projectId: 'not-a-project',
-      }));
+      expect(process.env.FIREBASE_CONFIG).to.equal(
+        JSON.stringify({
+          databaseURL: 'https://not-a-project.firebaseio.com',
+          storageBucket: 'not-a-project.appspot.com',
+          projectId: 'not-a-project',
+        })
+      );
       expect(process.env.GCLOUD_PROJECT).to.equal('not-a-project');
       expect(process.env.GOOGLE_APPLICATION_CREDENTIALS).to.be.undefined;
     });
@@ -57,9 +59,13 @@ describe('lifecycle', () => {
       };
       test.init(firebaseConfig, 'path/to/key.json');
 
-      expect(process.env.FIREBASE_CONFIG).to.equal(JSON.stringify(firebaseConfig));
+      expect(process.env.FIREBASE_CONFIG).to.equal(
+        JSON.stringify(firebaseConfig)
+      );
       expect(process.env.GCLOUD_PROJECT).to.equal('my-project');
-      expect(process.env.GOOGLE_APPLICATION_CREDENTIALS).to.equal('path/to/key.json');
+      expect(process.env.GOOGLE_APPLICATION_CREDENTIALS).to.equal(
+        'path/to/key.json'
+      );
     });
   });
 
@@ -81,7 +87,7 @@ describe('lifecycle', () => {
     it('deletes all the env variables if they did not previously exist', () => {
       let test = new FirebaseFunctionsTest();
       test.init();
-      mockConfig({ foo: {bar: 'faz '}});
+      mockConfig({ foo: { bar: 'faz ' } });
       test.cleanup();
       expect(process.env.FIREBASE_CONFIG).to.be.undefined;
       expect(process.env.GCLOUD_PROJECT).to.be.undefined;

spec/main.spec.ts

@@ -28,12 +28,11 @@ import { mockConfig, makeChange, _makeResourceName, wrap } from '../src/main';
 
 describe('main', () => {
   describe('#wrap', () => {
-
     const constructCF = (eventType?: string) => {
       const cloudFunction = (input) => input;
       set(cloudFunction, 'run', (data, context) => {
-          return { data, context };
-        });
+        return { data, context };
+      });
       set(cloudFunction, '__trigger', {
         eventTrigger: {
           resource: 'ref/{wildcard}/nested/{anotherWildcard}',
@@ -53,8 +52,11 @@ describe('main', () => {
       const context = wrap(constructCF())('data').context;
       expect(typeof context.eventId).to.equal('string');
       expect(context.resource.service).to.equal('service');
-      expect(/ref\/wildcard[1-9]\/nested\/anotherWildcard[1-9]/
-        .test(context.resource.name)).to.be.true;
+      expect(
+        /ref\/wildcard[1-9]\/nested\/anotherWildcard[1-9]/.test(
+          context.resource.name
+        )
+      ).to.be.true;
       expect(context.eventType).to.equal('event');
       expect(Date.parse(context.timestamp)).to.be.greaterThan(0);
       expect(context.params).to.deep.equal({});
@@ -73,7 +75,9 @@ describe('main', () => {
     });
 
     it('should generate auth and authType for database functions', () => {
-      const context = wrap(constructCF('google.firebase.database.ref.write'))('data').context;
+      const context = wrap(constructCF('google.firebase.database.ref.write'))(
+        'data'
+      ).context;
       expect(context.auth).to.equal(null);
       expect(context.authType).to.equal('UNAUTHENTICATED');
     });
@@ -90,10 +94,12 @@ describe('main', () => {
 
     it('should throw when passed invalid options', () => {
       const wrapped = wrap(constructCF());
-      expect(() => wrapped('data', {
+      expect(() =>
+        wrapped('data', {
           auth: { uid: 'abc' },
           isInvalid: true,
-      } as any)).to.throw();
+        } as any)
+      ).to.throw();
     });
 
     it('should generate the appropriate resource based on params', () => {

spec/providers/database.spec.ts

@@ -15,11 +15,14 @@ describe('providers/database', () => {
   });
 
   it('produces the right snapshot with makeDataSnapshot', async () => {
-    const snapshot = makeDataSnapshot({
-      foo: 'bar',
-    }, 'path');
+    const snapshot = makeDataSnapshot(
+      {
+        foo: 'bar',
+      },
+      'path'
+    );
 
-    expect(snapshot.val()).to.deep.equal({foo: 'bar'});
+    expect(snapshot.val()).to.deep.equal({ foo: 'bar' });
     expect(snapshot.ref.key).to.equal('path');
   });
 

spec/providers/firestore.spec.ts

@@ -5,9 +5,12 @@ describe('providers/firestore', () => {
   it('produces the right snapshot with makeDocumentSnapshot', async () => {
     const test = fft();
 
-    const snapshot = test.firestore.makeDocumentSnapshot({
-      email_address: '[email protected]',
-    }, 'collection/doc-id');
+    const snapshot = test.firestore.makeDocumentSnapshot(
+      {
+        email_address: '[email protected]',
+      },
+      'collection/doc-id'
+    );
 
     expect(snapshot.data()).to.deep.equal({
       email_address: '[email protected]',
@@ -18,7 +21,10 @@ describe('providers/firestore', () => {
   it('should allow empty document in makeDocumentSnapshot', async () => {
     const test = fft();
 
-    const snapshot = test.firestore.makeDocumentSnapshot({}, 'collection/doc-id');
+    const snapshot = test.firestore.makeDocumentSnapshot(
+      {},
+      'collection/doc-id'
+    );
 
     expect(snapshot.data()).to.deep.equal(undefined);
     expect(snapshot.id).to.equal('doc-id');

spec/providers/https.spec.ts

@@ -37,24 +37,29 @@ describe('providers/https', () => {
   it('should run the wrapped onCall function and return result', async () => {
     const test = fft();
 
-    const result = await test.wrap(cfToUpperCaseOnCall)({ message: 'lowercase' });
+    const result = await test.wrap(cfToUpperCaseOnCall)({
+      message: 'lowercase',
+    });
 
     expect(result).to.deep.equal({ msg: 'LOWERCASE', from: 'anonymous' });
   });
 
   it('should accept auth params', async () => {
     const test = fft();
-    const options = {auth: {uid: 'abc'}};
+    const options = { auth: { uid: 'abc' } };
 
-    const result = await test.wrap(cfToUpperCaseOnCall)({ message: 'lowercase' }, options);
+    const result = await test.wrap(cfToUpperCaseOnCall)(
+      { message: 'lowercase' },
+      options
+    );
 
-    expect(result).to.deep.equal({msg: 'LOWERCASE', from: 'abc'});
+    expect(result).to.deep.equal({ msg: 'LOWERCASE', from: 'abc' });
   });
 
   it('should accept raw request', async () => {
     const mockRequest: any = (sessionData) => {
       return {
-        session: {data: sessionData},
+        session: { data: sessionData },
       };
     };
     mockRequest.rawBody = Buffer.from('foobar');
@@ -65,7 +70,7 @@ describe('providers/https', () => {
 
     const result = await test.wrap(cfToUpperCaseOnCall)(
       { message: 'lowercase' },
-      options,
+      options
     );
 
     expect(result).to.deep.equal({

src/app.ts

@@ -33,7 +33,7 @@ export function testApp(): testApp.App {
 /** @internal */
 export namespace testApp {
   export let singleton: testApp.App;
-  export let init = () => singleton = new testApp.App();
+  export let init = () => (singleton = new testApp.App());
 
   export class App {
     appSingleton: firebase.app.App;
@@ -44,7 +44,7 @@ export namespace testApp {
         this.appSingleton = firebase.initializeApp(
           JSON.parse(process.env.FIREBASE_CONFIG),
           // Give this app a name so it does not conflict with apps that user initialized.
-          'firebase-functions-test',
+          'firebase-functions-test'
         );
       }
       return this.appSingleton;

src/lifecycle.ts

@@ -35,37 +35,39 @@ export class FirebaseFunctionsTest {
 
   /** Initialize the SDK. */
   init(
-      /** Firebase config values for initializing a Firebase app for your test code to
-       * interact with (e.g. making database writes). It is recommended that you use
-       * a project that is specifically for testing. If omitted, mock config values will
-       * be used and your tests will not interact with a real Firebase app, and all Firebase
-       * methods need to be stubbed, otherwise they will fail.
-       */
-      firebaseConfig?: AppOptions,
-      /** Path to a service account key file to be used when initializing the Firebase app. */
-      pathToServiceAccountKey?: string,
-    ) {
-
+    /** Firebase config values for initializing a Firebase app for your test code to
+     * interact with (e.g. making database writes). It is recommended that you use
+     * a project that is specifically for testing. If omitted, mock config values will
+     * be used and your tests will not interact with a real Firebase app, and all Firebase
+     * methods need to be stubbed, otherwise they will fail.
+     */
+    firebaseConfig?: AppOptions,
+    /** Path to a service account key file to be used when initializing the Firebase app. */
+    pathToServiceAccountKey?: string
+  ) {
     this._oldEnv = {
       FIREBASE_CONFIG: process.env.FIREBASE_CONFIG,
-      GOOGLE_APPLICATION_CREDENTIALS: process.env.GOOGLE_APPLICATION_CREDENTIALS,
+      GOOGLE_APPLICATION_CREDENTIALS:
+        process.env.GOOGLE_APPLICATION_CREDENTIALS,
       GCLOUD_PROJECT: process.env.GCLOUD_PROJECT,
       CLOUD_RUNTIME_CONFIG: process.env.CLOUD_RUNTIME_CONFIG,
     };
 
     if (isEmpty(firebaseConfig)) {
       process.env.FIREBASE_CONFIG = JSON.stringify({
-          databaseURL: 'https://not-a-project.firebaseio.com',
-          storageBucket: 'not-a-project.appspot.com',
-          projectId: 'not-a-project',
+        databaseURL: 'https://not-a-project.firebaseio.com',
+        storageBucket: 'not-a-project.appspot.com',
+        projectId: 'not-a-project',
       });
     } else {
       process.env.FIREBASE_CONFIG = JSON.stringify(firebaseConfig);
       if (pathToServiceAccountKey) {
         process.env.GOOGLE_APPLICATION_CREDENTIALS = pathToServiceAccountKey;
       }
     }
-    process.env.GCLOUD_PROJECT = JSON.parse(process.env.FIREBASE_CONFIG).projectId;
+    process.env.GCLOUD_PROJECT = JSON.parse(
+      process.env.FIREBASE_CONFIG
+    ).projectId;
   }
 
   /** Complete clean up tasks. */