Request: Pure Typescript implementation sample

[ahaverty]

I'm struggling to get a pure typescript implementation working with this lib.
I've managed to get it working with requires and few type aliases to make it friendlier
e.g:

const test: FeaturesList = require('firebase-functions-test')({
    databaseURL: `https://${projectId}.firebaseio.com`,
    storageBucket: `${projectId}.appspot.com`,
    projectId: projectId,
}, `./service-accounts/${projectId}-key.json`);

//..and in the after:
(test as any).cleanup();

Tying a pure typescript import doesn't seem to be initializing things properly (errors about not-a-project.firebaseapp for example) and the definitions seem to be different than the samples (the constructor wants a single parameter versus the two in the above sample and the js samples)

Rather than raising an issue for everything I can't get to work, would it be possible to get a typescript sample? 🤓

[adamduren]

Just ran into this as well. Mainly the typings not accepting a second parameter for the service account for use in online mode.

[jeremylorino]

@ahaverty see if this helps.

I haven't updated the example repo with what I am currently using in my day-to-day:

import { FeaturesList } from 'firebase-functions-test/lib/features';
import { FirebaseFunctionsTest } from 'firebase-functions-test/lib/lifecycle';

export declare type FirebaseFunctionsTestSuite =
  FirebaseFunctionsTest &
  { _cleanup: () => void; } &
  FeaturesList;

export async function getModelService() {
  const firebaseTestHarness: FirebaseFunctionsTestSuite = await require('firebase-functions-test')(projectConfig, process.env.GOOGLE_APPLICATION_CREDENTIALS);
  firebaseTestHarness._cleanup = firebaseTestHarness.cleanup;
  firebaseTestHarness.cleanup = function () {
    if (admin.apps.find(a => a.name === '[DEFAULT]')) {
      admin.app().delete();
    }
    // tslint:disable-next-line:no-invalid-this
    return this._cleanup();
  };

  return firebaseTestHarness;
}

[abeisgoat]

Hey folks,

Sorry about the lack of response on this. It's definitely possible that the typings are incorrect or not idiomatic for Typescript (which would be funny since FFT is written in TS), however it's hard for me to know as of today what does / doesn't work since no specific sample is given and this issue is pretty old.

Could someone possibly give me a single failing Typescript test which I can work at? Otherwise I'm not sure where to start looking.

Thanks a ton!
abe

[abeisgoat]

Following up, when testing the library in Typescript, it appears the biggest issue I see is the use of export = in our index.ts file which forces people to import into TS via require which is prone to breaking typings if you don't use the esoteric import fft = require("firebase-functions-test"), which is never shown in our examples.

If you import this way, then @jeremylorino's harness should be unnecessary. Can someone give this type of import a check in their use case and report back?

[eliotstock]

@AbeHaskins Thanks. This does indeed seem to work in my project without the test harness now.

index.test.ts:

import * as admin from 'firebase-admin';
import * as functions from 'firebase-functions';

const projectConfig = {
  projectId: 'my-project',
  databaseURL: 'https://my-projecty.firebaseio.com'
};
const test = require('firebase-functions-test')(projectConfig, './my-project-key.json');

export * from './some.test';
export * from './another.test';

[mayurdhurpate]

Following up, when testing the library in Typescript, it appears the biggest issue I see is the use of export = in our index.ts file which forces people to import into TS via require which is prone to breaking typings if you don't use the esoteric import fft = require("firebase-functions-test"), which is never shown in our examples.

Using import firebaseTest = require('firebase-functions-test') works great for me! Recently created an integration test for a Cloud Firestore trigger. Typescript is able to understand and show all typings for firebase-functions-test in VSCode.

Here is how I implemented it in Typescript and Jest:

Initialization

import * as admin from 'firebase-admin';
import {mockConfigData} from 'mockConfigData';
import * as path from "path";
import firebaseTest = require('firebase-functions-test'); 

const firebaseConfig = {
  databaseURL: 'https://project-id.firebaseio.com',
  storageBucket: 'project-id.appspot.com',
  projectId: 'project-id',
};
const testEnv = firebaseTest(firebaseConfig, path.resolve('service-key.json'));
testEnv.mockConfig(mockConfigData);  //optional

Integration Test

const myFunctions = require('../index.ts');   // relative path to functions code
const user_doc_data = { name: 'Mayur Dhurpate' };

describe('onUserCreate',()=>{
  beforeAll(async ()=>{
    await admin.firestore().collection('user_data').doc('1').set(user_doc_data);
  });

  it('creates correct firstname', async () => { 
    const snap = testEnv.firestore.makeDocumentSnapshot(user_doc_data, 'user_data/1');
    const wrapped = testEnv.wrap(myFunctions.onUserCreate);    // onUserCreate creates a new field firstName
    await wrapped(snap);
    const createdSnap = await admin.firestore().collection('user_data').doc('1').get();
    console.log(createdSnap.data());
    return expect(createdSnap.data()!.firstName).toBe('Mayur');
  });

  afterAll(async ()=>{
    await admin.firestore().collection('user_data').doc('1').delete(); 
  })
});

The only issue I faced is importing Functions code using const myFunctions = require('../index.ts') gets myFunctions as any type, maybe because of the way the Firebase Functions triggers are written. Would be great if we can add a Typescript implementation sample to the docs aiding the ones added for Firebase Functions.

[jaonoctus]

And what about tests with Typescript HTTPS Functions using express app? How can we test it?

Cloud Function example

import { https } from 'firebase-functions'
import * as express from 'express'
import * as cors from 'cors'

const app = express()

app.use(cors({ origin: true }))

const verifyBodyMiddleware = (
  req: express.Request,
  res: express.Response,
  next: express.NextFunction
) => {
  if (!req.body.someRequiredField) next('undefined-field')

  next()
}

const helloWorldPostHandler = (
  req: express.Request,
  res: express.Response
) => {
  // at this point, we know that the body contains required fields
  const { someRequiredField } = req.body

  res.json({ data: { someRequiredField } })
}

const defaultErrorHandler = (
  err: any,
  req: express.Request,
  res: express.Response,
  next: express.NextFunction
) => {
  if (err === 'undefined-field') {
    // some handler for this error here
  }

  res.status(500).json({ error: 'error message' })
}

app.post('/', [
  verifyBodyMiddleware,
  helloWorldPostHandler,
  defaultErrorHandler
])

export const helloWorld = https.onRequest(app)

[Andrew-Pynch]

Can we please get an in-depth exploration of typescript + firebase-functions-test in online mode? I really don't understand how to get this working from the limited docs on firebase-functions-test or typescript support for firebase :-(