@start9labs/start-sdk 0.3.6-alpha8 → 0.3.6-alpha9

package/package/lib/test/inputSpecBuilder.test.js

@@ -0,0 +1,775 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const output_test_1 = require("./output.test");
+const inputSpec_1 = require("../../../base/lib/actions/input/builder/inputSpec");
+const list_1 = require("../../../base/lib/actions/input/builder/list");
+const value_1 = require("../../../base/lib/actions/input/builder/value");
+const variants_1 = require("../../../base/lib/actions/input/builder/variants");
+const setupManifest_1 = require("../manifest/setupManifest");
+const StartSdk_1 = require("../StartSdk");
+const VersionGraph_1 = require("../version/VersionGraph");
+const VersionInfo_1 = require("../version/VersionInfo");
+describe("builder tests", () => {
+    test("text", async () => {
+        const bitcoinPropertiesBuilt = await inputSpec_1.InputSpec.of({
+            "peer-tor-address": value_1.Value.text({
+                name: "Peer tor address",
+                description: "The Tor address of the peer interface",
+                required: { default: null },
+            }),
+        }).build({});
+        expect(bitcoinPropertiesBuilt).toMatchObject({
+            "peer-tor-address": {
+                type: "text",
+                description: "The Tor address of the peer interface",
+                warning: null,
+                masked: false,
+                placeholder: null,
+                minLength: null,
+                maxLength: null,
+                patterns: [],
+                disabled: false,
+                inputmode: "text",
+                name: "Peer tor address",
+                required: true,
+                default: null,
+            },
+        });
+    });
+});
+describe("values", () => {
+    test("toggle", async () => {
+        const value = value_1.Value.toggle({
+            name: "Testing",
+            description: null,
+            warning: null,
+            default: false,
+        });
+        const validator = value.validator;
+        validator.unsafeCast(false);
+        (0, output_test_1.testOutput)()(null);
+    });
+    test("text", async () => {
+        const value = value_1.Value.text({
+            name: "Testing",
+            required: { default: null },
+        });
+        const validator = value.validator;
+        const rawIs = await value.build({});
+        validator.unsafeCast("test text");
+        expect(() => validator.unsafeCast(null)).toThrowError();
+        (0, output_test_1.testOutput)()(null);
+    });
+    test("text with default", async () => {
+        const value = value_1.Value.text({
+            name: "Testing",
+            required: { default: "this is a default value" },
+        });
+        const validator = value.validator;
+        const rawIs = await value.build({});
+        validator.unsafeCast("test text");
+        expect(() => validator.unsafeCast(null)).toThrowError();
+        (0, output_test_1.testOutput)()(null);
+    });
+    test("optional text", async () => {
+        const value = value_1.Value.text({
+            name: "Testing",
+            required: false,
+        });
+        const validator = value.validator;
+        const rawIs = await value.build({});
+        validator.unsafeCast("test text");
+        validator.unsafeCast(null);
+        (0, output_test_1.testOutput)()(null);
+    });
+    test("color", async () => {
+        const value = value_1.Value.color({
+            name: "Testing",
+            required: false,
+            description: null,
+            warning: null,
+        });
+        const validator = value.validator;
+        validator.unsafeCast("#000000");
+        (0, output_test_1.testOutput)()(null);
+    });
+    test("datetime", async () => {
+        const value = value_1.Value.datetime({
+            name: "Testing",
+            required: { default: null },
+            description: null,
+            warning: null,
+            inputmode: "date",
+            min: null,
+            max: null,
+        });
+        const validator = value.validator;
+        validator.unsafeCast("2021-01-01");
+        (0, output_test_1.testOutput)()(null);
+    });
+    test("optional datetime", async () => {
+        const value = value_1.Value.datetime({
+            name: "Testing",
+            required: false,
+            description: null,
+            warning: null,
+            inputmode: "date",
+            min: null,
+            max: null,
+        });
+        const validator = value.validator;
+        validator.unsafeCast("2021-01-01");
+        (0, output_test_1.testOutput)()(null);
+    });
+    test("textarea", async () => {
+        const value = value_1.Value.textarea({
+            name: "Testing",
+            required: false,
+            description: null,
+            warning: null,
+            minLength: null,
+            maxLength: null,
+            placeholder: null,
+        });
+        const validator = value.validator;
+        validator.unsafeCast("test text");
+        (0, output_test_1.testOutput)()(null);
+    });
+    test("number", async () => {
+        const value = value_1.Value.number({
+            name: "Testing",
+            required: { default: null },
+            integer: false,
+            description: null,
+            warning: null,
+            min: null,
+            max: null,
+            step: null,
+            units: null,
+            placeholder: null,
+        });
+        const validator = value.validator;
+        validator.unsafeCast(2);
+        (0, output_test_1.testOutput)()(null);
+    });
+    test("optional number", async () => {
+        const value = value_1.Value.number({
+            name: "Testing",
+            required: false,
+            integer: false,
+            description: null,
+            warning: null,
+            min: null,
+            max: null,
+            step: null,
+            units: null,
+            placeholder: null,
+        });
+        const validator = value.validator;
+        validator.unsafeCast(2);
+        (0, output_test_1.testOutput)()(null);
+    });
+    test("select", async () => {
+        const value = value_1.Value.select({
+            name: "Testing",
+            required: { default: null },
+            values: {
+                a: "A",
+                b: "B",
+            },
+            description: null,
+            warning: null,
+        });
+        const validator = value.validator;
+        validator.unsafeCast("a");
+        validator.unsafeCast("b");
+        expect(() => validator.unsafeCast("c")).toThrowError();
+        (0, output_test_1.testOutput)()(null);
+    });
+    test("nullable select", async () => {
+        const value = value_1.Value.select({
+            name: "Testing",
+            required: false,
+            values: {
+                a: "A",
+                b: "B",
+            },
+            description: null,
+            warning: null,
+        });
+        const validator = value.validator;
+        validator.unsafeCast("a");
+        validator.unsafeCast("b");
+        validator.unsafeCast(null);
+        (0, output_test_1.testOutput)()(null);
+    });
+    test("multiselect", async () => {
+        const value = value_1.Value.multiselect({
+            name: "Testing",
+            values: {
+                a: "A",
+                b: "B",
+            },
+            default: [],
+            description: null,
+            warning: null,
+            minLength: null,
+            maxLength: null,
+        });
+        const validator = value.validator;
+        validator.unsafeCast([]);
+        validator.unsafeCast(["a", "b"]);
+        expect(() => validator.unsafeCast(["e"])).toThrowError();
+        expect(() => validator.unsafeCast([4])).toThrowError();
+        (0, output_test_1.testOutput)()(null);
+    });
+    test("object", async () => {
+        const value = value_1.Value.object({
+            name: "Testing",
+            description: null,
+        }, inputSpec_1.InputSpec.of({
+            a: value_1.Value.toggle({
+                name: "test",
+                description: null,
+                warning: null,
+                default: false,
+            }),
+        }));
+        const validator = value.validator;
+        validator.unsafeCast({ a: true });
+        (0, output_test_1.testOutput)()(null);
+    });
+    test("union", async () => {
+        const value = value_1.Value.union({
+            name: "Testing",
+            required: { default: null },
+            description: null,
+            warning: null,
+        }, variants_1.Variants.of({
+            a: {
+                name: "a",
+                spec: inputSpec_1.InputSpec.of({
+                    b: value_1.Value.toggle({
+                        name: "b",
+                        description: null,
+                        warning: null,
+                        default: false,
+                    }),
+                }),
+            },
+        }));
+        const validator = value.validator;
+        validator.unsafeCast({ selection: "a", value: { b: false } });
+        (0, output_test_1.testOutput)()(null);
+    });
+    describe("dynamic", () => {
+        const fakeOptions = {
+            inputSpec: "inputSpec",
+            effects: "effects",
+            utils: "utils",
+        };
+        test("toggle", async () => {
+            const value = value_1.Value.dynamicToggle(async () => ({
+                name: "Testing",
+                description: null,
+                warning: null,
+                default: false,
+            }));
+            const validator = value.validator;
+            validator.unsafeCast(false);
+            expect(() => validator.unsafeCast(null)).toThrowError();
+            (0, output_test_1.testOutput)()(null);
+            expect(await value.build(fakeOptions)).toMatchObject({
+                name: "Testing",
+                description: null,
+                warning: null,
+                default: false,
+            });
+        });
+        test("text", async () => {
+            const value = value_1.Value.dynamicText(async () => ({
+                name: "Testing",
+                required: { default: null },
+            }));
+            const validator = value.validator;
+            const rawIs = await value.build({});
+            validator.unsafeCast("test text");
+            validator.unsafeCast(null);
+            (0, output_test_1.testOutput)()(null);
+            expect(await value.build(fakeOptions)).toMatchObject({
+                name: "Testing",
+                required: true,
+                default: null,
+            });
+        });
+        test("text with default", async () => {
+            const value = value_1.Value.dynamicText(async () => ({
+                name: "Testing",
+                required: { default: "this is a default value" },
+            }));
+            const validator = value.validator;
+            validator.unsafeCast("test text");
+            validator.unsafeCast(null);
+            (0, output_test_1.testOutput)()(null);
+            expect(await value.build(fakeOptions)).toMatchObject({
+                name: "Testing",
+                required: true,
+                default: "this is a default value",
+            });
+        });
+        test("optional text", async () => {
+            const value = value_1.Value.dynamicText(async () => ({
+                name: "Testing",
+                required: false,
+            }));
+            const validator = value.validator;
+            const rawIs = await value.build({});
+            validator.unsafeCast("test text");
+            validator.unsafeCast(null);
+            (0, output_test_1.testOutput)()(null);
+            expect(await value.build(fakeOptions)).toMatchObject({
+                name: "Testing",
+                required: false,
+                default: null,
+            });
+        });
+        test("color", async () => {
+            const value = value_1.Value.dynamicColor(async () => ({
+                name: "Testing",
+                required: false,
+                description: null,
+                warning: null,
+            }));
+            const validator = value.validator;
+            validator.unsafeCast("#000000");
+            validator.unsafeCast(null);
+            (0, output_test_1.testOutput)()(null);
+            expect(await value.build(fakeOptions)).toMatchObject({
+                name: "Testing",
+                required: false,
+                default: null,
+                description: null,
+                warning: null,
+            });
+        });
+        test("datetime", async () => {
+            const sdk = StartSdk_1.StartSdk.of()
+                .withManifest((0, setupManifest_1.setupManifest)(VersionGraph_1.VersionGraph.of(VersionInfo_1.VersionInfo.of({
+                version: "1.0.0:0",
+                releaseNotes: "",
+                migrations: {},
+            })), {
+                id: "testOutput",
+                title: "",
+                license: "",
+                wrapperRepo: "",
+                upstreamRepo: "",
+                supportSite: "",
+                marketingSite: "",
+                donationUrl: null,
+                description: {
+                    short: "",
+                    long: "",
+                },
+                containers: {},
+                images: {},
+                volumes: [],
+                assets: [],
+                alerts: {
+                    install: null,
+                    update: null,
+                    uninstall: null,
+                    restore: null,
+                    start: null,
+                    stop: null,
+                },
+                dependencies: {
+                    "remote-test": {
+                        description: "",
+                        optional: true,
+                        s9pk: "https://example.com/remote-test.s9pk",
+                    },
+                },
+            }))
+                .withStore()
+                .build(true);
+            const value = value_1.Value.dynamicDatetime(async ({ effects }) => {
+                ;
+                async () => {
+                    ;
+                    (await sdk.store
+                        .getOwn(effects, sdk.StorePath.test)
+                        .once());
+                };
+                return {
+                    name: "Testing",
+                    required: { default: null },
+                    inputmode: "date",
+                };
+            });
+            const validator = value.validator;
+            validator.unsafeCast("2021-01-01");
+            validator.unsafeCast(null);
+            (0, output_test_1.testOutput)()(null);
+            expect(await value.build(fakeOptions)).toMatchObject({
+                name: "Testing",
+                required: true,
+                default: null,
+                description: null,
+                warning: null,
+                inputmode: "date",
+            });
+        });
+        test("textarea", async () => {
+            const value = value_1.Value.dynamicTextarea(async () => ({
+                name: "Testing",
+                required: false,
+                description: null,
+                warning: null,
+                minLength: null,
+                maxLength: null,
+                placeholder: null,
+            }));
+            const validator = value.validator;
+            validator.unsafeCast("test text");
+            expect(() => validator.unsafeCast(null)).toThrowError();
+            (0, output_test_1.testOutput)()(null);
+            expect(await value.build(fakeOptions)).toMatchObject({
+                name: "Testing",
+                required: false,
+            });
+        });
+        test("number", async () => {
+            const value = value_1.Value.dynamicNumber(() => ({
+                name: "Testing",
+                required: { default: null },
+                integer: false,
+                description: null,
+                warning: null,
+                min: null,
+                max: null,
+                step: null,
+                units: null,
+                placeholder: null,
+            }));
+            const validator = value.validator;
+            validator.unsafeCast(2);
+            validator.unsafeCast(null);
+            expect(() => validator.unsafeCast("null")).toThrowError();
+            (0, output_test_1.testOutput)()(null);
+            expect(await value.build(fakeOptions)).toMatchObject({
+                name: "Testing",
+                required: true,
+            });
+        });
+        test("select", async () => {
+            const value = value_1.Value.dynamicSelect(() => ({
+                name: "Testing",
+                required: { default: null },
+                values: {
+                    a: "A",
+                    b: "B",
+                },
+                description: null,
+                warning: null,
+            }));
+            const validator = value.validator;
+            validator.unsafeCast("a");
+            validator.unsafeCast("b");
+            validator.unsafeCast("c");
+            validator.unsafeCast(null);
+            (0, output_test_1.testOutput)()(null);
+            expect(await value.build(fakeOptions)).toMatchObject({
+                name: "Testing",
+                required: true,
+            });
+        });
+        test("multiselect", async () => {
+            const value = value_1.Value.dynamicMultiselect(() => ({
+                name: "Testing",
+                values: {
+                    a: "A",
+                    b: "B",
+                },
+                default: [],
+                description: null,
+                warning: null,
+                minLength: null,
+                maxLength: null,
+            }));
+            const validator = value.validator;
+            validator.unsafeCast([]);
+            validator.unsafeCast(["a", "b"]);
+            validator.unsafeCast(["c"]);
+            expect(() => validator.unsafeCast([4])).toThrowError();
+            expect(() => validator.unsafeCast(null)).toThrowError();
+            (0, output_test_1.testOutput)()(null);
+            expect(await value.build(fakeOptions)).toMatchObject({
+                name: "Testing",
+                default: [],
+            });
+        });
+    });
+    describe("filtering", () => {
+        test("union", async () => {
+            const value = value_1.Value.filteredUnion(() => ["a", "c"], {
+                name: "Testing",
+                required: { default: null },
+                description: null,
+                warning: null,
+            }, variants_1.Variants.of({
+                a: {
+                    name: "a",
+                    spec: inputSpec_1.InputSpec.of({
+                        b: value_1.Value.toggle({
+                            name: "b",
+                            description: null,
+                            warning: null,
+                            default: false,
+                        }),
+                    }),
+                },
+                b: {
+                    name: "b",
+                    spec: inputSpec_1.InputSpec.of({
+                        b: value_1.Value.toggle({
+                            name: "b",
+                            description: null,
+                            warning: null,
+                            default: false,
+                        }),
+                    }),
+                },
+            }));
+            const validator = value.validator;
+            validator.unsafeCast({ selection: "a", value: { b: false } });
+            (0, output_test_1.testOutput)()(null);
+            const built = await value.build({});
+            expect(built).toMatchObject({
+                name: "Testing",
+                variants: {
+                    b: {},
+                },
+            });
+            expect(built).toMatchObject({
+                name: "Testing",
+                variants: {
+                    a: {},
+                    b: {},
+                },
+            });
+            expect(built).toMatchObject({
+                name: "Testing",
+                variants: {
+                    a: {},
+                    b: {},
+                },
+                disabled: ["a", "c"],
+            });
+        });
+    });
+    test("dynamic union", async () => {
+        const value = value_1.Value.dynamicUnion(() => ({
+            disabled: ["a", "c"],
+            name: "Testing",
+            required: { default: null },
+            description: null,
+            warning: null,
+        }), variants_1.Variants.of({
+            a: {
+                name: "a",
+                spec: inputSpec_1.InputSpec.of({
+                    b: value_1.Value.toggle({
+                        name: "b",
+                        description: null,
+                        warning: null,
+                        default: false,
+                    }),
+                }),
+            },
+            b: {
+                name: "b",
+                spec: inputSpec_1.InputSpec.of({
+                    b: value_1.Value.toggle({
+                        name: "b",
+                        description: null,
+                        warning: null,
+                        default: false,
+                    }),
+                }),
+            },
+        }));
+        const validator = value.validator;
+        validator.unsafeCast({ selection: "a", value: { b: false } });
+        (0, output_test_1.testOutput)()(null);
+        const built = await value.build({});
+        expect(built).toMatchObject({
+            name: "Testing",
+            variants: {
+                b: {},
+            },
+        });
+        expect(built).toMatchObject({
+            name: "Testing",
+            variants: {
+                a: {},
+                b: {},
+            },
+        });
+        expect(built).toMatchObject({
+            name: "Testing",
+            variants: {
+                a: {},
+                b: {},
+            },
+            disabled: ["a", "c"],
+        });
+    });
+});
+describe("Builder List", () => {
+    test("obj", async () => {
+        const value = value_1.Value.list(list_1.List.obj({
+            name: "test",
+        }, {
+            spec: inputSpec_1.InputSpec.of({
+                test: value_1.Value.toggle({
+                    name: "test",
+                    description: null,
+                    warning: null,
+                    default: false,
+                }),
+            }),
+        }));
+        const validator = value.validator;
+        validator.unsafeCast([{ test: true }]);
+        (0, output_test_1.testOutput)()(null);
+    });
+    test("text", async () => {
+        const value = value_1.Value.list(list_1.List.text({
+            name: "test",
+        }, {
+            patterns: [],
+        }));
+        const validator = value.validator;
+        validator.unsafeCast(["test", "text"]);
+        (0, output_test_1.testOutput)()(null);
+    });
+    describe("dynamic", () => {
+        test("text", async () => {
+            const value = value_1.Value.list(list_1.List.dynamicText(() => ({
+                name: "test",
+                spec: { patterns: [] },
+            })));
+            const validator = value.validator;
+            validator.unsafeCast(["test", "text"]);
+            expect(() => validator.unsafeCast([3, 4])).toThrowError();
+            expect(() => validator.unsafeCast(null)).toThrowError();
+            (0, output_test_1.testOutput)()(null);
+            expect(await value.build({})).toMatchObject({
+                name: "test",
+                spec: { patterns: [] },
+            });
+        });
+    });
+});
+describe("Nested nullable values", () => {
+    test("Testing text", async () => {
+        const value = inputSpec_1.InputSpec.of({
+            a: value_1.Value.text({
+                name: "Temp Name",
+                description: "If no name is provided, the name from inputSpec will be used",
+                required: false,
+            }),
+        });
+        const validator = value.validator;
+        validator.unsafeCast({ a: null });
+        validator.unsafeCast({ a: "test" });
+        expect(() => validator.unsafeCast({ a: 4 })).toThrowError();
+        (0, output_test_1.testOutput)()(null);
+    });
+    test("Testing number", async () => {
+        const value = inputSpec_1.InputSpec.of({
+            a: value_1.Value.number({
+                name: "Temp Name",
+                description: "If no name is provided, the name from inputSpec will be used",
+                required: false,
+                warning: null,
+                placeholder: null,
+                integer: false,
+                min: null,
+                max: null,
+                step: null,
+                units: null,
+            }),
+        });
+        const validator = value.validator;
+        validator.unsafeCast({ a: null });
+        validator.unsafeCast({ a: 5 });
+        expect(() => validator.unsafeCast({ a: "4" })).toThrowError();
+        (0, output_test_1.testOutput)()(null);
+    });
+    test("Testing color", async () => {
+        const value = inputSpec_1.InputSpec.of({
+            a: value_1.Value.color({
+                name: "Temp Name",
+                description: "If no name is provided, the name from inputSpec will be used",
+                required: false,
+                warning: null,
+            }),
+        });
+        const validator = value.validator;
+        validator.unsafeCast({ a: null });
+        validator.unsafeCast({ a: "5" });
+        expect(() => validator.unsafeCast({ a: 4 })).toThrowError();
+        (0, output_test_1.testOutput)()(null);
+    });
+    test("Testing select", async () => {
+        const value = inputSpec_1.InputSpec.of({
+            a: value_1.Value.select({
+                name: "Temp Name",
+                description: "If no name is provided, the name from inputSpec will be used",
+                required: false,
+                warning: null,
+                values: {
+                    a: "A",
+                },
+            }),
+        });
+        const higher = await value_1.Value.select({
+            name: "Temp Name",
+            description: "If no name is provided, the name from inputSpec will be used",
+            required: false,
+            warning: null,
+            values: {
+                a: "A",
+            },
+        }).build({});
+        const validator = value.validator;
+        validator.unsafeCast({ a: null });
+        validator.unsafeCast({ a: "a" });
+        expect(() => validator.unsafeCast({ a: "4" })).toThrowError();
+        (0, output_test_1.testOutput)()(null);
+    });
+    test("Testing multiselect", async () => {
+        const value = inputSpec_1.InputSpec.of({
+            a: value_1.Value.multiselect({
+                name: "Temp Name",
+                description: "If no name is provided, the name from inputSpec will be used",
+                warning: null,
+                default: [],
+                values: {
+                    a: "A",
+                },
+                minLength: null,
+                maxLength: null,
+            }),
+        });
+        const validator = value.validator;
+        validator.unsafeCast({ a: [] });
+        validator.unsafeCast({ a: ["a"] });
+        expect(() => validator.unsafeCast({ a: ["4"] })).toThrowError();
+        expect(() => validator.unsafeCast({ a: "4" })).toThrowError();
+        (0, output_test_1.testOutput)()(null);
+    });
+});
+//# sourceMappingURL=inputSpecBuilder.test.js.map