Skip to content

Voice-to-text dictation app with local (Nvidia Parakeet/Whisper) and cloud models (BYOK). Privacy-first and available cross-platform.

6.4 KB
Raw Blame
const test = require("node:test");
const assert = require("node:assert/strict");
const fs = require("node:fs");
const os = require("node:os");
const path = require("node:path");
const Module = require("node:module");

let userDataDir = fs.mkdtempSync(path.join(os.tmpdir(), "openwhispr-granola-db-"));
const originalLoad = Module._load;

Module._load = function patchedLoad(request, parent, isMain) {
  if (request === "electron") {
    return {
      app: {
        getPath: () => userDataDir,
        getAppPath: () => process.cwd(),
        isReady: () => false,
      },
    };
  }
  return originalLoad.call(this, request, parent, isMain);
};

process.env.NODE_ENV = "test";

const DatabaseManager = require("../../src/helpers/database.js");
const loadGranolaImport = () => import("../../src/helpers/granolaImport.js");

function isNativeBindingUnavailable(error) {
  const message = String(error?.message || error);
  return (
    message.includes("NODE_MODULE_VERSION") ||
    message.includes("Could not locate the bindings file")
  );
}

function createDb(t) {
  userDataDir = fs.mkdtempSync(path.join(os.tmpdir(), "openwhispr-granola-db-"));
  try {
    return new DatabaseManager();
  } catch (error) {
    if (isNativeBindingUnavailable(error)) {
      t.skip("better-sqlite3 native binding is not available for this Node runtime");
      return null;
    }
    throw error;
  }
}

function granolaRow(key, overrides = {}) {
  return {
    clientNoteId: `00000000-0000-4000-8000-${key.repeat(12).slice(0, 12)}`,
    sourceFile: `granola:${key}`,
    title: `Meeting ${key}`,
    content: `Summary body ${key}`,
    transcript: null,
    participants: null,
    createdAt: "2024-05-01 10:00:00",
    ...overrides,
  };
}

test("importNotes inserts backdated meeting notes into the Imported folder", (t) => {
  const db = createDb(t);
  if (!db) return;

  const result = db.importNotes([granolaRow("a"), granolaRow("b")]);
  assert.equal(result.success, true);
  assert.equal(result.imported, 2);
  assert.equal(result.skipped, 0);
  assert.deepEqual(result.errors, []);
  assert.equal(result.noteIds.length, 2);

  const note = db.getNote(result.noteIds[0]);
  assert.equal(note.created_at, "2024-05-01 10:00:00");
  assert.equal(note.updated_at, "2024-05-01 10:00:00");
  assert.equal(note.note_type, "meeting");
  assert.equal(note.sync_status, "pending");
  assert.equal(note.source_file, "granola:a");
  assert.equal(note.space_id, db.getPrivateSpaceId());
  assert.equal(note.folder_id, result.folderId);

  const folder = db.getFolders().find((f) => f.id === result.folderId);
  assert.equal(folder.name, "Imported");
  db.db.close();
});

test("importNotes falls back to the current time when createdAt is null", (t) => {
  const db = createDb(t);
  if (!db) return;

  const result = db.importNotes([granolaRow("c", { createdAt: null })]);
  const note = db.getNote(result.noteIds[0]);
  assert.match(note.created_at, /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/);
  db.db.close();
});

test("importNotes is idempotent across re-runs", (t) => {
  const db = createDb(t);
  if (!db) return;

  const rows = [granolaRow("d"), granolaRow("e")];
  db.importNotes(rows);
  const rerun = db.importNotes(rows);
  assert.equal(rerun.imported, 0);
  assert.equal(rerun.skipped, 2);
  const count = db.db.prepare("SELECT COUNT(*) AS n FROM notes").get().n;
  assert.equal(count, 2);
  db.db.close();
});

test("a released Granola fallback id remains idempotent after the parser upgrade", async (t) => {
  const db = createDb(t);
  if (!db) return;
  const { parseGranolaCsv } = await loadGranolaImport();
  const csv = 'title,summary,created_at\nSync,"Some notes",2026-07-15T14:30:00Z';
  const legacyRow = {
    clientNoteId: "d9182b86-aa74-4c1a-8dbe-5060160ef305",
    sourceFile: "granola:0852623745d4c283",
    title: "Sync",
    content: "Some notes",
    transcript: null,
    participants: null,
    createdAt: "2026-07-15 14:30:00",
  };
  db.importNotes([legacyRow]);

  const result = db.importNotes(parseGranolaCsv(csv).notes);

  assert.equal(result.imported, 0);
  assert.equal(result.skipped, 1);
  assert.equal(db.db.prepare("SELECT COUNT(*) AS count FROM notes").get().count, 1);
  db.db.close();
});

test("parsed Granola fallback collisions persist distinctly and remain idempotent", async (t) => {
  const db = createDb(t);
  if (!db) return;
  const { parseGranolaCsv } = await loadGranolaImport();
  const csv = [
    "title,summary,created_at,transcript",
    'Sync,"Same summary",2026-07-15T14:30:00Z,"Alice: First meeting"',
    'Sync,"Same summary",2026-07-15T14:30:00Z,"Bob: Second meeting"',
    'Sync,"Same summary",2026-07-15T14:30:00Z,"Carol: Third meeting"',
  ].join("\n");

  const firstImport = db.importNotes(parseGranolaCsv(csv).notes);
  const secondImport = db.importNotes(parseGranolaCsv(csv).notes);

  assert.equal(firstImport.imported, 3);
  assert.equal(firstImport.skipped, 0);
  assert.equal(secondImport.imported, 0);
  assert.equal(secondImport.skipped, 3);
  assert.equal(db.db.prepare("SELECT COUNT(*) AS count FROM notes").get().count, 3);
  db.db.close();
});

test("importNotes handles a mixed batch of new and duplicate rows", (t) => {
  const db = createDb(t);
  if (!db) return;

  db.importNotes([granolaRow("f")]);
  const result = db.importNotes([granolaRow("f"), granolaRow("1")]);
  assert.equal(result.imported, 1);
  assert.equal(result.skipped, 1);
  db.db.close();
});

test("importNotes rows are searchable through FTS", (t) => {
  const db = createDb(t);
  if (!db) return;

  db.importNotes([granolaRow("a", { title: "Quarterly Roadmap Review" })]);
  const hits = db.searchNotes("Roadmap");
  assert.equal(hits.length, 1);
  assert.equal(hits[0].title, "Quarterly Roadmap Review");
  db.db.close();
});

test("importNotes reuses an existing Imported folder", (t) => {
  const db = createDb(t);
  if (!db) return;

  const created = db.createFolder("Imported");
  const result = db.importNotes([granolaRow("a")]);
  assert.equal(result.folderId, created.folder.id);
  const folders = db.getFolders().filter((f) => f.name === "Imported");
  assert.equal(folders.length, 1);
  db.db.close();
});

test("getExistingClientNoteIds reports only ids already in the table", (t) => {
  const db = createDb(t);
  if (!db) return;

  const rowA = granolaRow("a");
  db.importNotes([rowA]);
  const existing = db.getExistingClientNoteIds([rowA.clientNoteId, granolaRow("b").clientNoteId]);
  assert.deepEqual(existing, [rowA.clientNoteId]);
  db.db.close();
});