@start9labs/start-sdk 0.4.0-beta.9 → 0.4.0

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

@@ -1,784 +0,0 @@
-"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");
-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: true,
-                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: true,
-            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: true,
-            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,
-            default: null,
-        });
-        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,
-            default: null,
-            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: true,
-            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,
-            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("textarea", async () => {
-        const value = value_1.Value.textarea({
-            name: "Testing",
-            required: false,
-            default: null,
-            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: true,
-            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,
-            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("select", async () => {
-        const value = value_1.Value.select({
-            name: "Testing",
-            default: "a",
-            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",
-            default: "a",
-            values: {
-                a: "A",
-                b: "B",
-            },
-            description: null,
-            warning: null,
-        });
-        const validator = value.validator;
-        validator.unsafeCast("a");
-        validator.unsafeCast("b");
-        (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",
-            default: "a",
-            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: false,
-                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: false,
-                default: null,
-            });
-        });
-        test("text with default", async () => {
-            const value = value_1.Value.dynamicText(async () => ({
-                name: "Testing",
-                required: false,
-                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: false,
-                default: "this is a default value",
-            });
-        });
-        test("optional text", async () => {
-            const value = value_1.Value.dynamicText(async () => ({
-                name: "Testing",
-                required: false,
-                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: false,
-                default: null,
-            });
-        });
-        test("color", async () => {
-            const value = value_1.Value.dynamicColor(async () => ({
-                name: "Testing",
-                required: false,
-                default: null,
-                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)({
-                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: true,
-                    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,
-                default: null,
-                description: null,
-                warning: null,
-                minLength: null,
-                maxLength: null,
-                placeholder: null,
-            }));
-            const validator = value.validator;
-            validator.unsafeCast("test text");
-            (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: true,
-                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",
-                default: "a",
-                values: {
-                    a: "A",
-                    b: "B",
-                },
-                description: null,
-                warning: null,
-            }));
-            const validator = value.validator;
-            validator.unsafeCast("a");
-            validator.unsafeCast("b");
-            validator.unsafeCast("c");
-            (0, output_test_1.testOutput)()(null);
-            expect(await value.build(fakeOptions)).toMatchObject({
-                name: "Testing",
-            });
-        });
-        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",
-                default: "a",
-                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",
-            default: "b",
-            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,
-                default: null,
-            }),
-        });
-        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,
-                default: null,
-                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,
-                default: null,
-                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",
-                default: "a",
-                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",
-            default: "a",
-            warning: null,
-            values: {
-                a: "A",
-            },
-        }).build({});
-        const validator = value.validator;
-        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