test: Improve tests

Author: idirouhab

packages/cli/src/environments.ee/source-control/__tests__/source-control-git.service.test.ts

@@ -124,6 +124,17 @@ describe('SourceControlGitService', () => {
 
 				// Mock the getPrivateKeyPath to return a Windows path
 				mockPreferencesService.getPrivateKeyPath.mockResolvedValue(windowsPath);
+				// Mock getPreferences to return SSH connection type (required for new functionality)
+				mockPreferencesService.getPreferences.mockReturnValue({
+					connectionType: 'ssh',
+					connected: true,
+					repositoryUrl: 'git@github.com:user/repo.git',
+					branchName: 'main',
+					branchReadOnly: false,
+					branchColor: '#5296D6',
+					initRepo: false,
+					keyGeneratorType: 'ed25519',
+				});
 
 				const gitService = new SourceControlGitService(mock(), mock(), mockPreferencesService);
 
@@ -154,6 +165,17 @@ describe('SourceControlGitService', () => {
 
 				// Mock the getPrivateKeyPath to return a path with spaces
 				mockPreferencesService.getPrivateKeyPath.mockResolvedValue(privateKeyPath);
+				// Mock getPreferences to return SSH connection type
+				mockPreferencesService.getPreferences.mockReturnValue({
+					connectionType: 'ssh',
+					connected: true,
+					repositoryUrl: 'git@github.com:user/repo.git',
+					branchName: 'main',
+					branchReadOnly: false,
+					branchColor: '#5296D6',
+					initRepo: false,
+					keyGeneratorType: 'ed25519',
+				});
 
 				const gitService = new SourceControlGitService(mock(), mock(), mockPreferencesService);
 
@@ -187,6 +209,17 @@ describe('SourceControlGitService', () => {
 
 				// Mock the getPrivateKeyPath to return a path with quotes
 				mockPreferencesService.getPrivateKeyPath.mockResolvedValue(pathWithQuotes);
+				// Mock getPreferences to return SSH connection type
+				mockPreferencesService.getPreferences.mockReturnValue({
+					connectionType: 'ssh',
+					connected: true,
+					repositoryUrl: 'git@github.com:user/repo.git',
+					branchName: 'main',
+					branchReadOnly: false,
+					branchColor: '#5296D6',
+					initRepo: false,
+					keyGeneratorType: 'ed25519',
+				});
 
 				const gitService = new SourceControlGitService(mock(), mock(), mockPreferencesService);
 

packages/cli/src/environments.ee/source-control/__tests__/source-control-https.service.ee.test.ts

@@ -6,14 +6,17 @@ import type { SourceControlPreferences } from '../types/source-control-preferenc
 
 // Mock simple-git
 const mockSimpleGit = {
-	env: jest.fn().mockReturnThis(),
+	env: jest.fn(),
 	init: jest.fn().mockResolvedValue(undefined),
 	addRemote: jest.fn().mockResolvedValue(undefined),
 	getRemotes: jest.fn().mockResolvedValue([]),
 };
 
+// Set up chaining for env method
+mockSimpleGit.env.mockReturnValue(mockSimpleGit);
+
 jest.mock('simple-git', () => ({
-	simpleGit: jest.fn().mockImplementation(() => mockSimpleGit),
+	simpleGit: jest.fn().mockReturnValue(mockSimpleGit),
 }));
 
 describe('SourceControlGitService - HTTPS functionality', () => {
@@ -37,10 +40,17 @@ describe('SourceControlGitService - HTTPS functionality', () => {
 
 		jest.spyOn(sourceControlPreferencesService, 'getPreferences').mockReturnValue(mockPreferences);
 		jest.clearAllMocks();
+
+		// Reset the mock chaining after clearAllMocks
+		mockSimpleGit.env.mockReturnValue(mockSimpleGit);
 	});
 
 	afterEach(() => {
-		jest.resetAllMocks();
+		// Don't reset all mocks to preserve simple-git module mock
+		mockSimpleGit.env.mockClear();
+		mockSimpleGit.init.mockClear();
+		mockSimpleGit.addRemote.mockClear();
+		mockSimpleGit.getRemotes.mockClear();
 	});
 
 	describe('setGitSshCommand', () => {

packages/cli/src/environments.ee/source-control/__tests__/source-control-integration.test.ts

@@ -0,0 +1,234 @@
+import { mock } from 'jest-mock-extended';
+
+import { SourceControlService } from '../source-control.service.ee';
+import type { SourceControlGitService } from '../source-control-git.service.ee';
+import type { SourceControlPreferencesService } from '../source-control-preferences.service.ee';
+import type { SourceControlPreferences } from '../types/source-control-preferences';
+
+describe('SourceControl Integration Tests', () => {
+	let sourceControlService: SourceControlService;
+	let mockGitService: SourceControlGitService;
+	let mockPreferencesService: SourceControlPreferencesService;
+
+	beforeEach(() => {
+		mockGitService = mock<SourceControlGitService>();
+		mockPreferencesService = mock<SourceControlPreferencesService>();
+
+		sourceControlService = new SourceControlService(
+			mock(),
+			mockGitService,
+			mockPreferencesService,
+			mock(),
+			mock(),
+			mock(),
+			mock(),
+			mock(),
+			mock(),
+		);
+	});
+
+	describe('HTTPS vs SSH Integration', () => {
+		it('should handle HTTPS connection flow', async () => {
+			// Arrange
+			const httpsPrefs: SourceControlPreferences = {
+				connected: true,
+				repositoryUrl: 'https://github.com/user/repo.git',
+				branchName: 'main',
+				branchReadOnly: false,
+				branchColor: '#5296D6',
+				connectionType: 'https',
+				initRepo: false,
+				keyGeneratorType: 'ed25519',
+			};
+
+			jest.spyOn(mockPreferencesService, 'getPreferences').mockReturnValue(httpsPrefs);
+			jest.spyOn(mockPreferencesService, 'getDecryptedHttpsCredentials').mockResolvedValue({
+				username: 'testuser',
+				password: 'testtoken',
+			});
+
+			// Act & Assert
+			expect(httpsPrefs.connectionType).toBe('https');
+			expect(mockPreferencesService.getPreferences().connectionType).toBe('https');
+		});
+
+		it('should handle SSH connection flow', async () => {
+			// Arrange
+			const sshPrefs: SourceControlPreferences = {
+				connected: true,
+				repositoryUrl: 'git@github.com:user/repo.git',
+				branchName: 'main',
+				branchReadOnly: false,
+				branchColor: '#5296D6',
+				connectionType: 'ssh',
+				initRepo: false,
+				keyGeneratorType: 'ed25519',
+				publicKey: 'ssh-ed25519 AAAAC3NzaC1...',
+			};
+
+			jest.spyOn(mockPreferencesService, 'getPreferences').mockReturnValue(sshPrefs);
+
+			// Act & Assert
+			expect(sshPrefs.connectionType).toBe('ssh');
+			expect(mockPreferencesService.getPreferences().connectionType).toBe('ssh');
+			expect(sshPrefs.publicKey).toBeDefined();
+		});
+	});
+
+	describe('Connection Type Switching', () => {
+		it('should support switching from SSH to HTTPS', () => {
+			// Arrange
+			const initialSSHPrefs: SourceControlPreferences = {
+				connected: false,
+				repositoryUrl: 'git@github.com:user/repo.git',
+				branchName: '',
+				branchReadOnly: false,
+				branchColor: '#5296D6',
+				connectionType: 'ssh',
+				initRepo: false,
+				keyGeneratorType: 'ed25519',
+			};
+
+			const updatedHTTPSPrefs: SourceControlPreferences = {
+				...initialSSHPrefs,
+				repositoryUrl: 'https://github.com/user/repo.git',
+				connectionType: 'https',
+			};
+
+			// Act
+			const isValidTransition =
+				initialSSHPrefs.connectionType === 'ssh' && updatedHTTPSPrefs.connectionType === 'https';
+
+			// Assert
+			expect(isValidTransition).toBe(true);
+			expect(updatedHTTPSPrefs.repositoryUrl.startsWith('https://')).toBe(true);
+		});
+
+		it('should validate repository URL format matches connection type', () => {
+			// Test cases for URL validation
+			const testCases = [
+				{ url: 'https://github.com/user/repo.git', connectionType: 'https', expected: true },
+				{ url: 'git@github.com:user/repo.git', connectionType: 'ssh', expected: true },
+				{ url: 'https://github.com/user/repo.git', connectionType: 'ssh', expected: false },
+				{ url: 'git@github.com:user/repo.git', connectionType: 'https', expected: false },
+			];
+
+			testCases.forEach(({ url, connectionType, expected }) => {
+				const isHTTPSUrl = url.startsWith('https://');
+				const isSSHUrl = url.startsWith('git@') || url.startsWith('ssh://');
+
+				const isValid =
+					(connectionType === 'https' && isHTTPSUrl) || (connectionType === 'ssh' && isSSHUrl);
+
+				expect(isValid).toBe(expected);
+			});
+		});
+	});
+
+	describe('Credential Management', () => {
+		it('should handle HTTPS credentials securely', async () => {
+			// Arrange
+			const credentials = { username: 'testuser', password: 'secret' };
+
+			jest
+				.spyOn(mockPreferencesService, 'getDecryptedHttpsCredentials')
+				.mockResolvedValue(credentials);
+
+			// Act
+			const retrievedCredentials = await mockPreferencesService.getDecryptedHttpsCredentials();
+
+			// Assert
+			expect(retrievedCredentials).toEqual(credentials);
+			expect(mockPreferencesService.getDecryptedHttpsCredentials).toHaveBeenCalled();
+		});
+
+		it('should clean up credentials on disconnect', async () => {
+			// Arrange
+			jest.spyOn(mockPreferencesService, 'deleteHttpsCredentials').mockResolvedValue();
+
+			// Act
+			await mockPreferencesService.deleteHttpsCredentials();
+
+			// Assert
+			expect(mockPreferencesService.deleteHttpsCredentials).toHaveBeenCalled();
+		});
+	});
+
+	describe('URL Encoding and Security', () => {
+		it('should properly encode URLs with credentials', () => {
+			// Arrange
+			const baseUrl = 'https://github.com/user/repo.git';
+			const username = 'user@domain.com';
+			const password = 'p@ssw0rd!';
+
+			// Act
+			const urlWithCredentials = new URL(baseUrl);
+			urlWithCredentials.username = encodeURIComponent(username);
+			urlWithCredentials.password = encodeURIComponent(password);
+			const encodedUrl = urlWithCredentials.toString();
+
+			// Assert
+			expect(encodedUrl).toContain(encodeURIComponent(username));
+			expect(encodedUrl).toContain('github.com/user/repo.git');
+			expect(encodedUrl.startsWith('https://')).toBe(true);
+		});
+
+		it('should normalize URLs for comparison', () => {
+			// Arrange
+			const urlWithCredentials = 'https://user:token@github.com/user/repo.git';
+			const urlWithoutCredentials = 'https://github.com/user/repo.git';
+
+			// Act
+			const normalize = (url: string) => {
+				try {
+					const urlObj = new URL(url);
+					urlObj.username = '';
+					urlObj.password = '';
+					return urlObj.toString();
+				} catch {
+					return url;
+				}
+			};
+
+			const normalized1 = normalize(urlWithCredentials);
+			const normalized2 = normalize(urlWithoutCredentials);
+
+			// Assert
+			expect(normalized1).toBe(normalized2);
+		});
+	});
+
+	describe('Error Handling', () => {
+		it('should handle connection errors gracefully', async () => {
+			// Arrange
+			const error = new Error('Connection failed');
+			jest.spyOn(mockGitService, 'hasRemoteConfigured').mockRejectedValue(error);
+
+			// Act & Assert
+			await expect(mockGitService.hasRemoteConfigured('test-url')).rejects.toThrow(
+				'Connection failed',
+			);
+		});
+
+		it('should handle invalid preferences', () => {
+			// Arrange
+			const invalidPrefs = {
+				connectionType: 'https' as const,
+				repositoryUrl: 'invalid-url',
+			};
+
+			// Act
+			const isValidUrl = (url: string) => {
+				try {
+					new URL(url);
+					return true;
+				} catch {
+					return false;
+				}
+			};
+
+			// Assert
+			expect(isValidUrl(invalidPrefs.repositoryUrl)).toBe(false);
+		});
+	});
+});