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

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

@@ -1,100 +1,101 @@
 import { createSchema, testCreate, testUpdate } from './utils'
 import { InputValidation as v, SchemaDefinition as d } from '@contember/schema-definition'
 import { testUuid } from '../../../../src/testUuid'
-import { suite } from 'uvu'
+import { describe, it } from 'vitest'
 
-const nestedValidationTest = suite('Nested validations')
+describe('Nested validations', () => {
 
-nestedValidationTest('validates nested m:n create with an alias', async () => {
-	class Post {
-		title = d.stringColumn()
-		tags: d.ManyHasManyDefinition = d.manyHasMany(Tag, 'posts')
-	}
 
-	class Tag {
-		@v.required('Tag label is required')
-		label = d.stringColumn()
-		posts = d.manyHasManyInverse(Post, 'tags')
-	}
+	it('validates nested m:n create with an alias', async () => {
+		class Post {
+			title = d.stringColumn()
+			tags: d.ManyHasManyDefinition = d.manyHasMany(Tag, 'posts')
+		}
 
-	const schema = createSchema({ Post, Tag })
-	await testCreate({
-		schema,
-		entity: 'Post',
-		data: {
-			title: 'Hello world',
-			tags: [{ alias: 'foo', create: { label: null } }],
-		},
-		executes: [],
-		errors: [
-			{
-				message: {
-					text: 'Tag label is required',
-				},
-				path: [
-					{
-						field: 'tags',
-					},
-					{
-						index: 0,
-						alias: 'foo',
-					},
-					{
-						field: 'label',
-					},
-				],
+		class Tag {
+			@v.required('Tag label is required')
+			label = d.stringColumn()
+			posts = d.manyHasManyInverse(Post, 'tags')
+		}
+
+		const schema = createSchema({ Post, Tag })
+		await testCreate({
+			schema,
+			entity: 'Post',
+			data: {
+				title: 'Hello world',
+				tags: [{ alias: 'foo', create: { label: null } }],
 			},
-		],
+			executes: [],
+			errors: [
+				{
+					message: {
+						text: 'Tag label is required',
+					},
+					path: [
+						{
+							field: 'tags',
+						},
+						{
+							index: 0,
+							alias: 'foo',
+						},
+						{
+							field: 'label',
+						},
+					],
+				},
+			],
+		})
 	})
-})
 
-nestedValidationTest('validates nested m:n update', async () => {
-	class Post {
-		title = d.stringColumn()
-		tags: d.ManyHasManyDefinition = d.manyHasMany(Tag, 'posts')
-	}
+	it('validates nested m:n update', async () => {
+		class Post {
+			title = d.stringColumn()
+			tags: d.ManyHasManyDefinition = d.manyHasMany(Tag, 'posts')
+		}
 
-	class Tag {
-		@v.required('Tag label is required')
-		label = d.stringColumn()
-		posts = d.manyHasManyInverse(Post, 'tags')
-	}
+		class Tag {
+			@v.required('Tag label is required')
+			label = d.stringColumn()
+			posts = d.manyHasManyInverse(Post, 'tags')
+		}
 
-	const schema = createSchema({ Post, Tag })
-	await testUpdate({
-		schema,
-		entity: 'Post',
-		by: { id: testUuid(1) },
-		data: {
-			tags: [{ alias: 'foo', create: { label: null } }],
-		},
-		executes: [],
-		errors: ['Tag label is required'],
+		const schema = createSchema({ Post, Tag })
+		await testUpdate({
+			schema,
+			entity: 'Post',
+			by: { id: testUuid(1) },
+			data: {
+				tags: [{ alias: 'foo', create: { label: null } }],
+			},
+			executes: [],
+			errors: ['Tag label is required'],
+		})
 	})
-})
 
-nestedValidationTest('validates nested m:1 update', async () => {
-	class Post {
-		title = d.stringColumn()
-		author = d.manyHasOne(Author, 'posts')
-	}
+	it('validates nested m:1 update', async () => {
+		class Post {
+			title = d.stringColumn()
+			author = d.manyHasOne(Author, 'posts')
+		}
 
-	class Author {
-		@v.required('Author name is required')
-		name = d.stringColumn()
-		posts: d.OneHasManyDefinition = d.oneHasMany(Post, 'author')
-	}
+		class Author {
+			@v.required('Author name is required')
+			name = d.stringColumn()
+			posts: d.OneHasManyDefinition = d.oneHasMany(Post, 'author')
+		}
 
-	const schema = createSchema({ Post, Author })
-	await testUpdate({
-		schema,
-		entity: 'Post',
-		by: { id: testUuid(1) },
-		data: {
-			author: { create: { name: null } },
-		},
-		executes: [],
-		errors: ['Author name is required'],
+		const schema = createSchema({ Post, Author })
+		await testUpdate({
+			schema,
+			entity: 'Post',
+			by: { id: testUuid(1) },
+			data: {
+				author: { create: { name: null } },
+			},
+			executes: [],
+			errors: ['Author name is required'],
+		})
 	})
 })
-nestedValidationTest.run()

package/tests/cases/integration/graphQlRequests/validation/optionalAssert.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()
@@ -12,54 +12,56 @@ export class Author {
 
 const schema = createSchema({ Author })
 
-const optionalValidationTest = suite('Optional validation')
-optionalValidationTest('create succeeds when null', async () => {
-	await testCreate({
-		schema,
-		entity: 'Author',
-		data: { email: null },
-		executes: [],
-		errors: [],
+describe('Optional validation', () => {
+
+	it('create succeeds when null', async () => {
+		await testCreate({
+			schema,
+			entity: 'Author',
+			data: { email: null },
+			executes: [],
+			errors: [],
+		})
 	})
-})
-optionalValidationTest('create succeeds when not set', async () => {
-	await testCreate({
-		schema,
-		entity: 'Author',
-		data: {},
-		executes: [],
-		errors: [],
+	it('create succeeds when not set', async () => {
+		await testCreate({
+			schema,
+			entity: 'Author',
+			data: {},
+			executes: [],
+			errors: [],
+		})
 	})
-})
-optionalValidationTest('create fails when filled but not valid', async () => {
-	await testCreate({
-		schema,
-		entity: 'Author',
-		data: { email: 'xx' },
-		executes: [],
-		errors: ['E-mail is not valid'],
+	it('create fails when filled but not valid', async () => {
+		await testCreate({
+			schema,
+			entity: 'Author',
+			data: { email: 'xx' },
+			executes: [],
+			errors: ['E-mail is not valid'],
+		})
 	})
-})
 
-optionalValidationTest('update fails when value is invalid', async () => {
-	await testUpdate({
-		schema: createSchema({ Author }),
-		entity: 'Author',
-		data: { email: 'aaa' },
-		by: { id: testUuid(1) },
-		executes: [],
-		errors: ['E-mail is not valid'],
+	it('update fails when value is invalid', async () => {
+		await testUpdate({
+			schema: createSchema({ Author }),
+			entity: 'Author',
+			data: { email: 'aaa' },
+			by: { id: testUuid(1) },
+			executes: [],
+			errors: ['E-mail is not valid'],
+		})
 	})
-})
 
-optionalValidationTest('update succeeds when value is valid', async () => {
-	await testUpdate({
-		schema: createSchema({ Author }),
-		entity: 'Author',
-		data: { email: 'aaa@b.com' },
-		by: { id: testUuid(1) },
-		executes: [],
-		errors: [],
+	it('update succeeds when value is valid', async () => {
+		await testUpdate({
+			schema: createSchema({ Author }),
+			entity: 'Author',
+			data: { email: 'aaa@b.com' },
+			by: { id: testUuid(1) },
+			executes: [],
+			errors: [],
+		})
 	})
+
 })
-optionalValidationTest.run()