Firebase mock: refactoring to mock functions with specific arguments

__mocks__/gatsby-plugin-firebase.js

@@ -1,34 +1,33 @@
 import path from 'path';
 import fs from 'fs';
 
-const testUser = {
+const __testUser = {
   email: 'test.user@noemail.com',
   name: 'Test User',
   uid: 'testuser123',
 };
-let onAuthStateChangedObservers = [];
-let resumesDictionary = {};
-let useDemoResume = false;
+let __onAuthStateChangedObservers = [];
+let __resumesDictionary = {};
 
 const auth = () => {
   const __init = () => {
-    onAuthStateChangedObservers = [];
+    __onAuthStateChangedObservers = [];
   };
 
   const onAuthStateChanged = (observer) => {
-    onAuthStateChangedObservers.push(observer);
+    __onAuthStateChangedObservers.push(observer);
 
     return () => {
-      onAuthStateChangedObservers = onAuthStateChangedObservers.filter(
+      __onAuthStateChangedObservers = __onAuthStateChangedObservers.filter(
         (observer) => observer !== observer,
       );
     };
   };
 
   const signInAnonymously = async () => {
-    onAuthStateChangedObservers.forEach((observer) => observer(testUser));
+    __onAuthStateChangedObservers.forEach((observer) => observer(__testUser));
 
-    var result = await Promise.resolve(testUser);
+    var result = await Promise.resolve(__testUser);
     return result;
   };
 
@@ -40,24 +39,23 @@ const auth = () => {
 };
 
 const database = () => {
-  const demoResumeId = 'demore';
-  const emptyResumeId = 'mtre01';
+  const __demoResumeId = 'demore';
+  const __emptyResumeId = 'mtre01';
 
   const __init = () => {
-    resumesDictionary = {};
-    useDemoResume = false;
+    __resumesDictionary = {};
 
     const demoResume = __readFile('../src/data/demoState.json');
-    resumesDictionary[demoResumeId] = demoResume;
+    __resumesDictionary[__demoResumeId] = demoResume;
     const emptyResume = __readFile('../src/data/initialState.json');
-    resumesDictionary[emptyResumeId] = emptyResume;
+    __resumesDictionary[__emptyResumeId] = emptyResume;
 
-    for (var key in resumesDictionary) {
-      const resume = resumesDictionary[key];
+    for (var key in __resumesDictionary) {
+      const resume = __resumesDictionary[key];
 
       resume.id = key;
       resume.name = `Test Resume ${key}`;
-      resume.user = testUser.uid;
+      resume.user = __testUser.uid;
 
       let date = new Date('December 15, 2020 11:20:25');
       resume.updatedAt = date.valueOf();
@@ -73,25 +71,71 @@ const database = () => {
     return fileData;
   };
 
-  const __getResume = () => {
-    return useDemoResume
-      ? resumesDictionary[demoResumeId]
-      : resumesDictionary[emptyResumeId];
-  };
+  const ref = (path) => {
+    if (!path) {
+      throw new Error('Not implemented.');
+    }
 
-  const __useDemoResume = (value) => {
-    useDemoResume = value;
+    const resumesPath = path.startsWith('resumes/');
+    const usersPath = path.startsWith('users/');
+    if (!resumesPath && !usersPath) {
+      throw new Error('Unknown Reference path.');
+    }
+
+    const databaseLocationId = path.substring(path.indexOf('/') + 1);
+    if (!databaseLocationId) {
+      throw new Error('Unknown database location id.');
+    }
+
+    const once = async (eventType) => {
+      if (!eventType) {
+        throw new Error('Event type must be provided.');
+      }
+
+      if (eventType !== 'value') {
+        throw new Error('Unknown event type.');
+      }
+
+      const val = () => {
+        if (resumesPath) {
+          return __resumesDictionary[databaseLocationId]
+            ? __resumesDictionary[databaseLocationId]
+            : null;
+        }
+
+        if (usersPath) {
+          return __testUser;
+        }
+
+        return null;
+      };
+
+      return Promise.resolve({ val });
+    };
+
+    const set = (value) => {
+      if (resumesPath) {
+        if (value === null) {
+          delete __resumesDictionary[databaseLocationId];
+        } else {
+          __resumesDictionary[databaseLocationId] = value;
+        }
+      }
+
+      return Promise.resolve();
+    };
+
+    return {
+      once,
+      set,
+    };
   };
 
   return {
+    __demoResumeId,
+    __emptyResumeId,
     __init,
-    __getResume,
-    __useDemoResume,
-    ref: jest.fn().mockReturnValue({
-      once: jest.fn().mockResolvedValue({
-        val: jest.fn(__getResume),
-      }),
-    }),
+    ref,
   };
 };
 

src/pages/app/__tests__/builder.test.js

@@ -9,8 +9,6 @@ import { ResumeProvider } from '../../../contexts/ResumeContext';
 import { StorageProvider } from '../../../contexts/StorageContext';
 import Builder from '../builder';
 
-let resume = null;
-
 beforeEach(() => {
   firebaseMock.auth().__init();
   firebaseMock.database().__init();
@@ -19,10 +17,15 @@ beforeEach(() => {
 afterEach(cleanup);
 
 describe('builder', () => {
+  let resumeId = null;
+  let resume = null;
+
   describe('with demo resume', () => {
     beforeEach(async () => {
-      firebaseMock.database().__useDemoResume(true);
-      resume = firebaseMock.database().__getResume();
+      resumeId = firebaseMock.database().__demoResumeId;
+      resume = (
+        await firebaseMock.database().ref(`resumes/${resumeId}`).once('value')
+      ).val();
 
       render(
         <UserProvider>
@@ -59,8 +62,10 @@ describe('builder', () => {
 
   describe('with empty resume', () => {
     beforeEach(async () => {
-      firebaseMock.database().__useDemoResume(false);
-      resume = firebaseMock.database().__getResume();
+      resumeId = firebaseMock.database().__emptyResumeId;
+      resume = (
+        await firebaseMock.database().ref(`resumes/${resumeId}`).once('value')
+      ).val();
 
       render(
         <UserProvider>