firestore-node-mock 0.0.1

package/mocks/fieldValue.js

@@ -0,0 +1,57 @@
+import { mock } from 'node:test';
+
+export const mockArrayUnionFieldValue = mock.fn();
+export const mockArrayRemoveFieldValue = mock.fn();
+export const mockDeleteFieldValue = mock.fn();
+export const mockIncrementFieldValue = mock.fn();
+export const mockServerTimestampFieldValue = mock.fn();
+
+export class FieldValue {
+  constructor(type, value) {
+    this.type = type;
+    this.value = value;
+  }
+
+  isEqual(other) {
+    return other instanceof FieldValue && other.type === this.type && other.value === this.value;
+  }
+
+  static arrayUnion(elements = []) {
+    mockArrayUnionFieldValue(...arguments);
+    if (!Array.isArray(elements)) {
+      elements = [elements];
+    }
+    return new FieldValue('arrayUnion', elements);
+  }
+
+  static arrayRemove(elements) {
+    mockArrayRemoveFieldValue(...arguments);
+    if (!Array.isArray(elements)) {
+      elements = [elements];
+    }
+    return new FieldValue('arrayRemove', elements);
+  }
+
+  static increment(amount = 1) {
+    mockIncrementFieldValue(...arguments);
+    return new FieldValue('increment', amount);
+  }
+
+  static serverTimestamp() {
+    mockServerTimestampFieldValue(...arguments);
+    return new FieldValue('serverTimestamp');
+  }
+
+  static delete() {
+    mockDeleteFieldValue(...arguments);
+    return new FieldValue('delete');
+  }
+}
+
+export const mocks = {
+  mockArrayUnionFieldValue,
+  mockArrayRemoveFieldValue,
+  mockDeleteFieldValue,
+  mockIncrementFieldValue,
+  mockServerTimestampFieldValue,
+};

package/mocks/firebase.d.ts

@@ -0,0 +1,37 @@
+import { Mock } from 'node:test';
+import type { FirebaseUser, FakeAuth } from './auth.js';
+import type { FakeFirestore } from './firestore.js';
+
+export interface DatabaseDocument {
+  id: string;
+  _collections?: DatabaseCollections;
+  [key: string]: unknown;
+}
+
+export interface DatabaseCollections {
+  [collectionName: string]: Array<DatabaseDocument> | undefined;
+}
+
+export type FakeFirestoreDocumentData = Record<string, unknown>;
+
+export interface StubOverrides {
+  database?: DatabaseCollections;
+  currentUser?: FirebaseUser;
+}
+
+type DefaultOptions = typeof import('./helpers/defaultMockOptions.js');
+export interface StubOptions extends Partial<DefaultOptions> {}
+
+export interface FirebaseMock {
+  initializeApp: Mock<any>;
+  credential: {
+    cert: Mock<any>;
+  };
+  auth(): FakeAuth;
+  firestore(): FakeFirestore;
+}
+
+export const firebaseStub: (overrides?: StubOverrides, options?: StubOptions) => FirebaseMock;
+export const mockFirebase: (overrides?: StubOverrides, options?: StubOptions) => void;
+export const mockInitializeApp: Mock<any>;
+export const mockCert: Mock<any>;

package/mocks/firebase.js

@@ -0,0 +1,79 @@
+import { mock } from 'node:test';
+import { createRequire } from 'node:module';
+import { FakeFirestore } from './firestore.js';
+import { FakeAuth } from './auth.js';
+import defaultOptions from './helpers/defaultMockOptions.js';
+
+const require = createRequire(import.meta.url);
+
+export const mockInitializeApp = mock.fn();
+export const mockCert = mock.fn();
+
+let activeOverrides = {};
+let activeOptions = defaultOptions;
+const mockedModules = new Set();
+
+export const firebaseStub = () => {
+  // Prepare namespaced classes
+  function firestoreConstructor() {
+    return new FakeFirestore(activeOverrides.database, activeOptions);
+  }
+
+  firestoreConstructor.Query = FakeFirestore.Query;
+  firestoreConstructor.CollectionReference = FakeFirestore.CollectionReference;
+  firestoreConstructor.DocumentReference = FakeFirestore.DocumentReference;
+  firestoreConstructor.FieldValue = FakeFirestore.FieldValue;
+  firestoreConstructor.Timestamp = FakeFirestore.Timestamp;
+  firestoreConstructor.Transaction = FakeFirestore.Transaction;
+  firestoreConstructor.FieldPath = FakeFirestore.FieldPath;
+
+  //Remove methods which do not exist in Firebase
+  delete firestoreConstructor.DocumentReference.prototype.listCollections;
+
+  // The Firebase mock
+  return {
+    initializeApp: mockInitializeApp,
+
+    credential: {
+      cert: mockCert,
+    },
+
+    auth() {
+      return new FakeAuth(activeOverrides.currentUser);
+    },
+
+    firestore: firestoreConstructor,
+  };
+};
+
+export const mockFirebase = (overrides = {}, options = defaultOptions) => {
+  activeOverrides = overrides;
+  activeOptions = options;
+
+  const moduleFound = 
+    mockModuleIfFound('firebase') |
+    mockModuleIfFound('firebase-admin');
+  
+  if (!moduleFound && mockedModules.size === 0) {
+    console.info(`Neither 'firebase' nor 'firebase-admin' modules found, mocking skipped.`);
+  }
+};
+
+function mockModuleIfFound(moduleName) {
+  if (mockedModules.has(moduleName)) {
+    return true;
+  }
+  try {
+    require.resolve(moduleName);
+    const stub = firebaseStub();
+    mock.module(moduleName, {
+      defaultExport: stub,
+      namedExports: stub,
+    });
+    mockedModules.add(moduleName);
+    return true;
+  } catch (e) {
+    // console.error(`Error mocking ${moduleName}:`, e);
+    return false;
+  }
+}

package/mocks/firestore.d.ts

@@ -0,0 +1,181 @@
+import { Mock } from 'node:test';
+import type { FieldValue } from './fieldValue.js';
+import type { Query } from './query.js';
+import type { Timestamp } from './timestamp.js';
+import type { Transaction } from './transaction.js';
+import type { FieldPath } from './path.js';
+
+import type { MockedDocument, DocumentData } from './helpers/buildDocFromHash.js';
+import type { MockedQuerySnapshot } from './helpers/buildQuerySnapShot.js';
+
+interface DatabaseDocument extends DocumentData {
+  id: string;
+  _collections?: DatabaseCollections;
+}
+
+interface DatabaseCollections {
+  [collectionName: string]: Array<DatabaseDocument> | undefined;
+}
+
+interface SetOptions {
+  merge?: boolean;
+}
+
+interface FirestoreBatch {
+  delete(): FirestoreBatch;
+  set(doc: DocumentReference, data: DocumentData, options?: SetOptions): FirestoreBatch;
+  update(doc: DocumentReference, data: DocumentData): FirestoreBatch;
+  create(doc: DocumentReference, data: DocumentData): FirestoreBatch;
+  commit(): Promise<void>;
+}
+
+export type FakeFirestoreDatabase = DatabaseCollections;
+
+export class FakeFirestore {
+  static FieldValue: typeof FieldValue;
+  static Timestamp: typeof Timestamp
+  static Query: typeof Query;
+  static Transaction: typeof Transaction;
+  static FieldPath: typeof FieldPath;
+
+  static DocumentReference: typeof DocumentReference;
+  static CollectionReference: typeof CollectionReference;
+
+  database: FakeFirestoreDatabase;
+  options: Record<string, never>;
+  query: Query;
+  collectionName: string;
+  
+  constructor(stubbedDatabase?: DatabaseCollections, options?: Record<string, never>);
+
+  getAll(): Array<MockedQuerySnapshot>;
+  batch(): FirestoreBatch;
+  settings(): void;
+  useEmulator(): void;
+  collection(collectionName: string): CollectionReference;
+  collectionGroup(collectionName: string): Query;
+  doc(path: string): DocumentReference;
+  runTransaction<T>(updateFunction: (transaction: Transaction) => Promise<T>): Promise<T>;
+  recursiveDelete(ref: DocumentReference|CollectionReference): Promise<void>;
+}
+
+declare class DocumentReference {
+  id: string;
+  parent: CollectionReference;
+  firestore: FakeFirestore;
+  path: string;
+  
+  constructor(id: string, parent: CollectionReference);
+
+  collection(collectionName: string): CollectionReference;
+  delete(): Promise<void>;
+  get(): Promise<MockedDocument>;
+
+  create(object: DocumentData): Promise<MockedDocument>;
+  update(object: DocumentData): Promise<MockedDocument>;
+  set(object: DocumentData): Promise<MockedDocument>;
+
+  isEqual(other: DocumentReference): boolean;
+
+  withConverter(): DocumentReference;
+
+  onSnapshot(callback: () => void, errorCallback: () => void): () => void;
+  onSnapshot(options: Record<string, never>, callback: () => void, errorCallback: () => void): () => void;
+
+  /** @deprecated Call the analagous method on a `Query` instance instead. */
+  orderBy(): never;
+
+  /** @deprecated Call the analagous method on a `Query` instance instead. */
+  limit(): never;
+
+  /** @deprecated Call the analagous method on a `Query` instance instead. */
+  offset(): never;
+
+  /** @deprecated Call the analagous method on a `Query` instance instead. */
+  startAfter(): never;
+
+  /** @deprecated Call the analagous method on a `Query` instance instead. */
+  startAt(): never;
+}
+
+declare class CollectionReference extends FakeFirestore.Query {
+  id: string;
+  parent: DocumentReference;
+  path: string;
+  
+  constructor(id: string, parent: DocumentReference, firestore?: FakeFirestore);
+
+  doc(id?: string): DocumentReference;
+  get(): Promise<MockedQuerySnapshot>;
+  add(data: DocumentData): Promise<DocumentReference>;
+  isEqual(other: CollectionReference): boolean;
+
+  /**
+   * An internal method, meant mainly to be used by `get` and other internal objects to retrieve
+   * the list of database records referenced by this CollectionReference.
+   * @returns An array of mocked document records.
+   */
+  private _records(): Array<MockedDocument>
+}
+
+// Mocks exported from this module
+export const mockBatch: Mock<any>;
+export const mockRunTransaction: Mock<any>;
+export const mockRecursiveDelete: Mock<any>;
+
+export const mockCollection: Mock<any>;
+export const mockCollectionGroup: Mock<any>;
+export const mockDoc: Mock<any>;
+export const mockCreate: Mock<any>;
+export const mockUpdate: Mock<any>;
+export const mockSet: Mock<any>;
+export const mockAdd: Mock<any>;
+export const mockDelete: Mock<any>;
+export const mockSettings: Mock<any>;
+
+// FIXME: We should decide whether this should be exported from auth or firestore
+export const mockUseEmulator: Mock<any>;
+export const mockListDocuments: Mock<any>;
+
+export const mockBatchDelete: Mock<any>;
+export const mockBatchCommit: Mock<any>;
+export const mockBatchUpdate: Mock<any>;
+export const mockBatchSet: Mock<any>;
+export const mockBatchCreate: Mock<any>;
+
+export const mockOnSnapShot: Mock<any>;
+
+// Mocks exported from FieldValue
+export const mockArrayUnionFieldValue: Mock<any>;
+export const mockArrayRemoveFieldValue: Mock<any>;
+export const mockDeleteFieldValue: Mock<any>;
+export const mockIncrementFieldValue: Mock<any>;
+export const mockServerTimestampFieldValue: Mock<any>;
+
+// Mocks exported from Query
+export const mockGet: Mock<any>;
+export const mockWhere: Mock<any>;
+export const mockLimit: Mock<any>;
+export const mockOrderBy: Mock<any>;
+export const mockOffset: Mock<any>;
+export const mockStartAfter: Mock<any>;
+export const mockStartAt: Mock<any>;
+export const mockQueryOnSnapshot: Mock<any>;
+export const mockQueryOnSnapshotUnsubscribe: Mock<any>;
+export const mockWithConverter: Mock<any>;
+
+// Mocks exported from Timestamp
+export const mockTimestampToDate: Mock<any>;
+export const mockTimestampToMillis: Mock<any>;
+export const mockTimestampFromDate: Mock<any>;
+export const mockTimestampFromMillis: Mock<any>;
+export const mockTimestampNow: Mock<any>;
+
+// Mocks exported from Transaction
+export const mockGetAll: Mock<any>;
+export const mockGetAllTransaction: Mock<any>;
+export const mockGetTransaction: Mock<any>;
+export const mockSetTransaction: Mock<any>;
+export const mockUpdateTransaction: Mock<any>;
+export const mockDeleteTransaction: Mock<any>;
+export const mockCreateTransaction: Mock<any>;