@bikky/replication 1.0.1

package/Transformers/__tests__/Replicable.Transformers.Serialiser.test.js

@@ -0,0 +1,320 @@
+import { fn } from "@vitest/spy";
+import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { BikPath } from "@bikky/path";
+import { Serialiser } from "../Serialiser.js";
+import { Versions } from "../../Constants/Versions.js";
+import { Expression, PropertyTypes } from "../../Main.js";
+import { ReplicableRegistry } from "../../Constants/ReplicableRegistry.js";
+import { TestPropertyDecorators } from "./Examples.js";
+import { ExpressionScopes } from "../../Expressions/TypeRegistry/Registry.js";
+import { Constructor } from "../Constructor.js";
+import { Pointer } from "../Reference.js";
+import "../Loader.js";
+var TransformersTheLotClass = TestPropertyDecorators.TransformersTheLotClass;
+var TransformersBasicStruct = TestPropertyDecorators.TransformersBasicStruct;
+var TransformersBasicClass = TestPropertyDecorators.TransformersBasicClass;
+//TODO: Test serialising & deserialising custom types that are represented by strings in code (e.g. UUID).
+describe("Serialiser", () => {
+    const ReplType = ReplicableRegistry.__GetReplicablesFor(TransformersTheLotClass)[0];
+    const StructType = ReplicableRegistry.__GetReplicablesFor(TransformersBasicStruct)[0];
+    const ClassType = ReplicableRegistry.__GetReplicablesFor(TransformersBasicClass)[0];
+    ExpressionScopes.addLocalVariable(TransformersTheLotClass.name, "thisEntity", [TransformersTheLotClass]);
+    Expression.setCurrentStartScopeType(TransformersTheLotClass.name);
+    Expression.setCurrentScope(TransformersTheLotClass, { thisEntity: TestPropertyDecorators.TransformersTheLotClass.MakeExampleObj() });
+    let def = ReplType.getPropDefinition(Versions.v1_0_0, "val");
+    let exprConfig = def.expressionForProperty[Versions.v1_0_0];
+    const Expr = new Expression({ text: "${thisEntity.Val}", sourceFile: BikPath.getCurrentFilepath() }, exprConfig);
+    let def2 = ReplType.getPropDefinition(Versions.v1_0_0, "val2");
+    let def3 = ReplType.getPropDefinition(Versions.v1_0_0, "val3");
+    let def4 = ReplType.getPropDefinition(Versions.v1_0_0, "val4");
+    let def5 = ReplType.getPropDefinition(Versions.v1_0_0, "val5");
+    let def6 = ReplType.getPropDefinition(Versions.v1_0_0, "val6");
+    let def7 = ReplType.getPropDefinition(Versions.v1_0_0, "val7");
+    let def9 = ReplType.getPropDefinition(Versions.v1_0_0, "val9");
+    let def10 = ReplType.getPropDefinition(Versions.v1_0_0, "val10");
+    let example = TestPropertyDecorators.TransformersTheLotClass.MakeExampleObj();
+    example.val14 = 4;
+    let variedExample = TestPropertyDecorators.VariedSerialisationStruct.MakeExampleObj();
+    let source = {
+        Version: Versions.v1_0_0,
+        SourceFile: BikPath.getCurrentFilepath()
+    };
+    function getRepls(def) {
+        return def.types.flatMap((e) => e.types);
+    }
+    const VSerType = ReplicableRegistry.__GetReplicablesFor(TestPropertyDecorators.VariedSerialisationStruct)[0];
+    let vDef = VSerType.getPropDefinition(Versions.v1_0_0, "ser");
+    describe.sequential("1. SerialiseProp", () => {
+        let original = Serialiser.SerialiseSingle;
+        Serialiser.SerialiseSingle = ((info, conf, val, mods) => "transformed:" + val);
+        let info = {
+            ownerRepl: ReplType,
+            source: { Version: Versions.v1_0_0, SourceFile: BikPath.getCurrentFilepath() },
+        };
+        afterAll(() => {
+            Serialiser.SerialiseSingle = original;
+        });
+        test("Serialise simple property", () => {
+            expect(Serialiser.SerialiseProp(info, def, 1)).toStrictEqual("transformed:1");
+        });
+        test("Serialise expression property", () => {
+            expect(Serialiser.SerialiseProp(info, def, Expr)).toStrictEqual(["Expression", "${thisEntity.Val}"]);
+        });
+        test("Serialise optional property", () => {
+            expect(Serialiser.SerialiseProp(info, def2, undefined)).toStrictEqual("transformed:undefined");
+            expect(Serialiser.SerialiseProp(info, def2, 1)).toStrictEqual("transformed:1");
+        });
+        test("Serialise Dict property", () => {
+            expect(Serialiser.SerialiseProp(info, def4, { a: 1 })).toStrictEqual(["Dict", { a: "transformed:1" }]);
+        });
+        test("Serialise Map property", () => {
+            expect(Serialiser.SerialiseProp(info, def3, new Map([["a", 1]]))).toStrictEqual(["Map", { a: "transformed:1" }]);
+        });
+        test("Serialise Array property", () => {
+            expect(Serialiser.SerialiseProp(info, def5, [1])).toStrictEqual(["Array", ["transformed:1"]]);
+        });
+        test("Serialise Double Array property", () => {
+            expect(Serialiser.SerialiseProp(info, def6, [[1]])).toStrictEqual(["Array2", [["transformed:1"]]]);
+        });
+    });
+    describe.sequential("2. DeserialiseProp", () => {
+        let original = Serialiser.DeserialiseSingle;
+        Serialiser.DeserialiseSingle = ((info, conf, target, val, mods) => Array.isArray(val) ? "transformed:" + val[1] : "transformed:" + val);
+        let info = {
+            ownerRepl: ReplType,
+            source: { Version: Versions.v1_0_0, SourceFile: BikPath.getCurrentFilepath() },
+        };
+        afterAll(() => {
+            Serialiser.DeserialiseSingle = original;
+        });
+        let target = {};
+        test("Deserialise simple property", () => {
+            expect(Serialiser.DeserialiseProp(info, def, target, ["Primitive", 1])).toStrictEqual("transformed:1");
+        });
+        test.skip("Deserialise expression property", () => {
+            expect(Serialiser.DeserialiseProp(info, def, target, ["Expression", "${thisEntity.Val}"])).toStrictEqual("something");
+        });
+        test("Deserialise optional property", () => {
+            expect(Serialiser.DeserialiseProp(info, def2, target, ["Primitive", undefined])).toStrictEqual("transformed:undefined");
+            expect(Serialiser.DeserialiseProp(info, def2, target, ["Primitive", 1])).toStrictEqual("transformed:1");
+        });
+        test("Deserialise Dict property", () => {
+            expect(Serialiser.DeserialiseProp(info, def4, target, ["Dict", { a: 1 }])).toStrictEqual({ a: "transformed:1" });
+        });
+        test("Deserialise Map property", () => {
+            expect(Serialiser.DeserialiseProp(info, def3, target, ["Map", { a: 1 }])).toStrictEqual(new Map([["a", "transformed:1"]]));
+        });
+        test("Deserialise Array property", () => {
+            expect(Serialiser.DeserialiseProp(info, def5, target, ["Array", [1]])).toStrictEqual(["transformed:1"]);
+        });
+        test("Deserialise Double Array property", () => {
+            expect(Serialiser.DeserialiseProp(info, def6, target, ["Array2", [[1]]])).toStrictEqual([["transformed:1"]]);
+        });
+    });
+    describe.sequential("3. SerialiseSingle", () => {
+        let originalSerialise = Serialiser.Serialise;
+        let spy = fn((val) => ["Repl", val]);
+        beforeAll(() => {
+            Serialiser.Serialise = spy;
+        });
+        let info = {
+            ownerRepl: ReplType,
+            source: { Version: Versions.v1_0_0, SourceFile: BikPath.getCurrentFilepath() },
+        };
+        afterAll(() => {
+            Serialiser.Serialise = originalSerialise;
+        });
+        test("Serialise single primitive", () => {
+            spy.mockClear();
+            expect(Serialiser.SerialiseSingle(info, def, "1", PropertyTypes.Solo)).toStrictEqual(["Primitive", "1"]);
+            expect(spy).not.toBeCalled();
+            spy.mockClear();
+            expect(() => Serialiser.SerialiseSingle(info, def, 1, PropertyTypes.Solo)).toThrowError(`${TransformersTheLotClass.name}.val is not a valid type for serialisation.`);
+            expect(spy).not.toBeCalled();
+            spy.mockClear();
+        });
+        test("Serialise single repl", () => {
+            spy.mockClear();
+            expect(Serialiser.SerialiseSingle(info, def7, example.val7, PropertyTypes.Solo))
+                .toStrictEqual(["Repl", example.val7]);
+            expect(spy).toBeCalledWith(example.val7);
+            spy.mockClear();
+        });
+        test("Serialise single repl with pointer", () => {
+            spy.mockClear();
+            expect(Serialiser.SerialiseSingle(info, def10, example.val10, PropertyTypes.Solo))
+                .toStrictEqual([TransformersBasicClass.name, example.val10.val.val]);
+            // We get the ref from the pointer so don't need to serialise.
+            expect(spy).not.toBeCalled();
+            spy.mockClear();
+        });
+        test("Serialise inline repl", () => {
+            spy.mockClear();
+            expect(Serialiser.SerialiseSingle(info, def9, example.val9, PropertyTypes.Solo | PropertyTypes.ForceInline))
+                .toStrictEqual(["Repl", example.val9.val]);
+            expect(spy).toBeCalledWith(example.val9.val);
+            spy.mockClear();
+        });
+    });
+    describe.sequential("4. DeserialiseSingle", () => {
+        const ClearObj = new TransformersTheLotClass();
+        const Config = {
+            source: { Version: Versions.v1_0_0, SourceFile: BikPath.getCurrentFilepath() },
+            owner: ClearObj
+        };
+        let info = {
+            ownerRepl: ReplType,
+            source: { Version: Versions.v1_0_0, SourceFile: BikPath.getCurrentFilepath() },
+            owner: ClearObj
+        };
+        let originalDeserialise = Serialiser.Deserialise;
+        let sSpyResult = undefined;
+        let sSpy = fn((object, val) => sSpyResult !== null && sSpyResult !== void 0 ? sSpyResult : ["Deserialised", val[1]]);
+        let originalConstruct = Constructor.Construct;
+        let cSpyResult = undefined;
+        let cSpy = fn((type, source, owner, args) => cSpyResult !== null && cSpyResult !== void 0 ? cSpyResult : ["Constructed", args[1]]);
+        beforeAll(() => {
+            Serialiser.Deserialise = sSpy;
+            Constructor.Construct = cSpy;
+        });
+        test.sequential("Deserialise simple primitive", () => {
+            sSpy.mockClear();
+            cSpy.mockClear();
+            expect(Serialiser.DeserialiseSingle(info, def, ClearObj.val, ["Primitive", "1"], PropertyTypes.Solo)).toStrictEqual("1");
+            expect(sSpy).not.toBeCalled();
+            expect(cSpy).not.toBeCalled();
+            sSpy.mockClear();
+            cSpy.mockClear();
+        });
+        test.sequential("Deserialise struct repl - construct", () => {
+            sSpy.mockClear();
+            cSpy.mockClear();
+            expect(Serialiser.DeserialiseSingle(info, def7, ClearObj.val7, [TransformersBasicStruct.name, { val: ["Primitive", example.val7.val] }], PropertyTypes.Solo))
+                .toStrictEqual(["Constructed", { val: ["Primitive", example.val7.val] }]);
+            expect(sSpy).not.toBeCalled();
+            expect(cSpy).toBeCalledWith(StructType, Config.source, Config.owner, [TransformersBasicStruct.name, { val: ["Primitive", example.val7.val] }]);
+            sSpy.mockClear();
+            cSpy.mockClear();
+        });
+        test.sequential("Deserialise struct repl - deserialise", () => {
+            ClearObj.val7 = new TransformersBasicStruct();
+            sSpy.mockClear();
+            cSpy.mockClear();
+            expect(Serialiser.DeserialiseSingle(info, def7, ClearObj.val7, [TransformersBasicStruct.name, { val: ["Primitive", example.val7.val] }], PropertyTypes.Solo))
+                .toStrictEqual(["Deserialised", { val: ["Primitive", example.val7.val] }]);
+            expect(sSpy).toBeCalledWith(ClearObj.val7, [TransformersBasicStruct.name, { val: ["Primitive", example.val7.val] }]);
+            expect(cSpy).not.toBeCalled();
+            sSpy.mockClear();
+            cSpy.mockClear();
+        });
+        test.sequential("Deserialise class repl - reference", () => {
+            sSpy.mockClear();
+            cSpy.mockClear();
+            let test = new TransformersBasicClass();
+            test.val = example.val10.val.val;
+            expect(Serialiser.DeserialiseSingle(info, def10, ClearObj.val10, [TransformersBasicClass.name, example.val10.val.val], PropertyTypes.Solo))
+                .toStrictEqual(new Pointer(test));
+            expect(sSpy).not.toBeCalled();
+            expect(cSpy).not.toBeCalled();
+            sSpy.mockClear();
+            cSpy.mockClear();
+        });
+        test.sequential("Deserialise inline class repl - construct", () => {
+            cSpyResult = new TransformersBasicClass();
+            cSpyResult.val = example.val10.val.val;
+            sSpy.mockClear();
+            cSpy.mockClear();
+            expect(Serialiser.DeserialiseSingle(info, def9, ClearObj.val9, [TransformersBasicClass.name, { val: ["Primitive", example.val9.val] }], PropertyTypes.Solo))
+                .toStrictEqual(new Pointer(cSpyResult));
+            expect(sSpy).not.toBeCalled();
+            expect(cSpy).toBeCalledWith(ClassType, Config.source, Config.owner, [TransformersBasicClass.name, { val: ["Primitive", example.val9.val] }]);
+            sSpy.mockClear();
+            cSpy.mockClear();
+        });
+        test.sequential("Deserialise inline class repl - deserialise", () => {
+            sSpyResult = new TransformersBasicClass();
+            sSpyResult.val = example.val10.val.val;
+            ClearObj.val9 = new Pointer(new TransformersBasicClass());
+            sSpy.mockClear();
+            cSpy.mockClear();
+            expect(Serialiser.DeserialiseSingle(info, def9, ClearObj.val9, [TransformersBasicClass.name, { val: ["Primitive", example.val9.val] }], PropertyTypes.Solo))
+                .toStrictEqual(new Pointer(sSpyResult));
+            expect(sSpy).toBeCalledWith(ClearObj.val9.val, [TransformersBasicClass.name, { val: ["Primitive", example.val9.val] }]);
+            expect(cSpy).not.toBeCalled();
+            sSpy.mockClear();
+            cSpy.mockClear();
+        });
+        afterAll(() => {
+            Serialiser.Deserialise = originalDeserialise;
+            Constructor.Construct = originalConstruct;
+        });
+    });
+    describe.sequential("5. SerialiseRepl", () => {
+        test("Serialise the lot", () => {
+            expect(Serialiser.SerialiseRepl(ReplType, source, example)).toStrictEqual([TransformersTheLotClass.name, {
+                    val: ["Primitive", example.val],
+                    val2: ["Primitive", example.val2],
+                    val3: ["Map", { hello: ["Primitive", 1] }],
+                    val4: ["Dict", { 1: ["Primitive", "world"] }],
+                    val5: ["Array", [["Primitive", "hello"]]],
+                    val6: ["Array2", [[["Primitive", 1], ["Primitive", 2]]]],
+                    val7: [TransformersBasicStruct.name, { val: ["Primitive", example.val7.val], version: Versions.MAX }],
+                    val8: ["Primitive", "hello"],
+                    val9: [TransformersBasicClass.name, { val: ["Primitive", example.val9.val.val], version: Versions.MAX }],
+                    val10: [TransformersBasicClass.name, example.val10.val.val],
+                    val13: ["Array2", [[["Primitive", 1], ["Primitive", 2]]]],
+                    val14: ["Primitive", example.val14],
+                    version: Versions.MAX,
+                }]);
+        });
+        test("Serialise varied", () => {
+            expect(Serialiser.SerialiseRepl(VSerType, source, variedExample)).toStrictEqual([TestPropertyDecorators.VariedSerialisationStruct.name, {
+                    ser: [TransformersBasicClass.name, { val: ["Primitive", variedExample.ser.val.val], version: Versions.MAX }],
+                    ser2: [TransformersBasicClass.name, variedExample.ser2.val.val],
+                    // ser3: variedExample.ser3,
+                    ser4: variedExample.ser4,
+                    ser5: [TransformersBasicClass.name, variedExample.ser5],
+                    ser7: [TransformersBasicStruct.name, { val: ["Primitive", variedExample.ser7.val], version: Versions.MAX }],
+                    ser9: variedExample.ser9,
+                    ser10: [TransformersBasicStruct.name, variedExample.ser10],
+                    version: Versions.MAX,
+                }]);
+        });
+    });
+    describe.sequential("6. Combo SerialiseRepl and DeserialiseRepl", () => {
+        let example = TestPropertyDecorators.TransformersTheLotClass.MakeExampleObj();
+        example.val14 = 4;
+        delete example.val11;
+        let variedExample = TestPropertyDecorators.VariedSerialisationStruct.MakeExampleObj();
+        test("Serialise and Deserialise the lot", () => {
+            let serialised = Serialiser.SerialiseRepl(ReplType, source, example);
+            let target = new TransformersTheLotClass();
+            let deserialised = Serialiser.DeserialiseRepl(ReplType, source, target, serialised);
+            expect(deserialised).toStrictEqual(example);
+        });
+        test("Serialise and Deserialise varied", () => {
+            let serialised = Serialiser.SerialiseRepl(VSerType, source, variedExample);
+            let target = new TestPropertyDecorators.VariedSerialisationStruct();
+            let deserialised = Serialiser.DeserialiseRepl(VSerType, source, target, serialised);
+            expect(deserialised).toStrictEqual(variedExample);
+        });
+    });
+    describe.sequential("7. Combo Serialise and Deserialise", () => {
+        let example = TestPropertyDecorators.TransformersTheLotClass.MakeExampleObj();
+        example.val14 = 4;
+        delete example.val11;
+        let variedExample = TestPropertyDecorators.VariedSerialisationStruct.MakeExampleObj();
+        test("Serialise and Deserialise the lot", () => {
+            let serialised = Serialiser.Serialise(example);
+            let target = new TransformersTheLotClass();
+            let deserialised = Serialiser.Deserialise(target, serialised);
+            expect(deserialised).toStrictEqual(example);
+        });
+        test("Serialise and Deserialise varied", () => {
+            let serialised = Serialiser.Serialise(variedExample);
+            let target = new TestPropertyDecorators.VariedSerialisationStruct();
+            let deserialised = Serialiser.Deserialise(target, serialised);
+            expect(deserialised).toStrictEqual(variedExample);
+        });
+    });
+});

package/Transformers/__tests__/Replicable.Transformers.Utils.test.d.ts

@@ -0,0 +1 @@
+export {};