@contember/schema-utils 2.0.0-alpha.32 → 2.0.0-alpha.36

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

@@ -1,4 +1,4 @@
-import { assert, test } from 'vitest'
+import { expect, test } from 'bun:test'
 import { MembershipResolver, MembershipValidationErrorType } from '../../../src'
 import { Acl } from '@contember/schema'
 
@@ -17,8 +17,8 @@ test('read membership with entity variable', () => {
 	}, [
 		{ role: 'editor', variables: [{ name: 'localeID', values: [id1] }] },
 	], MembershipResolver.UnknownIdentity)
-	assert.lengthOf(result.errors, 0)
-	assert.deepStrictEqual(result.memberships, [
+	expect(result.errors).toStrictEqual([])
+	expect(result.memberships).toStrictEqual([
 		{ role: 'editor', variables: [{ name: 'localeID', condition: { in: [id1] } }] },
 	])
 })
@@ -37,13 +37,13 @@ test('read fails when variable is not provided', () => {
 	}, [
 		{ role: 'editor', variables: [] },
 	], MembershipResolver.UnknownIdentity)
-	assert.deepStrictEqual(result.errors, [{
+	expect(result.errors).toEqual([{
 		error: MembershipValidationErrorType.VARIABLE_EMPTY,
 		role: 'editor',
 		variable: 'localeID',
 	}])
 
-	assert.deepStrictEqual(result.memberships, [
+	expect(result.memberships).toStrictEqual([
 		{ role: 'editor', variables: [{ name: 'localeID', condition: { never: true } }] },
 	])
 })
@@ -64,8 +64,8 @@ test('read membership with predefined variable', () => {
 	], {
 		identityId: id1,
 	})
-	assert.lengthOf(result.errors, 0)
-	assert.deepStrictEqual(result.memberships, [
+	expect(result.errors).toStrictEqual([])
+	expect(result.memberships).toStrictEqual([
 		{ role: 'editor', variables: [{ name: 'self', condition: { in: [id1] } }] },
 	])
 })
@@ -84,8 +84,8 @@ test('read membership with condition variable', () => {
 	}, [
 		{ role: 'editor', variables: [{ name: 'cond', values: [JSON.stringify({ eq: 'foo' })] }] },
 	], MembershipResolver.UnknownIdentity)
-	assert.lengthOf(result.errors, 0)
-	assert.deepStrictEqual(result.memberships, [
+	expect(result.errors).toStrictEqual([])
+	expect(result.memberships).toStrictEqual([
 		{ role: 'editor', variables: [{ name: 'cond', condition: { eq: 'foo' } }] },
 	])
 })
@@ -105,13 +105,13 @@ test('fails on invalid condition', () => {
 		{ role: 'editor', variables: [{ name: 'cond', values: [JSON.stringify('abcd')] }] },
 	], MembershipResolver.UnknownIdentity)
 
-	assert.deepStrictEqual(result.errors, [{
+	expect(result.errors).toEqual([{
 		error: MembershipValidationErrorType.VARIABLE_INVALID,
 		role: 'editor',
 		variable: 'cond',
 	}])
 
-	assert.deepStrictEqual(result.memberships, [
+	expect(result.memberships).toStrictEqual([
 		{ role: 'editor', variables: [{ name: 'cond', condition: { never: true } }] },
 	])
 })
@@ -127,13 +127,13 @@ test('fails on undefined role', () => {
 		identityId: id1,
 	})
 
-	assert.deepStrictEqual(result.errors, [{
+	expect(result.errors).toEqual([{
 		error: MembershipValidationErrorType.ROLE_NOT_FOUND,
 		role: 'editor',
 		variable: undefined,
 	}])
 
-	assert.deepStrictEqual(result.memberships, [])
+	expect(result.memberships).toStrictEqual([])
 })
 
 test('fails on undefined variable', () => {
@@ -149,13 +149,13 @@ test('fails on undefined variable', () => {
 		{ role: 'editor', variables: [{ name: 'cond', values: [JSON.stringify('abcd')] }] },
 	], MembershipResolver.UnknownIdentity)
 
-	assert.deepStrictEqual(result.errors, [{
+	expect(result.errors).toEqual([{
 		error: MembershipValidationErrorType.VARIABLE_NOT_FOUND,
 		role: 'editor',
 		variable: 'cond',
 	}])
 
-	assert.deepStrictEqual(result.memberships, [
+	expect(result.memberships).toStrictEqual([
 		{ role: 'editor', variables: [] },
 	])
 })
@@ -175,9 +175,9 @@ test('use fallback value', () => {
 	}, [
 		{ role: 'editor', variables: [] },
 	], MembershipResolver.UnknownIdentity)
-	assert.deepStrictEqual(result.errors, [])
+	expect(result.errors).toStrictEqual([])
 
-	assert.deepStrictEqual(result.memberships, [
+	expect(result.memberships).toStrictEqual([
 		{ role: 'editor', variables: [{ name: 'localeID', condition: { always: true } }] },
 	])
 })

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

@@ -1,4 +1,4 @@
-import { assert, describe, test } from 'vitest'
+import { expect, describe, test } from 'bun:test'
 import { modelSchema } from '../../../src/type-schema'
 import { Model } from '@contember/schema'
 
@@ -51,7 +51,7 @@ describe('model schema', () => {
 				},
 				enums: {},
 			}
-			assert.deepStrictEqual(modelSchema(model), model)
+			expect(modelSchema(model)).toStrictEqual(model)
 		})
 	}
 
@@ -81,7 +81,7 @@ describe('model schema', () => {
 				},
 				enums: {},
 			}
-			assert.throw(() => modelSchema(model), `value at path /entities/Test/fields/column: all variants of union has failed:
+			expect(() => modelSchema(model)).toThrow(`value at path /entities/Test/fields/column: all variants of union has failed:
             value at path /entities/Test/fields/column/columnType: must be valid column type, "${dataType.replaceAll('"', '\\"')}" given`)
 		})
 	}

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

@@ -1,4 +1,4 @@
-import { assert, test } from 'vitest'
+import { expect, test } from 'bun:test'
 import { Model } from '@contember/schema'
 import { ModelValidator } from '../../../src'
 import { c, createSchema } from '@contember/schema-definition'
@@ -64,7 +64,7 @@ test('"meta" collision', () => {
 		},
 	}
 	const validator = new ModelValidator(model)
-	assert.deepStrictEqual(validator.validate(), [
+	expect(validator.validate()).toStrictEqual([
 		{
 			code: 'MODEL_NAME_COLLISION',
 			message: 'entity FooMeta collides with entity Foo, because a GraphQL type with "Meta" suffix is created for every entity',
@@ -83,7 +83,7 @@ namespace ColumnNameCollision {
 test('column name collision', () => {
 	const schema = createSchema(ColumnNameCollision)
 	const validator = new ModelValidator(schema.model)
-	assert.deepStrictEqual(validator.validate(), [
+	expect(validator.validate()).toStrictEqual([
 		{
 			code: 'MODEL_NAME_COLLISION',
 			message: 'Column name "rel_id" on field "relId" collides with a column name on field "rel".',

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

@@ -1,100 +1,88 @@
-import { beforeAll, describe, expect, test } from 'vitest'
+import { beforeAll, describe, expect, test } from 'bun:test'
 import { printJsValue } from '../../../src/utils/printJsValue'
 
-beforeAll(() => {
-	expect.addSnapshotSerializer({
-		test: val => typeof val === 'string',
-		print: val => String(val),
-	})
-})
-
 describe('printJsValue', () => {
 	test('string', () => {
-		expect(printJsValue('foobar')).toMatchInlineSnapshot(`'foobar'`)
+		expect(printJsValue('foobar')).toEqual(`'foobar'`)
 	})
 
 	test('string escape', () => {
-		expect(printJsValue('foo\'bar')).toMatchInlineSnapshot(`'foo\\'bar'`)
+		expect(printJsValue('foo\'bar')).toEqual(`'foo\\'bar'`)
 	})
 
 	test('number', () => {
-		expect(printJsValue(11)).toMatchInlineSnapshot(`11`)
+		expect(printJsValue(11)).toEqual(`11`)
 	})
 
 	test('boolean', () => {
-		expect(printJsValue(true)).toMatchInlineSnapshot(`true`)
+		expect(printJsValue(true)).toEqual(`true`)
 	})
 
 	test('null', () => {
-		expect(printJsValue(null)).toMatchInlineSnapshot(`null`)
+		expect(printJsValue(null)).toEqual(`null`)
 	})
 
 	test('inline array', () => {
-		expect(printJsValue([1, 2, 3])).toMatchInlineSnapshot(`[1, 2, 3]`)
+		expect(printJsValue([1, 2, 3])).toEqual(`[1, 2, 3]`)
 	})
 	test('block array', () => {
-		expect(printJsValue([1, 2, 3], () => true)).toMatchInlineSnapshot(`
-			[
-				1,
-				2,
-				3,
-			]
-		`)
+		expect(printJsValue([1, 2, 3], () => true)).toEqual(
+			`[
+	1,
+	2,
+	3,
+]`)
 	})
 
 	test('inline object', () => {
-		expect(printJsValue({ a: 1, b: 2 })).toMatchInlineSnapshot('{ a: 1, b: 2 }')
+		expect(printJsValue({ a: 1, b: 2 })).toEqual('{ a: 1, b: 2 }')
 	})
 
 	test('block object', () => {
-		expect(printJsValue({ a: 1, b: 2 }, () => true)).toMatchInlineSnapshot(`
-			{
-				a: 1,
-				b: 2,
-			}
-		`)
+		expect(printJsValue({ a: 1, b: 2 }, () => true)).toEqual(
+			`{
+	a: 1,
+	b: 2,
+}`)
 	})
 
 	test('nested block object', () => {
-		expect(printJsValue({ a: 1, b: { c: { d: { e: 1 } } } }, () => true)).toMatchInlineSnapshot(`
-			{
-				a: 1,
-				b: {
-					c: {
-						d: {
-							e: 1,
-						},
-					},
-				},
-			}
-		`)
+		expect(printJsValue({ a: 1, b: { c: { d: { e: 1 } } } }, () => true)).toEqual(
+			`{
+	a: 1,
+	b: {
+		c: {
+			d: {
+				e: 1,
+			},
+		},
+	},
+}`)
 	})
 
 
 	test('one level nested block object', () => {
-		expect(printJsValue({ a: 1, b: { c: { d: { e: 1 } } } }, (_, path) => path.length === 0)).toMatchInlineSnapshot(`
-			{
-				a: 1,
-				b: { c: { d: { e: 1 } } },
-			}
-		`)
+		expect(printJsValue({ a: 1, b: { c: { d: { e: 1 } } } }, (_, path) => path.length === 0)).toEqual(
+			`{
+	a: 1,
+	b: { c: { d: { e: 1 } } },
+}`)
 	})
 
 	test('nested block object and arr', () => {
-		expect(printJsValue({ a: 1, b: [2, { c: 4 }, [5, 6]] }, () => true)).toMatchInlineSnapshot(`
-			{
-				a: 1,
-				b: [
-					2,
-					{
-						c: 4,
-					},
-					[
-						5,
-						6,
-					],
-				],
-			}
-		`)
+		expect(printJsValue({ a: 1, b: [2, { c: 4 }, [5, 6]] }, () => true)).toEqual(
+			`{
+	a: 1,
+	b: [
+		2,
+		{
+			c: 4,
+		},
+		[
+			5,
+			6,
+		],
+	],
+}`)
 	})
 })

package/tests/cases/unit/schemas/acl.ts

@@ -1,30 +1,30 @@
 import { c } from '@contember/schema-definition'
 
-export const readerRole = c.createRole('reader', { stages: '*' })
-
 export const editorRole = c.createRole('editor', { stages: '*' })
 
+export const readerRole = c.createRole('reader', { stages: '*' })
+
 export const categoryEditorVariable = c.createEntityVariable('category', 'Category', editorRole)
 
-@c.Allow(readerRole, {
-	read: true,
-})
 @c.Allow(editorRole, {
 	when: { category: { id: categoryEditorVariable } },
 	read: true,
 	create: ['title', 'category'],
 	update: ['title', 'category'],
 })
+@c.Allow(readerRole, {
+	read: true,
+})
 export class Article {
 	title = c.stringColumn()
 	deletedAt = c.dateTimeColumn()
 	category = c.manyHasOne(Category)
 }
 
-@c.Allow(readerRole, {
+@c.Allow(editorRole, {
 	read: true,
 })
-@c.Allow(editorRole, {
+@c.Allow(readerRole, {
 	read: true,
 })
 export class Category {

package/tests/cases/unit/schemas/complex.ts

@@ -1,22 +1,22 @@
 import { c } from '@contember/schema-definition'
 
-export const readerRole = c.createRole('reader', { stages: '*' })
-
 export const editorRole = c.createRole('editor', { stages: '*' })
 
+export const readerRole = c.createRole('reader', { stages: '*' })
+
 export const categoryEditorVariable = c.createEntityVariable('category', 'Category', editorRole)
 
 @c.Unique('title')
 @c.View(`SELECT * FROM article`)
-@c.Allow(readerRole, {
-	read: true,
-})
 @c.Allow(editorRole, {
 	when: { category: { id: categoryEditorVariable } },
 	read: true,
 	create: ['title', 'category'],
 	update: ['title', 'category'],
 })
+@c.Allow(readerRole, {
+	read: true,
+})
 export class Article {
 	title = c.stringColumn()
 	deletedAt = c.dateTimeColumn()
@@ -27,10 +27,10 @@ export class Article {
 SELECT * FROM article
 
 `)
-@c.Allow(readerRole, {
+@c.Allow(editorRole, {
 	read: true,
 })
-@c.Allow(editorRole, {
+@c.Allow(readerRole, {
 	read: true,
 })
 export class Category {

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

@@ -1,5 +1,5 @@
 import { createSchema } from '@contember/schema-definition'
-import { expect, test } from 'vitest'
+import { expect, test } from 'bun:test'
 import * as basic from './schemas/basic'
 import * as complex from './schemas/complex'
 import * as relations from './schemas/relations'

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

@@ -1,4 +1,4 @@
-import { assert, test, describe } from 'vitest'
+import { expect, test, describe } from 'bun:test'
 import { conditionSchema } from '../../../src/type-schema'
 import { Model } from '@contember/schema'
 import { createSchema, SchemaDefinition as def } from '@contember/schema-definition'
@@ -27,7 +27,7 @@ describe('where schema', () => {
 		const where = {
 			title: { eq: 'foo' },
 		}
-		assert.deepStrictEqual(whereSchema({ schema, entity: schema.entities.Article })(where), where)
+		expect(whereSchema({ schema, entity: schema.entities.Article })(where)).toStrictEqual(where)
 	})
 
 	test('where with and / or /not', () => {
@@ -40,7 +40,7 @@ describe('where schema', () => {
 				},
 			],
 		}
-		assert.deepStrictEqual(whereSchema({ schema, entity: schema.entities.Article })(where), where)
+		expect(whereSchema({ schema, entity: schema.entities.Article })(where)).toStrictEqual(where)
 	})
 
 
@@ -48,17 +48,17 @@ describe('where schema', () => {
 		const where = {
 			tags: { name: { eq: 'xx' } },
 		}
-		assert.deepStrictEqual(whereSchema({ schema, entity: schema.entities.Article })(where), where)
+		expect(whereSchema({ schema, entity: schema.entities.Article })(where)).toStrictEqual(where)
 	})
 
 	test('undefined field', () => {
 		const where = {
 			name: { eq: 'foo' },
 		}
-		assert.throw(() => whereSchema({
+		expect(() => whereSchema({
 			schema,
 			entity: schema.entities.Article,
-		})(where), 'value at root: extra property name found')
+		})(where)).toThrow('value at root: extra property name found')
 	})
 
 
@@ -69,10 +69,10 @@ describe('where schema', () => {
 
 			},
 		}
-		assert.throw(() => whereSchema({
+		expect(() => whereSchema({
 			schema,
 			entity: schema.entities.Article,
-		})(where), 'value at path /tags: extra property caption found')
+		})(where)).toThrow('value at path /tags: extra property caption found')
 	})
 
 
@@ -80,10 +80,10 @@ describe('where schema', () => {
 		const where = {
 			title: { xx: 'foo' },
 		}
-		assert.throw(() => whereSchema({
+		expect(() => whereSchema({
 			schema,
 			entity: schema.entities.Article,
-		})(where), 'value at path /title: extra property xx found')
+		})(where)).toThrow('value at path /title: extra property xx found')
 	})
 
 })