feat: allow mocking FirebaseFunctionsRateLimiter

Author: Jblew

src/FirebaseFunctionsRateLimiter.integration.test.ts

@@ -34,12 +34,12 @@ afterEach(async () => {
 
 //
 describe("FirebaseFunctionsRateLimiter", () => {
-    const backends: Array<"firestore" | "realtimedb"> = ["firestore", "realtimedb"];
-    backends.forEach((backend: "firestore" | "realtimedb") =>
+    const backends: Array<"firestore" | "realtimedb" | "mock"> = ["firestore", "realtimedb", "mock"];
+    backends.forEach((backend: "firestore" | "realtimedb" | "mock") =>
         describe("Backend " + backend, () => {
             describe("isQuotaExceeded", () => {
                 it("Uses qualifier to identify document in the collection", async () => {
-                    const { rateLimiter, uniqueCollectionName, qualifier, getDocument } = mock("firestore", {});
+                    const { rateLimiter, uniqueCollectionName, qualifier, getDocument } = mock(backend, {});
                     await rateLimiter.isQuotaExceeded(qualifier);
 
                     const doc = await getDocument(uniqueCollectionName, qualifier);
@@ -51,7 +51,7 @@ describe("FirebaseFunctionsRateLimiter", () => {
                 });
 
                 it("Increments counter when limit is not exceeded", async () => {
-                    const { rateLimiter, getDocument, uniqueCollectionName, qualifier } = mock("firestore", {
+                    const { rateLimiter, getDocument, uniqueCollectionName, qualifier } = mock(backend, {
                         maxCalls: 10,
                     });
 

src/FirebaseFunctionsRateLimiter.mock.integration.test.ts

@@ -6,31 +6,42 @@ import * as uuid from "uuid/v4";
 
 import { FirebaseFunctionsRateLimiter } from "./FirebaseFunctionsRateLimiter";
 import { FirebaseFunctionsRateLimiterConfiguration } from "./FirebaseFunctionsRateLimiterConfiguration";
+import { PersistenceProviderMock } from "./persistence/PersistenceProviderMock";
 
-export function mock(backend: "firestore" | "realtimedb", configApply: FirebaseFunctionsRateLimiterConfiguration) {
+export function mock(
+    backend: "firestore" | "realtimedb" | "mock",
+    configApply: FirebaseFunctionsRateLimiterConfiguration,
+) {
     const app = firebase.initializeTestApp({ projectId: "unit-testing-" + Date.now(), databaseName: "db" });
     const uniqueCollectionName = uuid();
     const uniqueDocName = uuid();
     const qualifier = uuid();
     const firestore = app.firestore();
     const database = app.database();
+    const persistenceProviderMock = new PersistenceProviderMock();
     async function getDocument(collection: string, doc: string): Promise<any> {
         if (backend === "firestore") {
             return (await firestore
                 .collection(collection)
                 .doc(doc)
                 .get()).data();
-        } else return (await database.ref(`${collection}/${doc}`).once("value")).val();
+        } else if (backend === "realtimedb") {
+            return (await database.ref(`${collection}/${doc}`).once("value")).val();
+        } else if (backend === "mock") {
+            return persistenceProviderMock.getRecord(collection, doc);
+        } else throw new Error("Unknown backend " + backend);
     }
     const config: FirebaseFunctionsRateLimiterConfiguration = {
         name: uniqueCollectionName,
         debug: false,
         ...configApply,
     };
-    const rateLimiter =
-        backend === "firestore"
-            ? FirebaseFunctionsRateLimiter.withFirestoreBackend(config, firestore)
-            : FirebaseFunctionsRateLimiter.withRealtimeDbBackend(config, database);
+    let rateLimiter: FirebaseFunctionsRateLimiter;
+    if (backend === "firestore") rateLimiter = FirebaseFunctionsRateLimiter.withFirestoreBackend(config, firestore);
+    else if (backend === "realtimedb") {
+        rateLimiter = FirebaseFunctionsRateLimiter.withRealtimeDbBackend(config, database);
+    } else if (backend === "mock") rateLimiter = FirebaseFunctionsRateLimiter.mock(config, persistenceProviderMock);
+    else throw new Error("Unknown backend " + backend);
     return {
         app,
         firestore,

src/FirebaseFunctionsRateLimiter.ts

@@ -7,6 +7,7 @@ import { FirebaseFunctionsRateLimiterConfiguration } from "./FirebaseFunctionsRa
 import { GenericRateLimiter } from "./GenericRateLimiter";
 import { FirestorePersistenceProvider } from "./persistence/FirestorePersistenceProvider";
 import { PersistenceProvider } from "./persistence/PersistenceProvider";
+import { PersistenceProviderMock } from "./persistence/PersistenceProviderMock";
 import { RealtimeDbPersistenceProvider } from "./persistence/RealtimeDbPersistenceProvider";
 import { FirebaseTimestampProvider } from "./timestamp/FirebaseTimestampProvider";
 import { FirestoreEquivalent } from "./types/FirestoreEquivalent";
@@ -29,6 +30,18 @@ export class FirebaseFunctionsRateLimiter {
         return new FirebaseFunctionsRateLimiter(configuration, provider);
     }
 
+    public static mock(
+        configuration?: FirebaseFunctionsRateLimiterConfiguration,
+        persistenceProviderMock?: PersistenceProviderMock,
+    ): FirebaseFunctionsRateLimiter {
+        const defaultConfig: FirebaseFunctionsRateLimiterConfiguration = {
+            periodSeconds: 10,
+            maxCalls: Number.MAX_SAFE_INTEGER,
+        };
+        const provider = persistenceProviderMock || new PersistenceProviderMock();
+        return new FirebaseFunctionsRateLimiter(configuration || defaultConfig, provider);
+    }
+
     private configurationFull: FirebaseFunctionsRateLimiterConfiguration.ConfigurationFull;
     private genericRateLimiter: GenericRateLimiter;
     private debugFn: (msg: string) => void;

src/GenericRateLimiter.spec.test.ts

@@ -7,7 +7,7 @@ import { SinonSpy, spy } from "sinon";
 
 import { FirebaseFunctionsRateLimiterConfiguration } from "./FirebaseFunctionsRateLimiterConfiguration";
 import { GenericRateLimiter } from "./GenericRateLimiter";
-import { PersistenceProviderMock } from "./persistence/PersistenceProviderMock.test";
+import { PersistenceProviderMock } from "./persistence/PersistenceProviderMock";
 import { TimestampProviderMock } from "./timestamp/TimestampProviderMock.test";
 
 chaiUse(chaiAsPromised);

src/persistence/PersistenceProviderMock.test.ts renamed to src/persistence/PersistenceProviderMock.ts

@@ -26,16 +26,16 @@ export class PersistenceProviderMock implements PersistenceProvider {
         //
     }
 
-    private async runTransaction(asyncTransactionFn: () => Promise<void>): Promise<void> {
-        await asyncTransactionFn();
-    }
-
-    private async getRecord(collectionName: string, recordName: string): Promise<PersistenceRecord> {
+    public async getRecord(collectionName: string, recordName: string): Promise<PersistenceRecord> {
         await BluebirdPromise.delay(2);
         const key = this.getKey(collectionName, recordName);
         return this.persistenceObject[key] || this.createEmptyRecord();
     }
 
+    private async runTransaction(asyncTransactionFn: () => Promise<void>): Promise<void> {
+        await asyncTransactionFn();
+    }
+
     private async saveRecord(collectionName: string, recordName: string, record: PersistenceRecord): Promise<void> {
         await BluebirdPromise.delay(2);
         const key = this.getKey(collectionName, recordName);