@contember/engine-content-api 1.1.0-alpha.5 → 1.1.0-alpha.8

package/tests/cases/integration/graphQlRequests/validation/required.test.ts

@@ -1,205 +1,206 @@
 import { InputValidation as v, SchemaDefinition as d } from '@contember/schema-definition'
 import { createSchema, testCreate, testUpdate } from './utils'
 import { testUuid } from '../../../../src/testUuid'
-import { suite } from 'uvu'
-
-const requiredValidationTest = suite('Required validation')
-
-requiredValidationTest('create fails when column value is not set', async () => {
-	class Author {
-		@v.required('Author name is required')
-		name = d.stringColumn()
-	}
-
-	const schema = createSchema({
-		Author,
-	})
-	await testCreate({
-		schema,
-		entity: 'Author',
-		data: {},
-		errors: ['Author name is required'],
-	})
-})
-
-requiredValidationTest('create fails when column value is set to null', async () => {
-	class Author {
-		@v.required('Author name is required')
-		name = d.stringColumn()
-	}
-
-	const schema = createSchema({
-		Author,
-	})
-	await testCreate({
-		schema,
-		entity: 'Author',
-		data: { name: null },
-		errors: ['Author name is required'],
-	})
-})
-
-requiredValidationTest('create succeeds when column value is set', async () => {
-	class Author {
-		@v.required('Author name is required')
-		name = d.stringColumn()
-	}
-
-	const schema = createSchema({
-		Author,
-	})
-	await testCreate({
-		schema,
-		entity: 'Author',
-		data: { name: 'John' },
-		errors: [],
-	})
-})
-
-requiredValidationTest('create fails when required has-one relation is not set', async () => {
-	class Author {
-		@v.required('Contact is required')
-		contact: d.OneHasOneDefinition = d.oneHasOne(AuthorContact, 'author')
-	}
-
-	class AuthorContact {
-		email = d.stringColumn()
-		author = d.oneHasOneInverse(Author, 'contact')
-	}
-
-	const schema = createSchema({
-		Author,
-		AuthorContact,
-	})
-	await testCreate({
-		schema,
-		entity: 'Author',
-		data: {},
-		errors: ['Contact is required'],
-	})
-})
-
-requiredValidationTest('create succeeds when required has-one relation is set', async () => {
-	class Author {
-		@v.required('Contact is required')
-		contact: d.OneHasOneDefinition = d.oneHasOne(AuthorContact, 'author')
-	}
-
-	class AuthorContact {
-		email = d.stringColumn()
-		author = d.oneHasOneInverse(Author, 'contact')
-	}
-
-	const schema = createSchema({
-		Author,
-		AuthorContact,
-	})
-	await testCreate({
-		schema,
-		entity: 'Author',
-		data: { contact: { create: {} } },
-		errors: [],
-	})
-})
-requiredValidationTest('update succeeds when column value is not set', async () => {
-	class Author {
-		@v.required('Author name is required')
-		name = d.stringColumn()
-	}
-
-	const schema = createSchema({
-		Author,
-	})
-	await testUpdate({
-		schema,
-		entity: 'Author',
-		by: { id: testUuid(1) },
-		data: {},
-		errors: [],
-	})
-})
-
-requiredValidationTest('update fails when column value is set to null', async () => {
-	class Author {
-		@v.required('Author name is required')
-		name = d.stringColumn()
-	}
-
-	const schema = createSchema({
-		Author,
-	})
-	await testUpdate({
-		schema,
-		by: { id: testUuid(1) },
-		entity: 'Author',
-		data: { name: null },
-		errors: ['Author name is required'],
-	})
-})
-
-requiredValidationTest('update succeeds when column value is set', async () => {
-	class Author {
-		@v.required('Author name is required')
-		name = d.stringColumn()
-	}
-
-	const schema = createSchema({
-		Author,
-	})
-	await testUpdate({
-		schema,
-		by: { id: testUuid(1) },
-		entity: 'Author',
-		data: { name: 'John' },
-		errors: [],
-	})
-})
-
-requiredValidationTest('update succeeds when required has-one relation is not set', async () => {
-	class Author {
-		@v.required('Contact is required')
-		contact: d.OneHasOneDefinition = d.oneHasOne(AuthorContact, 'author')
-	}
-
-	class AuthorContact {
-		email = d.stringColumn()
-		author = d.oneHasOneInverse(Author, 'contact')
-	}
-
-	const schema = createSchema({
-		Author,
-		AuthorContact,
-	})
-	await testUpdate({
-		schema,
-		by: { id: testUuid(1) },
-		entity: 'Author',
-		data: {},
-		errors: [],
-	})
-})
-
-requiredValidationTest('update succeeds when required has-one relation is set', async () => {
-	class Author {
-		@v.required('Contact is required')
-		contact: d.OneHasOneDefinition = d.oneHasOne(AuthorContact, 'author')
-	}
-
-	class AuthorContact {
-		email = d.stringColumn()
-		author = d.oneHasOneInverse(Author, 'contact')
-	}
-
-	const schema = createSchema({
-		Author,
-		AuthorContact,
-	})
-	await testUpdate({
-		schema,
-		by: { id: testUuid(1) },
-		entity: 'Author',
-		data: { contact: { create: {} } },
-		errors: [],
+import { describe, it, assert } from 'vitest'
+
+describe('Required validation', () => {
+
+
+	it('create fails when column value is not set', async () => {
+		class Author {
+			@v.required('Author name is required')
+			name = d.stringColumn()
+		}
+
+		const schema = createSchema({
+			Author,
+		})
+		await testCreate({
+			schema,
+			entity: 'Author',
+			data: {},
+			errors: ['Author name is required'],
+		})
+	})
+
+	it('create fails when column value is set to null', async () => {
+		class Author {
+			@v.required('Author name is required')
+			name = d.stringColumn()
+		}
+
+		const schema = createSchema({
+			Author,
+		})
+		await testCreate({
+			schema,
+			entity: 'Author',
+			data: { name: null },
+			errors: ['Author name is required'],
+		})
+	})
+
+	it('create succeeds when column value is set', async () => {
+		class Author {
+			@v.required('Author name is required')
+			name = d.stringColumn()
+		}
+
+		const schema = createSchema({
+			Author,
+		})
+		await testCreate({
+			schema,
+			entity: 'Author',
+			data: { name: 'John' },
+			errors: [],
+		})
+	})
+
+	it('create fails when required has-one relation is not set', async () => {
+		class Author {
+			@v.required('Contact is required')
+			contact: d.OneHasOneDefinition = d.oneHasOne(AuthorContact, 'author')
+		}
+
+		class AuthorContact {
+			email = d.stringColumn()
+			author = d.oneHasOneInverse(Author, 'contact')
+		}
+
+		const schema = createSchema({
+			Author,
+			AuthorContact,
+		})
+		await testCreate({
+			schema,
+			entity: 'Author',
+			data: {},
+			errors: ['Contact is required'],
+		})
+	})
+
+	it('create succeeds when required has-one relation is set', async () => {
+		class Author {
+			@v.required('Contact is required')
+			contact: d.OneHasOneDefinition = d.oneHasOne(AuthorContact, 'author')
+		}
+
+		class AuthorContact {
+			email = d.stringColumn()
+			author = d.oneHasOneInverse(Author, 'contact')
+		}
+
+		const schema = createSchema({
+			Author,
+			AuthorContact,
+		})
+		await testCreate({
+			schema,
+			entity: 'Author',
+			data: { contact: { create: {} } },
+			errors: [],
+		})
+	})
+	it('update succeeds when column value is not set', async () => {
+		class Author {
+			@v.required('Author name is required')
+			name = d.stringColumn()
+		}
+
+		const schema = createSchema({
+			Author,
+		})
+		await testUpdate({
+			schema,
+			entity: 'Author',
+			by: { id: testUuid(1) },
+			data: {},
+			errors: [],
+		})
+	})
+
+	it('update fails when column value is set to null', async () => {
+		class Author {
+			@v.required('Author name is required')
+			name = d.stringColumn()
+		}
+
+		const schema = createSchema({
+			Author,
+		})
+		await testUpdate({
+			schema,
+			by: { id: testUuid(1) },
+			entity: 'Author',
+			data: { name: null },
+			errors: ['Author name is required'],
+		})
+	})
+
+	it('update succeeds when column value is set', async () => {
+		class Author {
+			@v.required('Author name is required')
+			name = d.stringColumn()
+		}
+
+		const schema = createSchema({
+			Author,
+		})
+		await testUpdate({
+			schema,
+			by: { id: testUuid(1) },
+			entity: 'Author',
+			data: { name: 'John' },
+			errors: [],
+		})
+	})
+
+	it('update succeeds when required has-one relation is not set', async () => {
+		class Author {
+			@v.required('Contact is required')
+			contact: d.OneHasOneDefinition = d.oneHasOne(AuthorContact, 'author')
+		}
+
+		class AuthorContact {
+			email = d.stringColumn()
+			author = d.oneHasOneInverse(Author, 'contact')
+		}
+
+		const schema = createSchema({
+			Author,
+			AuthorContact,
+		})
+		await testUpdate({
+			schema,
+			by: { id: testUuid(1) },
+			entity: 'Author',
+			data: {},
+			errors: [],
+		})
+	})
+
+	it('update succeeds when required has-one relation is set', async () => {
+		class Author {
+			@v.required('Contact is required')
+			contact: d.OneHasOneDefinition = d.oneHasOne(AuthorContact, 'author')
+		}
+
+		class AuthorContact {
+			email = d.stringColumn()
+			author = d.oneHasOneInverse(Author, 'contact')
+		}
+
+		const schema = createSchema({
+			Author,
+			AuthorContact,
+		})
+		await testUpdate({
+			schema,
+			by: { id: testUuid(1) },
+			entity: 'Author',
+			data: { contact: { create: {} } },
+			errors: [],
+		})
 	})
 })
-requiredValidationTest.run()

package/tests/cases/integration/graphQlRequests/validation/requiredWhen.test.ts

@@ -1,7 +1,7 @@
 import { InputValidation as v, SchemaDefinition as d } from '@contember/schema-definition'
 import { createSchema, testCreate, testUpdate } from './utils'
 import { testUuid } from '../../../../src/testUuid'
-import { suite } from 'uvu'
+import { describe, it, assert } from 'vitest'
 
 export class Author {
 	name = d.stringColumn()
@@ -13,82 +13,82 @@ export class Author {
 }
 
 const schema = createSchema({ Author })
-const requiredWhenTest = suite('Required when condition')
+describe('Required when condition', () => {
 
-requiredWhenTest('create succeeds when rule condition is not true', async () => {
-	await testCreate({
-		schema,
-		entity: 'Author',
-		data: { authorWithContact: false, email: null },
-		executes: [],
-		errors: [],
+
+	it('create succeeds when rule condition is not true', async () => {
+		await testCreate({
+			schema,
+			entity: 'Author',
+			data: { authorWithContact: false, email: null },
+			executes: [],
+			errors: [],
+		})
 	})
-})
-requiredWhenTest('create fails when rule condition is true and value is not filled', async () => {
-	await testCreate({
-		schema,
-		entity: 'Author',
-		data: { authorWithContact: true, email: null },
-		executes: [],
-		errors: ['E-mail is required'],
+	it('create fails when rule condition is true and value is not filled', async () => {
+		await testCreate({
+			schema,
+			entity: 'Author',
+			data: { authorWithContact: true, email: null },
+			executes: [],
+			errors: ['E-mail is required'],
+		})
 	})
-})
-requiredWhenTest('create succeeds when rule condition is true and value is set', async () => {
-	await testCreate({
-		schema,
-		entity: 'Author',
-		data: { authorWithContact: true, email: 'xx@foo' },
-		executes: [],
-		errors: [],
+	it('create succeeds when rule condition is true and value is set', async () => {
+		await testCreate({
+			schema,
+			entity: 'Author',
+			data: { authorWithContact: true, email: 'xx@foo' },
+			executes: [],
+			errors: [],
+		})
 	})
-})
-requiredWhenTest('update fails when setting condition to true and current value in db is null', async () => {
-	await testUpdate({
-		schema: createSchema({ Author }),
-		entity: 'Author',
-		data: { authorWithContact: true },
-		by: { id: testUuid(1) },
-		executes: [
-			{
-				sql: 'select "root_"."email" as "root_email", "root_"."id" as "root_id" from "public"."author" as "root_" where "root_"."id" = ?',
-				parameters: [testUuid(1)],
-				response: {
-					rows: [{ root_email: null, root_id: testUuid(1) }],
+	it('update fails when setting condition to true and current value in db is null', async () => {
+		await testUpdate({
+			schema: createSchema({ Author }),
+			entity: 'Author',
+			data: { authorWithContact: true },
+			by: { id: testUuid(1) },
+			executes: [
+				{
+					sql: 'select "root_"."email" as "root_email", "root_"."id" as "root_id" from "public"."author" as "root_" where "root_"."id" = ?',
+					parameters: [testUuid(1)],
+					response: {
+						rows: [{ root_email: null, root_id: testUuid(1) }],
+					},
 				},
-			},
-		],
-		errors: ['E-mail is required'],
+			],
+			errors: ['E-mail is required'],
+		})
 	})
-})
 
-requiredWhenTest('update succeeds when setting condition to true and current value in db is filled', async () => {
-	await testUpdate({
-		schema: createSchema({ Author }),
-		entity: 'Author',
-		data: { authorWithContact: true },
-		by: { id: testUuid(1) },
-		executes: [
-			{
-				sql: 'select "root_"."email" as "root_email", "root_"."id" as "root_id" from "public"."author" as "root_" where "root_"."id" = ?',
-				parameters: [testUuid(1)],
-				response: {
-					rows: [{ root_email: 'foo@bar.com', root_id: testUuid(1) }],
+	it('update succeeds when setting condition to true and current value in db is filled', async () => {
+		await testUpdate({
+			schema: createSchema({ Author }),
+			entity: 'Author',
+			data: { authorWithContact: true },
+			by: { id: testUuid(1) },
+			executes: [
+				{
+					sql: 'select "root_"."email" as "root_email", "root_"."id" as "root_id" from "public"."author" as "root_" where "root_"."id" = ?',
+					parameters: [testUuid(1)],
+					response: {
+						rows: [{ root_email: 'foo@bar.com', root_id: testUuid(1) }],
+					},
 				},
-			},
-		],
-		errors: [],
+			],
+			errors: [],
+		})
 	})
-})
 
-requiredWhenTest('update succeeds when setting condition to true and setting value to valid', async () => {
-	await testUpdate({
-		schema: createSchema({ Author }),
-		entity: 'Author',
-		data: { authorWithContact: true, email: 'aaa@b.com' },
-		by: { id: testUuid(1) },
-		executes: [],
-		errors: [],
+	it('update succeeds when setting condition to true and setting value to valid', async () => {
+		await testUpdate({
+			schema: createSchema({ Author }),
+			entity: 'Author',
+			data: { authorWithContact: true, email: 'aaa@b.com' },
+			by: { id: testUuid(1) },
+			executes: [],
+			errors: [],
+		})
 	})
 })
-
-requiredWhenTest.run()

package/tests/cases/integration/graphQlRequests/validation/rules/andRule.test.ts

@@ -1,6 +1,6 @@
 import { InputValidation as v, SchemaDefinition as d } from '@contember/schema-definition'
 import { createSchema, testCreate } from '../utils'
-import { suite } from 'uvu'
+import { describe, it } from 'vitest'
 
 class Item {
 	@v.assert(v.rules.and(v.rules.pattern(/.+@.+/), v.rules.minLength(5)), 'failure')
@@ -10,22 +10,23 @@ class Item {
 const schema = createSchema({
 	Item,
 })
-const test = suite('Logical AND rule')
-test('fails when value not valid', async () => {
-	await testCreate({
-		schema,
-		entity: 'Item',
-		data: { value: 'a@b' },
-		errors: ['failure'],
+describe('Logical AND rule', () => {
+
+	it('fails when value not valid', async () => {
+		await testCreate({
+			schema,
+			entity: 'Item',
+			data: { value: 'a@b' },
+			errors: ['failure'],
+		})
 	})
-})
 
-test('succeeds when value valid', async () => {
-	await testCreate({
-		schema,
-		entity: 'Item',
-		data: { value: 'abcde@bb.com' },
-		errors: [],
+	it('succeeds when value valid', async () => {
+		await testCreate({
+			schema,
+			entity: 'Item',
+			data: { value: 'abcde@bb.com' },
+			errors: [],
+		})
 	})
 })
-test.run()