@sanity/validation 3.14.3 → 6.12.0-next.32

package/src/validateDocument.test.ts

@@ -1,703 +0,0 @@
-import {
-  ArraySchemaType,
-  PortableTextTextBlock,
-  Rule,
-  SanityDocument,
-  Schema,
-  SchemaType,
-  ValidationContext,
-} from '@sanity/types'
-import {createSchema} from '../test/createSchema'
-import {createMockSanityClient} from '../test/mocks/mockSanityClient'
-import validateDocument, {resolveTypeForArrayItem, validateItem} from './validateDocument'
-import {convertToValidationMarker} from './util/convertToValidationMarker'
-
-jest.mock('./util/convertToValidationMarker', () => {
-  return {
-    convertToValidationMarker: jest.fn(
-      jest.requireActual('./util/convertToValidationMarker').convertToValidationMarker
-    ),
-  }
-})
-
-beforeEach(() => {
-  ;(convertToValidationMarker as jest.Mock).mockClear()
-})
-
-// mock client
-const client = createMockSanityClient() as any as ReturnType<ValidationContext['getClient']>
-const getClient = (options: {apiVersion: string}) => client
-
-describe('resolveTypeForArrayItem', () => {
-  const schema: Schema = createSchema({
-    types: [
-      {
-        name: 'foo',
-        type: 'object',
-        fields: [{name: 'title', type: 'number'}],
-      },
-      {
-        name: 'bar',
-        type: 'object',
-        fields: [{name: 'title', type: 'string'}],
-      },
-    ],
-  })
-
-  const fooType = schema.get('foo')
-  const barType = schema.get('bar')
-
-  it('finds a matching schema type for an array item value given a list of candidate types', () => {
-    const resolved = resolveTypeForArrayItem(
-      {
-        _type: 'bar',
-        _key: 'exampleKey',
-        title: 5,
-      },
-      [fooType!, barType!]
-    )
-
-    expect(resolved).toBe(barType)
-  })
-
-  it('assumes the type if there is only one possible candidate', () => {
-    const resolved = resolveTypeForArrayItem(
-      {
-        // notice no _type
-        _key: 'exampleKey',
-        title: 5,
-      },
-      [fooType!]
-    )
-
-    expect(resolved).toBe(fooType)
-  })
-})
-
-describe('validateDocument', () => {
-  it('takes in a document + a compiled schema and returns a list of validation markers', async () => {
-    const schema = createSchema({
-      types: [
-        {
-          name: 'simpleDoc',
-          type: 'document',
-          title: 'Simple Document',
-          fields: [
-            {
-              name: 'title',
-              type: 'string',
-              validation: (rule: Rule) => rule.required(),
-            },
-          ],
-        },
-      ],
-    })
-
-    const document: SanityDocument = {
-      _id: 'testId',
-      _createdAt: '2021-08-27T14:48:51.650Z',
-      _rev: 'exampleRev',
-      _type: 'simpleDoc',
-      _updatedAt: '2021-08-27T14:48:51.650Z',
-      title: null,
-    }
-
-    const result = await validateDocument(getClient, document, schema)
-    expect(result).toMatchObject([
-      {
-        level: 'error',
-        item: {
-          message: 'Expected type "String", got "null"',
-          paths: [],
-        },
-        path: ['title'],
-      },
-      {
-        level: 'error',
-        item: {
-          message: 'Required',
-          paths: [],
-        },
-        path: ['title'],
-      },
-    ])
-  })
-})
-
-describe('validateItem', () => {
-  it("runs nested validation on an undefined value for object types if it's required", async () => {
-    const validation = (rule: Rule) => [
-      rule.required().error('This is required!'),
-      rule.max(160).warning('Too long!'),
-    ]
-
-    const schema = createSchema({
-      types: [
-        {
-          name: 'testObj',
-          type: 'object',
-          title: 'Test Object',
-          fields: [
-            {name: 'registeredString', type: 'registeredString'},
-            {name: 'inlineString', type: 'string', validation},
-            {
-              name: 'registeredObject',
-              type: 'registeredObjectField',
-              validation: (rule: Rule) => rule.required(),
-            },
-            {
-              name: 'inlineObject',
-              type: 'object',
-              fields: [{name: 'foo', type: 'string', validation}],
-              validation: (rule: Rule) => rule.required(),
-            },
-            {
-              name: 'notRequiredRegisteredObject',
-              type: 'registeredObjectField',
-            },
-            {
-              name: 'notRequiredInlineObject',
-              type: 'object',
-              fields: [{name: 'foo', type: 'string', validation}],
-            },
-          ],
-        },
-        {name: 'registeredString', title: 'Registered String', type: 'string', validation},
-        {
-          title: 'Registered Object Field',
-          name: 'registeredObjectField',
-          type: 'object',
-          fields: [{name: 'foo', type: 'string', validation}],
-        },
-      ],
-    })
-    // ensures there are no schema formatting issues
-    expect(schema._validation).toHaveLength(0)
-
-    await expect(
-      validateItem({
-        getClient,
-        schema,
-        value: {},
-        document: undefined,
-        path: [],
-        parent: undefined,
-        type: schema.get('testObj'),
-        getDocumentExists: undefined,
-      })
-    ).resolves.toMatchObject([
-      {
-        level: 'error',
-        item: {message: 'This is required!'},
-        path: ['registeredString'],
-      },
-      {
-        level: 'error',
-        item: {message: 'This is required!'},
-        path: ['inlineString'],
-      },
-      {
-        level: 'error',
-        item: {message: 'Required'},
-        path: ['registeredObject'],
-      },
-      {
-        level: 'error',
-        item: {message: 'This is required!'},
-        path: ['registeredObject', 'foo'],
-      },
-      {
-        level: 'error',
-        item: {message: 'Required'},
-        path: ['inlineObject'],
-      },
-      {
-        level: 'error',
-        item: {message: 'This is required!'},
-        path: ['inlineObject', 'foo'],
-      },
-    ])
-  })
-
-  it('runs nested validation for object-level rules set via Rule.fields()', async () => {
-    const schema = createSchema({
-      types: [
-        {
-          name: 'testObj',
-          type: 'object',
-          title: 'Test Object',
-          fields: [
-            {name: 'foo', type: 'string'},
-            {name: 'bar', type: 'string'},
-          ],
-          validation: (rule: Rule) => [
-            rule.required(),
-            rule.fields({
-              foo: (r) => r.required(),
-              bar: (r) => r.required(),
-            }),
-          ],
-        },
-      ],
-    })
-
-    // ensures there are no schema formatting issues
-    expect(schema._validation).toHaveLength(0)
-
-    await expect(
-      validateItem({
-        getClient,
-        schema,
-        document: undefined,
-        parent: undefined,
-        path: undefined,
-        type: schema.get('testObj'),
-        value: {foo: 5},
-        getDocumentExists: undefined,
-      })
-    ).resolves.toMatchObject([
-      {
-        item: {message: 'Expected type "String", got "Number"'},
-        level: 'error',
-        path: ['foo'],
-      },
-      {
-        item: {message: 'Required'},
-        level: 'error',
-        path: ['bar'],
-      },
-    ])
-  })
-
-  // @todo this one fails, needs investigation for what is actually the expected outcome
-  it.skip('runs nested validation for markDefs', async () => {
-    const linkValidationSpy = jest.fn(() => true as const)
-    const internalLinkSpy = jest.fn(() => 'mock invalid response')
-
-    const schema = createSchema({
-      types: [
-        {
-          name: 'post',
-          title: 'Post',
-          type: 'document',
-          fields: [
-            {name: 'title', type: 'string'},
-            {name: 'body', type: 'string'},
-          ],
-        },
-        {
-          name: 'registeredEditor',
-          type: 'object',
-          title: 'Registered Editor',
-          fields: [
-            {
-              name: 'editor',
-              type: 'array',
-              of: [
-                {
-                  type: 'block',
-                  marks: {
-                    annotations: [
-                      {
-                        name: 'exampleAnnotation',
-                        type: 'object',
-                        fields: [{name: 'value', type: 'string'}],
-                      },
-                    ],
-                  },
-                },
-              ],
-            },
-          ],
-        },
-        {
-          name: 'blockTest',
-          type: 'document',
-          title: 'blockTest',
-          fields: [
-            {
-              name: 'content',
-              title: 'Content',
-              type: 'array',
-              of: [
-                {
-                  type: 'block',
-                  marks: {
-                    annotations: [
-                      {
-                        name: 'link',
-                        type: 'object',
-                        title: 'link',
-                        fields: [{name: 'url', type: 'url'}],
-                        validation: (rule: Rule) => rule.custom(linkValidationSpy),
-                      },
-                      {
-                        name: 'internalLink',
-                        type: 'object',
-                        title: 'Internal link',
-                        fields: [{name: 'reference', type: 'reference', to: [{type: 'post'}]}],
-                        validation: (rule: Rule) => rule.custom(internalLinkSpy),
-                      },
-                      {name: 'nestedEditor', type: 'registeredEditor'},
-                    ],
-                  },
-                },
-              ],
-            },
-          ],
-        },
-      ],
-    })
-
-    expect(schema._validation).toHaveLength(0)
-
-    const nestedBlock: PortableTextTextBlock = {
-      _type: 'block',
-      _key: 'nested-block-key',
-      children: [
-        {
-          _key: 'some-key',
-          _type: 'span',
-          text: 'hey',
-          marks: ['example-annotation-key'],
-        },
-      ],
-      markDefs: [
-        {
-          _type: 'exampleAnnotation',
-          _key: 'example-annotation-key',
-          value: 5,
-        },
-      ],
-      style: 'normal',
-    }
-
-    const block: PortableTextTextBlock = {
-      _key: 'block-key',
-      _type: 'block',
-      children: [
-        {
-          _key: 'child-0',
-          _type: 'span',
-          marks: ['0', '1', '2'],
-          text: 'hey',
-        },
-      ],
-      markDefs: [
-        {
-          _key: '0',
-          _type: 'link',
-          url: 'https://example.com',
-        },
-        {
-          _key: '1',
-          _type: 'internalLink',
-          _ref: 'post-id',
-        },
-        {
-          _key: '2',
-          _type: 'nestedEditor',
-          editor: [nestedBlock],
-        },
-      ],
-      style: 'normal',
-    }
-
-    const document: SanityDocument = {
-      _id: 'mock-id',
-      _type: 'blockTest',
-      _createdAt: '2021-11-15T21:06:41.812Z',
-      _rev: 'example-ref',
-      _updatedAt: '2021-11-15T21:06:41.812Z',
-      content: [block],
-    }
-
-    const result = await validateItem({
-      getClient,
-      schema,
-      document: document,
-      parent: undefined,
-      path: [],
-      type: schema.get('blockTest'),
-      value: document,
-      getDocumentExists: undefined,
-    })
-
-    expect(result).toMatchObject([
-      {
-        item: {message: 'mock invalid response', paths: []},
-        level: 'error',
-        path: ['content', {_key: 'block-key'}, 'markDefs', {_key: '1'}],
-      },
-      // this tests for nested markDef validation
-      {
-        item: {
-          message: 'Expected type "String", got "Number"',
-          paths: [],
-        },
-        level: 'error',
-        path: [
-          'content',
-          {_key: 'block-key'},
-          'markDefs',
-          {_key: '2'},
-          'editor',
-          {_key: 'nested-block-key'},
-          'markDefs',
-          {_key: 'example-annotation-key'},
-          'value',
-        ],
-      },
-    ])
-
-    expect(linkValidationSpy.mock.calls).toMatchObject([
-      [
-        {
-          _key: '0',
-          _type: 'link',
-          url: 'https://example.com',
-        },
-        {
-          document: {_id: 'mock-id'},
-          parent: {_key: 'block-key'},
-          path: ['content', {_key: 'block-key'}, 'markDefs', {_key: '0'}],
-          type: {name: 'link'},
-        },
-      ],
-    ])
-
-    expect(internalLinkSpy.mock.calls).toMatchObject([
-      [
-        {
-          _key: '1',
-          _ref: 'post-id',
-          _type: 'internalLink',
-        },
-        {
-          document: {_id: 'mock-id'},
-          parent: {_key: 'block-key'},
-          path: ['content', {_key: 'block-key'}, 'markDefs', {_key: '1'}],
-          type: {name: 'internalLink'},
-        },
-      ],
-    ])
-  })
-
-  it('resolves an array item type if there is just one type', async () => {
-    const schema = createSchema({
-      types: [
-        {
-          name: 'values',
-          title: 'Values',
-          type: 'array',
-          // note that there is only one type available
-          of: [{type: 'arrayItem'}],
-          validation: (rule: Rule) => rule.required(),
-        },
-        {
-          title: 'Array Item',
-          name: 'arrayItem',
-          type: 'object',
-          fields: [{name: 'title', type: 'string'}],
-        },
-      ],
-    })
-
-    // ensures there are no schema formatting issues
-    expect(schema._validation).toHaveLength(0)
-
-    const values = [
-      {
-        // note how this doesn't have a _type
-        title: 5,
-        _key: 'exampleKey',
-      },
-    ]
-
-    await expect(
-      validateItem({
-        getClient,
-        schema,
-        document: undefined,
-        parent: undefined,
-        path: [],
-        type: schema.get('values'),
-        value: values,
-        getDocumentExists: undefined,
-      })
-    ).resolves.toEqual([
-      {
-        level: 'error',
-        item: {
-          message: 'Expected type "String", got "Number"',
-          paths: [],
-        },
-        path: [{_key: 'exampleKey'}, 'title'],
-      },
-    ])
-  })
-
-  it('properly passes the nested value, type, and path to rule.validate', async () => {
-    const schema: Schema = createSchema({
-      types: [
-        {
-          name: 'root',
-          type: 'object',
-          title: 'Root',
-          fields: [
-            {
-              name: 'level1Object',
-              type: 'object',
-              validation: (rule: Rule) => rule.custom(() => 'from level 1 object'),
-              fields: [
-                {
-                  name: 'level2String',
-                  type: 'string',
-                  validation: (rule: Rule) => rule.custom(() => 'from level 2 via object'),
-                },
-              ],
-            },
-            {
-              name: 'level1Array',
-              type: 'array',
-              validation: (rule: Rule) => rule.custom(() => 'from level 1 array'),
-              of: [
-                {
-                  type: 'object',
-                  fields: [
-                    {
-                      name: 'level2Number',
-                      type: 'number',
-                      validation: (rule: Rule) => rule.custom(() => 'from level 2 via array'),
-                    },
-                  ],
-                },
-              ],
-            },
-          ],
-          validation: (rule: Rule) => rule.custom(() => 'from root'),
-        },
-      ],
-    })
-
-    // ensures there are no schema formatting issues
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    expect((schema as any)._validation).toHaveLength(0)
-
-    const value = {
-      level1Object: {level3String: 'a string'},
-      level1Array: [{level2Number: 5}],
-    }
-
-    const document: SanityDocument = {
-      value,
-      _type: 'something',
-      _createdAt: '2021-09-05T19:28:30.882Z',
-      _id: 'something.id',
-      _rev: 'exampleRev',
-      _updatedAt: '2021-09-05T19:28:30.882Z',
-    }
-
-    const getField = ({in: type, name}: {in: SchemaType; name: string}) => {
-      const result = 'fields' in type && type.fields.find((f) => f.name === name)?.type
-      if (!result) throw new Error(`Could not find field \`${name}\` in \`${type.name}\``)
-      return result
-    }
-
-    const rootType = schema.get('root')
-    const level1ObjectType = getField({in: rootType!, name: 'level1Object'})
-    const level2StringType = getField({in: level1ObjectType, name: 'level2String'})
-    const level1ArrayType = getField({in: rootType!, name: 'level1Array'})
-    const level2NumberType = getField({
-      in: (level1ArrayType as ArraySchemaType).of[0],
-      name: 'level2Number',
-    })
-
-    await expect(
-      validateItem({
-        getClient,
-        schema,
-        value,
-        type: rootType,
-        document,
-        parent: document,
-        path: undefined,
-        getDocumentExists: undefined,
-      })
-    ).resolves.toMatchObject([
-      {
-        item: {message: 'from root'},
-        path: [],
-      },
-      {
-        item: {message: 'from level 1 object'},
-        path: ['level1Object'],
-      },
-      {
-        item: {message: 'from level 2 via object'},
-        path: ['level1Object', 'level2String'],
-      },
-      {
-        item: {message: 'from level 1 array'},
-        path: ['level1Array'],
-      },
-      {
-        item: {message: 'from level 2 via array'},
-        path: ['level1Array', 0, 'level2Number'],
-      },
-    ])
-
-    const calls = (convertToValidationMarker as jest.Mock).mock.calls
-
-    expect(calls.find((call) => call[0] === 'from root')).toMatchObject([
-      'from root',
-      'error',
-      {
-        parent: document,
-        document: document,
-        path: [],
-        type: rootType,
-      },
-    ])
-    expect(calls.find((call) => call[0] === 'from level 1 object')).toMatchObject([
-      'from level 1 object',
-      'error',
-      {
-        parent: value,
-        document: document,
-        path: ['level1Object'],
-        type: level1ObjectType,
-      },
-    ])
-    expect(calls.find((call) => call[0] === 'from level 2 via object')).toMatchObject([
-      'from level 2 via object',
-      'error',
-      {
-        parent: value.level1Object,
-        document: document,
-        path: ['level1Object', 'level2String'],
-        type: level2StringType,
-      },
-    ])
-    expect(calls.find((call) => call[0] === 'from level 1 array')).toMatchObject([
-      'from level 1 array',
-      'error',
-      {
-        parent: value,
-        document: document,
-        path: ['level1Array'],
-        type: level1ArrayType,
-      },
-    ])
-    expect(calls.find((call) => call[0] === 'from level 2 via array')).toMatchObject([
-      'from level 2 via array',
-      'error',
-      {
-        parent: value.level1Array[0],
-        document: document,
-        path: ['level1Array', 0, 'level2Number'],
-        type: level2NumberType,
-      },
-    ])
-  })
-})