Dashboard test: draft version

__mocks__/gatsby-plugin-firebase.js

@@ -160,11 +160,14 @@ class Database {
 class Reference {
   static resumesPath = 'resumes';
   static usersPath = 'users';
+  static connectedPath = '/.info/connected';
   #rootPath = '.';
   #path = '';
   #uuid = '';
   #dataSnapshots = {};
   #getDatabaseData = () => null;
+  #orderByChildPath = '';
+  #equalToValue = '';
 
   constructor(path, getDatabaseData) {
     if (typeof path === 'undefined' || path === null) {
@@ -232,6 +235,24 @@ class Reference {
     return null;
   }
 
+  off() {}
+
+  on(eventType, callback) {
+    if (eventType !== 'value') {
+      return;
+    }
+
+    let snapshot = new DataSnapshot(eventType, this, null);
+
+    if (this.#path === Reference.connectedPath) {
+      snapshot = new DataSnapshot(eventType, this, true);
+    } else if (this.#path === Reference.resumesPath) {
+      snapshot = new DataSnapshot(eventType, this);
+    }
+
+    callback(snapshot);
+  }
+
   async once(eventType) {
     const newDataSnapshot = new DataSnapshot(eventType, this);
     const existingDataSnapshot = this.#dataSnapshots[newDataSnapshot.eventType];
@@ -243,6 +264,16 @@ class Reference {
     return Promise.resolve(newDataSnapshot);
   }
 
+  orderByChild(path) {
+    this.#orderByChildPath = path;
+    return this;
+  }
+
+  equalTo(value) {
+    this.#equalToValue = value;
+    return this;
+  }
+
   async update(value) {
     return Promise.resolve(true);
   }
@@ -255,8 +286,9 @@ class Reference {
 class DataSnapshot {
   #eventType = '';
   #reference = null;
+  #value = undefined;
 
-  constructor(eventType, reference) {
+  constructor(eventType, reference, value = undefined) {
     if (!eventType) {
       throw new Error('eventType must be provided.');
     } else if (typeof eventType !== 'string') {
@@ -272,15 +304,23 @@ class DataSnapshot {
     }
 
     this.#reference = reference;
+
+    this.#value = value;
   }
 
   get eventType() {
     return this.#eventType;
   }
 
+  get value() {
+    return this.#value;
+  }
+
   val() {
     if (this.eventType === 'value') {
-      return this.#reference.getData();
+      return typeof this.value !== 'undefined'
+        ? this.value
+        : this.#reference.getData();
     }
 
     return undefined;

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

@@ -1,7 +1,6 @@
 import React from 'react';
 import {
   act,
-  cleanup,
   fireEvent,
   render,
   screen,
@@ -25,8 +24,6 @@ beforeEach(() => {
   FirebaseStub.database().initializeData();
 });
 
-afterEach(cleanup);
-
 describe('Builder', () => {
   const resumesPath = FirebaseStub.database().resumesPath;
   let resumeId = null;

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

@@ -0,0 +1,71 @@
+import React from 'react';
+import { act, render, screen } from '@testing-library/react';
+
+import FirebaseStub from 'gatsby-plugin-firebase';
+
+import '../../../i18n/index';
+import { SettingsProvider } from '../../../contexts/SettingsContext';
+import { ModalProvider } from '../../../contexts/ModalContext';
+import { UserProvider } from '../../../contexts/UserContext';
+import { DatabaseProvider } from '../../../contexts/DatabaseContext';
+import { ResumeProvider } from '../../../contexts/ResumeContext';
+import { StorageProvider } from '../../../contexts/StorageContext';
+import Dashboard from '../dashboard';
+
+beforeEach(() => {
+  FirebaseStub.database().initializeData();
+});
+
+describe('Dashboard', () => {
+  const resumesPath = FirebaseStub.database().resumesPath;
+  let resumes = null;
+  let user = FirebaseStub.database().anonymousUser;
+  let container = null;
+
+  beforeEach(async () => {
+    resumes = (
+      await FirebaseStub.database()
+        .ref(resumesPath)
+        .orderByChild('user')
+        .equalTo(user.uid)
+        .once('value')
+    ).val();
+    expect(resumes).toBeTruthy();
+    expect(Object.keys(resumes).length).toEqual(2);
+
+    container = render(
+      <SettingsProvider>
+        <ModalProvider>
+          <UserProvider>
+            <DatabaseProvider>
+              <ResumeProvider>
+                <StorageProvider>
+                  <Dashboard user={user} />
+                </StorageProvider>
+              </ResumeProvider>
+            </DatabaseProvider>
+          </UserProvider>
+        </ModalProvider>
+      </SettingsProvider>,
+    );
+
+    await act(async () => {
+      await FirebaseStub.auth().signInAnonymously();
+    });
+  });
+
+  describe('renders', () => {
+    it('create resume', async () => {
+      expect(screen.getByText(new RegExp('Create Resume'))).toBeInTheDocument();
+    });
+
+    it('preview of user resumes', async () => {
+      expect(
+        screen.getByText(new RegExp(Object.values(resumes)[0].name)),
+      ).toBeInTheDocument();
+      expect(
+        screen.getByText(new RegExp(Object.values(resumes)[1].name)),
+      ).toBeInTheDocument();
+    });
+  });
+});

src/templates/__tests__/Castform.test.js

@@ -1,5 +1,5 @@
 import React from 'react';
-import { render, cleanup } from '@testing-library/react';
+import { render } from '@testing-library/react';
 import FirebaseStub from 'gatsby-plugin-firebase';
 
 import '../../i18n/index';
@@ -19,8 +19,6 @@ describe('Castform', () => {
     ).val();
   });
 
-  afterEach(cleanup);
-
   it('renders correctly', () => {
     const { container } = render(<Castform data={resume} />);