@actual-app/core 26.3.0

package/src/mocks/setup.ts

@@ -0,0 +1,180 @@
+// @ts-strict-ignore
+import * as nativeFs from 'fs';
+
+import * as fetchClient from '../platform/client/connection';
+import * as sqlite from '../platform/server/sqlite';
+import * as db from '../server/db';
+import type * as MigrationsType from '../server/migrate/migrations';
+import {
+  disableGlobalMutations,
+  enableGlobalMutations,
+} from '../server/mutators';
+import { setServer } from '../server/server-config';
+import * as sheet from '../server/sheet';
+import { setSyncingMode } from '../server/sync';
+import * as rules from '../server/transactions/transaction-rules';
+import { updateVersion } from '../server/update';
+import { resetTracer, tracer } from '../shared/test-helpers';
+
+vi.mock('../platform/client/connection');
+vi.mock('../platform/exceptions');
+vi.mock('../platform/server/asyncStorage');
+vi.mock('../platform/server/connection');
+vi.mock('../server/post');
+
+// By default, syncing is disabled
+setSyncingMode('disabled');
+
+// Set a mock url for the testing server
+setServer('https://test.env');
+
+process.on('unhandledRejection', reason => {
+  console.log('REJECTION', reason);
+});
+
+global.IS_TESTING = true;
+
+let _time = 123456789;
+const _oldDateNow = global.Date.now;
+global.Date.now = () => _time;
+
+global.restoreDateNow = () => (global.Date.now = _oldDateNow);
+global.restoreFakeDateNow = () => (global.Date.now = () => _time);
+
+global.stepForwardInTime = time => {
+  if (time) {
+    _time = time;
+  } else {
+    _time += 1000;
+  }
+};
+
+global.resetTime = () => {
+  _time = 123456789;
+};
+
+let _id = 1;
+global.resetRandomId = () => {
+  _id = 1;
+};
+
+vi.mock('uuid', () => ({
+  v4: () => {
+    return 'id' + _id++;
+  },
+}));
+vi.mock('../server/migrate/migrations', async () => {
+  const realMigrations = await vi.importActual<typeof MigrationsType>(
+    '../server/migrate/migrations',
+  );
+  return {
+    ...realMigrations,
+    migrate: async db => {
+      _id = 100_000_000;
+      await realMigrations.migrate(db);
+      _id = 1;
+    },
+  };
+});
+
+global.getDatabaseDump = async function (tables) {
+  if (!tables) {
+    const rows = sqlite.runQuery<{ name }>(
+      db.getDatabase(),
+      "SELECT name FROM sqlite_master WHERE type='table'",
+      [],
+      true,
+    );
+
+    tables = rows.map(row => row.name);
+  }
+
+  const data = await Promise.all(
+    tables.map(async table => {
+      let sortColumn;
+      switch (table) {
+        case 'spreadsheet_cells':
+          sortColumn = 'name';
+          break;
+        case 'created_budgets':
+          sortColumn = 'month';
+          break;
+        case 'db_version':
+          sortColumn = 'version';
+          break;
+        default:
+          sortColumn = 'id';
+      }
+
+      return [
+        table,
+        sqlite.runQuery(
+          db.getDatabase(),
+          'SELECT * FROM ' + table + ' ORDER BY ' + sortColumn,
+          [],
+          true,
+        ),
+      ];
+    }),
+  );
+
+  const grouped = {};
+  data.forEach(table => (grouped[table[0]] = table[1]));
+  return grouped;
+};
+
+// If you want to test the sql.js backend, you need this so it knows
+// where to find the webassembly file
+// process.env.PUBLIC_URL =
+//   __dirname + '/../../../../node_modules/@jlongster/sql.js/dist/';
+
+global.emptyDatabase = function (avoidUpdate) {
+  return async () => {
+    const path = ':memory:';
+    // let path = `/tmp/foo-${Math.random()}.sqlite`;
+    // console.log('Using db ' + path);
+
+    await sqlite.init();
+
+    const memoryDB = await sqlite.openDatabase(path);
+    sqlite.execQuery(
+      memoryDB,
+      nativeFs.readFileSync(__dirname + '/../server/sql/init.sql', 'utf8'),
+    );
+
+    db.setDatabase(memoryDB);
+    db.runQuery('INSERT INTO db_version (version) VALUES (?)', ['0.0.1']);
+
+    if (!avoidUpdate) {
+      await updateVersion();
+      await db.loadClock();
+    }
+  };
+};
+
+beforeEach(() => {
+  // This is necessary to create a valid rules state
+  rules.resetState();
+  resetTracer();
+});
+
+afterEach(() => {
+  global.resetRandomId();
+  tracer.end();
+  void fetchClient.clearServer();
+
+  return new Promise(resolve => {
+    if (sheet.get()) {
+      sheet.get().onFinish(() => {
+        sheet.unloadSpreadsheet();
+        resolve(undefined);
+      });
+    } else {
+      resolve(undefined);
+    }
+  });
+});
+
+// Tests by default are allowed to mutate the db at any time
+beforeEach(() => enableGlobalMutations());
+afterEach(() => disableGlobalMutations());

package/src/mocks/spreadsheet.ts

@@ -0,0 +1,101 @@
+// @ts-strict-ignore
+export function makeSpreadsheet() {
+  const cells = {};
+  return {
+    observers: [],
+    _getNode(sheetName, name) {
+      const resolvedName = `${sheetName}!${name}`;
+
+      const existing = cells[resolvedName];
+      if (existing) {
+        return existing;
+      }
+
+      cells[resolvedName] = {
+        name: resolvedName,
+        sheet: sheetName,
+        value: null,
+      };
+      return cells[resolvedName];
+    },
+
+    prewarmCache(sheetName = '__global', name, value) {
+      this._getNode(sheetName, name).value = value;
+    },
+
+    bind(sheetName, binding, cb) {
+      const { name } = binding;
+      const resolvedName = `${sheetName}!${name}`;
+      if (!this.observers[resolvedName]) {
+        this.observers[resolvedName] = [];
+      }
+      this.observers[resolvedName].push(cb);
+
+      const node = this._getNode(sheetName, name);
+      cb(node);
+
+      // bind returns a function which unsubscribes itself. In this mock
+      // it's a noop.
+      return () => {
+        this.observers[resolvedName] = this.observers[resolvedName].filter(
+          x => x !== cb,
+        );
+      };
+    },
+
+    create(sheetName, name, expr) {
+      this.set(sheetName, name, expr);
+    },
+
+    get(sheetName, name) {
+      return this._getNode(sheetName, name);
+    },
+
+    getValue(sheetName, name) {
+      return this._getNode(sheetName, name).value;
+    },
+
+    set(sheetName, name, expr) {
+      const node = this._getNode(sheetName, name);
+      node.value = expr;
+
+      const resolvedName = `${sheetName}!${name}`;
+      if (this.observers[resolvedName]) {
+        this.observers[resolvedName].forEach(cb => cb(node));
+      }
+    },
+
+    getCellNames(sheetName) {
+      const names = Object.keys(cells);
+      if (sheetName) {
+        return names.filter(name => name.startsWith(sheetName + '!'));
+      }
+      return names;
+    },
+
+    getCells() {
+      return cells;
+    },
+
+    setCells(cells) {
+      Object.keys(cells).forEach(sheet => {
+        Object.keys(cells[sheet]).forEach(name => {
+          this.set(sheet, name, cells[sheet][name]);
+        });
+      });
+    },
+
+    deleteCells(cells) {
+      Object.keys(cells).forEach(sheet => {
+        cells[sheet].forEach(name => {
+          this.set(sheet, name, '');
+        });
+      });
+    },
+
+    batchChange(batch) {
+      this.setCells(batch.updateCells);
+      this.deleteCells(batch.deleteCells);
+    },
+  };
+}

package/src/mocks/util.ts

@@ -0,0 +1,82 @@
+// @ts-strict-ignore
+import fs from 'fs/promises';
+import { basename, dirname, join } from 'path';
+
+import { diff } from 'jest-diff';
+
+export function expectSnapshotWithDiffer(
+  initialValue,
+  { onlyUpdates }: { onlyUpdates? } = {},
+) {
+  let currentValue = initialValue;
+  if (!onlyUpdates) {
+    expect(initialValue).toMatchSnapshot();
+  }
+  return {
+    expectToMatchDiff: value => {
+      expect(
+        diff(currentValue, value, {
+          aAnnotation: 'First value',
+          bAnnotation: 'Second value',
+          contextLines: 5,
+          expand: false,
+        }),
+      ).toMatchSnapshot();
+      currentValue = value;
+    },
+  };
+}
+
+export function getFixtures(filename) {
+  join(
+    dirname(filename),
+    '__fixtures__',
+    basename(filename).replace(/\.[^.]+.js/, '.fixtures.js'),
+  );
+}
+
+export function debugDOM(node) {
+  function debugDOM(node, indent = 0) {
+    let str = '';
+    if (node) {
+      str += ' '.repeat(indent);
+      if (node.tagName) {
+        str +=
+          node.tagName.toLowerCase() +
+          ' ' +
+          (node.tabIndex || '') +
+          (node.dataset['testid'] ? ' ' + node.dataset['testid'] : '') +
+          '\n';
+      } else {
+        str += node.textContent + '\n';
+      }
+
+      for (const child of node.childNodes) {
+        str += debugDOM(child, indent + 2);
+      }
+    }
+    return str;
+  }
+
+  return debugDOM(node);
+}
+
+export function patchFetchForSqlJS(baseURL: string) {
+  // Patch the global fetch to resolve to a file
+  // This is a workaround for the fact that initSqlJS uses fetch to load the wasm file
+  // and we can't use the file protocol directly in tests
+  vi.spyOn(global, 'fetch').mockImplementation(
+    async (url: string | URL | Request) => {
+      if (typeof url === 'string' && url.startsWith(baseURL)) {
+        return new Response(new Uint8Array(await fs.readFile(url)), {
+          status: 200,
+          statusText: 'OK',
+          headers: {
+            'Content-Type': 'application/wasm',
+          },
+        });
+      }
+      return Promise.reject(new Error(`fetch not mocked for ${String(url)}`));
+    },
+  );
+}

package/src/platform/client/connection/README.md

@@ -0,0 +1,3 @@
+# Client-side connection package
+
+This is the client counterpart of the `connection` server-side package (packages/loot-core/src/platform/server/connection). This contains methods to send and listen to messages to/from the browser server.

package/src/platform/client/connection/__mocks__/index.ts

@@ -0,0 +1,67 @@
+// @ts-strict-ignore
+import type * as T from '../index-types';
+
+let listeners = new Map();
+let serverHandler = null;
+
+export const initServer: T.InitServer = handlers => {
+  serverHandler = msg => {
+    const { name, args, catchErrors } = msg;
+    if (handlers[name]) {
+      return Promise.resolve().then(() => {
+        const promise = handlers[name](args);
+
+        if (catchErrors) {
+          return promise.then(
+            data => ({ data }),
+            error => ({ error }),
+          );
+        }
+        return promise;
+      });
+    }
+  };
+};
+
+export const clearServer: T.ClearServer = async () => {
+  serverHandler = null;
+  listeners = new Map();
+};
+
+export const serverPush: T.ServerPush = (name, args) => {
+  void Promise.resolve().then(() => {
+    const listens = listeners.get(name);
+    if (listens) {
+      listens.forEach(listener => {
+        listener(args);
+      });
+    }
+  });
+};
+
+export const send = async (name, args, { catchErrors = false } = {}) => {
+  if (serverHandler) {
+    return serverHandler({ name, args, catchErrors });
+  } else {
+    throw new Error('`send` called with no mock server installed');
+  }
+};
+
+export const sendCatch = (name, args) => {
+  return send(name, args, { catchErrors: true });
+};
+
+export const listen = (name, cb) => {
+  if (!listeners.get(name)) {
+    listeners.set(name, []);
+  }
+  listeners.get(name).push(cb);
+
+  return () => {
+    const arr = listeners.get(name);
+    listeners.set(
+      name,
+      arr.filter(cb_ => cb_ !== cb),
+    );
+  };
+};

package/src/platform/client/connection/index-types.ts

@@ -0,0 +1,95 @@
+import type { Handlers } from '../../../types/handlers';
+import type { ServerEvents } from '../../../types/server-events';
+
+export declare function init(): Promise<unknown>;
+export type Init = typeof init;
+
+/**
+ * Send a command to the browser server.
+ *
+ * @param name The name of the command to be executed by the browser server.
+ * @param args The command arguments.
+ * @param options The options for the command. If `catchErrors` is true,
+ * and an error occurs, the promise will be resolved with an object that
+ * has an `error` property. Otherwise, the promise will be rejected with the error.
+ * @returns A promise that resolves with the command result, or rejects with an error if one occurs.
+ * If you want to catch errors as part of the resolved value instead of rejecting, use `sendCatch` instead.
+ */
+export declare function send<K extends keyof Handlers>(
+  name: K,
+  args: Parameters<Handlers[K]>[0],
+  options: { catchErrors: true },
+): Promise<
+  | { data: Awaited<ReturnType<Handlers[K]>>; error: undefined }
+  | {
+      data: undefined;
+      error: {
+        type: 'APIError' | 'ServerError';
+        message: string;
+        cause?: unknown;
+      };
+    }
+>;
+export declare function send<K extends keyof Handlers>(
+  name: K,
+  args?: Parameters<Handlers[K]>[0],
+  options?: { catchErrors?: boolean },
+): Promise<Awaited<ReturnType<Handlers[K]>>>;
+export type Send = typeof send;
+
+/**
+ * Send a command to the browser server.
+ *
+ * @param name The name of the command to be executed by the browser server.
+ * @param args The command arguments.
+ * @returns A promise that resolves with an object containing either the command result or an error if one occurs.
+ * The promise will never reject, as errors are caught and returned as part of the resolved value.
+ */
+export declare function sendCatch<K extends keyof Handlers>(
+  name: K,
+  args?: Parameters<Handlers[K]>[0],
+): Promise<
+  | { data: Awaited<ReturnType<Handlers[K]>>; error: undefined }
+  | {
+      data: undefined;
+      error: {
+        type: 'APIError' | 'ServerError';
+        message: string;
+        cause?: unknown;
+      };
+    }
+>;
+export type SendCatch = typeof sendCatch;
+
+/** Server push listeners */
+
+/**
+ * Listen to events pushed to the client from the browser server.
+ *
+ * @param name The name of the event to listen to.
+ * @param cb The callback to be called when the event is received.
+ * @returns A function that can be called to unregister the listener.
+ */
+export declare function listen<K extends keyof ServerEvents>(
+  name: K,
+  cb: (arg: ServerEvents[K]) => void,
+): () => void;
+export type Listen = typeof listen;
+
+/**
+ * Stop listening to events pushed to the client from the browser server.
+ *
+ * @param name The name of the event to stop listening to.
+ */
+export declare function unlisten(name: string): void;
+export type Unlisten = typeof unlisten;
+
+/** Mock functions */
+export declare function initServer(handlers: Partial<Handlers>): void;
+export type InitServer = typeof initServer;
+
+export declare function serverPush(name: string, args: unknown): void;
+export type ServerPush = typeof serverPush;
+
+export declare function clearServer(): Promise<void>;
+export type ClearServer = typeof clearServer;