@ibgib/core-gib 0.0.5 → 0.0.7

package/src/witness/space/space-spec-helper.spec.mts

@@ -0,0 +1,232 @@
+import { IbGibAddr, getIbGibAddr } from "@ibgib/ts-gib";
+import { IbGib_V1 } from "@ibgib/ts-gib/dist/V1/types.mjs";
+import { Factory_V1 as factory } from '@ibgib/ts-gib/dist/V1/factory.mjs';
+
+import { deleteFromSpace, getFromSpace, parseSpaceIb, persistTransformResult, putInSpace } from "./space-helper.mjs";
+import { IbGibSpaceAny } from "./space-base-v1.mjs";
+
+export interface CommonSpaceSpecOptions {
+    /** @optional additional description label for testing */
+    desc?: string,
+    /**
+     * expression to get the initial data when constructing the space
+     */
+    fnGetInitialData: () => Promise<any | undefined>,
+    /**
+     * expression to get the initial rel8ns when constructing the space
+     */
+    fnGetInitialRel8ns: () => Promise<any | undefined>,
+    /**
+     * expression to get the space, used in a `beforeEach` call
+     * @param initialData passed into ctor of space
+     * @param initialRel8ns passed into ctor of space
+     * @returns space instance
+     */
+    fnGetSpace: (initialData: any, initialRel8ns: any) => Promise<IbGibSpaceAny>,
+    /**
+     * if true, will use `fit` to short-circuit testing.
+     */
+    useFit?: boolean,
+}
+
+/**
+ * Executes tests related to:
+ *
+ * space creation
+ * `await space.initialized`
+ * space ib related (`getSpaceIb` & `parseSpaceIb`)
+ *
+ * run tests on an ibgib space that are common to all/most spaces.
+ *
+ * So, we can run these against any space, inner, outer, local ionic/filesystem based, etc.
+ */
+export function testSpace_createAndInit({
+    desc,
+    fnGetInitialData,
+    fnGetInitialRel8ns,
+    fnGetSpace,
+    useFit,
+}: CommonSpaceSpecOptions): Promise<void> {
+    const logContext = `[${testSpace_PutGetDelete.name}]${desc ?? ''}`;
+
+    return new Promise<void>((resolve) => {
+        let initialData: any | undefined;
+        let initialRel8ns: any | undefined;
+        let space: IbGibSpaceAny;
+
+        beforeEach(async () => {
+            initialData = await fnGetInitialData();
+            initialRel8ns = await fnGetInitialRel8ns();
+        });
+
+        const fnIt: any = useFit ? fit : it;
+
+        fnIt(`when created and initialized, space should be initialized`, async () => {
+            space = await fnGetSpace(initialData, initialRel8ns);
+            await space.initialized;
+
+            expect(space).withContext('space').toBeTruthy();
+            expect(space.ib).withContext('ib').toBeTruthy();
+            expect(space.gib).withContext('gib').toBeTruthy();
+            if (initialData) {
+                expect(space.data).withContext('data, initialData truthy').toBeTruthy();
+            } else {
+                expect(space.rel8ns).withContext('data, initialData falsy').toBeUndefined();
+            }
+            if (initialRel8ns) {
+                expect(space.rel8ns).withContext('rel8ns, initialRel8ns truthy').toBeTruthy();
+            } else {
+                expect(space.rel8ns).withContext('rel8ns, initialRel8ns falsy').toBeUndefined();
+            }
+        });
+
+        fnIt(`space.ib should contain correct info per initialData`, async () => {
+            space = await fnGetSpace(initialData, initialRel8ns);
+            await space.initialized;
+
+            expect(space.ib).toContain(initialData.name);
+            expect(space.ib).toContain(initialData.uuid);
+
+            let { spaceClassname, spaceId, spaceName, } = parseSpaceIb({ spaceIb: space.ib });
+            expect(space.data?.classname).withContext('space.data?.classname').toEqual(spaceClassname);
+            expect(space.data?.name).withContext('space.data?.name, initial').toEqual(initialData.name);
+            expect(space.data?.name).withContext('space.data?.name, spaceName').toEqual(spaceName);
+            expect(space.data?.uuid).withContext('space.data?.uuid, initial').toEqual(initialData.uuid);
+            expect(space.data?.uuid).withContext('space.data?.uuid, spaceId').toEqual(spaceId);
+        });
+
+        resolve();
+    });
+}
+
+/**
+ * Executes tests related to:
+ *
+ * `putInSpace`
+ * `getFromSpace`
+ * `deleteFromSpace`
+ *
+ * run tests on an ibgib space that are common to all/most spaces.
+ *
+ * So, we can run these against any space, inner, outer, local ionic/filesystem based, etc.
+ */
+export function testSpace_PutGetDelete({
+    desc,
+    fnGetInitialData,
+    fnGetInitialRel8ns,
+    fnGetSpace,
+    useFit,
+}: CommonSpaceSpecOptions): Promise<void> {
+    const logContext = `[${testSpace_PutGetDelete.name}]${desc ?? ''}`;
+
+    return new Promise<void>((resolve) => {
+        let initialData: any | undefined;
+        let initialRel8ns: any | undefined;
+        let space: IbGibSpaceAny;
+
+        beforeEach(async () => {
+            initialData = await fnGetInitialData();
+            initialRel8ns = await fnGetInitialRel8ns();
+            space = await fnGetSpace(initialData, initialRel8ns);
+            await space.initialized;
+        });
+
+        const fnIt: any = useFit ? fit : it;
+
+        fnIt(`${logContext}, should put/get/delete`, async () => {
+            let newIbGib: IbGib_V1 = {
+                ib: 'test ib',
+                data: { x: 1 },
+                rel8ns: { ancestor: ['test ib^gib'] }
+            }
+            let newIbGibAddr: IbGibAddr = getIbGibAddr({ ibGib: newIbGib });
+
+            // put
+            let resPut = await putInSpace({ ibGib: newIbGib, space });
+            expect(resPut).withContext('resPut').toBeTruthy();
+            expect(resPut.success).toBeTrue();
+
+            // get
+            let resGet = await getFromSpace({ addr: newIbGibAddr, space });
+            expect(resGet).withContext('resGet').toBeTruthy();
+            expect(resGet.success).withContext('resGet').toBeTrue();
+            expect(resGet.errorMsg).withContext('resGet').toBeFalsy();
+            expect(resGet.ibGibs).withContext('resGet').toBeTruthy();
+            expect(resGet.ibGibs!.length).withContext('resGet').toEqual(1);
+            expect(resGet.ibGibs![0]).withContext('resGet').toEqual(newIbGib);
+
+            // delete
+            await deleteFromSpace({ addr: newIbGibAddr, space });
+            resGet = await getFromSpace({ addr: newIbGibAddr, space });
+            expect(resGet).withContext('resGet after delete').toBeTruthy();
+            expect(resGet.success).withContext('resGet after delete').toBeFalse();
+            expect(resGet.errorMsg).withContext('resGet after delete').toBeTruthy();
+            expect(resGet.ibGibs).withContext('resGet after delete').toBeUndefined();
+        });
+
+        resolve();
+    });
+}
+
+/**
+ * Executes tests related to:
+ *
+ * `persistTransformResults`
+ *
+ * run tests on an ibgib space that are common to all/most spaces.
+ *
+ * So, we can run these against any space, inner, outer, local ionic/filesystem based, etc.
+ */
+export function testSpace_persistTransformResult({
+    desc,
+    fnGetInitialData,
+    fnGetInitialRel8ns,
+    fnGetSpace,
+    useFit,
+}: CommonSpaceSpecOptions): Promise<void> {
+    const logContext = `[${testSpace_persistTransformResult.name}]${desc ?? ''}`;
+
+    return new Promise<void>((resolve) => {
+        let initialData: any | undefined;
+        let initialRel8ns: any | undefined;
+        let space: IbGibSpaceAny;
+
+        beforeEach(async () => {
+            initialData = await fnGetInitialData();
+            initialRel8ns = await fnGetInitialRel8ns();
+            space = await fnGetSpace(initialData, initialRel8ns);
+            await space.initialized;
+        });
+
+        const fnIt: any = useFit ? fit : it;
+
+        fnIt(`${logContext} should persist all ibgibs (new, dna, intermediate)`, async () => {
+            let resNew = await factory.firstGen({
+                ib: 'test ib',
+                parentIbGib: factory.primitive({ ib: 'test ib' }),
+                dna: true,
+                noTimestamp: true,
+            });
+            let { newIbGib } = resNew;
+
+            await persistTransformResult({ resTransform: resNew, space });
+
+            const allIbGibs = [
+                newIbGib,
+                ...(resNew.dnas ?? []),
+                ...(resNew.intermediateIbGibs ?? []),
+            ];
+            const allAddrs = allIbGibs.map(x => getIbGibAddr({ ibGib: x }));
+
+            let resGet = await getFromSpace({ addrs: allAddrs, space });
+
+            expect(resGet).withContext('resGet').toBeTruthy();
+            expect(resGet.success).toBeTrue();
+            expect(resGet.ibGibs).toBeTruthy();
+            expect(resGet.ibGibs!.length).toEqual(allAddrs.length);
+            expect(resGet.ibGibs![0]).toEqual(newIbGib);
+        });
+
+        resolve();
+    });
+}

package/src/witness/witness-base-v1.mts

@@ -117,9 +117,25 @@ export abstract class WitnessBase_V1<
 
     // #endregion IbGib interface fields: ib, gib, data, rel8ns
 
+    /**
+     * await this to ensure the witness is ready.
+     *
+     * This is called in the base `Witness.witness` function before `witnessImpl`.
+     */
+    initialized: Promise<void> | undefined;
+
     constructor(initialData?: TData, initialRel8ns?: TRel8ns) {
         if (initialData) { this.data = initialData; }
         if (initialRel8ns) { this.rel8ns = initialRel8ns; }
+        this.initialized = this.initialize();
+    }
+
+    /**
+     * by default, simply returns true atow in base class.
+     * override this to perform code before any other code is executed.
+     */
+    protected initialize(): Promise<void> {
+        return Promise.resolve();
     }
 
     /**
@@ -214,6 +230,7 @@ export abstract class WitnessBase_V1<
     async witness(arg: TOptionsIbGib): Promise<TResultIbGib | undefined> {
         const lc = `${this.lc}[${this.witness.name}]`;
         try {
+            await this.initialized;
             if (!this.gib) { this.gib = await sha256v1(this.toIbGibDto()); }
             const validationErrors_this = await this.validateThis();
             if (validationErrors_this?.length > 0) {