1import * as Option from "effect/Option"
2import * as Result from "effect/Result"
3import * as Schema from "effect/Schema"
4import * as SchemaParser from "effect/SchemaParser"
5import assert from "node:assert/strict"
6
7const schema = Schema.Struct({
8 a: Schema.String,
9 b: Schema.Number
10})
11const input = { a: "a", b: 1 }
12const invalidInput = { a: "a", b: "invalid" }
13
14export const makeValid = () => ({
15 run: () => schema.make(input),
16 validate: (result) => assert.deepEqual(result, input)
17})
18
19export const parserExitInvalid = () => {
20 const run = SchemaParser.decodeUnknownExit(schema)
21 return {
22 run: () => run(invalidInput),
23 validate: (result) => assert.equal(result._tag, "Failure")
24 }
25}
26
27export const exitValid = () => {
28 const run = Schema.decodeUnknownExit(schema)
29 return {
30 run: () => run(input),
31 validate: (result) => {
32 assert.equal(result._tag, "Success")
33 assert.deepEqual(result.value, input)
34 }
35 }
36}
37
38export const exitInvalid = () => {
39 const run = Schema.decodeUnknownExit(schema)
40 return {
41 run: () => run(invalidInput),
42 validate: (result) => assert.equal(result._tag, "Failure")
43 }
44}
45
46export const optionValid = () => {
47 const run = Schema.decodeUnknownOption(schema)
48 return {
49 run: () => run(input),
50 validate: (result) => {
51 assert.equal(Option.isSome(result), true)
52 if (Option.isSome(result)) assert.deepEqual(result.value, input)
53 }
54 }
55}
56
57export const optionInvalid = () => {
58 const run = Schema.decodeUnknownOption(schema)
59 return {
60 run: () => run(invalidInput),
61 validate: (result) => assert.equal(Option.isNone(result), true)
62 }
63}
64
65export const resultValid = () => {
66 const run = Schema.decodeUnknownResult(schema)
67 return {
68 run: () => run(input),
69 validate: (result) => {
70 assert.equal(Result.isSuccess(result), true)
71 if (Result.isSuccess(result)) assert.deepEqual(result.success, input)
72 }
73 }
74}
75
76export const resultInvalid = () => {
77 const run = Schema.decodeUnknownResult(schema)
78 return {
79 run: () => run(invalidInput),
80 validate: (result) => assert.equal(Result.isFailure(result), true)
81 }
82}
83
84export const syncInvalid = () => {
85 const run = Schema.decodeUnknownSync(schema)
86 return {
87 run: () => {
88 try {
89 run(invalidInput)
90 } catch (error) {
91 return error
92 }
93 return undefined
94 },
95 validate: (result) => assert.equal(result instanceof Error, true)
96 }
97}