@ditojs/admin 3.0.0 → 3.1.0

package/src/utils/schema/validation.test.js

@@ -1,395 +0,0 @@
-import NumberMixin from '../../mixins/NumberMixin.js'
-import { registerTypeComponent } from './types.js'
-import {
-  getValidations,
-  getValueValidationErrors,
-  getDataValidationErrors,
-  getMatchingValidationErrors
-} from './validation.js'
-
-// Register minimal type options, as the actual type components can't be
-// imported without a Vue SFC compiler:
-registerTypeComponent('text', { defaultNested: true })
-registerTypeComponent('password', {
-  defaultNested: true,
-  getTypeValidations: () => ({ password: true })
-})
-registerTypeComponent('number', { ...NumberMixin, defaultNested: true })
-registerTypeComponent('integer', { ...NumberMixin, defaultNested: true })
-registerTypeComponent('section', { defaultNested: false })
-registerTypeComponent('panel', { defaultNested: false })
-registerTypeComponent('list', {
-  defaultNested: true,
-  getSourceType: () => 'list'
-})
-registerTypeComponent('object', {
-  defaultNested: true,
-  getSourceType: () => 'object'
-})
-
-describe('getValidations()', () => {
-  it('returns no validations for plain schemas', () => {
-    expect(getValidations({ type: 'text' })).toEqual({})
-  })
-
-  it('supports `required` as value and callback', () => {
-    expect(getValidations({ type: 'text', required: true })).toEqual({
-      required: true
-    })
-    const schema = { type: 'text', required: ({ value }) => value === 1 }
-    expect(getValidations(schema, { value: 1 })).toEqual({
-      required: true
-    })
-    expect(getValidations(schema, { value: 2 })).toEqual({})
-  })
-
-  it('adds the validations of the type', () => {
-    expect(getValidations({ type: 'password' })).toEqual({
-      password: true
-    })
-  })
-
-  it('applies `schema.rules` overrides', () => {
-    expect(
-      getValidations({
-        type: 'password',
-        required: true,
-        rules: { password: undefined, required: undefined, email: true }
-      })
-    ).toEqual({ email: true })
-  })
-
-  it('ignores unknown types', () => {
-    expect(getValidations({ type: 'unknown', required: true })).toEqual({
-      required: true
-    })
-  })
-
-  describe('number types', () => {
-    it.each([
-      [{ type: 'number' }, {}],
-      [{ type: 'number', min: 1 }, { min: 1 }],
-      [{ type: 'number', max: 2 }, { max: 2 }],
-      [{ type: 'number', min: 1, max: 2 }, { range: [1, 2] }],
-      [{ type: 'number', range: [1, 2] }, { range: [1, 2] }],
-      [{ type: 'number', range: [1, 2], min: 0 }, { range: [0, 2] }],
-      [{ type: 'number', decimals: 2 }, { decimals: 2 }],
-      [{ type: 'number', step: 0.25 }, { decimals: 2 }],
-      [{ type: 'number', step: 5 }, { integer: true }],
-      [{ type: 'number', step: 0.5, decimals: 3 }, { decimals: 3 }],
-      [{ type: 'integer' }, { integer: true }],
-      [
-        { type: 'integer', range: [0.5, 1.5], step: 0.5 },
-        { range: [0, 2], integer: true }
-      ]
-    ])('%j', (schema, validations) => {
-      expect(getValidations(schema)).toEqual(validations)
-    })
-
-    it('evaluates callbacks with the context', () => {
-      const schema = { type: 'number', max: ({ item }) => item.limit }
-      expect(getValidations(schema, { item: { limit: 3 } })).toEqual({
-        max: 3
-      })
-    })
-  })
-})
-
-describe('getValueValidationErrors()', () => {
-  it('returns no errors for valid values', () => {
-    const validations = { required: true, range: [0, 2] }
-    expect(getValueValidationErrors(1, validations)).toEqual([])
-  })
-
-  it('applies `required` only to empty values', () => {
-    expect(getValueValidationErrors(null, { required: true })).toEqual([
-      { message: 'is required' }
-    ])
-    expect(getValueValidationErrors('', { required: true })).toEqual([
-      { message: 'is required' }
-    ])
-    expect(getValueValidationErrors(undefined, { required: true })).toEqual([
-      { message: 'is required' }
-    ])
-    expect(getValueValidationErrors(0, { required: true })).toEqual([])
-  })
-
-  it('applies other validations only to non-empty values', () => {
-    expect(getValueValidationErrors(null, { min: 1, email: true })).toEqual([])
-    expect(getValueValidationErrors('', { min: 1, email: true })).toEqual([])
-    expect(getValueValidationErrors(0, { min: 1 })).toEqual([
-      { message: 'must be 1 or more' }
-    ])
-  })
-
-  it('returns all errors, with messages without label prefix', () => {
-    expect(getValueValidationErrors(1.5, { min: 2, integer: true })).toEqual([
-      { message: 'must be 2 or more' },
-      { message: 'must be whole number' }
-    ])
-    expect(getValueValidationErrors(5, { range: [1, 2] })).toEqual([
-      { message: 'must be between 1 and 2' }
-    ])
-  })
-
-  it('passes the other validations to the validators', () => {
-    // Unchanged passwords are `undefined` and satisfy `required`:
-    const validations = { required: true, password: true }
-    expect(getValueValidationErrors(undefined, validations)).toEqual([])
-    expect(getValueValidationErrors(null, validations)).toEqual([
-      { message: 'is required' }
-    ])
-  })
-
-  it('ignores unknown validations', () => {
-    expect(getValueValidationErrors('a', { unknown: true })).toEqual([])
-  })
-})
-
-describe('getDataValidationErrors()', () => {
-  const required = { message: 'is required' }
-
-  it('returns `null` for valid data', () => {
-    const schema = {
-      components: {
-        title: { type: 'text', required: true }
-      }
-    }
-    expect(getDataValidationErrors(schema, { title: 'Title' })).toBe(null)
-  })
-
-  it('validates the components of panel components', () => {
-    // Panels share the data of their schema, like unnested sections.
-    const schema = {
-      components: {
-        links: {
-          type: 'panel',
-          components: { website: { type: 'text', required: true } }
-        }
-      }
-    }
-    expect(getDataValidationErrors(schema, { website: '' })).toEqual({
-      website: [required]
-    })
-  })
-
-  it('returns errors by data path, in the format of server errors', () => {
-    const schema = {
-      components: {
-        title: { type: 'text', required: true },
-        count: { type: 'integer', min: 1 },
-        note: { type: 'text' }
-      }
-    }
-    expect(getDataValidationErrors(schema, { title: '', count: 0.5 })).toEqual({
-      title: [required],
-      count: [
-        { message: 'must be 1 or more' },
-        { message: 'must be whole number' }
-      ]
-    })
-  })
-
-  it('prefixes errors with `dataPath`', () => {
-    const schema = {
-      components: { title: { type: 'text', required: true } }
-    }
-    expect(
-      getDataValidationErrors(schema, {}, { dataPath: 'items/0' })
-    ).toEqual({
-      'items/0/title': [required]
-    })
-  })
-
-  it('validates tabs, panels and unnested components', () => {
-    const schema = {
-      components: {
-        section: {
-          type: 'section',
-          components: { a: { type: 'text', required: true } }
-        }
-      },
-      tabs: {
-        tab: {
-          type: 'tab',
-          components: { b: { type: 'text', required: true } }
-        }
-      },
-      panels: {
-        panel: {
-          type: 'panel',
-          components: { c: { type: 'text', required: true } }
-        }
-      }
-    }
-    expect(getDataValidationErrors(schema, {})).toEqual({
-      a: [required],
-      b: [required],
-      c: [required]
-    })
-  })
-
-  it('validates the items of nested forms', () => {
-    const schema = {
-      components: {
-        items: {
-          type: 'list',
-          form: {
-            type: 'form',
-            components: { title: { type: 'text', required: true } }
-          }
-        },
-        object: {
-          type: 'object',
-          forms: {
-            a: {
-              type: 'form',
-              components: { a: { type: 'text', required: true } }
-            },
-            b: {
-              type: 'form',
-              components: { b: { type: 'text', required: true } }
-            }
-          }
-        }
-      }
-    }
-    const data = {
-      items: [{ title: 'Title' }, { title: null }],
-      object: { type: 'b' }
-    }
-    expect(getDataValidationErrors(schema, data)).toEqual({
-      'items/1/title': [required],
-      'object/b': [required]
-    })
-  })
-
-  it('skips components whose `if` is false', () => {
-    const schema = {
-      components: {
-        show: { type: 'text' },
-        a: {
-          type: 'text',
-          required: true,
-          if: ({ item }) => item.show
-        },
-        section: {
-          type: 'section',
-          if: ({ item }) => item.show,
-          components: { b: { type: 'text', required: true } }
-        },
-        items: {
-          type: 'list',
-          if: ({ item }) => item.show,
-          form: {
-            type: 'form',
-            components: { c: { type: 'text', required: true } }
-          }
-        }
-      },
-      tabs: {
-        tab: {
-          type: 'tab',
-          if: ({ item }) => item.show,
-          components: { d: { type: 'text', required: true } }
-        }
-      }
-    }
-    const data = { items: [{}] }
-    expect(getDataValidationErrors(schema, data)).toBe(null)
-    expect(getDataValidationErrors(schema, { ...data, show: true })).toEqual({
-      'a': [required],
-      'b': [required],
-      'items/0/c': [required],
-      'd': [required]
-    })
-  })
-
-  it('skips sources with their own resource', () => {
-    const schema = {
-      components: {
-        items: {
-          type: 'list',
-          resource: { path: 'items' },
-          form: {
-            type: 'form',
-            components: { title: { type: 'text', required: true } }
-          }
-        }
-      }
-    }
-    expect(getDataValidationErrors(schema, { items: [{}] })).toBe(null)
-  })
-
-  it('validates formatted values', () => {
-    const schema = {
-      components: {
-        name: {
-          type: 'text',
-          required: true,
-          format: ({ value }) => value?.trim()
-        }
-      }
-    }
-    expect(getDataValidationErrors(schema, { name: '  ' })).toEqual({
-      name: [required]
-    })
-  })
-
-  it('passes `rootData` and `dataPath` to callbacks', () => {
-    const rootData = { strict: true }
-    const schema = {
-      components: {
-        name: {
-          type: 'text',
-          required: ({ rootItem, dataPath }) => (
-            rootItem.strict && dataPath === 'item/name'
-          )
-        }
-      }
-    }
-    expect(
-      getDataValidationErrors(schema, {}, { dataPath: 'item', rootData })
-    ).toEqual({ 'item/name': [required] })
-  })
-})
-
-describe('getMatchingValidationErrors()', () => {
-  const required = [{ message: 'is required' }]
-  const errors = {
-    'title': required,
-    'items/0/title': required,
-    'items/1/name': required
-  }
-
-  it('matches data paths with functions', () => {
-    expect(
-      getMatchingValidationErrors(errors, dataPath => dataPath.length > 5)
-    ).toEqual({
-      'items/0/title': required,
-      'items/1/name': required
-    })
-  })
-
-  it('matches data paths with regular expressions', () => {
-    expect(getMatchingValidationErrors(errors, /^items\/\d+\/title$/)).toEqual(
-      { 'items/0/title': required }
-    )
-  })
-
-  it('matches normalized data paths and arrays of them', () => {
-    expect(getMatchingValidationErrors(errors, 'items[1].name')).toEqual({
-      'items/1/name': required
-    })
-    expect(getMatchingValidationErrors(errors, ['title', 'items/1/name']))
-      .toEqual({
-        'title': required,
-        'items/1/name': required
-      })
-  })
-
-  it('returns `null` if nothing matches', () => {
-    expect(getMatchingValidationErrors(errors, 'name')).toBe(null)
-    expect(getMatchingValidationErrors(null, /.*/)).toBe(null)
-  })
-})

package/src/utils/units.test.js

@@ -1,71 +0,0 @@
-import { formatFileSize, parseFileSize } from './units.js'
-
-describe('formatFileSize()', () => {
-  // Expected values match the previously used `filesize` package.
-  it.each([
-    [0, '0 B'],
-    [1, '1 B'],
-    [0.5, '1 B'],
-    [999, '999 B'],
-    [1000, '1 kB'],
-    [1001, '1 kB'],
-    [1234, '1.23 kB'],
-    [1500, '1.5 kB'],
-    [9999, '10 kB'],
-    [123456, '123.46 kB'],
-    [999999, '1 MB'],
-    [1234567, '1.23 MB'],
-    [1e9, '1 GB'],
-    [1.5e12, '1.5 TB'],
-    [2.5e15, '2.5 PB'],
-    [1e18, '1 EB'],
-    [1e21, '1 ZB'],
-    [-1500, '-1.5 kB']
-  ])('formats %o as %o', (size, expected) => {
-    expect(formatFileSize(size)).toBe(expected)
-  })
-
-  it('supports base 2', () => {
-    expect(formatFileSize(1024, { base: 2 })).toBe('1 KiB')
-    expect(formatFileSize(1536, { base: 2 })).toBe('1.5 KiB')
-    expect(formatFileSize(1048576, { base: 2 })).toBe('1 MiB')
-    expect(formatFileSize(1073741824, { base: 2 })).toBe('1 GiB')
-  })
-})
-
-describe('parseFileSize()', () => {
-  it.each([
-    ['1024', 1024],
-    [1024, 1024],
-    ['100 bytes', 100],
-    ['100B', 100],
-    ['1k', 1000],
-    ['1 kB', 1000],
-    ['1 KB', 1000],
-    ['1kb', 1000],
-    ['1.5 MB', 1.5e6],
-    ['1,5M', 1.5e6],
-    ['1T', 1e12],
-    ['1KiB', 1024],
-    ['1 Ki', 1024],
-    ['1.5 MiB', 1.5 * 1024 ** 2],
-    ['2 GiB', 2 * 1024 ** 3],
-    ['8b', 1],
-    ['8 bits', 1],
-    ['1Kb', 125],
-    ['1Mb', 125000]
-  ])('parses %o as %o bytes', (input, expected) => {
-    expect(parseFileSize(input)).toBe(expected)
-  })
-
-  it('supports base 2', () => {
-    expect(parseFileSize('1 MB', { base: 2 })).toBe(1024 ** 2)
-    expect(parseFileSize('1 MiB', { base: 2 })).toBe(1024 ** 2)
-    expect(parseFileSize('1Kb', { base: 2 })).toBe(128)
-  })
-
-  it('throws on invalid input', () => {
-    expect(() => parseFileSize('MB')).toThrow()
-    expect(() => parseFileSize('10 XB')).toThrow()
-  })
-})