mirror of
https://github.com/Start9Labs/start-os.git
synced 2026-03-26 02:11:53 +00:00
a535fc17c3
* bugfixes * update fe types * implement new registry types in marketplace and ui * fix marketplace types to have default params * add alt implementation toggle * merge cleanup * more cleanup and notes * fix build * cleanup sync with next/minor * add exver JS parser * parse ValidExVer to string * update types to interface * add VersionRange and comparative functions * Parse ExtendedVersion from string * add conjunction, disjunction, and inversion logic * consider flavor in satisfiedBy fn * consider prerelease for ordering * add compare fn for sorting * rename fns for consistency * refactoring * update compare fn to return null if flavors don't match * begin simplifying dependencies * under construction * wip * add dependency metadata to CurrentDependencyInfo * ditch inheritance for recursive VersionRange constructor. Recursive 'satisfiedBy' fn wip * preprocess manifest * misc fixes * use sdk version as osVersion in manifest * chore: Change the type to just validate and not generate all solutions. * add publishedAt * fix pegjs exports * integrate exver into sdk * misc fixes * complete satisfiedBy fn * refactor - use greaterThanOrEqual and lessThanOrEqual fns * fix tests * update dependency details * update types * remove interim types * rename alt implementation to flavor * cleanup os update * format exver.ts * add s9pk parsing endpoints * fix build * update to exver * exver and bug fixes * update static endpoints + cleanup * cleanup * update static proxy verification * make mocks more robust; fix dep icon fallback; cleanup * refactor alert versions and update fixtures * registry bugfixes * misc fixes * cleanup unused * convert patchdb ui seed to camelCase * update otherVersions type * change otherVersions: null to 'none' * refactor and complete feature * improve static endpoints * fix install params * mask systemd-networkd-wait-online * fix static file fetching * include non-matching versions in otherVersions * convert release notes to modal and clean up displayExver * alert for no other versions * Fix ack-instructions casing * fix indeterminate loader on service install --------- Co-authored-by: Aiden McClelland <me@drbonez.dev> Co-authored-by: Shadowy Super Coder <musashidisciple@proton.me> Co-authored-by: Aiden McClelland <3732071+dr-bonez@users.noreply.github.com> Co-authored-by: J H <dragondef@gmail.com> Co-authored-by: Matt Hill <mattnine@protonmail.com>
832 lines
23 KiB
TypeScript
832 lines
23 KiB
TypeScript
import { testOutput } from "./output.test"
|
|
import { Config } from "../config/builder/config"
|
|
import { List } from "../config/builder/list"
|
|
import { Value } from "../config/builder/value"
|
|
import { Variants } from "../config/builder/variants"
|
|
import { ValueSpec } from "../config/configTypes"
|
|
import { setupManifest } from "../manifest/setupManifest"
|
|
import { StartSdk } from "../StartSdk"
|
|
|
|
describe("builder tests", () => {
|
|
test("text", async () => {
|
|
const bitcoinPropertiesBuilt: {
|
|
"peer-tor-address": ValueSpec
|
|
} = await Config.of({
|
|
"peer-tor-address": Value.text({
|
|
name: "Peer tor address",
|
|
description: "The Tor address of the peer interface",
|
|
required: { default: null },
|
|
}),
|
|
}).build({} as any)
|
|
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.toggle({
|
|
name: "Testing",
|
|
description: null,
|
|
warning: null,
|
|
default: false,
|
|
})
|
|
const validator = value.validator
|
|
validator.unsafeCast(false)
|
|
testOutput<typeof validator._TYPE, boolean>()(null)
|
|
})
|
|
test("text", async () => {
|
|
const value = Value.text({
|
|
name: "Testing",
|
|
required: { default: null },
|
|
})
|
|
const validator = value.validator
|
|
const rawIs = await value.build({} as any)
|
|
validator.unsafeCast("test text")
|
|
expect(() => validator.unsafeCast(null)).toThrowError()
|
|
testOutput<typeof validator._TYPE, string>()(null)
|
|
})
|
|
test("text with default", async () => {
|
|
const value = Value.text({
|
|
name: "Testing",
|
|
required: { default: "this is a default value" },
|
|
})
|
|
const validator = value.validator
|
|
const rawIs = await value.build({} as any)
|
|
validator.unsafeCast("test text")
|
|
expect(() => validator.unsafeCast(null)).toThrowError()
|
|
testOutput<typeof validator._TYPE, string>()(null)
|
|
})
|
|
test("optional text", async () => {
|
|
const value = Value.text({
|
|
name: "Testing",
|
|
required: false,
|
|
})
|
|
const validator = value.validator
|
|
const rawIs = await value.build({} as any)
|
|
validator.unsafeCast("test text")
|
|
validator.unsafeCast(null)
|
|
testOutput<typeof validator._TYPE, string | null | undefined>()(null)
|
|
})
|
|
test("color", async () => {
|
|
const value = Value.color({
|
|
name: "Testing",
|
|
required: false,
|
|
description: null,
|
|
warning: null,
|
|
})
|
|
const validator = value.validator
|
|
validator.unsafeCast("#000000")
|
|
testOutput<typeof validator._TYPE, string | null | undefined>()(null)
|
|
})
|
|
test("datetime", async () => {
|
|
const value = 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")
|
|
testOutput<typeof validator._TYPE, string>()(null)
|
|
})
|
|
test("optional datetime", async () => {
|
|
const value = 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")
|
|
testOutput<typeof validator._TYPE, string | null | undefined>()(null)
|
|
})
|
|
test("textarea", async () => {
|
|
const value = Value.textarea({
|
|
name: "Testing",
|
|
required: false,
|
|
description: null,
|
|
warning: null,
|
|
minLength: null,
|
|
maxLength: null,
|
|
placeholder: null,
|
|
})
|
|
const validator = value.validator
|
|
validator.unsafeCast("test text")
|
|
testOutput<typeof validator._TYPE, string>()(null)
|
|
})
|
|
test("number", async () => {
|
|
const value = 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)
|
|
testOutput<typeof validator._TYPE, number>()(null)
|
|
})
|
|
test("optional number", async () => {
|
|
const value = 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)
|
|
testOutput<typeof validator._TYPE, number | null | undefined>()(null)
|
|
})
|
|
test("select", async () => {
|
|
const value = 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()
|
|
testOutput<typeof validator._TYPE, "a" | "b">()(null)
|
|
})
|
|
test("nullable select", async () => {
|
|
const value = 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)
|
|
testOutput<typeof validator._TYPE, "a" | "b" | null | undefined>()(null)
|
|
})
|
|
test("multiselect", async () => {
|
|
const value = 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()
|
|
testOutput<typeof validator._TYPE, Array<"a" | "b">>()(null)
|
|
})
|
|
test("object", async () => {
|
|
const value = Value.object(
|
|
{
|
|
name: "Testing",
|
|
description: null,
|
|
warning: null,
|
|
},
|
|
Config.of({
|
|
a: Value.toggle({
|
|
name: "test",
|
|
description: null,
|
|
warning: null,
|
|
default: false,
|
|
}),
|
|
}),
|
|
)
|
|
const validator = value.validator
|
|
validator.unsafeCast({ a: true })
|
|
testOutput<typeof validator._TYPE, { a: boolean }>()(null)
|
|
})
|
|
test("union", async () => {
|
|
const value = Value.union(
|
|
{
|
|
name: "Testing",
|
|
required: { default: null },
|
|
description: null,
|
|
warning: null,
|
|
},
|
|
Variants.of({
|
|
a: {
|
|
name: "a",
|
|
spec: Config.of({
|
|
b: Value.toggle({
|
|
name: "b",
|
|
description: null,
|
|
warning: null,
|
|
default: false,
|
|
}),
|
|
}),
|
|
},
|
|
}),
|
|
)
|
|
const validator = value.validator
|
|
validator.unsafeCast({ selection: "a", value: { b: false } })
|
|
type Test = typeof validator._TYPE
|
|
testOutput<Test, { selection: "a"; value: { b: boolean } }>()(null)
|
|
})
|
|
|
|
describe("dynamic", () => {
|
|
const fakeOptions = {
|
|
config: "config",
|
|
effects: "effects",
|
|
utils: "utils",
|
|
} as any
|
|
test("toggle", async () => {
|
|
const value = Value.dynamicToggle(async () => ({
|
|
name: "Testing",
|
|
description: null,
|
|
warning: null,
|
|
default: false,
|
|
}))
|
|
const validator = value.validator
|
|
validator.unsafeCast(false)
|
|
expect(() => validator.unsafeCast(null)).toThrowError()
|
|
testOutput<typeof validator._TYPE, boolean>()(null)
|
|
expect(await value.build(fakeOptions)).toMatchObject({
|
|
name: "Testing",
|
|
description: null,
|
|
warning: null,
|
|
default: false,
|
|
})
|
|
})
|
|
test("text", async () => {
|
|
const value = Value.dynamicText(async () => ({
|
|
name: "Testing",
|
|
required: { default: null },
|
|
}))
|
|
const validator = value.validator
|
|
const rawIs = await value.build({} as any)
|
|
validator.unsafeCast("test text")
|
|
validator.unsafeCast(null)
|
|
testOutput<typeof validator._TYPE, string | null | undefined>()(null)
|
|
expect(await value.build(fakeOptions)).toMatchObject({
|
|
name: "Testing",
|
|
required: true,
|
|
default: null,
|
|
})
|
|
})
|
|
test("text with default", async () => {
|
|
const value = Value.dynamicText(async () => ({
|
|
name: "Testing",
|
|
required: { default: "this is a default value" },
|
|
}))
|
|
const validator = value.validator
|
|
validator.unsafeCast("test text")
|
|
validator.unsafeCast(null)
|
|
testOutput<typeof validator._TYPE, string | null | undefined>()(null)
|
|
expect(await value.build(fakeOptions)).toMatchObject({
|
|
name: "Testing",
|
|
required: true,
|
|
default: "this is a default value",
|
|
})
|
|
})
|
|
test("optional text", async () => {
|
|
const value = Value.dynamicText(async () => ({
|
|
name: "Testing",
|
|
required: false,
|
|
}))
|
|
const validator = value.validator
|
|
const rawIs = await value.build({} as any)
|
|
validator.unsafeCast("test text")
|
|
validator.unsafeCast(null)
|
|
testOutput<typeof validator._TYPE, string | null | undefined>()(null)
|
|
expect(await value.build(fakeOptions)).toMatchObject({
|
|
name: "Testing",
|
|
required: false,
|
|
default: null,
|
|
})
|
|
})
|
|
test("color", async () => {
|
|
const value = Value.dynamicColor(async () => ({
|
|
name: "Testing",
|
|
required: false,
|
|
description: null,
|
|
warning: null,
|
|
}))
|
|
const validator = value.validator
|
|
validator.unsafeCast("#000000")
|
|
validator.unsafeCast(null)
|
|
testOutput<typeof validator._TYPE, string | null | undefined>()(null)
|
|
expect(await value.build(fakeOptions)).toMatchObject({
|
|
name: "Testing",
|
|
required: false,
|
|
default: null,
|
|
description: null,
|
|
warning: null,
|
|
})
|
|
})
|
|
test("datetime", async () => {
|
|
const sdk = StartSdk.of()
|
|
.withManifest(
|
|
setupManifest({
|
|
id: "testOutput",
|
|
title: "",
|
|
version: "1.0.0:0",
|
|
releaseNotes: "",
|
|
license: "",
|
|
replaces: [],
|
|
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<{ test: "a" }>()
|
|
.build(true)
|
|
|
|
const value = Value.dynamicDatetime<{ test: "a" }>(
|
|
async ({ effects }) => {
|
|
;async () => {
|
|
;(await sdk.store
|
|
.getOwn(effects, sdk.StorePath.test)
|
|
.once()) satisfies "a"
|
|
}
|
|
|
|
return {
|
|
name: "Testing",
|
|
required: { default: null },
|
|
inputmode: "date",
|
|
}
|
|
},
|
|
)
|
|
const validator = value.validator
|
|
validator.unsafeCast("2021-01-01")
|
|
validator.unsafeCast(null)
|
|
testOutput<typeof validator._TYPE, string | null | undefined>()(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.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()
|
|
testOutput<typeof validator._TYPE, string>()(null)
|
|
expect(await value.build(fakeOptions)).toMatchObject({
|
|
name: "Testing",
|
|
required: false,
|
|
})
|
|
})
|
|
test("number", async () => {
|
|
const value = 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()
|
|
testOutput<typeof validator._TYPE, number | null | undefined>()(null)
|
|
expect(await value.build(fakeOptions)).toMatchObject({
|
|
name: "Testing",
|
|
required: true,
|
|
})
|
|
})
|
|
test("select", async () => {
|
|
const value = 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)
|
|
testOutput<typeof validator._TYPE, string | null | undefined>()(null)
|
|
expect(await value.build(fakeOptions)).toMatchObject({
|
|
name: "Testing",
|
|
required: true,
|
|
})
|
|
})
|
|
test("multiselect", async () => {
|
|
const value = 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()
|
|
testOutput<typeof validator._TYPE, Array<string>>()(null)
|
|
expect(await value.build(fakeOptions)).toMatchObject({
|
|
name: "Testing",
|
|
default: [],
|
|
})
|
|
})
|
|
})
|
|
describe("filtering", () => {
|
|
test("union", async () => {
|
|
const value = Value.filteredUnion(
|
|
() => ["a", "c"],
|
|
{
|
|
name: "Testing",
|
|
required: { default: null },
|
|
description: null,
|
|
warning: null,
|
|
},
|
|
Variants.of({
|
|
a: {
|
|
name: "a",
|
|
spec: Config.of({
|
|
b: Value.toggle({
|
|
name: "b",
|
|
description: null,
|
|
warning: null,
|
|
default: false,
|
|
}),
|
|
}),
|
|
},
|
|
b: {
|
|
name: "b",
|
|
spec: Config.of({
|
|
b: Value.toggle({
|
|
name: "b",
|
|
description: null,
|
|
warning: null,
|
|
default: false,
|
|
}),
|
|
}),
|
|
},
|
|
}),
|
|
)
|
|
const validator = value.validator
|
|
validator.unsafeCast({ selection: "a", value: { b: false } })
|
|
type Test = typeof validator._TYPE
|
|
testOutput<
|
|
Test,
|
|
| { selection: "a"; value: { b: boolean } }
|
|
| { selection: "b"; value: { b: boolean } }
|
|
>()(null)
|
|
|
|
const built = await value.build({} as any)
|
|
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.dynamicUnion(
|
|
() => ({
|
|
disabled: ["a", "c"],
|
|
name: "Testing",
|
|
required: { default: null },
|
|
description: null,
|
|
warning: null,
|
|
}),
|
|
Variants.of({
|
|
a: {
|
|
name: "a",
|
|
spec: Config.of({
|
|
b: Value.toggle({
|
|
name: "b",
|
|
description: null,
|
|
warning: null,
|
|
default: false,
|
|
}),
|
|
}),
|
|
},
|
|
b: {
|
|
name: "b",
|
|
spec: Config.of({
|
|
b: Value.toggle({
|
|
name: "b",
|
|
description: null,
|
|
warning: null,
|
|
default: false,
|
|
}),
|
|
}),
|
|
},
|
|
}),
|
|
)
|
|
const validator = value.validator
|
|
validator.unsafeCast({ selection: "a", value: { b: false } })
|
|
type Test = typeof validator._TYPE
|
|
testOutput<
|
|
Test,
|
|
| { selection: "a"; value: { b: boolean } }
|
|
| { selection: "b"; value: { b: boolean } }
|
|
| null
|
|
| undefined
|
|
>()(null)
|
|
|
|
const built = await value.build({} as any)
|
|
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.list(
|
|
List.obj(
|
|
{
|
|
name: "test",
|
|
},
|
|
{
|
|
spec: Config.of({
|
|
test: Value.toggle({
|
|
name: "test",
|
|
description: null,
|
|
warning: null,
|
|
default: false,
|
|
}),
|
|
}),
|
|
},
|
|
),
|
|
)
|
|
const validator = value.validator
|
|
validator.unsafeCast([{ test: true }])
|
|
testOutput<typeof validator._TYPE, { test: boolean }[]>()(null)
|
|
})
|
|
test("text", async () => {
|
|
const value = Value.list(
|
|
List.text(
|
|
{
|
|
name: "test",
|
|
},
|
|
{
|
|
patterns: [],
|
|
},
|
|
),
|
|
)
|
|
const validator = value.validator
|
|
validator.unsafeCast(["test", "text"])
|
|
testOutput<typeof validator._TYPE, string[]>()(null)
|
|
})
|
|
describe("dynamic", () => {
|
|
test("text", async () => {
|
|
const value = Value.list(
|
|
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()
|
|
testOutput<typeof validator._TYPE, string[]>()(null)
|
|
expect(await value.build({} as any)).toMatchObject({
|
|
name: "test",
|
|
spec: { patterns: [] },
|
|
})
|
|
})
|
|
})
|
|
})
|
|
|
|
describe("Nested nullable values", () => {
|
|
test("Testing text", async () => {
|
|
const value = Config.of({
|
|
a: Value.text({
|
|
name: "Temp Name",
|
|
description:
|
|
"If no name is provided, the name from config will be used",
|
|
required: false,
|
|
}),
|
|
})
|
|
const validator = value.validator
|
|
validator.unsafeCast({ a: null })
|
|
validator.unsafeCast({ a: "test" })
|
|
expect(() => validator.unsafeCast({ a: 4 })).toThrowError()
|
|
testOutput<typeof validator._TYPE, { a: string | null | undefined }>()(null)
|
|
})
|
|
test("Testing number", async () => {
|
|
const value = Config.of({
|
|
a: Value.number({
|
|
name: "Temp Name",
|
|
description:
|
|
"If no name is provided, the name from config 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()
|
|
testOutput<typeof validator._TYPE, { a: number | null | undefined }>()(null)
|
|
})
|
|
test("Testing color", async () => {
|
|
const value = Config.of({
|
|
a: Value.color({
|
|
name: "Temp Name",
|
|
description:
|
|
"If no name is provided, the name from config 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()
|
|
testOutput<typeof validator._TYPE, { a: string | null | undefined }>()(null)
|
|
})
|
|
test("Testing select", async () => {
|
|
const value = Config.of({
|
|
a: Value.select({
|
|
name: "Temp Name",
|
|
description:
|
|
"If no name is provided, the name from config will be used",
|
|
required: false,
|
|
warning: null,
|
|
values: {
|
|
a: "A",
|
|
},
|
|
}),
|
|
})
|
|
const higher = await Value.select({
|
|
name: "Temp Name",
|
|
description: "If no name is provided, the name from config will be used",
|
|
required: false,
|
|
warning: null,
|
|
values: {
|
|
a: "A",
|
|
},
|
|
}).build({} as any)
|
|
|
|
const validator = value.validator
|
|
validator.unsafeCast({ a: null })
|
|
validator.unsafeCast({ a: "a" })
|
|
expect(() => validator.unsafeCast({ a: "4" })).toThrowError()
|
|
testOutput<typeof validator._TYPE, { a: "a" | null | undefined }>()(null)
|
|
})
|
|
test("Testing multiselect", async () => {
|
|
const value = Config.of({
|
|
a: Value.multiselect({
|
|
name: "Temp Name",
|
|
description:
|
|
"If no name is provided, the name from config 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()
|
|
testOutput<typeof validator._TYPE, { a: "a"[] }>()(null)
|
|
})
|
|
})
|