Firebase functions offline test stubbing - unit-testing

Question

I'm writing test for firebase database onWrite trigger function in offline mode using stubbing as suggested in the docs and the github sample.
But I'm confused how to stub multiple .child().val() for value in my data coming in the trigger. Here is my progress to create data object:
let data={
before: {
val : ()=> null,
},
after:{
val: ()=> {/*after data here */},
child: {
"child1": "How have value here from val",
"child2": "How have value here from val"
}
}
}
Since my function is a bit complex so there are lots of value reads from the incoming data (2 to 3 level nesting) and then there are multiple access to database as well.
So is there any easy way to stub all these calls ? Or is the stubbing is only good for functions which have simple data and less read access to database?
P.S: I used online mode testing as well but that changes the state of the database which I cannot restore then

Answer 1

Testing functions with firestore is not easy. I have used a lot of energy to try different patterns, and ended up with this strategy.
Create generic methods in your project, for extracting data. For example a function called collectionQuery, docQuery etc.
Initialise the functions test in online mode. (this way you tests will not endless complain about things not being stubbed and mocked :))
Now in your tests, you can simply spy on your functions from step 1. If you create the functions, so that they return values, it becomes really easy.
Example of collectionQuery function (typescript):
/**
* The purpose of this relatively simple function is to query firestore!
* By wrapping the operation in a helper function, it becomes much easier to test.
* #export
* #template T Provide the variable type for the function
* #param {FirebaseFirestore.Firestore} afs The firestore instance, usefull for switching between functions/admin
* #param {FirebaseFirestore.Query} query The query to perform. By accepting a query, it becomes very flexpible
* #returns {Promise<Array<T>>} The result as an array
*/
export async function collectionQuery<T>(afs: FirebaseFirestore.Firestore, query: FirebaseFirestore.Query): Promise<Array<T>> {
try {
if (afs == null || query == null) {
throw new Error(`You must provide an firestore instance, or a query`);
}
const snapshot = await query.get();
const returnData: T[] = snapshot.docs.map((doc) => doc.data() as T);
return returnData;
} catch (error) {
throw new Error(`collectionQuery failed unexpected with: ${error.message}`);
}
}
The benefit is that in a unit test, I can now simply spy on this function. I am using Jest, so something like this:
jest.spyOn(firehelpers, 'collectionQuery').mockReturnValue([]} // simulate no data returned by query
jest.spyOn(firehelpers, 'collectionQuery').mockReturnValue([{foo: 'bar'}]} // One result returned
This strategy makes it easy to test functions that read and write to the db/firestore. Could also be used in combination with stubbing on the firebase libraries if needed.
Let me know if it helps :)