firestore-node-mock 0.0.1

package/mocks/reactNativeFirebaseFirestore.js

@@ -0,0 +1,43 @@
+import { mock } from 'node:test';
+import { createRequire } from 'node:module';
+import { FakeFirestore } from './firestore.js';
+import defaultOptions from './helpers/defaultMockOptions.js';
+
+const require = createRequire(import.meta.url);
+
+export const firestoreStub = (overrides, options = defaultOptions) => {
+  class Firestore extends FakeFirestore {
+    constructor() {
+      super(overrides.database, options);
+    }
+  }
+  return {
+    Query: FakeFirestore.Query,
+    CollectionReference: FakeFirestore.CollectionReference,
+    DocumentReference: FakeFirestore.DocumentReference,
+    FieldValue: FakeFirestore.FieldValue,
+    FieldPath: FakeFirestore.FieldPath,
+    Timestamp: FakeFirestore.Timestamp,
+    Transaction: FakeFirestore.Transaction,
+    /** @type {Firestore.constructor} */
+    Firestore,
+  };
+};
+
+export const mockReactNativeFirestore = (overrides = {}, options = defaultOptions) => {
+  mockModuleIfFound('@react-native-firebase/firestore', overrides, options);
+};
+
+function mockModuleIfFound(moduleName, overrides, options) {
+  try {
+    require.resolve(moduleName);
+    const stub = firestoreStub(overrides, options);
+    mock.module(moduleName, {
+        defaultExport: stub,
+        namedExports: stub,
+    });
+  } catch (e) {
+    // eslint-disable-next-line no-console
+    console.info(`Module ${moduleName} not found, mocking skipped.`);
+  }
+}

package/mocks/timestamp.d.ts

@@ -0,0 +1,22 @@
+import { Mock } from 'node:test';
+
+export class Timestamp {
+  constructor(seconds: number, nanoseconds: number);
+
+  isEqual(other: Timestamp): boolean;
+  toDate(): Date;
+  toMillis(): number;
+  valueOf(): string;
+
+  static fromDate(date: Date): Timestamp;
+  static fromMillis(millis: number): Timestamp;
+  static now(): Timestamp;
+}
+
+export const mocks: {
+  mockTimestampToDate: Mock<any>;
+  mockTimestampToMillis: Mock<any>;
+  mockTimestampFromDate: Mock<any>;
+  mockTimestampFromMillis: Mock<any>;
+  mockTimestampNow: Mock<any>;
+};

package/mocks/timestamp.js

@@ -0,0 +1,103 @@
+import { mock } from 'node:test';
+
+export const mockTimestampToDate = mock.fn();
+export const mockTimestampToMillis = mock.fn();
+export const mockTimestampFromDate = mock.fn();
+export const mockTimestampFromMillis = mock.fn();
+export const mockTimestampNow = mock.fn();
+
+export class Timestamp {
+  constructor(seconds, nanoseconds) {
+    this.seconds = seconds;
+    this.nanoseconds = nanoseconds;
+  }
+
+  isEqual(other) {
+    return (
+      other instanceof Timestamp &&
+      other.seconds === this.seconds &&
+      other.nanoseconds === this.nanoseconds
+    );
+  }
+
+  toDate() {
+    return mockTimestampToDate(...arguments) || new Date(this._toMillis());
+  }
+
+  toMillis() {
+    return mockTimestampToMillis(...arguments) || this._toMillis();
+  }
+
+  valueOf() {
+    return JSON.stringify(this.toMillis());
+  }
+
+  static fromDate(date) {
+    return mockTimestampFromDate(...arguments) || Timestamp._fromMillis(date.getTime());
+  }
+
+  static fromMillis(millis) {
+    return mockTimestampFromMillis(...arguments) || Timestamp._fromMillis(millis);
+  }
+
+  static _fromMillis(millis) {
+    const seconds = Math.floor(millis / 1000);
+    const nanoseconds = 1000000 * (millis - seconds * 1000);
+    return new Timestamp(seconds, nanoseconds);
+  }
+
+  // Dates only return whole-number millis
+  _toMillis() {
+    return this.seconds * 1000 + Math.round(this.nanoseconds / 1000000);
+  }
+
+  static now() {
+    const now = new Date();
+    return mockTimestampNow(...arguments) || Timestamp.fromDate(now);
+  }
+}
+
+//
+// Search data for possible timestamps and convert to class.
+export function convertTimestamps(data, path = []) {
+  if (!data) {
+    return data;
+  }
+  // we need to avoid self-referencing DB's (can happen on db.get)
+  // Check we have not looped.  If we have, backout
+  if (path.includes(data)) {
+    return;
+  }
+
+  // Check if this object is or contains a timestamp
+  if (typeof data === 'object') {
+    const keys = Object.keys(data);
+    // if it is a timestamp, convert to the appropriate class
+    if (
+      keys.length === 2 &&
+      keys.find(k => k === 'seconds') &&
+      keys.find(k => k === 'nanoseconds')
+    ) {
+      return new Timestamp(data.seconds, data.nanoseconds);
+    } else {
+      // Search recursively for any timestamps in this data
+      // Keep track of the path taken, so we can avoid self-referencing loops
+      // Note: running full-setup.test.js will fail without this check
+      // add console.log(`${path} => ${k}`); to see how this class is added as a property
+      path.push(data);
+      keys.forEach(k => {
+        data[k] = convertTimestamps(data[k], path);
+      });
+      path.pop();
+    }
+  }
+  return data;
+}
+
+export const mocks = {
+  mockTimestampToDate,
+  mockTimestampToMillis,
+  mockTimestampFromDate,
+  mockTimestampFromMillis,
+  mockTimestampNow,
+};

package/mocks/transaction.d.ts

@@ -0,0 +1,22 @@
+import { Mock } from 'node:test';
+import type { Query } from './query.js';
+import type { MockedQuerySnapshot } from './helpers/buildQuerySnapShot.js';
+
+export class Transaction {
+  getAll(...refsOrReadOptions: Array<Query | Record<string, never>>): Promise<Array<MockedQuerySnapshot>>;
+  get(ref: Query): Promise<MockedQuerySnapshot>;
+  set(ref: Query): Transaction;
+  update(ref: Query): Transaction;
+  delete(ref: Query): Transaction;
+  create(ref: Query, options: unknown): Transaction;
+}
+
+export const mocks: {
+  mockGetAll: Mock<any>;
+  mockGetAllTransaction: Mock<any>;
+  mockGetTransaction: Mock<any>;
+  mockSetTransaction: Mock<any>;
+  mockUpdateTransaction: Mock<any>;
+  mockDeleteTransaction: Mock<any>;
+  mockCreateTransaction: Mock<any>;
+};

package/mocks/transaction.js

@@ -0,0 +1,62 @@
+import { mock } from 'node:test';
+
+export const mockGetAll = mock.fn();
+export const mockGetAllTransaction = mock.fn();
+export const mockGetTransaction = mock.fn();
+export const mockSetTransaction = mock.fn();
+export const mockUpdateTransaction = mock.fn();
+export const mockDeleteTransaction = mock.fn();
+export const mockCreateTransaction = mock.fn();
+
+export class Transaction {
+  getAll(...refsOrReadOptions) {
+    mockGetAll(...arguments);
+    mockGetAllTransaction(...arguments);
+    // TODO: Assert that read options, if provided, are the last argument
+    // Filter out the read options before calling .get()
+    return Promise.all(refsOrReadOptions.filter(ref => !!ref.get).map(ref => ref.get()));
+  }
+
+  get(ref) {
+    mockGetTransaction(...arguments);
+    return Promise.resolve(ref._get());
+  }
+
+  set(ref) {
+    mockSetTransaction(...arguments);
+    const args = [...arguments];
+    args.shift();
+    ref.set(...args);
+    return this;
+  }
+
+  update(ref) {
+    mockUpdateTransaction(...arguments);
+    const args = [...arguments];
+    args.shift();
+    ref.update(...args);
+    return this;
+  }
+
+  delete(ref) {
+    mockDeleteTransaction(...arguments);
+    ref.delete();
+    return this;
+  }
+
+  create(ref, options) {
+    mockCreateTransaction(...arguments);
+    ref.set(options);
+    return this;
+  }
+}
+
+export const mocks = {
+  mockGetAll,
+  mockGetAllTransaction,
+  mockGetTransaction,
+  mockSetTransaction,
+  mockUpdateTransaction,
+  mockDeleteTransaction,
+  mockCreateTransaction,
+};

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "firestore-node-mock",
+  "version": "0.0.1",
+  "description": "Helper for mocking Google Cloud Firestore with Node.js test runner",
+  "author": "",
+  "license": "MIT",
+  "keywords": [
+    "Mock",
+    "Firestore"
+  ],
+  "main": "index.js",
+  "types": "index.d.ts",
+  "files": [
+    "mocks",
+    "index.d.ts",
+    "index.d.ts.map",
+    "index.js",
+    "index.js.map"
+  ],
+  "type": "module",
+  "scripts": {
+    "lint": "eslint . --ext .js,.ts",
+    "cleanup": "rm -fr ./mocks ./index.d.ts ./index.d.ts.map ./index.js ./index.js.map",
+    "prebuild": "npm run cleanup",
+    "build": "tsc -P tsconfig.json && cp -r src/mocks .",
+    "prepublishOnly": "npm run build",
+    "test": "node --experimental-test-module-mocks --test __tests__/**/*.test.js",
+    "test:watch": "node --experimental-test-module-mocks --test --watch __tests__/**/*.test.js",
+    "test:coverage": "node --experimental-test-module-mocks --test --experimental-test-coverage __tests__/**/*.test.js"
+  },
+  "lint-staged": {
+    "*.{js,css,json,md}": [
+      "prettier --write"
+    ],
+    "*.js": [
+      "eslint --fix"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/WestonThayer/firestore-node-mock.git"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.5.5",
+    "@babel/preset-env": "^7.5.5",
+    "@react-native-firebase/firestore": "^15.1.1",
+    "@typescript-eslint/eslint-plugin": "^4.17.0",
+    "@typescript-eslint/parser": "^4.17.0",
+    "babel-eslint": "^10.0.3",
+    "eslint": "^7.20.0",
+    "eslint-config-prettier": "^8.1.0",
+    "firebase": "^8.1.2",
+    "firebase-admin": "^9.4.1",
+    "husky": "^4.2.1",
+    "lint-staged": "^10.0.2",
+    "lodash": "^4.17.21",
+    "prettier": "^3.1.1",
+    "typescript": "^5.0.0",
+    "@types/node": "^20.0.0"
+  }
+}