Preparing v0.24.0

src/modules/extras/devUtil/TestPane.svelte

@@ -0,0 +1,119 @@
+<script lang="ts">
+    import { onDestroy, onMount } from "svelte";
+    import type ObsidianLiveSyncPlugin from "../../../main.ts";
+    import { perf_trench } from "./tests.ts";
+    import { MarkdownRenderer, Notice } from "../../../deps.ts";
+    import type { ModuleDev } from "../ModuleDev.ts";
+    import { fireAndForget } from "octagonal-wheels/promises";
+    import { EVENT_LAYOUT_READY, eventHub } from "../../../common/events.ts";
+    import { writable } from "svelte/store";
+    export let plugin: ObsidianLiveSyncPlugin;
+    export let moduleDev: ModuleDev;
+    let performanceTestResult = "";
+    let functionCheckResult = "";
+    let testRunning = false;
+    let prefTestResultEl: HTMLDivElement;
+    let isReady = false;
+    $: {
+        if (performanceTestResult != "" && isReady) {
+            MarkdownRenderer.render(plugin.app, performanceTestResult, prefTestResultEl, "/", plugin);
+        }
+    }
+
+    async function performTest() {
+        try {
+            testRunning = true;
+            performanceTestResult = await perf_trench(plugin);
+        } finally {
+            testRunning = false;
+        }
+    }
+    function clearResult() {
+        moduleDev.testResults.update((v) => {
+            v = [];
+            return v;
+        });
+    }
+    function clearPerfTestResult() {
+        prefTestResultEl.empty();
+    }
+    onMount(async () => {
+        isReady = true;
+        // performTest();
+
+        eventHub.once(EVENT_LAYOUT_READY, async () => {
+            if (await plugin.storageAccess.isExistsIncludeHidden("_AUTO_TEST.md")) {
+                new Notice("Auto test file found, running tests...");
+                fireAndForget(async () => {
+                    await allTest();
+                });
+            } else {
+                // new Notice("No auto test file found, skipping tests...");
+            }
+        });
+    });
+
+    let moduleTesting = false;
+    function moduleMultiDeviceTest() {
+        if (moduleTesting) return;
+        moduleTesting = true;
+        plugin.$everyModuleTestMultiDevice().finally(() => {
+            moduleTesting = false;
+        });
+    }
+    function moduleSingleDeviceTest() {
+        if (moduleTesting) return;
+        moduleTesting = true;
+        plugin.$everyModuleTest().finally(() => {
+            moduleTesting = false;
+        });
+    }
+    async function allTest() {
+        if (moduleTesting) return;
+        moduleTesting = true;
+        try {
+            await plugin.$everyModuleTest();
+            await plugin.$everyModuleTestMultiDevice();
+        } finally {
+            moduleTesting = false;
+        }
+    }
+
+    const results = moduleDev.testResults;
+    $: resultLines = $results;
+
+    let syncStatus = [] as string[];
+    eventHub.on<string[]>("debug-sync-status", (status) => {
+        syncStatus = [...status];
+    });
+</script>
+
+<h2>TESTING BENCH: Self-hosted LiveSync</h2>
+
+<h3>Module Checks</h3>
+<button on:click={() => moduleMultiDeviceTest()} disabled={moduleTesting}>MultiDevice Test</button>
+<button on:click={() => moduleSingleDeviceTest()} disabled={moduleTesting}>SingleDevice Test</button>
+<button on:click={() => allTest()} disabled={moduleTesting}>All Test</button>
+<button on:click={() => clearResult()}>Clear</button>
+
+{#each resultLines as [result, line, message]}
+    <details open={!result}>
+        <summary>[{result ? "PASS" : "FAILED"}] {line}</summary>
+        <pre>{message}</pre>
+    </details>
+{/each}
+
+<h3>Synchronisation Result Status</h3>
+<pre>{syncStatus.join("\n")}</pre>
+
+<h3>Performance test</h3>
+<button on:click={() => performTest()} disabled={testRunning}>Test!</button>
+<button on:click={() => clearPerfTestResult()}>Clear</button>
+
+<div bind:this={prefTestResultEl}></div>
+
+<style>
+    * {
+        box-sizing: border-box;
+    }
+</style>

src/modules/extras/devUtil/TestPaneView.ts

@@ -0,0 +1,55 @@
+import {
+    ItemView,
+    WorkspaceLeaf
+} from "obsidian";
+import TestPaneComponent from "./TestPane.svelte"
+import type ObsidianLiveSyncPlugin from "../../../main.ts"
+import type { ModuleDev } from "../ModuleDev.ts";
+export const VIEW_TYPE_TEST = "ols-pane-test";
+//Log view
+export class TestPaneView extends ItemView {
+
+    component?: TestPaneComponent;
+    plugin: ObsidianLiveSyncPlugin;
+    moduleDev: ModuleDev;
+    icon = "view-log";
+    title: string = "Self-hosted LiveSync Test and Results"
+    navigation = true;
+
+    getIcon(): string {
+        return "view-log";
+    }
+
+    constructor(leaf: WorkspaceLeaf, plugin: ObsidianLiveSyncPlugin, moduleDev: ModuleDev) {
+        super(leaf);
+        this.plugin = plugin;
+        this.moduleDev = moduleDev;
+    }
+
+
+    getViewType() {
+        return VIEW_TYPE_TEST;
+    }
+
+    getDisplayText() {
+        return "Self-hosted LiveSync Test and Results";
+    }
+
+    // eslint-disable-next-line require-await
+    async onOpen() {
+        this.component = new TestPaneComponent({
+            target: this.contentEl,
+            props: {
+                plugin: this.plugin,
+                moduleDev: this.moduleDev
+            },
+        });
+        await Promise.resolve();
+    }
+
+    // eslint-disable-next-line require-await
+    async onClose() {
+        this.component?.$destroy();
+        await Promise.resolve();
+    }
+}

src/modules/extras/devUtil/testUtils.ts

@@ -0,0 +1,46 @@
+import { fireAndForget } from "../../../lib/src/common/utils.ts";
+import { serialized } from "../../../lib/src/concurrency/lock.ts";
+import type ObsidianLiveSyncPlugin from "../../../main.ts";
+
+let plugin: ObsidianLiveSyncPlugin;
+export function enableTestFunction(plugin_: ObsidianLiveSyncPlugin) {
+    plugin = plugin_;
+}
+export function addDebugFileLog(message: any, stackLog = false) {
+    fireAndForget(serialized("debug-log", async () => {
+        const now = new Date();
+        const filename = `debug-log`
+        const time = now.toISOString().split("T")[0];
+        const outFile = `${filename}${time}.jsonl`;
+        // const messageContent = typeof message == "string" ? message : message instanceof Error ? `${message.name}:${message.message}` : JSON.stringify(message, null, 2);
+        const timestamp = now.toLocaleString();
+        const timestampEpoch = now;
+        let out = { "timestamp": timestamp, epoch: timestampEpoch, } as Record<string, any>;
+        if (message instanceof Error) {
+            // debugger;
+            // console.dir(message.stack);
+            out = { ...out, message };
+        } else if (stackLog) {
+            if (stackLog) {
+                const stackE = new Error();
+                const stack = stackE.stack;
+                out = { ...out, stack }
+            }
+        }
+        if (typeof message == "object") {
+            out = { ...out, ...message, }
+        } else {
+            out = {
+                result: message
+            }
+        }
+        // const out = "--" + timestamp + "--\n" + messageContent + " " + (stack || "");
+        // const out
+        try {
+            await plugin.storageAccess.appendHiddenFile(plugin.app.vault.configDir + "/ls-debug/" + outFile, JSON.stringify(out) + "\n")
+        } catch {
+
+            //NO OP
+        }
+    }));
+}

src/modules/extras/devUtil/tests.ts

@@ -0,0 +1,71 @@
+import { Trench } from "../../../lib/src/memory/memutil.ts";
+import type ObsidianLiveSyncPlugin from "../../../main.ts";
+type MeasureResult = [times: number, spent: number];
+type NamedMeasureResult = [name: string, result: MeasureResult];
+const measures = new Map<string, MeasureResult>();
+
+function clearResult(name: string) {
+    measures.set(name, [0, 0]);
+}
+async function measureEach(name: string, proc: () => (void | Promise<void>)) {
+    const [times, spent] = measures.get(name) ?? [0, 0];
+
+    const start = performance.now();
+    const result = proc();
+    if (result instanceof Promise) await result;
+    const end = performance.now();
+    measures.set(name, [times + 1, spent + (end - start)]);
+
+}
+function formatNumber(num: number) {
+    return num.toLocaleString('en-US', { maximumFractionDigits: 2 });
+}
+async function measure(name: string, proc: () => (void | Promise<void>), times: number = 10000, duration: number = 1000): Promise<NamedMeasureResult> {
+    const from = Date.now();
+    let last = times;
+    clearResult(name);
+    do {
+        await measureEach(name, proc);
+    } while (last-- > 0 && (Date.now() - from) < duration)
+    return [name, measures.get(name) as MeasureResult];
+}
+
+// eslint-disable-next-line require-await, @typescript-eslint/require-await
+async function formatPerfResults(items: NamedMeasureResult[]) {
+    return `| Name | Runs | Each | Total |\n| --- | --- | --- | --- | \n` + items.map(e => `| ${e[0]} | ${e[1][0]} | ${e[1][0] != 0 ? formatNumber(e[1][1] / e[1][0]) : "-"} | ${formatNumber(e[1][0])} |`).join("\n");
+
+}
+export async function perf_trench(plugin: ObsidianLiveSyncPlugin) {
+    clearResult("trench");
+    const trench = new Trench(plugin.simpleStore);
+    const result = [] as NamedMeasureResult[];
+    result.push(await measure("trench-short-string", async () => {
+        const p = trench.evacuate("string");
+        await p();
+    }));
+    {
+        const testBinary = await plugin.storageAccess.readHiddenFileBinary("testdata/10kb.png");
+        const uint8Array = new Uint8Array(testBinary);
+        result.push(await measure("trench-binary-10kb", async () => {
+            const p = trench.evacuate(uint8Array);
+            await p();
+        }));
+    }
+    {
+        const testBinary = await plugin.storageAccess.readHiddenFileBinary("testdata/100kb.jpeg");
+        const uint8Array = new Uint8Array(testBinary);
+        result.push(await measure("trench-binary-100kb", async () => {
+            const p = trench.evacuate(uint8Array);
+            await p();
+        }));
+    }
+    {
+        const testBinary = await plugin.storageAccess.readHiddenFileBinary("testdata/1mb.png");
+        const uint8Array = new Uint8Array(testBinary);
+        result.push(await measure("trench-binary-1mb", async () => {
+            const p = trench.evacuate(uint8Array);
+            await p();
+        }));
+    }
+    return formatPerfResults(result);
+}