@contember/engine-content-api 1.1.0-alpha.4 → 1.1.0-alpha.7

package/tests/cases/unit/inputPreValidator.test.ts

@@ -11,8 +11,7 @@ import { getEntity } from '@contember/schema-utils'
 import { Mapper } from '../../../src/mapper'
 import { createMock } from '../../src/utils'
 import { testUuid } from '../../src/testUuid'
-import * as assert from 'uvu/assert'
-import { suite } from 'uvu'
+import { describe, it, assert } from 'vitest'
 import { SchemaDefinition as def } from '@contember/schema-definition'
 
 type PrimaryValueExpectation = { entity: string; where: Input.UniqueWhere; result: Value.PrimaryValue }
@@ -31,8 +30,8 @@ const createDataSelectorMock = (primaryValues: PrimaryValueExpectation[], select
 			if (!entry) {
 				throw new Error(`Unexpected getPrimaryValue call`)
 			}
-			assert.is(entity.name, entry.entity)
-			assert.equal(where, entry.where)
+			assert.deepStrictEqual(entity.name, entry.entity)
+			assert.deepStrictEqual(where, entry.where)
 			return entry.result
 		},
 		select: async (
@@ -49,10 +48,10 @@ const createDataSelectorMock = (primaryValues: PrimaryValueExpectation[], select
 				console.log(JSON.stringify({ entity: entity.name, where, dependencies, result: {} }))
 				throw new Error(`Unexpected select call`)
 			}
-			assert.is(entity.name, entry.entity)
-			assert.equal(where, entry.where)
+			assert.equal(entity.name, entry.entity)
+			assert.deepStrictEqual(where, entry.where)
 			//console.log(JSON.stringify(entry))
-			assert.equal(dependencies, entry.dependencies)
+			assert.deepStrictEqual(dependencies, entry.dependencies)
 			return entry.result
 		},
 	})
@@ -80,374 +79,376 @@ const createValidator = ({
 	)
 const mapper = {} as Mapper
 
-const inputPreValidatorTest = suite('Input pre-validator')
-inputPreValidatorTest('validates implicit rules', async () => {
-	const model = new SchemaBuilder()
-		.entity('Book', e => e.column('title', c => c.notNull().type(Model.ColumnType.String)).column('description'))
-		.buildSchema()
 
-	const validator = createValidator({ model, validation: {} })
-	const result = await validator.validateCreate({
-		entity: getEntity(model, 'Book'),
-		data: {},
-		overRelation: null,
-		path: [],
-		mapper,
-	})
-	assert.equal(result, [
-		{
-			path: [
-				{
-					field: 'title',
+namespace ViewModelDefinition {
+	export class Book {
+		title = def.stringColumn()
+		stats = def.oneHasOneInverse(BookStats, 'book').notNull()
+	}
+
+	@def.View('SELECT 1')
+	export class BookStats {
+		book = def.oneHasOne(Book, 'stats').notNull()
+		foo = def.intColumn()
+	}
+}
+
+
+describe('Input pre-validator', () => {
+
+
+	it('validates implicit rules', async () => {
+		const model = new SchemaBuilder()
+			.entity('Book', e => e.column('title', c => c.notNull().type(Model.ColumnType.String)).column('description'))
+			.buildSchema()
+
+		const validator = createValidator({ model, validation: {} })
+		const result = await validator.validateCreate({
+			entity: getEntity(model, 'Book'),
+			data: {},
+			overRelation: null,
+			path: [],
+			mapper,
+		})
+		assert.deepStrictEqual(result, [
+			{
+				path: [
+					{
+						field: 'title',
+					},
+				],
+				message: {
+					text: 'Field is required',
 				},
-			],
-			message: {
-				text: 'Field is required',
 			},
-		},
-	])
-})
+		])
+	})
 
-inputPreValidatorTest('validates explicit rules', async () => {
-	const model = new SchemaBuilder()
-		.entity('Book', e => e.column('title', c => c.notNull().type(Model.ColumnType.String)).column('description'))
-		.buildSchema()
+	it('validates explicit rules', async () => {
+		const model = new SchemaBuilder()
+			.entity('Book', e => e.column('title', c => c.notNull().type(Model.ColumnType.String)).column('description'))
+			.buildSchema()
 
-	const validator = createValidator({
-		model,
-		validation: {
-			Book: {
-				description: [{ message: { text: 'Minimum length is 10 characters' }, validator: v.rules.minLength(10) }],
+		const validator = createValidator({
+			model,
+			validation: {
+				Book: {
+					description: [{ message: { text: 'Minimum length is 10 characters' }, validator: v.rules.minLength(10) }],
+				},
 			},
-		},
-	})
-	const result = await validator.validateCreate({
-		entity: getEntity(model, 'Book'),
-		data: {
-			title: 'Hello',
-			description: 'World',
-		},
-		overRelation: null,
-		path: [],
-		mapper,
-	})
-	assert.equal(result, [
-		{
-			path: [
-				{
-					field: 'description',
+		})
+		const result = await validator.validateCreate({
+			entity: getEntity(model, 'Book'),
+			data: {
+				title: 'Hello',
+				description: 'World',
+			},
+			overRelation: null,
+			path: [],
+			mapper,
+		})
+		assert.deepStrictEqual(result, [
+			{
+				path: [
+					{
+						field: 'description',
+					},
+				],
+				message: {
+					text: 'Minimum length is 10 characters',
 				},
-			],
-			message: {
-				text: 'Minimum length is 10 characters',
 			},
-		},
-	])
+		])
 
-	const result2 = await validator.validateCreate({
-		entity: getEntity(model, 'Book'),
-		data: {
-			title: 'Hello',
-			description: 'World abcdef',
-		},
-		overRelation: null,
-		path: [],
-		mapper,
+		const result2 = await validator.validateCreate({
+			entity: getEntity(model, 'Book'),
+			data: {
+				title: 'Hello',
+				description: 'World abcdef',
+			},
+			overRelation: null,
+			path: [],
+			mapper,
+		})
+		assert.deepStrictEqual(result2, [])
 	})
-	assert.equal(result2, [])
-})
 
-inputPreValidatorTest('dependent rules invalid', async () => {
-	const model = new SchemaBuilder()
-		.entity('Book', e => e.column('title', c => c.notNull().type(Model.ColumnType.String)).column('description'))
-		.buildSchema()
+	it('dependent rules invalid', async () => {
+		const model = new SchemaBuilder()
+			.entity('Book', e => e.column('title', c => c.notNull().type(Model.ColumnType.String)).column('description'))
+			.buildSchema()
 
-	const rule = v.rules.conditional(v.rules.on('title', v.rules.notEmpty()), v.rules.minLength(10))
-	const validator = createValidator({
-		model,
-		validation: {
-			Book: {
-				description: [{ message: { text: 'Minimum length is 10 characters' }, validator: rule }],
-			},
-		},
-	})
-	const result = await validator.validateCreate({
-		entity: getEntity(model, 'Book'),
-		data: {
-			title: 'Hello',
-			description: 'World',
-		},
-		overRelation: null,
-		path: [],
-		mapper,
-	})
-	assert.equal(result, [
-		{
-			path: [
-				{
-					field: 'description',
+		const rule = v.rules.conditional(v.rules.on('title', v.rules.notEmpty()), v.rules.minLength(10))
+		const validator = createValidator({
+			model,
+			validation: {
+				Book: {
+					description: [{ message: { text: 'Minimum length is 10 characters' }, validator: rule }],
 				},
-			],
-			message: {
-				text: 'Minimum length is 10 characters',
 			},
-		},
-	])
-})
-
-inputPreValidatorTest('dependent rules valid', async () => {
-	const model = new SchemaBuilder()
-		.entity('Book', e => e.column('title', c => c.notNull().type(Model.ColumnType.String)).column('description'))
-		.buildSchema()
-
-	const rule = v.rules.conditional(v.rules.on('title', v.rules.notEmpty()), v.rules.minLength(10))
-	const validator = createValidator({
-		model,
-		validation: {
-			Book: {
-				description: [{ message: { text: 'Minimum length is 10 characters' }, validator: rule }],
+		})
+		const result = await validator.validateCreate({
+			entity: getEntity(model, 'Book'),
+			data: {
+				title: 'Hello',
+				description: 'World',
 			},
-		},
-	})
-	const result = await validator.validateCreate({
-		entity: getEntity(model, 'Book'),
-		data: {
-			title: '',
-			description: 'World',
-		},
-		overRelation: null,
-		path: [],
-		mapper,
+			overRelation: null,
+			path: [],
+			mapper,
+		})
+		assert.deepStrictEqual(result, [
+			{
+				path: [
+					{
+						field: 'description',
+					},
+				],
+				message: {
+					text: 'Minimum length is 10 characters',
+				},
+			},
+		])
 	})
-	assert.equal(result, [])
-})
 
-inputPreValidatorTest('rules on relations', async () => {
-	const model = new SchemaBuilder()
-		.entity('Book', e =>
-			e
-				.column('title', c => c.notNull().type(Model.ColumnType.String))
-				.manyHasOne('author', r => r.target('Author', e => e.column('name')).notNull()),
-		)
-		.buildSchema()
+	it('dependent rules valid', async () => {
+		const model = new SchemaBuilder()
+			.entity('Book', e => e.column('title', c => c.notNull().type(Model.ColumnType.String)).column('description'))
+			.buildSchema()
 
-	const validator = createValidator({ model, validation: {} })
-	const result = await validator.validateCreate({
-		entity: getEntity(model, 'Book'),
-		data: {
-			title: 'Hello',
-		},
-		overRelation: null,
-		path: [],
-		mapper,
-	})
-	assert.equal(result, [
-		{
-			path: [
-				{
-					field: 'author',
+		const rule = v.rules.conditional(v.rules.on('title', v.rules.notEmpty()), v.rules.minLength(10))
+		const validator = createValidator({
+			model,
+			validation: {
+				Book: {
+					description: [{ message: { text: 'Minimum length is 10 characters' }, validator: rule }],
 				},
-			],
-			message: {
-				text: 'Field is required',
 			},
-		},
-	])
-})
+		})
+		const result = await validator.validateCreate({
+			entity: getEntity(model, 'Book'),
+			data: {
+				title: '',
+				description: 'World',
+			},
+			overRelation: null,
+			path: [],
+			mapper,
+		})
+		assert.deepStrictEqual(result, [])
+	})
 
-inputPreValidatorTest('validates update', async () => {
-	const model = new SchemaBuilder()
-		.entity('Book', e => e.column('title', c => c.notNull().type(Model.ColumnType.String)).column('description'))
-		.buildSchema()
+	it('rules on relations', async () => {
+		const model = new SchemaBuilder()
+			.entity('Book', e =>
+				e
+					.column('title', c => c.notNull().type(Model.ColumnType.String))
+					.manyHasOne('author', r => r.target('Author', e => e.column('name')).notNull()),
+			)
+			.buildSchema()
 
-	const validator = createValidator({
-		model,
-		validation: {
-			Book: {
-				description: [{ message: { text: 'Minimum length is 10 characters' }, validator: v.rules.minLength(10) }],
+		const validator = createValidator({ model, validation: {} })
+		const result = await validator.validateCreate({
+			entity: getEntity(model, 'Book'),
+			data: {
+				title: 'Hello',
 			},
-		},
-	})
-	const result = await validator.validateUpdate({
-		entity: getEntity(model, 'Book'),
-		data: {
-			description: 'World',
-		},
-		where: {},
-		path: [],
-		mapper,
-	})
-	assert.equal(result, [
-		{
-			path: [
-				{
-					field: 'description',
+			overRelation: null,
+			path: [],
+			mapper,
+		})
+		assert.deepStrictEqual(result, [
+			{
+				path: [
+					{
+						field: 'author',
+					},
+				],
+				message: {
+					text: 'Field is required',
 				},
-			],
-			message: {
-				text: 'Minimum length is 10 characters',
 			},
-		},
-	])
-})
+		])
+	})
 
-inputPreValidatorTest('validate update w dependent rules - invalid', async () => {
-	const model = new SchemaBuilder()
-		.entity('Book', e => e.column('title', c => c.notNull().type(Model.ColumnType.String)).column('description'))
-		.buildSchema()
+	it('validates update', async () => {
+		const model = new SchemaBuilder()
+			.entity('Book', e => e.column('title', c => c.notNull().type(Model.ColumnType.String)).column('description'))
+			.buildSchema()
 
-	const rule = v.rules.conditional(v.rules.on('title', v.rules.notEmpty()), v.rules.minLength(10))
-	const validator = createValidator({
-		model,
-		validation: {
-			Book: {
-				description: [{ message: { text: 'Minimum length is 10 characters' }, validator: rule }],
+		const validator = createValidator({
+			model,
+			validation: {
+				Book: {
+					description: [{ message: { text: 'Minimum length is 10 characters' }, validator: v.rules.minLength(10) }],
+				},
 			},
-		},
-		selects: [
+		})
+		const result = await validator.validateUpdate({
+			entity: getEntity(model, 'Book'),
+			data: {
+				description: 'World',
+			},
+			where: {},
+			path: [],
+			mapper,
+		})
+		assert.deepStrictEqual(result, [
 			{
-				entity: 'Book',
-				where: { id: testUuid(1) },
-				dependencies: { title: {} },
-				result: { title: 'abcd' },
+				path: [
+					{
+						field: 'description',
+					},
+				],
+				message: {
+					text: 'Minimum length is 10 characters',
+				},
 			},
-		],
-	})
-	const result = await validator.validateUpdate({
-		entity: getEntity(model, 'Book'),
-		data: {
-			description: 'World',
-		},
-		where: { id: testUuid(1) },
-		path: [],
-		mapper,
+		])
 	})
-	assert.equal(result, [
-		{
-			path: [
+
+	it('validate update w dependent rules - invalid', async () => {
+		const model = new SchemaBuilder()
+			.entity('Book', e => e.column('title', c => c.notNull().type(Model.ColumnType.String)).column('description'))
+			.buildSchema()
+
+		const rule = v.rules.conditional(v.rules.on('title', v.rules.notEmpty()), v.rules.minLength(10))
+		const validator = createValidator({
+			model,
+			validation: {
+				Book: {
+					description: [{ message: { text: 'Minimum length is 10 characters' }, validator: rule }],
+				},
+			},
+			selects: [
 				{
-					field: 'description',
+					entity: 'Book',
+					where: { id: testUuid(1) },
+					dependencies: { title: {} },
+					result: { title: 'abcd' },
 				},
 			],
-			message: {
-				text: 'Minimum length is 10 characters',
-			},
-		},
-	])
-})
-
-inputPreValidatorTest('validate update w dependent rules - valid', async () => {
-	const model = new SchemaBuilder()
-		.entity('Book', e => e.column('title', c => c.notNull().type(Model.ColumnType.String)).column('description'))
-		.buildSchema()
-
-	const rule = v.rules.conditional(v.rules.on('title', v.rules.notEmpty()), v.rules.minLength(10))
-	const validator = createValidator({
-		model,
-		validation: {
-			Book: {
-				description: [{ message: { text: 'Minimum length is 10 characters' }, validator: rule }],
+		})
+		const result = await validator.validateUpdate({
+			entity: getEntity(model, 'Book'),
+			data: {
+				description: 'World',
 			},
-		},
-		selects: [
+			where: { id: testUuid(1) },
+			path: [],
+			mapper,
+		})
+		assert.deepStrictEqual(result, [
 			{
-				entity: 'Book',
-				where: { id: testUuid(1) },
-				dependencies: { title: {} },
-				result: { title: '' },
+				path: [
+					{
+						field: 'description',
+					},
+				],
+				message: {
+					text: 'Minimum length is 10 characters',
+				},
 			},
-		],
-	})
-	const result = await validator.validateUpdate({
-		entity: getEntity(model, 'Book'),
-		data: {
-			description: 'World',
-		},
-		where: { id: testUuid(1) },
-		path: [],
-		mapper,
+		])
 	})
-	assert.equal(result, [])
-})
 
-inputPreValidatorTest('validate update with dependent rules on relation - invalid', async () => {
-	const model = new SchemaBuilder()
-		.entity('Article', e =>
-			e
-				.column('publishedAt', c => c.type(Model.ColumnType.DateTime))
-				.manyHasOne('image', image => image.target('Image', e => e.column('url'))),
-		)
-		.buildSchema()
+	it('validate update w dependent rules - valid', async () => {
+		const model = new SchemaBuilder()
+			.entity('Book', e => e.column('title', c => c.notNull().type(Model.ColumnType.String)).column('description'))
+			.buildSchema()
 
-	const rule = v.rules.conditional(v.rules.on('publishedAt', v.rules.notNull()), v.rules.defined())
-	const validator = createValidator({
-		model,
-		validation: {
-			Article: {
-				image: [{ message: { text: 'Published article must have an image' }, validator: rule }],
-			},
-		},
-		selects: [
-			{
-				entity: 'Article',
-				where: { id: testUuid(1) },
-				dependencies: { image: {} },
-				result: { id: testUuid(1), image: null },
+		const rule = v.rules.conditional(v.rules.on('title', v.rules.notEmpty()), v.rules.minLength(10))
+		const validator = createValidator({
+			model,
+			validation: {
+				Book: {
+					description: [{ message: { text: 'Minimum length is 10 characters' }, validator: rule }],
+				},
 			},
-		],
-	})
-	const result = await validator.validateUpdate({
-		entity: getEntity(model, 'Article'),
-		data: {
-			publishedAt: 'now',
-		},
-		where: { id: testUuid(1) },
-		path: [],
-		mapper,
-	})
-	assert.equal(result, [
-		{
-			path: [
+			selects: [
 				{
-					field: 'image',
+					entity: 'Book',
+					where: { id: testUuid(1) },
+					dependencies: { title: {} },
+					result: { title: '' },
 				},
 			],
-			message: {
-				text: 'Published article must have an image',
+		})
+		const result = await validator.validateUpdate({
+			entity: getEntity(model, 'Book'),
+			data: {
+				description: 'World',
 			},
-		},
-	])
-})
+			where: { id: testUuid(1) },
+			path: [],
+			mapper,
+		})
+		assert.deepStrictEqual(result, [])
+	})
 
+	it('validate update with dependent rules on relation - invalid', async () => {
+		const model = new SchemaBuilder()
+			.entity('Article', e =>
+				e
+					.column('publishedAt', c => c.type(Model.ColumnType.DateTime))
+					.manyHasOne('image', image => image.target('Image', e => e.column('url'))),
+			)
+			.buildSchema()
 
-namespace ViewModelDefinition {
-	export class Book {
-		title = def.stringColumn()
-		stats = def.oneHasOneInverse(BookStats, 'book').notNull()
-	}
+		const rule = v.rules.conditional(v.rules.on('publishedAt', v.rules.notNull()), v.rules.defined())
+		const validator = createValidator({
+			model,
+			validation: {
+				Article: {
+					image: [{ message: { text: 'Published article must have an image' }, validator: rule }],
+				},
+			},
+			selects: [
+				{
+					entity: 'Article',
+					where: { id: testUuid(1) },
+					dependencies: { image: {} },
+					result: { id: testUuid(1), image: null },
+				},
+			],
+		})
+		const result = await validator.validateUpdate({
+			entity: getEntity(model, 'Article'),
+			data: {
+				publishedAt: 'now',
+			},
+			where: { id: testUuid(1) },
+			path: [],
+			mapper,
+		})
+		assert.deepStrictEqual(result, [
+			{
+				path: [
+					{
+						field: 'image',
+					},
+				],
+				message: {
+					text: 'Published article must have an image',
+				},
+			},
+		])
+	})
 
-	@def.View('SELECT 1')
-	export class BookStats {
-		book = def.oneHasOne(Book, 'stats').notNull()
-		foo = def.intColumn()
-	}
-}
 
-inputPreValidatorTest('ignore not null on view relation', async () => {
-	const model = SchemaDefinition.createModel(ViewModelDefinition)
+	it('ignore not null on view relation', async () => {
+		const model = SchemaDefinition.createModel(ViewModelDefinition)
 
-	const validator = createValidator({ model, validation: {} })
-	const result = await validator.validateCreate({
-		entity: getEntity(model, 'Book'),
-		data: {
-			title: 'Hello',
-		},
-		overRelation: null,
-		path: [],
-		mapper,
+		const validator = createValidator({ model, validation: {} })
+		const result = await validator.validateCreate({
+			entity: getEntity(model, 'Book'),
+			data: {
+				title: 'Hello',
+			},
+			overRelation: null,
+			path: [],
+			mapper,
+		})
+		assert.deepStrictEqual(result, [])
 	})
-	assert.equal(result, [])
 })
-
-
-inputPreValidatorTest.run()