first commit

packages/cli/test/integration/database/repositories/scope.repository.test.ts

@@ -0,0 +1,488 @@
+import { testDb } from '@n8n/backend-test-utils';
+import { type Scope, ScopeRepository } from '@n8n/db';
+import { Container } from '@n8n/di';
+import type { Scope as ScopeType } from '@n8n/permissions';
+
+import { createScope, createScopes, createTestScopes } from '../../shared/db/roles';
+
+describe('ScopeRepository', () => {
+	let scopeRepository: ScopeRepository;
+
+	beforeAll(async () => {
+		await testDb.init();
+		scopeRepository = Container.get(ScopeRepository);
+	});
+
+	beforeEach(async () => {
+		// Truncate in the correct order to respect foreign key constraints
+		// user table references role via roleSlug
+		// project_relation references role
+		// role_scope references scope, so truncate it first
+		await testDb.truncate(['User', 'ProjectRelation', 'Role', 'Scope']);
+	});
+
+	afterAll(async () => {
+		await testDb.terminate();
+	});
+
+	describe('findByList()', () => {
+		describe('successful queries', () => {
+			it('should return empty array when given empty slug array', async () => {
+				//
+				// ARRANGE
+				//
+				await createTestScopes(); // Create some scopes but don't query for them
+
+				//
+				// ACT
+				//
+				const scopes = await scopeRepository.findByList([]);
+
+				//
+				// ASSERT
+				//
+				expect(scopes).toEqual([]);
+			});
+
+			it('should return empty array when no scopes exist', async () => {
+				//
+				// ARRANGE & ACT
+				//
+				const scopes = await scopeRepository.findByList(['non-existent:scope']);
+
+				//
+				// ASSERT
+				//
+				expect(scopes).toEqual([]);
+			});
+
+			it('should return single scope when one slug matches', async () => {
+				//
+				// ARRANGE
+				//
+				const { readScope } = await createTestScopes();
+
+				//
+				// ACT
+				//
+				const scopes = await scopeRepository.findByList([readScope.slug]);
+
+				//
+				// ASSERT
+				//
+				expect(scopes).toHaveLength(1);
+				expect(scopes[0]).toEqual(
+					expect.objectContaining({
+						slug: readScope.slug,
+						displayName: readScope.displayName,
+						description: readScope.description,
+					}),
+				);
+			});
+
+			it('should return multiple scopes when multiple slugs match', async () => {
+				//
+				// ARRANGE
+				//
+				const { readScope, writeScope, deleteScope, adminScope } = await createTestScopes();
+
+				//
+				// ACT
+				//
+				const scopes = await scopeRepository.findByList([
+					readScope.slug,
+					writeScope.slug,
+					deleteScope.slug,
+				]);
+
+				//
+				// ASSERT
+				//
+				expect(scopes).toHaveLength(3);
+				expect(scopes).toEqual(
+					expect.arrayContaining([
+						expect.objectContaining({ slug: readScope.slug }),
+						expect.objectContaining({ slug: writeScope.slug }),
+						expect.objectContaining({ slug: deleteScope.slug }),
+					]),
+				);
+
+				// Verify adminScope is NOT included
+				expect(scopes.find((s) => s.slug === adminScope.slug)).toBeUndefined();
+			});
+
+			it('should return all existing scopes when all slugs match', async () => {
+				//
+				// ARRANGE
+				//
+				const { readScope, writeScope, deleteScope, adminScope } = await createTestScopes();
+
+				//
+				// ACT
+				//
+				const scopes = await scopeRepository.findByList([
+					readScope.slug,
+					writeScope.slug,
+					deleteScope.slug,
+					adminScope.slug,
+				]);
+
+				//
+				// ASSERT
+				//
+				expect(scopes).toHaveLength(4);
+				expect(scopes).toEqual(
+					expect.arrayContaining([
+						expect.objectContaining({ slug: readScope.slug }),
+						expect.objectContaining({ slug: writeScope.slug }),
+						expect.objectContaining({ slug: deleteScope.slug }),
+						expect.objectContaining({ slug: adminScope.slug }),
+					]),
+				);
+			});
+		});
+
+		describe('partial matches', () => {
+			it('should return only existing scopes when some slugs do not exist', async () => {
+				//
+				// ARRANGE
+				//
+				const { readScope, writeScope } = await createTestScopes();
+
+				//
+				// ACT
+				//
+				const scopes = await scopeRepository.findByList([
+					readScope.slug,
+					'non-existent:scope:1' as ScopeType,
+					writeScope.slug,
+					'non-existent:scope:2' as ScopeType,
+				]);
+
+				//
+				// ASSERT
+				//
+				expect(scopes).toHaveLength(2);
+				expect(scopes).toEqual(
+					expect.arrayContaining([
+						expect.objectContaining({ slug: readScope.slug }),
+						expect.objectContaining({ slug: writeScope.slug }),
+					]),
+				);
+			});
+
+			it('should return empty array when none of the slugs exist', async () => {
+				//
+				// ARRANGE
+				//
+				await createTestScopes(); // Create scopes but don't query for them
+
+				//
+				// ACT
+				//
+				const scopes = await scopeRepository.findByList([
+					'non-existent:scope:1' as ScopeType,
+					'non-existent:scope:2' as ScopeType,
+					'non-existent:scope:3' as ScopeType,
+				]);
+
+				//
+				// ASSERT
+				//
+				expect(scopes).toEqual([]);
+			});
+		});
+
+		describe('duplicate handling', () => {
+			it('should return each scope only once when slug array contains duplicates', async () => {
+				//
+				// ARRANGE
+				//
+				const { readScope, writeScope } = await createTestScopes();
+
+				//
+				// ACT
+				//
+				const scopes = await scopeRepository.findByList([
+					readScope.slug,
+					writeScope.slug,
+					readScope.slug, // Duplicate
+					writeScope.slug, // Duplicate
+					readScope.slug, // Another duplicate
+				]);
+
+				//
+				// ASSERT
+				//
+				expect(scopes).toHaveLength(2);
+				expect(scopes).toEqual(
+					expect.arrayContaining([
+						expect.objectContaining({ slug: readScope.slug }),
+						expect.objectContaining({ slug: writeScope.slug }),
+					]),
+				);
+
+				// Verify no duplicates in result
+				const slugs = scopes.map((s) => s.slug);
+				const uniqueSlugs = [...new Set(slugs)];
+				expect(slugs).toEqual(uniqueSlugs);
+			});
+
+			it('should handle mix of valid, invalid, and duplicate slugs', async () => {
+				//
+				// ARRANGE
+				//
+				const { readScope } = await createTestScopes();
+
+				//
+				// ACT
+				//
+				const scopes = await scopeRepository.findByList([
+					readScope.slug,
+					'invalid:scope:1' as ScopeType,
+					readScope.slug, // Duplicate valid
+					'invalid:scope:2' as ScopeType,
+					'invalid:scope:1' as ScopeType, // Duplicate invalid
+					readScope.slug, // Another duplicate valid
+				]);
+
+				//
+				// ASSERT
+				//
+				expect(scopes).toHaveLength(1);
+				expect(scopes[0]).toEqual(expect.objectContaining({ slug: readScope.slug }));
+			});
+		});
+
+		describe('large datasets', () => {
+			it('should handle querying for many scopes efficiently', async () => {
+				//
+				// ARRANGE
+				//
+				const createdScopes = await createScopes(50, { description: 'Bulk test scope' });
+				const slugsToQuery = createdScopes.slice(0, 25).map((s) => s.slug);
+
+				//
+				// ACT
+				//
+				const startTime = Date.now();
+				const scopes = await scopeRepository.findByList(slugsToQuery);
+				const endTime = Date.now();
+
+				//
+				// ASSERT
+				//
+				expect(scopes).toHaveLength(25);
+				expect(endTime - startTime).toBeLessThan(1000); // Should complete within 1 second
+
+				// Verify all requested scopes are returned
+				const returnedSlugs = scopes.map((s) => s.slug).sort();
+				const expectedSlugs = slugsToQuery.sort();
+				expect(returnedSlugs).toEqual(expectedSlugs);
+			});
+
+			it('should maintain data integrity with complex scope structures', async () => {
+				//
+				// ARRANGE
+				//
+				const complexScopes = await Promise.all([
+					createScope({
+						slug: 'complex:scope:with:colons' as ScopeType,
+						displayName: 'Complex Scope With Colons',
+						description: 'A scope with multiple colons in the slug',
+					}),
+					createScope({
+						slug: 'scope-with-dashes' as ScopeType,
+						displayName: 'Scope With Dashes',
+						description: 'A scope with dashes',
+					}),
+					createScope({
+						slug: 'scope_with_underscores' as ScopeType,
+						displayName: 'Scope With Underscores',
+						description: 'A scope with underscores',
+					}),
+				]);
+
+				const slugsToQuery = complexScopes.map((s) => s.slug);
+
+				//
+				// ACT
+				//
+				const scopes = await scopeRepository.findByList(slugsToQuery);
+
+				//
+				// ASSERT
+				//
+				expect(scopes).toHaveLength(3);
+
+				for (const originalScope of complexScopes) {
+					const foundScope = scopes.find((s) => s.slug === originalScope.slug);
+					expect(foundScope).toBeDefined();
+					expect(foundScope!.displayName).toBe(originalScope.displayName);
+					expect(foundScope!.description).toBe(originalScope.description);
+				}
+			});
+		});
+
+		describe('edge cases and validation', () => {
+			it('should handle null and undefined values gracefully', async () => {
+				//
+				// ARRANGE
+				//
+				const scope = await createScope({
+					slug: 'scope-with-nulls' as ScopeType,
+					displayName: null,
+					description: null,
+				});
+
+				//
+				// ACT
+				//
+				const scopes = await scopeRepository.findByList([scope.slug]);
+
+				//
+				// ASSERT
+				//
+				expect(scopes).toHaveLength(1);
+				expect(scopes[0].slug).toBe(scope.slug);
+				expect(scopes[0].displayName).toBeNull();
+				expect(scopes[0].description).toBeNull();
+			});
+
+			it('should preserve order consistency across multiple queries', async () => {
+				//
+				// ARRANGE
+				//
+				const { readScope, writeScope, deleteScope, adminScope } = await createTestScopes();
+				const slugsToQuery = [adminScope.slug, readScope.slug, deleteScope.slug, writeScope.slug];
+
+				//
+				// ACT
+				//
+				const scopes1 = await scopeRepository.findByList(slugsToQuery);
+				const scopes2 = await scopeRepository.findByList(slugsToQuery);
+				const scopes3 = await scopeRepository.findByList(slugsToQuery);
+
+				//
+				// ASSERT
+				//
+				expect(scopes1).toHaveLength(4);
+				expect(scopes2).toHaveLength(4);
+				expect(scopes3).toHaveLength(4);
+
+				// All queries should return the same scopes (though order may vary due to SQL implementation)
+				const getSortedSlugs = (scopeList: Scope[]) => scopeList.map((s) => s.slug).sort();
+
+				expect(getSortedSlugs(scopes1)).toEqual(getSortedSlugs(scopes2));
+				expect(getSortedSlugs(scopes2)).toEqual(getSortedSlugs(scopes3));
+			});
+
+			it('should verify database state remains consistent after queries', async () => {
+				//
+				// ARRANGE
+				//
+				const { readScope, writeScope } = await createTestScopes();
+
+				//
+				// ACT
+				//
+				const scopesBefore = await scopeRepository.find();
+				await scopeRepository.findByList([readScope.slug, writeScope.slug]);
+				const scopesAfter = await scopeRepository.find();
+
+				//
+				// ASSERT
+				//
+				expect(scopesBefore).toHaveLength(4); // readScope, writeScope, deleteScope, adminScope
+				expect(scopesAfter).toHaveLength(4);
+				expect(scopesBefore.map((s) => s.slug).sort()).toEqual(
+					scopesAfter.map((s) => s.slug).sort(),
+				);
+
+				// Verify specific scopes are unchanged
+				const readScopeBefore = scopesBefore.find((s) => s.slug === readScope.slug);
+				const readScopeAfter = scopesAfter.find((s) => s.slug === readScope.slug);
+				expect(readScopeBefore).toEqual(readScopeAfter);
+			});
+		});
+	});
+
+	describe('findByListOrFail()', () => {
+		describe('success path', () => {
+			it('should return empty array when given empty slug array', async () => {
+				await createTestScopes();
+
+				const scopes = await scopeRepository.findByListOrFail([]);
+
+				expect(scopes).toEqual([]);
+			});
+
+			it('should return single scope when one slug matches', async () => {
+				const { readScope } = await createTestScopes();
+
+				const scopes = await scopeRepository.findByListOrFail([readScope.slug]);
+
+				expect(scopes).toHaveLength(1);
+				expect(scopes[0]).toEqual(
+					expect.objectContaining({
+						slug: readScope.slug,
+						displayName: readScope.displayName,
+						description: readScope.description,
+					}),
+				);
+			});
+
+			it('should return multiple scopes when multiple slugs match', async () => {
+				const { readScope, writeScope, deleteScope } = await createTestScopes();
+
+				const scopes = await scopeRepository.findByListOrFail([
+					readScope.slug,
+					writeScope.slug,
+					deleteScope.slug,
+				]);
+
+				expect(scopes).toHaveLength(3);
+				expect(scopes).toEqual(
+					expect.arrayContaining([
+						expect.objectContaining({ slug: readScope.slug }),
+						expect.objectContaining({ slug: writeScope.slug }),
+						expect.objectContaining({ slug: deleteScope.slug }),
+					]),
+				);
+			});
+		});
+
+		describe('error path (invalid scopes)', () => {
+			it('should throw when one slug does not exist', async () => {
+				await createTestScopes();
+
+				await expect(
+					scopeRepository.findByListOrFail(['non-existent:scope' as ScopeType]),
+				).rejects.toThrow('The following scopes are invalid: non-existent:scope');
+			});
+
+			it('should throw when some slugs do not exist and list invalid scopes in message', async () => {
+				const { readScope } = await createTestScopes();
+
+				await expect(
+					scopeRepository.findByListOrFail([
+						readScope.slug,
+						'non-existent:1' as ScopeType,
+						'non-existent:2' as ScopeType,
+					]),
+				).rejects.toThrow('The following scopes are invalid: non-existent:1, non-existent:2');
+			});
+
+			it('should throw when all slugs do not exist', async () => {
+				await createTestScopes();
+
+				await expect(
+					scopeRepository.findByListOrFail([
+						'non-existent:1' as ScopeType,
+						'non-existent:2' as ScopeType,
+					]),
+				).rejects.toThrow('The following scopes are invalid: non-existent:1, non-existent:2');
+			});
+		});
+	});
+});