FirebaseStub: refactoring

__mocks__/__tests__/gatsby-plugin-firebase.test.js

@@ -1,173 +1,182 @@
 import FirebaseStub from '../gatsby-plugin-firebase';
 
-describe('auth', () => {
+describe('FirebaseStub', () => {
-  afterEach(() => {
+  const resumesPath = FirebaseStub.database().resumesPath;
-    FirebaseStub.auth().dispose();
+  const usersPath = FirebaseStub.database().usersPath;
+
+  describe('auth', () => {
+    afterEach(() => {
+      FirebaseStub.auth().dispose();
+    });
+
+    it('reuses existing Auth instance', () => {
+      const auth1 = FirebaseStub.auth();
+      const auth2 = FirebaseStub.auth();
+
+      expect(auth1.uuid).toBeTruthy();
+      expect(auth2.uuid).toBeTruthy();
+      expect(auth1.uuid).toEqual(auth2.uuid);
+    });
+
+    it('returns anonymous user when signing in anonymously', async () => {
+      const user = await FirebaseStub.auth().signInAnonymously();
+
+      expect(user).toBeTruthy();
+      expect(user).toEqual(FirebaseStub.auth().anonymousUser);
+    });
+
+    it('calls onAuthStateChanged observer with anonymous user when signing in anonymously', async () => {
+      let user = null;
+      let error = null;
+      FirebaseStub.auth().onAuthStateChanged(
+        (_user) => {
+          user = _user;
+        },
+        (_error) => {
+          error = _error;
+        },
+      );
+
+      await FirebaseStub.auth().signInAnonymously();
+
+      expect(user).toBeTruthy();
+      expect(user).toEqual(FirebaseStub.auth().anonymousUser);
+      expect(error).toBeNull();
+    });
+
+    it('onAuthStateChanged unsubscribe removes observer', () => {
+      const observer = () => {};
+      const unsubscribe = FirebaseStub.auth().onAuthStateChanged(observer);
+      expect(unsubscribe).toBeTruthy();
+      expect(FirebaseStub.auth().onAuthStateChangedObservers.length).toEqual(1);
+      expect(FirebaseStub.auth().onAuthStateChangedObservers[0]).toEqual(
+        observer,
+      );
+
+      unsubscribe();
+
+      expect(FirebaseStub.auth().onAuthStateChangedObservers.length).toEqual(0);
+    });
   });
 
-  it('reuses existing Auth instance', () => {
+  describe('database', () => {
-    const auth1 = FirebaseStub.auth();
+    it('reuses existing Database instance', () => {
-    const auth2 = FirebaseStub.auth();
+      const database1 = FirebaseStub.database();
+      const database2 = FirebaseStub.database();
 
-    expect(auth1.uuid).toBeTruthy();
+      expect(database1.uuid).toBeTruthy();
-    expect(auth2.uuid).toBeTruthy();
+      expect(database2.uuid).toBeTruthy();
-    expect(auth1.uuid).toEqual(auth2.uuid);
+      expect(database1.uuid).toEqual(database2.uuid);
-  });
+    });
 
-  it('returns anonymous user when signing in anonymously', async () => {
+    it('reuses existing Reference instance', () => {
-    const user = await FirebaseStub.auth().signInAnonymously();
+      const ref1 = FirebaseStub.database().ref(`${resumesPath}/123`);
+      const ref2 = FirebaseStub.database().ref(`${resumesPath}/123`);
 
-    expect(user).toBeTruthy();
+      expect(ref1.uuid).toBeTruthy();
-    expect(user).toEqual(FirebaseStub.auth().anonymousUser);
+      expect(ref2.uuid).toBeTruthy();
-  });
+      expect(ref1.uuid).toEqual(ref2.uuid);
+    });
 
-  it('calls onAuthStateChanged observer with anonymous user when signing in anonymously', async () => {
+    it('ServerValue.TIMESTAMP returns current time in milliseconds', () => {
-    let user = null;
+      const now = new Date().getTime();
-    let error = null;
+      const timestamp = FirebaseStub.database.ServerValue.TIMESTAMP;
-    FirebaseStub.auth().onAuthStateChanged(
-      (_user) => {
-        user = _user;
-      },
-      (_error) => {
-        error = _error;
-      },
-    );
 
-    await FirebaseStub.auth().signInAnonymously();
+      expect(timestamp).toBeTruthy();
+      expect(timestamp).toBeGreaterThanOrEqual(now);
+    });
 
-    expect(user).toBeTruthy();
+    it("can spy on Reference 'update' function", async () => {
-    expect(user).toEqual(FirebaseStub.auth().anonymousUser);
+      const referencePath = `${resumesPath}/123456`;
-    expect(error).toBeNull();
+      const functionSpy = jest.spyOn(
-  });
+        FirebaseStub.database().ref(referencePath),
+        'update',
+      );
+      const updateArgument = 'test value 123';
 
-  it('onAuthStateChanged unsubscribe removes observer', () => {
+      await FirebaseStub.database().ref(referencePath).update(updateArgument);
-    const observer = () => {};
-    const unsubscribe = FirebaseStub.auth().onAuthStateChanged(observer);
-    expect(unsubscribe).toBeTruthy();
-    expect(FirebaseStub.auth().onAuthStateChangedObservers.length).toEqual(1);
-    expect(FirebaseStub.auth().onAuthStateChangedObservers[0]).toEqual(
-      observer,
-    );
 
-    unsubscribe();
+      expect(functionSpy).toHaveBeenCalledTimes(1);
+      const functionCallArgument = functionSpy.mock.calls[0][0];
+      expect(functionCallArgument).toBeTruthy();
+      expect(functionCallArgument).toEqual(updateArgument);
+    });
 
-    expect(FirebaseStub.auth().onAuthStateChangedObservers.length).toEqual(0);
+    it('initializing data sets up resumes and users', async () => {
-  });
+      FirebaseStub.database().initializeData();
-});
+
-
+      const resumesRef = FirebaseStub.database().ref(resumesPath);
-describe('database', () => {
+      const resumesDataSnapshot = await resumesRef.once('value');
-  it('reuses existing Database instance', () => {
+      const resumes = resumesDataSnapshot.val();
-    const database1 = FirebaseStub.database();
+      expect(resumes).toBeTruthy();
-    const database2 = FirebaseStub.database();
+      expect(Object.keys(resumes).length).toEqual(2);
-
+      const demoResume = resumes[FirebaseStub.database().demoResumeId];
-    expect(database1.uuid).toBeTruthy();
+      expect(demoResume).toBeTruthy();
-    expect(database2.uuid).toBeTruthy();
+      expect(demoResume.id).toEqual(FirebaseStub.database().demoResumeId);
-    expect(database1.uuid).toEqual(database2.uuid);
+      const emptyResume = resumes[FirebaseStub.database().emptyResumeId];
-  });
+      expect(emptyResume).toBeTruthy();
-
+      expect(emptyResume.id).toEqual(FirebaseStub.database().emptyResumeId);
-  it('reuses existing Reference instance', () => {
+
-    const ref1 = FirebaseStub.database().ref('resumes/123');
+      const usersRef = FirebaseStub.database().ref(usersPath);
-    const ref2 = FirebaseStub.database().ref('resumes/123');
+      const usersDataSnapshot = await usersRef.once('value');
-
+      const users = usersDataSnapshot.val();
-    expect(ref1.uuid).toBeTruthy();
+      expect(users).toBeTruthy();
-    expect(ref2.uuid).toBeTruthy();
+      expect(Object.keys(users).length).toEqual(1);
-    expect(ref1.uuid).toEqual(ref2.uuid);
+      const anonymousUser = users[FirebaseStub.database().anonymousUser.uid];
-  });
+      expect(anonymousUser).toBeTruthy();
-
+      expect(anonymousUser).toEqual(FirebaseStub.database().anonymousUser);
-  it('ServerValue.TIMESTAMP returns current time in milliseconds', () => {
+    });
-    const now = new Date().getTime();
+
-    const timestamp = FirebaseStub.database.ServerValue.TIMESTAMP;
+    it('retrieves resume if it exists', async () => {
-
+      FirebaseStub.database().initializeData();
-    expect(timestamp).toBeTruthy();
+
-    expect(timestamp).toBeGreaterThanOrEqual(now);
+      const resume = (
-  });
+        await FirebaseStub.database()
-
+          .ref(`${resumesPath}/${FirebaseStub.database().demoResumeId}`)
-  it("can spy on Reference 'update' function", async () => {
+          .once('value')
-    const referencePath = 'resumes/123456';
+      ).val();
-    const functionSpy = jest.spyOn(
+
-      FirebaseStub.database().ref(referencePath),
+      expect(resume).toBeTruthy();
-      'update',
+      expect(resume.id).toEqual(FirebaseStub.database().demoResumeId);
-    );
+    });
-    const updateArgument = 'test value 123';
+
-
+    it('retrieves null if resume does not exist', async () => {
-    await FirebaseStub.database().ref(referencePath).update(updateArgument);
+      FirebaseStub.database().initializeData();
-
+      const resumeId = 'invalidResumeId';
-    expect(functionSpy).toHaveBeenCalledTimes(1);
+
-    const functionCallArgument = functionSpy.mock.calls[0][0];
+      const resume = (
-    expect(functionCallArgument).toBeTruthy();
+        await FirebaseStub.database()
-    expect(functionCallArgument).toEqual(updateArgument);
+          .ref(`${resumesPath}/${resumeId}`)
-  });
+          .once('value')
-
+      ).val();
-  it('initializing data sets up resumes and users', async () => {
+
-    FirebaseStub.database().initializeData();
+      expect(resume).toBeNull();
-
+    });
-    const resumesRef = FirebaseStub.database().ref('resumes');
+
-    const resumesDataSnapshot = await resumesRef.once('value');
+    it('retrieves user if it exists', async () => {
-    const resumes = resumesDataSnapshot.val();
+      FirebaseStub.database().initializeData();
-    expect(resumes).toBeTruthy();
+
-    expect(Object.keys(resumes).length).toEqual(2);
+      const user = (
-    const demoResume = resumes[FirebaseStub.database().demoResumeId];
+        await FirebaseStub.database()
-    expect(demoResume).toBeTruthy();
+          .ref(`${usersPath}/${FirebaseStub.database().anonymousUser.uid}`)
-    expect(demoResume.id).toEqual(FirebaseStub.database().demoResumeId);
+          .once('value')
-    const emptyResume = resumes[FirebaseStub.database().emptyResumeId];
+      ).val();
-    expect(emptyResume).toBeTruthy();
+
-    expect(emptyResume.id).toEqual(FirebaseStub.database().emptyResumeId);
+      expect(user).toBeTruthy();
-
+      expect(user).toEqual(FirebaseStub.database().anonymousUser);
-    const usersRef = FirebaseStub.database().ref('users');
+    });
-    const usersDataSnapshot = await usersRef.once('value');
+
-    const users = usersDataSnapshot.val();
+    it('retrieves null if user does not exist', async () => {
-    expect(users).toBeTruthy();
+      FirebaseStub.database().initializeData();
-    expect(Object.keys(users).length).toEqual(1);
+      const userId = 'invalidUserId';
-    const anonymousUser = users[FirebaseStub.database().anonymousUser.uid];
+
-    expect(anonymousUser).toBeTruthy();
+      const user = (
-    expect(anonymousUser).toEqual(FirebaseStub.database().anonymousUser);
+        await FirebaseStub.database()
-  });
+          .ref(`${usersPath}/${userId}`)
-
+          .once('value')
-  it('retrieves resume if it exists', async () => {
+      ).val();
-    FirebaseStub.database().initializeData();
+
-
+      expect(user).toBeNull();
-    const resume = (
+    });
-      await FirebaseStub.database()
-        .ref(`resumes/${FirebaseStub.database().demoResumeId}`)
-        .once('value')
-    ).val();
-
-    expect(resume).toBeTruthy();
-    expect(resume.id).toEqual(FirebaseStub.database().demoResumeId);
-  });
-
-  it('retrieves null if resume does not exist', async () => {
-    FirebaseStub.database().initializeData();
-    const resumeId = 'invalidResumeId';
-
-    const resume = (
-      await FirebaseStub.database().ref(`resumes/${resumeId}`).once('value')
-    ).val();
-
-    expect(resume).toBeNull();
-  });
-
-  it('retrieves user if it exists', async () => {
-    FirebaseStub.database().initializeData();
-
-    const user = (
-      await FirebaseStub.database()
-        .ref(`users/${FirebaseStub.database().anonymousUser.uid}`)
-        .once('value')
-    ).val();
-
-    expect(user).toBeTruthy();
-    expect(user).toEqual(FirebaseStub.database().anonymousUser);
-  });
-
-  it('retrieves null if user does not exist', async () => {
-    FirebaseStub.database().initializeData();
-    const userId = 'invalidUserId';
-
-    const user = (
-      await FirebaseStub.database().ref(`users/${userId}`).once('value')
-    ).val();
-
-    expect(user).toBeNull();
   });
 });

__mocks__/gatsby-plugin-firebase.js

@@ -60,13 +60,13 @@ class Auth {
 }
 
 class Database {
-  static resumesPath = 'resumes';
-  static usersPath = 'users';
   static #instance = undefined;
   #uuid = '';
   #data = {};
   #references = {};
   #anonymousUser = undefined;
+  #demoResumeId = 'demore';
+  #emptyResumeId = 'mtre01';
 
   constructor() {
     if (Database.#instance) {
@@ -82,15 +82,23 @@ class Database {
     };
   }
 
+  get resumesPath() {
+    return Reference.resumesPath;
+  }
+
+  get usersPath() {
+    return Reference.usersPath;
+  }
+
   get anonymousUser() {
     return this.#anonymousUser;
   }
 
   get demoResumeId() {
-    return 'demore';
+    return this.#demoResumeId;
   }
   get emptyResumeId() {
-    return 'mtre01';
+    return this.#emptyResumeId;
   }
 
   get uuid() {
@@ -124,11 +132,11 @@ class Database {
       resume.createdAt = date.valueOf();
     }
 
-    this.#data[Database.resumesPath] = resumes;
+    this.#data[this.resumesPath] = resumes;
 
     const users = {};
     users[this.anonymousUser.uid] = this.anonymousUser;
-    this.#data[Database.usersPath] = users;
+    this.#data[this.usersPath] = users;
   }
 
   ref(path) {
@@ -144,6 +152,8 @@ class Database {
 }
 
 class Reference {
+  static resumesPath = 'resumes';
+  static usersPath = 'users';
   #rootPath = '.';
   #path = '';
   #uuid = '';
@@ -188,15 +198,15 @@ class Reference {
     }
 
     if (
-      this.#path === Database.resumesPath ||
+      this.#path === Reference.resumesPath ||
-      this.#path === Database.usersPath
+      this.#path === Reference.usersPath
     ) {
       return this.#path in databaseData ? databaseData[this.#path] : null;
     }
 
     if (
-      this.#path.startsWith(`${Database.resumesPath}/`) ||
+      this.#path.startsWith(`${Reference.resumesPath}/`) ||
-      this.#path.startsWith(`${Database.usersPath}/`)
+      this.#path.startsWith(`${Reference.usersPath}/`)
     ) {
       const databaseLocationId = this.#path.substring(
         this.#path.indexOf('/') + 1,

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

@@ -26,6 +26,7 @@ beforeEach(() => {
 afterEach(cleanup);
 
 describe('builder', () => {
+  const resumesPath = FirebaseStub.database().resumesPath;
   let resumeId = null;
   let resume = null;
   let mockUpdateFunction = null;
@@ -34,10 +35,12 @@ describe('builder', () => {
   beforeEach(async () => {
     resumeId = FirebaseStub.database().demoResumeId;
     resume = (
-      await FirebaseStub.database().ref(`resumes/${resumeId}`).once('value')
+      await FirebaseStub.database()
+        .ref(`${resumesPath}/${resumeId}`)
+        .once('value')
     ).val();
     mockUpdateFunction = jest.spyOn(
-      FirebaseStub.database().ref(`resumes/${resumeId}`),
+      FirebaseStub.database().ref(`${resumesPath}/${resumeId}`),
       'update',
     );