@ibgib/core-gib 0.1.18 → 0.1.20

package/src/sync/sync-innerspace-partial-update.respec.mts

@@ -0,0 +1,150 @@
+/**
+ * @module sync-innerspace-partial-update.respec
+ *
+ * Verifies Sync Scenarios where the Destination has partial history.
+ */
+
+import {
+    respecfully, lastOfAll, ifWe, iReckon,
+    ifWeMight
+} from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
+const maam = `[${import.meta.url}]`, sir = maam;
+import { delay, extractErrorMsg, pretty } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import { getIbGibAddr } from '@ibgib/ts-gib/dist/helper.mjs';
+import { getDependencyGraph } from '../common/other/graph-helper.mjs';
+
+import { SyncSagaCoordinator } from './sync-saga-coordinator.mjs';
+import { putInSpace, getFromSpace } from '../witness/space/space-helper.mjs';
+import { Metaspace_Innerspace } from '../witness/space/metaspace/metaspace-innerspace/metaspace-innerspace.mjs';
+import { InnerSpace_V1 } from '../witness/space/inner-space/inner-space-v1.mjs';
+import { createTimelineRootHelper, getTestKeystoneServiceHelper } from '../agent-helpers.mjs';
+import { mut8Timeline } from '../timeline/timeline-api.mjs';
+import { SyncPeerInnerspace_V1 } from './sync-peer/sync-peer-innerspace-v1.mjs';
+import { DEFAULT_INNER_SPACE_DATA_V1 } from '../witness/space/inner-space/inner-space-types.mjs';
+import { toDto } from '../common/other/ibgib-helper.mjs';
+
+const logalot = true;
+const lc = `[sync-innerspace-partial-update.respec]`;
+
+await respecfully(sir, `Sync InnerSpaces (Partial Update)`, async () => {
+
+    let metaspace: Metaspace_Innerspace;
+    let sourceSpace: InnerSpace_V1;
+    let destSpace: InnerSpace_V1;
+
+    interface TestData {
+        type: string;
+        label?: string;
+        uuid?: string;
+        n?: number;
+    }
+
+    await respecfully(sir, `Sender Newer (Partial History)`, async () => {
+        // 1. Setup Spaces
+        metaspace = new Metaspace_Innerspace(undefined);
+        await metaspace.initialize({
+            getFnAlert: () => async ({ title, msg }) => { },
+            getFnPrompt: () => async ({ title, msg }) => { return ''; },
+            getFnPromptPassword: () => async (title, msg) => { return null; },
+        });
+        while (!metaspace.initialized) { await delay(10); }
+
+        const defaultLocalUserSpace = await metaspace.getLocalUserSpace({ lock: false });
+        await defaultLocalUserSpace!.initialized;
+
+        sourceSpace = new InnerSpace_V1({
+            ...DEFAULT_INNER_SPACE_DATA_V1,
+            name: 'source',
+            uuid: 'source_uuid',
+            description: 'source test space',
+        });
+        await sourceSpace.initialized;
+
+        destSpace = new InnerSpace_V1({
+            ...DEFAULT_INNER_SPACE_DATA_V1,
+            name: 'dest',
+            uuid: 'dest_uuid',
+            description: 'dest test space',
+        });
+        await destSpace.initialized;
+
+        // 2. See Data
+        // Root -> V1 (Shared) -> V2 (Source Only)
+
+        const root = await createTimelineRootHelper<TestData>({
+            ib: 'timeline_root_partial',
+            data: { type: 'root', label: 'Root' },
+            space: sourceSpace,
+        });
+
+        // V1
+        const v1 = await mut8Timeline<TestData>({
+            timeline: root,
+            mut8Opts: { dataToAddOrPatch: { type: 'comment', label: 'V1' } },
+            metaspace,
+            space: sourceSpace,
+        });
+
+        // V2 (Source Only)
+        const v2 = await mut8Timeline<TestData>({
+            timeline: v1,
+            mut8Opts: { dataToAddOrPatch: { type: 'comment', label: 'V2' } },
+            metaspace,
+            space: sourceSpace,
+        });
+        const addrV2 = getIbGibAddr({ ibGib: v2 });
+
+        // Transfer Root & V1 to Dest (Simulate previous sync)
+        await putInSpace({ space: destSpace, ibGibs: [root, v1] });
+
+        await ifWe(sir, 'verify setup', async () => {
+            // Verify Dest has V1
+            const checkV1 = await getFromSpace({ space: destSpace, addr: getIbGibAddr({ ibGib: v1 }) });
+            iReckon(sir, checkV1.success).asTo('Dest has V1').isGonnaBeTrue();
+
+            // Verify Dest does NOT have V2
+            const checkV2 = await getFromSpace({ space: destSpace, addr: addrV2 });
+            iReckon(sir, checkV2.success && !!checkV2.ibGibs?.length).asTo('Dest has V2').isGonnaBeFalse();
+        });
+
+        // 3. Setup Sync
+        const mockKeystone = await getTestKeystoneServiceHelper();
+        const senderCoordinator = new SyncSagaCoordinator(mockKeystone);
+        const receiverCoordinator = new SyncSagaCoordinator(mockKeystone);
+
+        const peer = new SyncPeerInnerspace_V1({
+            senderSpace: sourceSpace,
+            receiverSpace: destSpace,
+            receiverCoordinator: receiverCoordinator,
+            receiverMetaspace: metaspace,
+        });
+
+        // 4. Run Sync (Source Pushes V2)
+        console.log(`${lc} Running Sync...`);
+        const resSync = await senderCoordinator.sync({
+            peer: peer,
+            localSpace: sourceSpace,
+            metaspace: metaspace,
+            domainIbGibs: [v2],
+            useSessionIdentity: false,
+        });
+
+        await resSync.done;
+
+        // 5. Verify Dest (Should now have V2)
+        console.log(`${lc} Verifying Destination...`);
+
+        await ifWe(sir, `verify dest updated`, async () => {
+            // Verify Tip (V2)
+            const getV2 = await getFromSpace({ space: destSpace, addr: addrV2 });
+            iReckon(sir, getV2.success).asTo('V2 present in Dest').isGonnaBeTrue();
+
+            // Verify V2 points to V1
+            const v2IbGib = getV2.ibGibs![0];
+            const pastAddr = v2IbGib.rel8ns?.past?.at(-1);
+            iReckon(sir, pastAddr === getIbGibAddr({ ibGib: v1 })).asTo('V2 points to V1').isGonnaBeTrue();
+        });
+
+    });
+
+});

package/src/sync/sync-innerspace.respec.mts

@@ -33,7 +33,7 @@ await respecfully(sir, `Sync InnerSpaces`, async () => {
     let sourceSpace: InnerSpace_V1;
     let destSpace: InnerSpace_V1;
 
-    await ifWeMight(sir, `Basic Push Sync (Source -> Dest)`, async () => {
+    await respecfully(sir, `Basic Push Sync (Source -> Dest)`, async () => {
         // 1. Setup Spaces
         metaspace = new Metaspace_Innerspace(undefined);
         await metaspace.initialize({
@@ -150,18 +150,18 @@ await respecfully(sir, `Sync InnerSpaces`, async () => {
         try {
             const getChildInDest = await getFromSpace({ space: destSpace, addr: childAddr });
 
-            await ifWeMight(sir, `verify success getChildInDest`, async () => {
+            await ifWe(sir, `verify success getChildInDest`, async () => {
                 iReckon(sir, getChildInDest.success).asTo('Child present in Dest').isGonnaBeTrue();
             });
 
-            await ifWeMight(sir, `verify getChildInDest.ibGibs`, async () => {
+            await ifWe(sir, `verify getChildInDest.ibGibs`, async () => {
                 const firstChild = getChildInDest.ibGibs?.[0];
                 console.log(`${lc} firstChild: ${pretty(firstChild)}`);
                 iReckon(sir, firstChild?.data?.n).asTo('Child content matches').isGonnaBe(2);
             });
 
         } catch (error) {
-            await ifWeMight(sir, `doh`, async () => {
+            await ifWe(sir, `doh`, async () => {
                 // hack here I'm getting tired...
                 iReckon(sir, true).asTo(`error: ${extractErrorMsg(error)}`).isGonnaBeFalse();
             });