mirror of
https://github.com/vrtmrz/obsidian-livesync.git
synced 2026-10-27 19:43:20 +00:00
231 lines
11 KiB
TypeScript
231 lines
11 KiB
TypeScript
/** Exercises optional file admission, actual save completion, and replay in a real Obsidian Vault. */
|
|
import { createHash } from "node:crypto";
|
|
import { readFile, writeFile } from "node:fs/promises";
|
|
import { join } from "node:path";
|
|
import { evalObsidianJson } from "../runner/cli.ts";
|
|
import { requireObsidianCli, requireObsidianBinary } from "../runner/environment.ts";
|
|
import {
|
|
createE2eCouchDbPluginData,
|
|
createE2eObsidianDeviceLocalState,
|
|
waitForLiveSyncCoreReady,
|
|
} from "../runner/liveSyncWorkflow.ts";
|
|
import { startObsidianLiveSyncSession, type ObsidianLiveSyncSession } from "../runner/session.ts";
|
|
import { createTemporaryVault } from "../runner/vault.ts";
|
|
|
|
process.env.E2E_OBSIDIAN_CLI_TIMEOUT_MS ??= "60000";
|
|
|
|
async function main(): Promise<void> {
|
|
const binary = requireObsidianBinary();
|
|
const cliBinary = requireObsidianCli();
|
|
const vault = await createTemporaryVault("obsidian-optional-save-");
|
|
let session: ObsidianLiveSyncSession | undefined;
|
|
const observations: unknown[] = [];
|
|
const bundleHash = createHash("sha256")
|
|
.update(new Uint8Array(await readFile("main.js")))
|
|
.digest("hex");
|
|
const settings = createE2eCouchDbPluginData(
|
|
// These scenarios use only the local database; every replication trigger is disabled.
|
|
{ uri: "http://127.0.0.1:1", username: "unused", password: "unused", dbName: "optional-save-local" },
|
|
{
|
|
syncInternalFiles: true,
|
|
usePluginSync: true,
|
|
usePluginSyncV2: true,
|
|
deviceAndVaultName: "optional-save-device",
|
|
watchInternalFileChanges: true,
|
|
syncInternalFilesTargetPatterns: "^\\.obsidian(?:$|/(?:optional-save|snippets)(?:/|$))",
|
|
syncInternalFilesIgnorePatterns: "",
|
|
autoSweepPlugins: false,
|
|
autoSweepPluginsPeriodic: false,
|
|
syncInternalFilesInterval: 0,
|
|
liveSync: false,
|
|
periodicReplication: false,
|
|
syncOnStart: false,
|
|
syncOnSave: false,
|
|
syncOnFileOpen: false,
|
|
syncOnEditorSave: false,
|
|
syncAfterMerge: false,
|
|
showVerboseLog: true,
|
|
}
|
|
);
|
|
|
|
async function start(restart = false): Promise<void> {
|
|
session = await startObsidianLiveSyncSession({
|
|
binary,
|
|
cliBinary: cliBinary,
|
|
vault,
|
|
pluginStartup: restart ? "natural" : undefined,
|
|
pluginData: restart ? undefined : settings,
|
|
localStorageEntries: restart ? undefined : createE2eObsidianDeviceLocalState(vault.name),
|
|
lifecycle: {
|
|
beforeLaunch: async () => {
|
|
const registryPath = join(vault.userDataPath, "obsidian.json");
|
|
const registry = JSON.parse(await readFile(registryPath, "utf8"));
|
|
registry.updateDisabled = true;
|
|
await writeFile(registryPath, JSON.stringify(registry));
|
|
},
|
|
},
|
|
});
|
|
await waitForLiveSyncCoreReady(cliBinary, session.cliEnv);
|
|
}
|
|
|
|
async function evaluate<T>(body: string): Promise<T> {
|
|
if (!session) throw new Error("The Obsidian session is not running");
|
|
return await evalObsidianJson<T>(
|
|
cliBinary,
|
|
`(async()=>{
|
|
const core=app.plugins.plugins['obsidian-livesync'].core;
|
|
const manager=core.serviceModules.storageAccess.vaultManager;
|
|
const config=core.getAddOn('ConfigSync');
|
|
const sleep=ms=>new Promise(resolve=>setTimeout(resolve,ms));
|
|
const require=(condition,message)=>{if(!condition)throw new Error(message);};
|
|
const waitFor=async (predicate,message)=>{
|
|
const until=Date.now()+10000;
|
|
while(!(await predicate())) {
|
|
if(Date.now()>until)throw new Error(message);
|
|
await sleep(20);
|
|
}
|
|
};
|
|
const pending=async path=>(await manager.adapter.persistence.loadSnapshot()??[])
|
|
.some(event=>event.args?.file?.path===path);
|
|
const entry=async path=>await core.localDatabase.getDBEntry(path,undefined,false,true);
|
|
const contents=doc=>Array.isArray(doc.data)?doc.data.join(''):doc.data;
|
|
const represents=(doc,content)=>doc&& !doc.deleted &&
|
|
(contents(doc).includes(content)||contents(doc).includes(btoa(content)));
|
|
const notify=async path=>{
|
|
await manager._watchVaultRawEvents(path);
|
|
await sleep(30);
|
|
};
|
|
${body}
|
|
})()`,
|
|
session.cliEnv
|
|
);
|
|
}
|
|
|
|
try {
|
|
await start();
|
|
await evaluate(`
|
|
require(core.services.fileProcessing.processOptionalFileEventWithResult?.hasHandlers,
|
|
'Typed optional providers were not registered');
|
|
core.services.setting.setDeviceAndVaultName('optional-save-device');
|
|
await core.services.setting.saveSettingData();
|
|
for(const path of ['.obsidian/optional-save','.obsidian/snippets']) {
|
|
if(!(await app.vault.adapter.exists(path)))await app.vault.adapter.mkdir(path);
|
|
}
|
|
return JSON.stringify({ready:true});
|
|
`);
|
|
|
|
for (const mode of ["hidden", "config-v1", "config-v2"]) {
|
|
observations.push(
|
|
await evaluate(`
|
|
const mode=${JSON.stringify(mode)};
|
|
core.settings.usePluginSyncV2=mode!=='config-v1';
|
|
await core.services.setting.saveSettingData();
|
|
require(await core.services.fileProcessing.commitPendingFileEvents(),'Initial flush failed');
|
|
const path=mode==='hidden'?'.obsidian/optional-save/content.json':
|
|
'.obsidian/snippets/optional-save-'+mode+'.css';
|
|
const databasePath=mode==='hidden'?'i:'+path:mode==='config-v1'?
|
|
config.filenameToUnifiedKey(path):config.filenameWithUnifiedKey(path);
|
|
const content='optional save '+mode+' initial';
|
|
const original=core.localDatabase.putDBEntry.bind(core.localDatabase);
|
|
let release;
|
|
const gate=new Promise(resolve=>{release=resolve;});
|
|
let started=false;
|
|
core.localDatabase.putDBEntry=async data=>{
|
|
if(data.path===databasePath){started=true;await gate;}
|
|
return await original(data);
|
|
};
|
|
try {
|
|
await app.vault.adapter.write(path,content);
|
|
await notify(path);
|
|
await waitFor(()=>started,'The optional database save did not start: '+mode);
|
|
require(await pending(path),'The in-flight optional save was missing from the snapshot: '+mode);
|
|
let flushed=false;
|
|
const flush=core.services.fileProcessing.commitPendingFileEvents().then(result=>{flushed=true;return result;});
|
|
await sleep(30);
|
|
require(!flushed,'Flush returned before the actual database save: '+mode);
|
|
release();
|
|
require(await flush,'Flush failed after the write was released: '+mode);
|
|
} finally {
|
|
release();
|
|
core.localDatabase.putDBEntry=original;
|
|
}
|
|
const first=await entry(databasePath);
|
|
require(represents(first,content),'The completed save did not contain the expected content: '+mode);
|
|
await notify(path);
|
|
require(await core.services.fileProcessing.commitPendingFileEvents(),'Unchanged notification failed: '+mode);
|
|
require((await entry(databasePath))._rev===first._rev,'Unchanged notification added a revision: '+mode);
|
|
const updated=content+' with a later edit';
|
|
await app.vault.adapter.write(path,updated);
|
|
await notify(path);
|
|
require(await core.services.fileProcessing.commitPendingFileEvents(),'Later edit was blocked: '+mode);
|
|
require(represents(await entry(databasePath),updated),'Later edit was not saved: '+mode);
|
|
await app.vault.adapter.remove(path);
|
|
await notify(path);
|
|
require(await core.services.fileProcessing.commitPendingFileEvents(),'Deletion failed: '+mode);
|
|
const deleted=await core.localDatabase.getDBEntryMeta(databasePath,undefined,true);
|
|
require(deleted&&deleted.deleted,'Deletion was not represented: '+mode);
|
|
await notify(path);
|
|
require(await core.services.fileProcessing.commitPendingFileEvents(),'Repeated deletion failed: '+mode);
|
|
require((await core.localDatabase.getDBEntryMeta(databasePath,undefined,true))._rev===deleted._rev,
|
|
'Repeated deletion added a revision: '+mode);
|
|
return JSON.stringify({mode,saveWaited:true,unchangedPreservedRevision:true,laterEditSaved:true,deletionReplayed:true});
|
|
`)
|
|
);
|
|
}
|
|
|
|
const replay = [
|
|
{ path: ".obsidian/optional-save/replay.json", content: "hidden save retained across restart" },
|
|
{
|
|
path: ".obsidian/snippets/optional-save-replay.css",
|
|
content: "customisation save retained across restart",
|
|
},
|
|
];
|
|
observations.push(
|
|
await evaluate(`
|
|
const fixtures=${JSON.stringify(replay)};
|
|
core.settings.usePluginSyncV2=true;
|
|
await core.services.setting.saveSettingData();
|
|
const failures=new Set(fixtures.map(({path})=>path.endsWith('.json')?'i:'+path:config.filenameWithUnifiedKey(path)));
|
|
const original=core.localDatabase.putDBEntry.bind(core.localDatabase);
|
|
let failed=0;
|
|
core.localDatabase.putDBEntry=async data=>{
|
|
if(failures.delete(data.path)){failed++;return false;}
|
|
return await original(data);
|
|
};
|
|
try {
|
|
for(const {path,content} of fixtures) {
|
|
await app.vault.adapter.write(path,content);
|
|
await notify(path);
|
|
}
|
|
await waitFor(()=>failed===fixtures.length,'Injected optional failures were not reached');
|
|
require(!(await core.services.fileProcessing.commitPendingFileEvents()),'Failed saves were acknowledged');
|
|
for(const {path} of fixtures)require(await pending(path),'Failed save was lost: '+path);
|
|
} finally {
|
|
core.localDatabase.putDBEntry=original;
|
|
}
|
|
return JSON.stringify({failedSavesRetained:failed});
|
|
`)
|
|
);
|
|
await session!.app.stop();
|
|
session = undefined;
|
|
await start(true);
|
|
observations.push(
|
|
await evaluate(`
|
|
const fixtures=${JSON.stringify(replay)};
|
|
for(const {path,content} of fixtures) {
|
|
const databasePath=path.endsWith('.json')?'i:'+path:config.filenameWithUnifiedKey(path);
|
|
require(represents(await entry(databasePath),content),'Start-up did not recover '+path);
|
|
require(!(await pending(path)),'Recovered save is still pending: '+path);
|
|
}
|
|
return JSON.stringify({replayedBeforeReadiness:fixtures.length,ready:core.services.appLifecycle.isReady()});
|
|
`)
|
|
);
|
|
console.log(JSON.stringify({ ok: true, bundleHash, observations }, null, 2));
|
|
} finally {
|
|
await session?.app.stop();
|
|
await vault.dispose();
|
|
}
|
|
}
|
|
|
|
await main();
|