test: Add credential helper and ndv helper (#18636)

packages/testing/playwright/tests/ui/credential-api-operations.spec.ts

@@ -0,0 +1,195 @@
+import type { CreateCredentialDto } from '@n8n/api-types';
+
+import { test, expect } from '../../fixtures/base';
+
+test.describe('Credential API Operations', () => {
+	test.describe('Basic CRUD Operations', () => {
+		test('should create, retrieve, update, and delete credential', async ({ api }) => {
+			const credentialData: CreateCredentialDto = {
+				name: 'Test HTTP Basic Auth',
+				type: 'httpBasicAuth',
+				data: {
+					user: 'test_user',
+					password: 'test_password',
+				},
+			};
+
+			const { credentialId, createdCredential } =
+				await api.credentialApi.createCredentialFromDefinition(credentialData);
+
+			expect(credentialId).toBeTruthy();
+			expect(createdCredential.type).toBe('httpBasicAuth');
+			expect(createdCredential.name).toContain('Test HTTP Basic Auth (Test');
+
+			const retrievedCredential = await api.credentialApi.getCredential(credentialId);
+			expect(retrievedCredential.id).toBe(credentialId);
+			expect(retrievedCredential.type).toBe('httpBasicAuth');
+			expect(retrievedCredential.name).toBe(createdCredential.name);
+
+			const credentialWithData = await api.credentialApi.getCredential(credentialId, {
+				includeData: true,
+			});
+			expect(credentialWithData.data).toBeDefined();
+			expect(credentialWithData.data?.user).toBe('test_user');
+
+			const updatedName = 'Updated HTTP Basic Auth';
+			const updatedCredential = await api.credentialApi.updateCredential(credentialId, {
+				name: updatedName,
+				data: {
+					user: 'updated_user',
+					password: 'updated_password',
+				},
+			});
+			expect(updatedCredential.name).toBe(updatedName);
+
+			const verifyUpdated = await api.credentialApi.getCredential(credentialId, {
+				includeData: true,
+			});
+			expect(verifyUpdated.name).toBe(updatedName);
+			expect(verifyUpdated.data?.user).toBe('updated_user');
+
+			const deleteResult = await api.credentialApi.deleteCredential(credentialId);
+			expect(deleteResult).toBe(true);
+
+			await expect(api.credentialApi.getCredential(credentialId)).rejects.toThrow();
+		});
+	});
+
+	test.describe('Credential Listing', () => {
+		test('should list credentials with different query options', async ({ api }) => {
+			const credential1 = await api.credentialApi.createCredentialFromDefinition({
+				name: 'First Test Credential',
+				type: 'httpBasicAuth',
+				data: { user: 'user1', password: 'pass1' },
+			});
+
+			const credential2 = await api.credentialApi.createCredentialFromDefinition({
+				name: 'Second Test Credential',
+				type: 'httpHeaderAuth',
+				data: { name: 'Authorization', value: 'Bearer token' },
+			});
+
+			const allCredentials = await api.credentialApi.getCredentials();
+			expect(allCredentials.length).toBeGreaterThanOrEqual(2);
+
+			const createdIds = [credential1.credentialId, credential2.credentialId];
+			const foundCredentials = allCredentials.filter((c) => createdIds.includes(c.id));
+			expect(foundCredentials).toHaveLength(2);
+
+			const credentialsWithScopes = await api.credentialApi.getCredentials({
+				includeScopes: true,
+			});
+			expect(credentialsWithScopes[0].scopes).toBeDefined();
+			expect(Array.isArray(credentialsWithScopes[0].scopes)).toBe(true);
+
+			const credentialsWithData = await api.credentialApi.getCredentials({
+				includeData: true,
+			});
+			const foundWithData = credentialsWithData.filter((c) => createdIds.includes(c.id));
+			expect(foundWithData.some((c) => c.data)).toBe(true);
+		});
+	});
+
+	test.describe('Project Integration', () => {
+		test('should handle credential-project associations', async ({ api }) => {
+			await api.enableFeature('projectRole:admin');
+			await api.enableFeature('projectRole:editor');
+			await api.setMaxTeamProjectsQuota(-1);
+
+			const project = await api.projectApi.createProject('Test Project for Credentials');
+
+			const credential = await api.credentialApi.createCredentialFromDefinition({
+				name: 'Project Credential',
+				type: 'httpBasicAuth',
+				data: { user: 'user', password: 'pass' },
+				projectId: project.id,
+			});
+
+			const projectCredentials = await api.credentialApi.getCredentialsForWorkflow({
+				projectId: project.id,
+			});
+
+			expect(projectCredentials).toBeDefined();
+			expect(Array.isArray(projectCredentials)).toBe(true);
+
+			const foundCredential = projectCredentials.find((c) => c.id === credential.credentialId);
+			expect(foundCredential).toBeDefined();
+		});
+
+		test('should transfer credential between projects', async ({ api }) => {
+			await api.enableFeature('projectRole:admin');
+			await api.enableFeature('projectRole:editor');
+			await api.setMaxTeamProjectsQuota(-1);
+
+			const sourceProject = await api.projectApi.createProject('Source Project');
+			const destinationProject = await api.projectApi.createProject('Destination Project');
+
+			const credential = await api.credentialApi.createCredentialFromDefinition({
+				name: 'Transfer Test Credential',
+				type: 'httpBasicAuth',
+				data: { user: 'user', password: 'pass' },
+				projectId: sourceProject.id,
+			});
+
+			const sourceCredentials = await api.credentialApi.getCredentialsForWorkflow({
+				projectId: sourceProject.id,
+			});
+			const foundInSource = sourceCredentials.find((c) => c.id === credential.credentialId);
+			expect(foundInSource).toBeDefined();
+
+			await api.credentialApi.transferCredential(credential.credentialId, destinationProject.id);
+
+			const destinationCredentials = await api.credentialApi.getCredentialsForWorkflow({
+				projectId: destinationProject.id,
+			});
+			const foundInDestination = destinationCredentials.find(
+				(c) => c.id === credential.credentialId,
+			);
+			expect(foundInDestination).toBeDefined();
+
+			const sourceCredentialsAfter = await api.credentialApi.getCredentialsForWorkflow({
+				projectId: sourceProject.id,
+			});
+			const stillInSource = sourceCredentialsAfter.find((c) => c.id === credential.credentialId);
+			expect(stillInSource).toBeUndefined();
+		});
+	});
+
+	test.describe('Data Persistence', () => {
+		test('should maintain credential data across operations', async ({ api }) => {
+			const originalData: CreateCredentialDto = {
+				name: 'Persistence Test Credential',
+				type: 'httpBasicAuth',
+				data: {
+					user: 'persistent_user',
+					password: 'persistent_password',
+				},
+			};
+
+			const { credentialId } = await api.credentialApi.createCredentialFromDefinition(originalData);
+
+			const afterCreate = await api.credentialApi.getCredential(credentialId, {
+				includeData: true,
+			});
+			expect(afterCreate.data?.user).toBe('persistent_user');
+
+			await api.credentialApi.updateCredential(credentialId, {
+				data: {
+					user: 'updated_persistent_user',
+					password: 'updated_persistent_password',
+				},
+			});
+
+			const afterUpdate = await api.credentialApi.getCredential(credentialId, {
+				includeData: true,
+			});
+			expect(afterUpdate.data?.user).toBe('updated_persistent_user');
+			expect(afterUpdate.data?.password).toBeDefined();
+
+			const allCredentials = await api.credentialApi.getCredentials();
+			const foundCredential = allCredentials.find((c) => c.id === credentialId);
+			expect(foundCredential).toBeDefined();
+			expect(foundCredential!.type).toBe('httpBasicAuth');
+		});
+	});
+});