schematox 1.2.2-alpha → 1.2.3-alpha

package/src/tests/by-struct/boolean.test.ts

@@ -1,741 +0,0 @@
-import * as x from '../../'
-import * as fixture from '../fixtures'
-
-import type { StructSharedKeys } from '../type'
-
-describe('Type inference and parse by schema/construct/struct (foldA)', () => {
-  it('required', () => {
-    const schema = { type: 'boolean' } as const satisfies x.Schema
-    const struct = x.boolean()
-
-    type ExpectedSubj = boolean
-
-    const subjects: Array<ExpectedSubj> = [true, false]
-
-    foldA: {
-      const construct = x.makeStruct(schema)
-
-      /* ensure that schema/construct/struct/~standard subject types are identical */
-
-      type ConstructSchemaSubj = x.Infer<typeof construct.__schema>
-
-      x.tCh<ConstructSchemaSubj, ExpectedSubj>()
-      x.tCh<ExpectedSubj, ConstructSchemaSubj>()
-
-      type SchemaSubj = x.Infer<typeof schema>
-
-      x.tCh<SchemaSubj, ExpectedSubj>()
-      x.tCh<ExpectedSubj, SchemaSubj>()
-
-      type StructSubj = x.Infer<typeof struct.__schema>
-
-      x.tCh<StructSubj, ExpectedSubj>()
-      x.tCh<ExpectedSubj, StructSubj>()
-
-      type StandardSubj = NonNullable<
-        (typeof struct)['~standard']['types']
-      >['output']
-
-      x.tCh<StandardSubj, ExpectedSubj>()
-      x.tCh<ExpectedSubj, StandardSubj>()
-
-      /* parsed either type check */
-
-      type ExpectedParsed = x.ParseResult<ExpectedSubj>
-
-      const parsed = x.parse(schema, undefined)
-
-      type SchemaParsed = typeof parsed
-
-      x.tCh<SchemaParsed, ExpectedParsed>()
-      x.tCh<ExpectedParsed, SchemaParsed>()
-
-      type ConstructParsed = ReturnType<typeof construct.parse>
-
-      x.tCh<ConstructParsed, ExpectedParsed>()
-      x.tCh<ExpectedParsed, ConstructParsed>()
-
-      type StructParsed = ReturnType<typeof struct.parse>
-
-      x.tCh<StructParsed, ExpectedParsed>()
-      x.tCh<ExpectedParsed, StructParsed>()
-
-      type StandardParsed = Extract<
-        ReturnType<(typeof struct)['~standard']['validate']>,
-        { value: unknown }
-      >['value']
-
-      x.tCh<StandardParsed, ExpectedSubj>()
-      x.tCh<ExpectedSubj, StandardParsed>()
-
-      /* runtime schema check */
-
-      expect(struct.__schema).toStrictEqual(schema)
-      expect(construct.__schema).toStrictEqual(schema)
-      expect(construct.__schema === schema).toBe(false)
-
-      /* parse result check */
-
-      for (const subj of subjects) {
-        const schemaParsed = x.parse(schema, subj)
-
-        expect(schemaParsed.error).toBe(undefined)
-        expect(schemaParsed.data).toStrictEqual(subj)
-
-        const constructParsed = construct.parse(subj)
-
-        expect(constructParsed.error).toBe(undefined)
-        expect(constructParsed.data).toStrictEqual(subj)
-
-        const structParsed = struct.parse(subj)
-
-        expect(structParsed.error).toBe(undefined)
-        expect(structParsed.data).toStrictEqual(subj)
-
-        const standardParsed = struct['~standard'].validate(subj)
-
-        if (standardParsed instanceof Promise) {
-          throw Error('Not expected')
-        }
-
-        if (standardParsed.issues !== undefined) {
-          throw Error('not expected')
-        }
-
-        expect(standardParsed.value).toStrictEqual(subj)
-      }
-    }
-  })
-
-  it('optional', () => {
-    const schema = {
-      type: 'boolean',
-      optional: true,
-    } as const satisfies x.Schema
-    const struct = x.boolean().optional()
-
-    type ExpectedSubj = boolean | undefined
-
-    const subjects: Array<ExpectedSubj> = [true, false, undefined]
-
-    foldA: {
-      const construct = x.makeStruct(schema)
-
-      /* ensure that schema/construct/struct/~standard subject types are identical */
-
-      type ConstructSchemaSubj = x.Infer<typeof construct.__schema>
-
-      x.tCh<ConstructSchemaSubj, ExpectedSubj>()
-      x.tCh<ExpectedSubj, ConstructSchemaSubj>()
-
-      type SchemaSubj = x.Infer<typeof schema>
-
-      x.tCh<SchemaSubj, ExpectedSubj>()
-      x.tCh<ExpectedSubj, SchemaSubj>()
-
-      type StructSubj = x.Infer<typeof struct.__schema>
-
-      x.tCh<StructSubj, ExpectedSubj>()
-      x.tCh<ExpectedSubj, StructSubj>()
-
-      type StandardSubj = NonNullable<
-        (typeof struct)['~standard']['types']
-      >['output']
-
-      x.tCh<StandardSubj, ExpectedSubj>()
-      x.tCh<ExpectedSubj, StandardSubj>()
-
-      /* parsed either type check */
-
-      type ExpectedParsed = x.ParseResult<ExpectedSubj>
-
-      const parsed = x.parse(schema, undefined)
-
-      type SchemaParsed = typeof parsed
-
-      x.tCh<SchemaParsed, ExpectedParsed>()
-      x.tCh<ExpectedParsed, SchemaParsed>()
-
-      type ConstructParsed = ReturnType<typeof construct.parse>
-
-      x.tCh<ConstructParsed, ExpectedParsed>()
-      x.tCh<ExpectedParsed, ConstructParsed>()
-
-      type StructParsed = ReturnType<typeof struct.parse>
-
-      x.tCh<StructParsed, ExpectedParsed>()
-      x.tCh<ExpectedParsed, StructParsed>()
-
-      type StandardParsed = Extract<
-        ReturnType<(typeof struct)['~standard']['validate']>,
-        { value: unknown }
-      >['value']
-
-      x.tCh<StandardParsed, ExpectedSubj>()
-      x.tCh<ExpectedSubj, StandardParsed>()
-
-      /* runtime schema check */
-
-      expect(struct.__schema).toStrictEqual(schema)
-      expect(construct.__schema).toStrictEqual(schema)
-      expect(construct.__schema === schema).toBe(false)
-
-      /* parse result check */
-
-      for (const subj of subjects) {
-        const schemaParsed = x.parse(schema, subj)
-
-        expect(schemaParsed.error).toBe(undefined)
-        expect(schemaParsed.data).toStrictEqual(subj)
-
-        const constructParsed = construct.parse(subj)
-
-        expect(constructParsed.error).toBe(undefined)
-        expect(constructParsed.data).toStrictEqual(subj)
-
-        const structParsed = struct.parse(subj)
-
-        expect(structParsed.error).toBe(undefined)
-        expect(structParsed.data).toStrictEqual(subj)
-
-        const standardParsed = struct['~standard'].validate(subj)
-
-        if (standardParsed instanceof Promise) {
-          throw Error('Not expected')
-        }
-
-        if (standardParsed.issues !== undefined) {
-          throw Error('not expected')
-        }
-
-        expect(standardParsed.value).toStrictEqual(subj)
-      }
-    }
-  })
-
-  it('nullable', () => {
-    const schema = {
-      type: 'boolean',
-      nullable: true,
-    } as const satisfies x.Schema
-    const struct = x.boolean().nullable()
-
-    type ExpectedSubj = boolean | null
-
-    const subjects: Array<ExpectedSubj> = [true, false, null]
-
-    foldA: {
-      const construct = x.makeStruct(schema)
-
-      /* ensure that schema/construct/struct/~standard subject types are identical */
-
-      type ConstructSchemaSubj = x.Infer<typeof construct.__schema>
-
-      x.tCh<ConstructSchemaSubj, ExpectedSubj>()
-      x.tCh<ExpectedSubj, ConstructSchemaSubj>()
-
-      type SchemaSubj = x.Infer<typeof schema>
-
-      x.tCh<SchemaSubj, ExpectedSubj>()
-      x.tCh<ExpectedSubj, SchemaSubj>()
-
-      type StructSubj = x.Infer<typeof struct.__schema>
-
-      x.tCh<StructSubj, ExpectedSubj>()
-      x.tCh<ExpectedSubj, StructSubj>()
-
-      type StandardSubj = NonNullable<
-        (typeof struct)['~standard']['types']
-      >['output']
-
-      x.tCh<StandardSubj, ExpectedSubj>()
-      x.tCh<ExpectedSubj, StandardSubj>()
-
-      /* parsed either type check */
-
-      type ExpectedParsed = x.ParseResult<ExpectedSubj>
-
-      const parsed = x.parse(schema, undefined)
-
-      type SchemaParsed = typeof parsed
-
-      x.tCh<SchemaParsed, ExpectedParsed>()
-      x.tCh<ExpectedParsed, SchemaParsed>()
-
-      type ConstructParsed = ReturnType<typeof construct.parse>
-
-      x.tCh<ConstructParsed, ExpectedParsed>()
-      x.tCh<ExpectedParsed, ConstructParsed>()
-
-      type StructParsed = ReturnType<typeof struct.parse>
-
-      x.tCh<StructParsed, ExpectedParsed>()
-      x.tCh<ExpectedParsed, StructParsed>()
-
-      type StandardParsed = Extract<
-        ReturnType<(typeof struct)['~standard']['validate']>,
-        { value: unknown }
-      >['value']
-
-      x.tCh<StandardParsed, ExpectedSubj>()
-      x.tCh<ExpectedSubj, StandardParsed>()
-
-      /* runtime schema check */
-
-      expect(struct.__schema).toStrictEqual(schema)
-      expect(construct.__schema).toStrictEqual(schema)
-      expect(construct.__schema === schema).toBe(false)
-
-      /* parse result check */
-
-      for (const subj of subjects) {
-        const schemaParsed = x.parse(schema, subj)
-
-        expect(schemaParsed.error).toBe(undefined)
-        expect(schemaParsed.data).toStrictEqual(subj)
-
-        const constructParsed = construct.parse(subj)
-
-        expect(constructParsed.error).toBe(undefined)
-        expect(constructParsed.data).toStrictEqual(subj)
-
-        const structParsed = struct.parse(subj)
-
-        expect(structParsed.error).toBe(undefined)
-        expect(structParsed.data).toStrictEqual(subj)
-
-        const standardParsed = struct['~standard'].validate(subj)
-
-        if (standardParsed instanceof Promise) {
-          throw Error('Not expected')
-        }
-
-        if (standardParsed.issues !== undefined) {
-          throw Error('not expected')
-        }
-
-        expect(standardParsed.value).toStrictEqual(subj)
-      }
-    }
-  })
-
-  it('optional + nullable', () => {
-    const schema = {
-      type: 'boolean',
-      optional: true,
-      nullable: true,
-    } as const satisfies x.Schema
-    const struct = x.boolean().optional().nullable()
-
-    type ExpectedSubj = boolean | undefined | null
-
-    const subjects: Array<ExpectedSubj> = [true, false, null, undefined]
-
-    foldA: {
-      const construct = x.makeStruct(schema)
-
-      /* ensure that schema/construct/struct/~standard subject types are identical */
-
-      type ConstructSchemaSubj = x.Infer<typeof construct.__schema>
-
-      x.tCh<ConstructSchemaSubj, ExpectedSubj>()
-      x.tCh<ExpectedSubj, ConstructSchemaSubj>()
-
-      type SchemaSubj = x.Infer<typeof schema>
-
-      x.tCh<SchemaSubj, ExpectedSubj>()
-      x.tCh<ExpectedSubj, SchemaSubj>()
-
-      type StructSubj = x.Infer<typeof struct.__schema>
-
-      x.tCh<StructSubj, ExpectedSubj>()
-      x.tCh<ExpectedSubj, StructSubj>()
-
-      type StandardSubj = NonNullable<
-        (typeof struct)['~standard']['types']
-      >['output']
-
-      x.tCh<StandardSubj, ExpectedSubj>()
-      x.tCh<ExpectedSubj, StandardSubj>()
-
-      /* parsed either type check */
-
-      type ExpectedParsed = x.ParseResult<ExpectedSubj>
-
-      const parsed = x.parse(schema, undefined)
-
-      type SchemaParsed = typeof parsed
-
-      x.tCh<SchemaParsed, ExpectedParsed>()
-      x.tCh<ExpectedParsed, SchemaParsed>()
-
-      type ConstructParsed = ReturnType<typeof construct.parse>
-
-      x.tCh<ConstructParsed, ExpectedParsed>()
-      x.tCh<ExpectedParsed, ConstructParsed>()
-
-      type StructParsed = ReturnType<typeof struct.parse>
-
-      x.tCh<StructParsed, ExpectedParsed>()
-      x.tCh<ExpectedParsed, StructParsed>()
-
-      type StandardParsed = Extract<
-        ReturnType<(typeof struct)['~standard']['validate']>,
-        { value: unknown }
-      >['value']
-
-      x.tCh<StandardParsed, ExpectedSubj>()
-      x.tCh<ExpectedSubj, StandardParsed>()
-
-      /* runtime schema check */
-
-      expect(struct.__schema).toStrictEqual(schema)
-      expect(construct.__schema).toStrictEqual(schema)
-      expect(construct.__schema === schema).toBe(false)
-
-      /* parse result check */
-
-      for (const subj of subjects) {
-        const schemaParsed = x.parse(schema, subj)
-
-        expect(schemaParsed.error).toBe(undefined)
-        expect(schemaParsed.data).toStrictEqual(subj)
-
-        const constructParsed = construct.parse(subj)
-
-        expect(constructParsed.error).toBe(undefined)
-        expect(constructParsed.data).toStrictEqual(subj)
-
-        const structParsed = struct.parse(subj)
-
-        expect(structParsed.error).toBe(undefined)
-        expect(structParsed.data).toStrictEqual(subj)
-
-        const standardParsed = struct['~standard'].validate(subj)
-
-        if (standardParsed instanceof Promise) {
-          throw Error('Not expected')
-        }
-
-        if (standardParsed.issues !== undefined) {
-          throw Error('not expected')
-        }
-
-        expect(standardParsed.value).toStrictEqual(subj)
-      }
-    }
-  })
-})
-
-describe('Struct parameter keys reduction and schema immutability (foldB)', () => {
-  it('optional', () => {
-    const schema = {
-      type: 'boolean',
-      optional: true,
-    } as const satisfies x.Schema
-
-    const prevStruct = x.boolean()
-    const struct = prevStruct.optional()
-
-    type ExpectedKeys = StructSharedKeys | 'brand' | 'nullable' | 'description'
-
-    foldB: {
-      const construct = x.makeStruct(schema)
-
-      /* ensure that struct keys are reduced after application */
-
-      type StructKeys = keyof typeof struct
-
-      x.tCh<StructKeys, ExpectedKeys>()
-      x.tCh<ExpectedKeys, StructKeys>()
-
-      type ConstructKeys = keyof typeof construct
-
-      x.tCh<ConstructKeys, ExpectedKeys>()
-      x.tCh<ExpectedKeys, ConstructKeys>()
-
-      /* ensure that construct/struct schema types are identical  */
-
-      type ExpectedSchema = typeof schema
-      type StructSchema = typeof struct.__schema
-
-      x.tCh<StructSchema, ExpectedSchema>()
-      x.tCh<ExpectedSchema, StructSchema>()
-
-      type ConstructSchema = typeof struct.__schema
-
-      x.tCh<ConstructSchema, ExpectedSchema>()
-      x.tCh<ExpectedSchema, ConstructSchema>()
-
-      /* runtime schema check */
-
-      expect(struct.__schema).toStrictEqual(schema)
-      expect(construct.__schema).toStrictEqual(schema)
-      expect(construct.__schema === schema).toBe(false)
-
-      /* runtime schema parameter application immutability check */
-
-      expect(prevStruct.__schema === struct.__schema).toBe(false)
-    }
-  })
-
-  it('optional + nullable', () => {
-    const schema = {
-      type: 'boolean',
-      optional: true,
-      nullable: true,
-    } as const satisfies x.Schema
-
-    const prevStruct = x.boolean().optional()
-    const struct = prevStruct.nullable()
-
-    type ExpectedKeys = StructSharedKeys | 'brand' | 'description'
-
-    foldB: {
-      const construct = x.makeStruct(schema)
-
-      /* ensure that struct keys are reduced after application */
-
-      type StructKeys = keyof typeof struct
-
-      x.tCh<StructKeys, ExpectedKeys>()
-      x.tCh<ExpectedKeys, StructKeys>()
-
-      type ConstructKeys = keyof typeof construct
-
-      x.tCh<ConstructKeys, ExpectedKeys>()
-      x.tCh<ExpectedKeys, ConstructKeys>()
-
-      /* ensure that construct/struct schema types are identical  */
-
-      type ExpectedSchema = typeof schema
-      type StructSchema = typeof struct.__schema
-
-      x.tCh<StructSchema, ExpectedSchema>()
-      x.tCh<ExpectedSchema, StructSchema>()
-
-      type ConstructSchema = typeof struct.__schema
-
-      x.tCh<ConstructSchema, ExpectedSchema>()
-      x.tCh<ExpectedSchema, ConstructSchema>()
-
-      /* runtime schema check */
-
-      expect(struct.__schema).toStrictEqual(schema)
-      expect(construct.__schema).toStrictEqual(schema)
-      expect(construct.__schema === schema).toBe(false)
-
-      /* runtime schema parameter application immutability check */
-
-      expect(prevStruct.__schema === struct.__schema).toBe(false)
-    }
-  })
-
-  it('optional + nullable + brand', () => {
-    const schema = {
-      type: 'boolean',
-      optional: true,
-      nullable: true,
-      brand: ['x', 'y'],
-    } as const satisfies x.Schema
-
-    const prevStruct = x.boolean().optional().nullable()
-    const struct = prevStruct.brand('x', 'y')
-
-    type ExpectedKeys = StructSharedKeys | 'description'
-
-    foldB: {
-      const construct = x.makeStruct(schema)
-
-      /* ensure that struct keys are reduced after application */
-
-      type StructKeys = keyof typeof struct
-
-      x.tCh<StructKeys, ExpectedKeys>()
-      x.tCh<ExpectedKeys, StructKeys>()
-
-      type ConstructKeys = keyof typeof construct
-
-      x.tCh<ConstructKeys, ExpectedKeys>()
-      x.tCh<ExpectedKeys, ConstructKeys>()
-
-      /* ensure that construct/struct schema types are identical  */
-
-      type ExpectedSchema = typeof schema
-      type StructSchema = typeof struct.__schema
-
-      x.tCh<StructSchema, ExpectedSchema>()
-      x.tCh<ExpectedSchema, StructSchema>()
-
-      type ConstructSchema = typeof struct.__schema
-
-      x.tCh<ConstructSchema, ExpectedSchema>()
-      x.tCh<ExpectedSchema, ConstructSchema>()
-
-      /* runtime schema check */
-
-      expect(struct.__schema).toStrictEqual(schema)
-      expect(construct.__schema).toStrictEqual(schema)
-      expect(construct.__schema === schema).toBe(false)
-
-      /* runtime schema parameter application immutability check */
-
-      expect(prevStruct.__schema === struct.__schema).toBe(false)
-    }
-  })
-
-  it('optional + nullable + brand + description', () => {
-    const schema = {
-      type: 'boolean',
-      optional: true,
-      nullable: true,
-      brand: ['x', 'y'],
-      description: 'x',
-    } as const satisfies x.Schema
-
-    const prevStruct = x.boolean().optional().nullable().brand('x', 'y')
-    const struct = prevStruct.description('x')
-
-    type ExpectedKeys = StructSharedKeys
-
-    foldB: {
-      const construct = x.makeStruct(schema)
-
-      /* ensure that struct keys are reduced after application */
-
-      type StructKeys = keyof typeof struct
-
-      x.tCh<StructKeys, ExpectedKeys>()
-      x.tCh<ExpectedKeys, StructKeys>()
-
-      type ConstructKeys = keyof typeof construct
-
-      x.tCh<ConstructKeys, ExpectedKeys>()
-      x.tCh<ExpectedKeys, ConstructKeys>()
-
-      /* ensure that construct/struct schema types are identical  */
-
-      type ExpectedSchema = typeof schema
-      type StructSchema = typeof struct.__schema
-
-      x.tCh<StructSchema, ExpectedSchema>()
-      x.tCh<ExpectedSchema, StructSchema>()
-
-      type ConstructSchema = typeof struct.__schema
-
-      x.tCh<ConstructSchema, ExpectedSchema>()
-      x.tCh<ExpectedSchema, ConstructSchema>()
-
-      /* runtime schema check */
-
-      expect(struct.__schema).toStrictEqual(schema)
-      expect(construct.__schema).toStrictEqual(schema)
-      expect(construct.__schema === schema).toBe(false)
-
-      /* runtime schema parameter application immutability check */
-
-      expect(prevStruct.__schema === struct.__schema).toBe(false)
-    }
-  })
-
-  it('description + brand + nullable + optional', () => {
-    const schema = {
-      type: 'boolean',
-      optional: true,
-      nullable: true,
-      brand: ['x', 'y'],
-      description: 'x',
-    } as const satisfies x.Schema
-
-    const prevStruct = x.boolean().description('x').brand('x', 'y').nullable()
-    const struct = prevStruct.optional()
-
-    type ExpectedKeys = StructSharedKeys
-
-    foldB: {
-      const construct = x.makeStruct(schema)
-
-      /* ensure that struct keys are reduced after application */
-
-      type StructKeys = keyof typeof struct
-
-      x.tCh<StructKeys, ExpectedKeys>()
-      x.tCh<ExpectedKeys, StructKeys>()
-
-      type ConstructKeys = keyof typeof construct
-
-      x.tCh<ConstructKeys, ExpectedKeys>()
-      x.tCh<ExpectedKeys, ConstructKeys>()
-
-      /* ensure that construct/struct schema types are identical  */
-
-      type ExpectedSchema = typeof schema
-      type StructSchema = typeof struct.__schema
-
-      x.tCh<StructSchema, ExpectedSchema>()
-      x.tCh<ExpectedSchema, StructSchema>()
-
-      type ConstructSchema = typeof struct.__schema
-
-      x.tCh<ConstructSchema, ExpectedSchema>()
-      x.tCh<ExpectedSchema, ConstructSchema>()
-
-      /* runtime schema check */
-
-      expect(struct.__schema).toStrictEqual(schema)
-      expect(construct.__schema).toStrictEqual(schema)
-      expect(construct.__schema === schema).toBe(false)
-
-      /* runtime schema parameter application immutability check */
-
-      expect(prevStruct.__schema === struct.__schema).toBe(false)
-    }
-  })
-})
-
-describe('ERROR_CODE.invalidType (foldC)', () => {
-  it('iterate over fixture.DATA_TYPE', () => {
-    const schema = { type: 'boolean' } satisfies x.Schema
-    const struct = x.boolean()
-    const source = fixture.DATA_TYPE
-
-    foldC: {
-      const construct = x.makeStruct(schema)
-
-      for (const [kind, types] of source) {
-        if (kind === schema.type) {
-          continue
-        }
-
-        for (const subject of types) {
-          const expectedError = [
-            {
-              code: x.ERROR_CODE.invalidType,
-              schema: schema,
-              subject: subject,
-              path: [],
-            },
-          ]
-
-          const parsedSchema = x.parse(schema, subject)
-          const parsedConstruct = construct.parse(subject)
-          const parsedStruct = struct.parse(subject)
-
-          expect(parsedSchema.error).toStrictEqual(expectedError)
-          expect(parsedConstruct.error).toStrictEqual(expectedError)
-          expect(parsedStruct.error).toStrictEqual(expectedError)
-
-          const parsedStandard = struct['~standard'].validate(subject)
-
-          if (parsedStandard instanceof Promise) {
-            throw Error('Not expected')
-          }
-
-          expect(parsedStandard.issues).toStrictEqual([
-            { message: x.ERROR_CODE.invalidType, path: [] },
-          ])
-        }
-      }
-    }
-  })
-})