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

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

@@ -10,204 +10,206 @@ import {
 	ValidationContext,
 } from '../../../src/input-validation'
 import { FieldNode, ObjectNode } from '../../../src/inputProcessing'
-import * as assert from 'uvu/assert'
-import { suite } from 'uvu'
-
-const inputValidationTest = suite('input validation tests')
-inputValidationTest('evaluates rule', () => {
-	const r = validation.rules
-	const rule = r.conditional(
-		r.on('books', r.filter(r.on('deleted', r.equals(false)), r.on('published', r.any(r.equals(true))))),
-		r.on('published', r.equals(true)),
-	)
-
-	const author = {
-		books: [
-			{ published: true, deleted: true },
-			{ published: false, deleted: false },
-			{ published: true, deleted: false },
-		],
-		published: true,
-	}
-
-	const context = ValidationContext.createRootContext(author)
-
-	assert.ok(evaluateValidation(context, rule))
-})
+import { describe, it, assert } from 'vitest'
 
-inputValidationTest('evaluates collection length rule', () => {
-	const rule = validation.rules.on('tags', validation.rules.minLength(2))
+describe('input validation tests', () => {
 
-	const author = {
-		tags: [{ value: 'abc' }, { value: 'xyz' }],
-	}
 
-	const context = ValidationContext.createRootContext(author)
+	it('evaluates rule', () => {
+		const r = validation.rules
+		const rule = r.conditional(
+			r.on('books', r.filter(r.on('deleted', r.equals(false)), r.on('published', r.any(r.equals(true))))),
+			r.on('published', r.equals(true)),
+		)
 
-	assert.ok(evaluateValidation(context, rule))
-})
+		const author = {
+			books: [
+				{ published: true, deleted: true },
+				{ published: false, deleted: false },
+				{ published: true, deleted: false },
+			],
+			published: true,
+		}
+
+		const context = ValidationContext.createRootContext(author)
+
+		assert.ok(evaluateValidation(context, rule))
+	})
+
+	it('evaluates collection length rule', () => {
+		const rule = validation.rules.on('tags', validation.rules.minLength(2))
 
-inputValidationTest('collects dependencies', () => {
-	const r = validation.rules
-	const validator = r.conditional(
-		r.on('books', r.filter(r.on('deleted', r.equals(false)), r.on('published', r.any(r.equals(true))))),
-		r.on('published', r.equals(true)),
-	)
+		const author = {
+			tags: [{ value: 'abc' }, { value: 'xyz' }],
+		}
 
-	assert.equal(DependencyCollector.collect(validator), {
-		books: {
-			deleted: {},
+		const context = ValidationContext.createRootContext(author)
+
+		assert.ok(evaluateValidation(context, rule))
+	})
+
+	it('collects dependencies', () => {
+		const r = validation.rules
+		const validator = r.conditional(
+			r.on('books', r.filter(r.on('deleted', r.equals(false)), r.on('published', r.any(r.equals(true))))),
+			r.on('published', r.equals(true)),
+		)
+
+		assert.deepStrictEqual(DependencyCollector.collect(validator), {
+			books: {
+				deleted: {},
+				published: {},
+			},
 			published: {},
-		},
-		published: {},
+		})
 	})
-})
 
-inputValidationTest('merges dependencies', () => {
-	const aDeps = {
-		a1: {
-			b1: {
-				c1: {},
-				c2: {},
+	it('merges dependencies', () => {
+		const aDeps = {
+			a1: {
+				b1: {
+					c1: {},
+					c2: {},
+				},
 			},
-		},
-		a2: {},
-	}
-	const bDeps = {
-		a1: {
-			b1: {
-				c1: { d1: {} },
-				c3: {},
+			a2: {},
+		}
+		const bDeps = {
+			a1: {
+				b1: {
+					c1: { d1: {} },
+					c3: {},
+				},
 			},
-		},
-		a3: {},
-	}
-	const result = DependencyMerger.merge(aDeps, bDeps)
-	assert.equal(result, {
-		a1: {
-			b1: {
-				c1: {
-					d1: {},
+			a3: {},
+		}
+		const result = DependencyMerger.merge(aDeps, bDeps)
+		assert.deepStrictEqual(result, {
+			a1: {
+				b1: {
+					c1: {
+						d1: {},
+					},
+					c2: {},
+					c3: {},
 				},
-				c2: {},
-				c3: {},
 			},
-		},
-		a2: {},
-		a3: {},
+			a2: {},
+			a3: {},
+		})
 	})
-})
 
-inputValidationTest('constructs query AST', () => {
-	const schema = new SchemaBuilder()
-		.entity('Book', e =>
-			e
-				.column('deleted', c => c.type(Model.ColumnType.Bool))
-				.column('published', c => c.type(Model.ColumnType.Bool))
-				.manyHasOne('category', r => r.target('Category')),
-		)
-		.entity('Category', e => e.column('name'))
-		.entity('Author', e =>
-			e
-				.oneHasMany('books', r => r.target('Book').ownedBy('author'))
-				.column('published', c => c.type(Model.ColumnType.Bool)),
-		)
-		.buildSchema()
-	const dependencies: Dependencies = {
-		books: {
-			deleted: {},
-			published: {},
-			category: {
-				name: {},
+	it('constructs query AST', () => {
+		const schema = new SchemaBuilder()
+			.entity('Book', e =>
+				e
+					.column('deleted', c => c.type(Model.ColumnType.Bool))
+					.column('published', c => c.type(Model.ColumnType.Bool))
+					.manyHasOne('category', r => r.target('Category')),
+			)
+			.entity('Category', e => e.column('name'))
+			.entity('Author', e =>
+				e
+					.oneHasMany('books', r => r.target('Book').ownedBy('author'))
+					.column('published', c => c.type(Model.ColumnType.Bool)),
+			)
+			.buildSchema()
+		const dependencies: Dependencies = {
+			books: {
+				deleted: {},
+				published: {},
+				category: {
+					name: {},
+				},
 			},
-		},
-		published: {},
-	}
-
-	const astFactory = new QueryAstFactory(schema)
-	const result = astFactory.create('Author', dependencies)
-
-	assert.equal(
-		result,
-		new ObjectNode(
-			'Author',
-			'Author',
-			[
-				new ObjectNode(
-					'books',
-					'books',
-					[
-						new FieldNode('id', 'id', {}),
-						new FieldNode('deleted', 'deleted', {}),
-						new FieldNode('published', 'published', {}),
-						new ObjectNode(
-							'category',
-							'category',
-							[new FieldNode('id', 'id', {}), new FieldNode('name', 'name', {})],
-							{},
-							{},
-							[],
-						),
-					],
-					{},
-					{},
-					[],
-				),
-				new FieldNode('published', 'published', {}),
-			],
-			{},
-			{},
-			[],
-		),
-	)
-})
-inputValidationTest.run()
+			published: {},
+		}
+
+		const astFactory = new QueryAstFactory(schema)
+		const result = astFactory.create('Author', dependencies)
+
+		assert.deepStrictEqual(
+			result,
+			new ObjectNode(
+				'Author',
+				'Author',
+				[
+					new ObjectNode(
+						'books',
+						'books',
+						[
+							new FieldNode('id', 'id', {}),
+							new FieldNode('deleted', 'deleted', {}),
+							new FieldNode('published', 'published', {}),
+							new ObjectNode(
+								'category',
+								'category',
+								[new FieldNode('id', 'id', {}), new FieldNode('name', 'name', {})],
+								{},
+								{},
+								[],
+							),
+						],
+						{},
+						{},
+						[],
+					),
+					new FieldNode('published', 'published', {}),
+				],
+				{},
+				{},
+				[],
+			),
+		)
+	})
 
-const trinaryLogicTest = suite('validation - trinary logic')
-trinaryLogicTest('trinary "and" results in a null', () => {
-	const rule = validation.rules.and(
-		validation.rules.on('email', validation.rules.pattern(/.+@.+/)),
-		validation.rules.on('name', validation.rules.pattern(/.+/)),
-	)
+	describe('validation - trinary logic', () => {
 
-	const author = {
-		name: 'john',
-		email: null,
-	}
+		it('trinary "and" results in a null', () => {
+			const rule = validation.rules.and(
+				validation.rules.on('email', validation.rules.pattern(/.+@.+/)),
+				validation.rules.on('name', validation.rules.pattern(/.+/)),
+			)
 
-	const context = ValidationContext.createRootContext(author)
+			const author = {
+				name: 'john',
+				email: null,
+			}
 
-	assert.is(evaluateValidation(context, rule), null)
-})
+			const context = ValidationContext.createRootContext(author)
 
-trinaryLogicTest('trinary "and" results in a false', () => {
-	const rule = validation.rules.and(
-		validation.rules.on('email', validation.rules.pattern(/.+@.+/)),
-		validation.rules.on('name', validation.rules.pattern(/.+/)),
-	)
+			assert.isNull(evaluateValidation(context, rule))
+		})
 
-	const author = {
-		name: null,
-		email: 'abcd',
-	}
+		it('trinary "and" results in a false', () => {
+			const rule = validation.rules.and(
+				validation.rules.on('email', validation.rules.pattern(/.+@.+/)),
+				validation.rules.on('name', validation.rules.pattern(/.+/)),
+			)
 
-	const context = ValidationContext.createRootContext(author)
+			const author = {
+				name: null,
+				email: 'abcd',
+			}
 
-	assert.not.ok(evaluateValidation(context, rule))
-})
-trinaryLogicTest('trinary "and" results in a true', () => {
-	const rule = validation.rules.and(
-		validation.rules.on('email', validation.rules.pattern(/.+@.+/)),
-		validation.rules.on('name', validation.rules.pattern(/.+/)),
-	)
+			const context = ValidationContext.createRootContext(author)
+
+			assert.notOk(evaluateValidation(context, rule))
+		})
+		it('trinary "and" results in a true', () => {
+			const rule = validation.rules.and(
+				validation.rules.on('email', validation.rules.pattern(/.+@.+/)),
+				validation.rules.on('name', validation.rules.pattern(/.+/)),
+			)
 
-	const author = {
-		name: 'johh',
-		email: 'abcd@foo',
-	}
+			const author = {
+				name: 'johh',
+				email: 'abcd@foo',
+			}
 
-	const context = ValidationContext.createRootContext(author)
+			const context = ValidationContext.createRootContext(author)
 
-	assert.ok(evaluateValidation(context, rule))
+			assert.ok(evaluateValidation(context, rule))
+		})
+	})
 })
-trinaryLogicTest.run()

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

@@ -1,8 +1,7 @@
 import { Input, Model } from '@contember/schema'
 import { OrderByHelper } from '../../../src/mapper'
 import { ObjectNode } from '../../../src/inputProcessing'
-import * as assert from 'uvu/assert'
-import { suite } from 'uvu'
+import { describe, it, assert } from 'vitest'
 
 const entity: Model.Entity = {
 	name: 'Foo',
@@ -11,59 +10,61 @@ const entity: Model.Entity = {
 	tableName: 'foo',
 	fields: {},
 	unique: {},
+	eventLog: { enabled: true },
 }
 
-const orderByHelperTest = suite('order by helper')
+describe('order by helper', () => {
 
-orderByHelperTest('set default order by without defined order', () => {
-	const objectNode = new ObjectNode('test', 'test', [], {}, {}, [])
 
-	const defaultOrderBy = [{ path: ['lorem', 'ipsum'], direction: Input.OrderDirection.desc }]
-	const newNode = OrderByHelper.appendDefaultOrderBy(entity, objectNode, defaultOrderBy)
-	assert.equal(newNode.args.orderBy, [
-		{ lorem: { ipsum: Input.OrderDirection.desc } },
-		{ id: Input.OrderDirection.asc },
-	])
-})
+	it('set default order by without defined order', () => {
+		const objectNode = new ObjectNode('test', 'test', [], {}, {}, [])
 
-orderByHelperTest('appends primary order by with already defined order by', () => {
-	const objectNode = new ObjectNode(
-		'test',
-		'test',
-		[],
-		{
-			orderBy: [{ foo: { bar: Input.OrderDirection.asc } }],
-		},
-		{},
-		[],
-	)
+		const defaultOrderBy = [{ path: ['lorem', 'ipsum'], direction: Input.OrderDirection.desc }]
+		const newNode = OrderByHelper.appendDefaultOrderBy(entity, objectNode, defaultOrderBy)
+		assert.deepStrictEqual(newNode.args.orderBy, [
+			{ lorem: { ipsum: Input.OrderDirection.desc } },
+			{ id: Input.OrderDirection.asc },
+		])
+	})
 
-	const defaultOrderBy = [{ path: ['lorem', 'ipsum'], direction: Input.OrderDirection.desc }]
-	const newNode = OrderByHelper.appendDefaultOrderBy(entity, objectNode, defaultOrderBy)
-	assert.equal(newNode.args.orderBy, [{ foo: { bar: Input.OrderDirection.asc } }, { id: Input.OrderDirection.asc }])
-})
+	it('appends primary order by with already defined order by', () => {
+		const objectNode = new ObjectNode(
+			'test',
+			'test',
+			[],
+			{
+				orderBy: [{ foo: { bar: Input.OrderDirection.asc } }],
+			},
+			{},
+			[],
+		)
 
-orderByHelperTest('appends primary order by with defined limit/offset', () => {
-	const objectNode = new ObjectNode(
-		'test',
-		'test',
-		[],
-		{
-			offset: 10,
-			limit: 10,
-		},
-		{},
-		[],
-	)
+		const defaultOrderBy = [{ path: ['lorem', 'ipsum'], direction: Input.OrderDirection.desc }]
+		const newNode = OrderByHelper.appendDefaultOrderBy(entity, objectNode, defaultOrderBy)
+		assert.deepStrictEqual(newNode.args.orderBy, [{ foo: { bar: Input.OrderDirection.asc } }, { id: Input.OrderDirection.asc }])
+	})
 
-	const newNode = OrderByHelper.appendDefaultOrderBy(entity, objectNode, [])
-	assert.equal(newNode.args.orderBy, [{ id: Input.OrderDirection.asc }])
-})
+	it('appends primary order by with defined limit/offset', () => {
+		const objectNode = new ObjectNode(
+			'test',
+			'test',
+			[],
+			{
+				offset: 10,
+				limit: 10,
+			},
+			{},
+			[],
+		)
+
+		const newNode = OrderByHelper.appendDefaultOrderBy(entity, objectNode, [])
+		assert.deepStrictEqual(newNode.args.orderBy, [{ id: Input.OrderDirection.asc }])
+	})
 
-orderByHelperTest('does not append default order by', () => {
-	const objectNode = new ObjectNode('test', 'test', [], {}, {}, [])
+	it('does not append default order by', () => {
+		const objectNode = new ObjectNode('test', 'test', [], {}, {}, [])
 
-	const newNode = OrderByHelper.appendDefaultOrderBy(entity, objectNode, [])
-	assert.equal(newNode.args.orderBy, undefined)
+		const newNode = OrderByHelper.appendDefaultOrderBy(entity, objectNode, [])
+		assert.isUndefined(newNode.args.orderBy)
+	})
 })
-orderByHelperTest.run()