Ryan/Reactive-Resume
1
0
Fork 0
mirror of https://github.com/AmruthPillai/Reactive-Resume.git synced 2025-11-15 09:11:57 +10:00
Code Issues Packages Projects Releases Wiki Activity

Firebase stub: refactoring

Browse Source
This commit is contained in:
gianantoniopini
2020-12-23 14:15:57 +01:00
parent f73359f83a
commit 356ae08643
2 changed files with 164 additions and 181 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
__mocks__/__tests__/gatsby-plugin-firebase_2.test.js
View File

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

263
__mocks__/gatsby-plugin-firebase_2.js
View File

@ -48,38 +48,87 @@ class Auth {
}
}
class DataSnapshot {
#eventType = '';
#reference = null;
class Database {
static testUser = {
email: 'test.user@noemail.com',
name: 'Test User',
uid: 'testuser123',
};
static resumesPath = 'resumes';
static usersPath = 'users';
static #instance = undefined;
#uuid = '';
#data = {};
#references = {};
constructor(eventType, reference) {
if (!eventType) {
throw new Error('eventType must be provided.');
} else if (typeof eventType !== 'string') {
throw new Error('eventType should be a string.');
constructor() {
if (Database.#instance) {
return Database.#instance;
}
this.#eventType = eventType;
Database.#instance = this;
if (!reference) {
throw new Error('reference must be provided.');
} else if (!(reference instanceof Reference)) {
throw new Error('reference must be an instance of the Reference class.');
}
this.#reference = reference;
this.#uuid = uuidv4();
}
get eventType() {
return this.#eventType;
get testUser() {
return Database.testUser;
}
val() {
if (this.eventType === 'value') {
return this.#reference.getData();
get demoResumeId() {
return 'demore';
}
get emptyResumeId() {
return 'mtre01';
}
get uuid() {
return this.#uuid;
}
static readFile(fileRelativePath) {
const fileAbsolutePath = path.resolve(__dirname, fileRelativePath);
const fileBuffer = fs.readFileSync(fileAbsolutePath);
const fileData = JSON.parse(fileBuffer);
return fileData;
}
initializeData() {
const resumes = {};
const demoResume = Database.readFile('../src/data/demoState.json');
resumes[this.demoResumeId] = demoResume;
const emptyResume = Database.readFile('../src/data/initialState.json');
resumes[this.emptyResumeId] = emptyResume;
for (var key in resumes) {
const resume = resumes[key];
resume.id = key;
resume.name = `Test Resume ${key}`;
resume.user = this.testUser.uid;
let date = new Date('December 15, 2020 11:20:25');
resume.updatedAt = date.valueOf();
date.setMonth(date.getMonth() - 2);
resume.createdAt = date.valueOf();
}
return undefined;
this.#data[Database.resumesPath] = resumes;
const users = {};
users[this.testUser.uid] = this.testUser;
this.#data[Database.usersPath] = users;
}
ref(path) {
const newRef = new Reference(path, () => this.#data);
const existingRef = this.#references[newRef.path];
if (existingRef) {
return existingRef;
}
this.#references[newRef.path] = newRef;
return newRef;
}
}
@ -170,136 +219,70 @@ class Reference {
async update(value) {
return Promise.resolve(true);
}
/*
const update = async (value) => {
if (resumesPath) {
if (value === null) {
delete __resumesDictionary[databaseLocationId];
} else {
__resumesDictionary[databaseLocationId] = value;
}
}
return Promise.resolve(true);
};
const set = (value) => {
if (resumesPath) {
if (value === null) {
delete __resumesDictionary[databaseLocationId];
} else {
__resumesDictionary[databaseLocationId] = value;
}
}
return Promise.resolve(true);
};
*/
}
class Database {
static testUser = {
email: 'test.user@noemail.com',
name: 'Test User',
uid: 'testuser123',
};
static resumesPath = 'resumes';
static usersPath = 'users';
static #instance = undefined;
#uuid = '';
#data = {};
#references = {};
class DataSnapshot {
#eventType = '';
#reference = null;
constructor() {
if (Database.#instance) {
return Database.#instance;
constructor(eventType, reference) {
if (!eventType) {
throw new Error('eventType must be provided.');
} else if (typeof eventType !== 'string') {
throw new Error('eventType should be a string.');
}
Database.#instance = this;
this.#eventType = eventType;
this.#uuid = uuidv4();
}
get testUser() {
return Database.testUser;
}
get demoResumeId() {
return 'demore';
}
get emptyResumeId() {
return 'mtre01';
}
get uuid() {
return this.#uuid;
}
static readFile(fileRelativePath) {
const fileAbsolutePath = path.resolve(__dirname, fileRelativePath);
const fileBuffer = fs.readFileSync(fileAbsolutePath);
const fileData = JSON.parse(fileBuffer);
return fileData;
}
initializeData() {
const resumes = {};
const demoResume = Database.readFile('../src/data/demoState.json');
resumes[this.demoResumeId] = demoResume;
const emptyResume = Database.readFile('../src/data/initialState.json');
resumes[this.emptyResumeId] = emptyResume;
for (var key in resumes) {
const resume = resumes[key];
resume.id = key;
resume.name = `Test Resume ${key}`;
resume.user = this.testUser.uid;
let date = new Date('December 15, 2020 11:20:25');
resume.updatedAt = date.valueOf();
date.setMonth(date.getMonth() - 2);
resume.createdAt = date.valueOf();
if (!reference) {
throw new Error('reference must be provided.');
} else if (!(reference instanceof Reference)) {
throw new Error('reference must be an instance of the Reference class.');
}
this.#data[Database.resumesPath] = resumes;
const users = {};
users[this.testUser.uid] = this.testUser;
this.#data[Database.usersPath] = users;
this.#reference = reference;
}
ref(path) {
const newRef = new Reference(path, () => this.#data);
const existingRef = this.#references[newRef.path];
if (existingRef) {
return existingRef;
get eventType() {
return this.#eventType;
}
val() {
if (this.eventType === 'value') {
return this.#reference.getData();
}
this.#references[newRef.path] = newRef;
return newRef;
return undefined;
}
}
/*
const database = () => {
const ref = (path) => {
const set = (value) => {
if (resumesPath) {
if (value === null) {
delete __resumesDictionary[databaseLocationId];
} else {
__resumesDictionary[databaseLocationId] = value;
}
}
return Promise.resolve(true);
};
const update = async (value) => {
if (resumesPath) {
if (value === null) {
delete __resumesDictionary[databaseLocationId];
} else {
__resumesDictionary[databaseLocationId] = value;
}
}
return Promise.resolve(true);
};
return {
once,
set,
update,
};
};
return {
__demoResumeId,
__emptyResumeId,
__init,
ref,
};
};
*/
class FirebaseMock {
class FirebaseStub {
static auth() {
return new Auth();
}
@ -309,11 +292,11 @@ class FirebaseMock {
}
}
FirebaseMock.database.ServerValue = {};
Object.defineProperty(FirebaseMock.database.ServerValue, 'TIMESTAMP', {
FirebaseStub.database.ServerValue = {};
Object.defineProperty(FirebaseStub.database.ServerValue, 'TIMESTAMP', {
get() {
return new Date().getTime();
},
});
export default FirebaseMock;
export default FirebaseStub;