@contember/engine-tenant-api 1.4.0-rc.8 → 2.0.0-alpha.8

package/tests/cases/integration/db/invite.test.ts

@@ -1,139 +0,0 @@
-import { testTenantDb } from '../../../src/testTenantDb'
-import { inviteMutation } from '../mocked/gql/invite'
-import { testUuid } from '../../../src/testUuid'
-import { GQL } from '../../../src/tags'
-import { test, assert } from 'vitest'
-
-
-test('admin can invite a user with a membership', testTenantDb(async ({ tester }) => {
-	const languageId = testUuid(555)
-	const result = await tester.execute(
-		inviteMutation({
-			email: 'john@doe.com',
-			projectSlug: 'blog',
-			memberships: [
-				{
-					role: 'editor',
-					variables: [{ name: 'language', values: [languageId] }],
-				},
-			],
-		}),
-	)
-	assert.isOk(result.data.invite.ok)
-	tester.mailer.expectMessage({ subject: 'You have been invited to blog' })
-	const identity = result.data.invite.result.person.identity.id
-	const resultListMembers = await tester.execute(GQL`
-			query {
-				projectBySlug(slug: "blog") {
-					members {
-						identity {
-							id
-						}
-						memberships {
-							role
-							variables {
-								name
-								values
-							}
-						}
-					}
-				}
-			}
-		`)
-	assert.equal(identity, testUuid(5))
-	assert.deepStrictEqual(resultListMembers.data, {
-		projectBySlug: {
-			members: [
-				{
-					identity: {
-						id: testUuid(5),
-					},
-					memberships: [
-						{
-							role: 'editor',
-							variables: [
-								{
-									name: 'language',
-									values: [languageId],
-								},
-							],
-						},
-					],
-				},
-			],
-		},
-	})
-	tester.mailer.expectEmpty()
-}))
-
-test('superEditor can invite a user with a membership', testTenantDb(async ({ tester }) => {
-	const languageId = testUuid(555)
-	const result = await tester.execute(
-		inviteMutation({
-			email: 'john@doe.com',
-			projectSlug: 'blog',
-			memberships: [
-				{
-					role: 'editor',
-					variables: [{ name: 'language', values: [languageId] }],
-				},
-			],
-		}),
-		{
-			membership: {
-				role: 'superEditor',
-				variables: [{ name: 'language', values: [languageId] }],
-			},
-		},
-	)
-	assert.equal(result.data.invite.ok, true)
-}))
-
-test('superEditor cannot invite a user with different variables', testTenantDb(async ({ tester }) => {
-	const languageId = testUuid(555)
-	const languageId2 = testUuid(556)
-	const result = await tester.execute(
-		inviteMutation({
-			email: 'john@doe.com',
-			projectSlug: 'blog',
-			memberships: [
-				{
-					role: 'editor',
-					variables: [{ name: 'language', values: [languageId2] }],
-				},
-			],
-		}),
-		{
-			membership: {
-				role: 'superEditor',
-				variables: [{ name: 'language', values: [languageId] }],
-			},
-			noErrorsCheck: true,
-		},
-	)
-	assert.equal(result.errors[0].message, 'You are not allowed to invite a person')
-}))
-
-test('editor cannot invite a user with a membership', testTenantDb(async ({ tester }) => {
-	const languageId = testUuid(555)
-	const result = await tester.execute(
-		inviteMutation({
-			email: 'john@doe.com',
-			projectSlug: 'blog',
-			memberships: [
-				{
-					role: 'editor',
-					variables: [{ name: 'language', values: [languageId] }],
-				},
-			],
-		}),
-		{
-			membership: {
-				role: 'editor',
-				variables: [{ name: 'language', values: [languageId] }],
-			},
-			noErrorsCheck: true,
-		},
-	)
-	assert.equal(result.errors[0].message, 'You are not allowed to invite a person')
-}))

package/tests/cases/integration/db/resetPassword.test.ts

@@ -1,46 +0,0 @@
-import { signUpMutation } from '../mocked/gql/signUp'
-import { createResetPasswordRequestMutation } from '../mocked/gql/createResetPasswordRequest'
-import { TenantRole } from '../../../../src/model/authorization'
-import { resetPasswordMutation } from '../mocked/gql/resetPassword'
-import { signInMutation } from '../mocked/gql/signIn'
-import { test, assert } from 'vitest'
-import { testTenantDb } from '../../../src/testTenantDb'
-
-test('execute password reset', testTenantDb(async ({ tester }) => {
-	const email = 'john@doe.com'
-	const password = 'foobar'
-
-	const signUpResult = await tester.execute(
-		signUpMutation({
-			email,
-			password: '123456',
-		}),
-		{ roles: [TenantRole.SUPER_ADMIN] },
-	)
-	assert.strictEqual(signUpResult.data.signUp.ok, true)
-	tester.mailer.expectEmpty()
-	const resetRequestResult = await tester.execute(createResetPasswordRequestMutation({ email }), {
-		roles: [TenantRole.LOGIN],
-	})
-	assert.strictEqual(resetRequestResult.data.createResetPasswordRequest.ok, true)
-	const mail = tester.mailer.expectMessage({ subject: 'Password reset' })
-	const matches = mail.html?.toString().match(/<code>(.+)<\/code>/)
-	const token = matches?.[1] as string
-	assert.strictEqual(token, '3030303030303030303030303030303030303030')
-
-	const resetResult = await tester.execute(resetPasswordMutation({ token, password }), {
-		roles: [TenantRole.LOGIN],
-	})
-	assert.strictEqual(resetResult.data.resetPassword.ok, true)
-
-	// used token
-	const resetResult2 = await tester.execute(resetPasswordMutation({ token, password }), {
-		roles: [TenantRole.LOGIN],
-	})
-	assert.strictEqual(resetResult2.data.resetPassword.ok, false)
-
-	const signInResult = await tester.execute(signInMutation({ email, password }), {
-		roles: [TenantRole.LOGIN],
-	})
-	assert.strictEqual(signInResult.data.signIn.ok, true)
-}))

package/tests/cases/integration/db/unmanagedInvite.test.ts

@@ -1,65 +0,0 @@
-import { testUuid } from '../../../src/testUuid'
-import { unmanagedInviteMutation } from '../mocked/gql/unmanagedInvite'
-import { signInMutation } from '../mocked/gql/signIn'
-import { TenantRole } from '../../../../src/model/authorization'
-import { test, assert } from 'vitest'
-import { testTenantDb } from '../../../src/testTenantDb'
-
-test('does not send an email and sets given password', testTenantDb(async ({ tester }) => {
-	const languageId = testUuid(555)
-	const email = 'john@doe.com'
-	const password = 'abcdefg'
-	const result = await tester.execute(
-		unmanagedInviteMutation({
-			email,
-			projectSlug: 'blog',
-			password,
-			memberships: [
-				{
-					role: 'editor',
-					variables: [{ name: 'language', values: [languageId] }],
-				},
-			],
-		}),
-	)
-	assert.deepStrictEqual(result.data.unmanagedInvite, {
-		ok: true,
-		errors: [],
-		result: {
-			person: {
-				id: testUuid(6),
-				identity: {
-					id: testUuid(5),
-				},
-			},
-		},
-	})
-	tester.mailer.expectEmpty()
-	const signInResult = await tester.execute(signInMutation({ email, password }, { withData: true }), {
-		roles: [TenantRole.LOGIN],
-	})
-	assert.deepStrictEqual(signInResult.data.signIn, {
-		ok: true,
-		errors: [],
-		result: {
-			token: '3030303030303030303030303030303030303030',
-			person: {
-				id: result.data.unmanagedInvite.result.person.id,
-				identity: {
-					projects: [
-						{
-							project: {
-								slug: 'blog',
-							},
-							memberships: [
-								{
-									role: 'editor',
-								},
-							],
-						},
-					],
-				},
-			},
-		},
-	})
-}))

package/tests/cases/integration/db/updateRoles.test.ts

@@ -1,74 +0,0 @@
-import { testTenantDb } from '../../../src/testTenantDb'
-import { GQL } from '../../../src/tags'
-import { assert, test } from 'vitest'
-import { signUpMutation } from '../mocked/gql/signUp'
-import { TenantRole } from '../../../../src'
-
-
-test('manage global roles', testTenantDb(async ({ tester }) => {
-	const result = await tester.execute(
-		signUpMutation({
-			email: 'john@doe.com',
-			password: 'abcdxy',
-		}),
-		{
-			roles: [TenantRole.SUPER_ADMIN],
-		},
-	)
-	assert.isOk(result.data.signUp.ok)
-	const identity = result.data.signUp.result.person.identity.id
-	assert.deepStrictEqual(result.data.signUp.result.person.identity.roles, [TenantRole.PERSON])
-
-	const resultAddRole = await tester.execute(GQL`
-			mutation {
-				addGlobalIdentityRoles(identityId: "${identity}", roles: ["project_admin", "super_admin"]) {
-					ok
-					result {
-						identity {
-							roles
-						}
-					}
-				}
-			}
-		`, {
-		roles: [TenantRole.SUPER_ADMIN],
-	})
-
-	assert.deepStrictEqual(resultAddRole.data, {
-		addGlobalIdentityRoles: {
-			ok: true,
-			result: {
-				identity: {
-					roles: [TenantRole.PERSON, TenantRole.PROJECT_ADMIN, TenantRole.SUPER_ADMIN],
-				},
-			},
-		},
-	})
-
-
-	const resultRemoveRole = await tester.execute(GQL`
-			mutation {
-				removeGlobalIdentityRoles(identityId: "${identity}", roles: ["project_admin", "super_admin"]) {
-					ok
-					result {
-						identity {
-							roles
-						}
-					}
-				}
-			}
-		`, {
-		roles: [TenantRole.SUPER_ADMIN],
-	})
-
-	assert.deepStrictEqual(resultRemoveRole.data, {
-		removeGlobalIdentityRoles: {
-			ok: true,
-			result: {
-				identity: {
-					roles: [TenantRole.PERSON],
-				},
-			},
-		},
-	})
-}))

package/vite.config.js

@@ -1,3 +0,0 @@
-import { createViteConfig } from '../../scripts/vite/createViteConfig'
-
-export default createViteConfig()