added tests for coverage

Author: sn2912

src/atlclients/strategyCrypto.test.ts

@@ -0,0 +1,150 @@
+// Mock crypto module at the top
+class MockHash {
+    private data: string = '';
+
+    update(data: any): this {
+        this.data += data.toString();
+        return this;
+    }
+
+    digest(): Buffer {
+        // Return a predictable hash for testing
+        const hash = Buffer.alloc(32);
+        for (let i = 0; i < 32; i++) {
+            hash[i] = (this.data.charCodeAt(i % this.data.length) + i) % 256;
+        }
+        return hash;
+    }
+}
+
+jest.mock('crypto', () => ({
+    default: {
+        createHash: () => new MockHash(),
+        randomBytes: (size: number) => {
+            // Return predictable bytes for testing
+            const buffer = Buffer.alloc(size);
+            for (let i = 0; i < size; i++) {
+                buffer[i] = i % 256;
+            }
+            return buffer;
+        },
+    },
+}));
+
+import { base64URLEncode, basicAuth, createVerifier, sha256 } from './strategyCrypto';
+
+describe('strategyCrypto', () => {
+    describe('basicAuth', () => {
+        it('should create basic auth string with username and password', () => {
+            const result = basicAuth('testuser', 'testpass');
+            expect(result).toBe('Basic dGVzdHVzZXI6dGVzdHBhc3M=');
+        });
+
+        it('should handle empty username and password', () => {
+            const result = basicAuth('', '');
+            expect(result).toBe('Basic Og==');
+        });
+
+        it('should handle special characters in username and password', () => {
+            const result = basicAuth('[email protected]', 'p@ssw0rd!');
+            expect(result).toBe('Basic dXNlckBkb21haW4uY29tOnBAc3N3MHJkIQ==');
+        });
+
+        it('should handle unicode characters', () => {
+            const result = basicAuth('用户', '密码');
+            expect(result).toContain('Basic ');
+            expect(result.length).toBeGreaterThan('Basic '.length);
+        });
+    });
+
+    describe('base64URLEncode', () => {
+        it('should encode buffer to base64 URL safe string', () => {
+            const buffer = Buffer.from('hello world');
+            const result = base64URLEncode(buffer);
+            expect(result).toBe('aGVsbG8gd29ybGQ');
+        });
+
+        it('should replace URL unsafe characters', () => {
+            // Create a buffer that will have + and / characters in base64
+            const buffer = Buffer.from('hello>world?test');
+            const result = base64URLEncode(buffer);
+            expect(result).not.toContain('+');
+            expect(result).not.toContain('/');
+            expect(result).not.toContain('=');
+        });
+
+        it('should handle empty buffer', () => {
+            const buffer = Buffer.from('');
+            const result = base64URLEncode(buffer);
+            expect(result).toBe('');
+        });
+
+        it('should handle binary data', () => {
+            const buffer = Buffer.from([0x00, 0x01, 0x02, 0x03, 0xff]);
+            const result = base64URLEncode(buffer);
+            expect(result).toBe('AAECA_8'); // Corrected expected value
+        });
+    });
+
+    describe('sha256', () => {
+        it('should create sha256 hash from string', () => {
+            const result = sha256('hello world');
+            expect(result).toBeInstanceOf(Buffer);
+            expect(result.length).toBe(32); // SHA256 produces 32 bytes
+        });
+
+        it('should create sha256 hash from buffer', () => {
+            const buffer = Buffer.from('test data');
+            const result = sha256(buffer);
+            expect(result).toBeInstanceOf(Buffer);
+            expect(result.length).toBe(32);
+        });
+
+        it('should produce consistent hash for same input', () => {
+            const input = 'consistent input';
+            const result1 = sha256(input);
+            const result2 = sha256(input);
+            expect(result1.equals(result2)).toBe(true);
+        });
+
+        it('should produce different hashes for different inputs', () => {
+            const result1 = sha256('input1');
+            const result2 = sha256('input2');
+            expect(result1.equals(result2)).toBe(false);
+        });
+
+        it('should handle empty string', () => {
+            const result = sha256('');
+            expect(result).toBeInstanceOf(Buffer);
+            expect(result.length).toBe(32);
+        });
+    });
+
+    describe('createVerifier', () => {
+        it('should create a verifier string', () => {
+            const result = createVerifier();
+            expect(typeof result).toBe('string');
+            expect(result.length).toBeGreaterThan(0);
+        });
+
+        it('should create consistent verifiers with mocked crypto', () => {
+            const result1 = createVerifier();
+            const result2 = createVerifier();
+            // With our mock, results should be the same
+            expect(result1).toBe(result2);
+        });
+
+        it('should create URL-safe verifier string', () => {
+            const result = createVerifier();
+            expect(result).not.toContain('+');
+            expect(result).not.toContain('/');
+            expect(result).not.toContain('=');
+        });
+
+        it('should create verifier of expected length', () => {
+            const result = createVerifier();
+            // 32 bytes base64URL encoded should be 43 characters (without padding)
+            expect(result.length).toBe(43);
+        });
+    });
+});

src/bitbucket/bbUtils.test.ts

@@ -0,0 +1,46 @@
+import { encodePathParts } from './bbUtils';
+
+describe('bbUtils', () => {
+    describe('encodePathParts', () => {
+        it('should encode path parts with special characters', () => {
+            const path = 'folder/sub folder/file with spaces.txt';
+            const result = encodePathParts(path);
+            expect(result).toBe('folder/sub%20folder/file%20with%20spaces.txt');
+        });
+
+        it('should handle paths with special URL characters', () => {
+            const path = 'folder/sub&folder/file?param=value.txt';
+            const result = encodePathParts(path);
+            expect(result).toBe('folder/sub%26folder/file%3Fparam%3Dvalue.txt');
+        });
+
+        it('should handle empty path parts', () => {
+            const path = 'folder//subfolder';
+            const result = encodePathParts(path);
+            expect(result).toBe('folder//subfolder');
+        });
+
+        it('should handle single folder name', () => {
+            const path = 'folder name';
+            const result = encodePathParts(path);
+            expect(result).toBe('folder%20name');
+        });
+
+        it('should handle empty string', () => {
+            const path = '';
+            const result = encodePathParts(path);
+            expect(result).toBe('');
+        });
+
+        it('should handle null/undefined input', () => {
+            expect(encodePathParts(null as any)).toBe(undefined);
+            expect(encodePathParts(undefined as any)).toBe(undefined);
+        });
+
+        it('should handle paths with unicode characters', () => {
+            const path = 'folder/测试文件/файл.txt';
+            const result = encodePathParts(path);
+            expect(result).toBe('folder/%E6%B5%8B%E8%AF%95%E6%96%87%E4%BB%B6/%D1%84%D0%B0%D0%B9%D0%BB.txt');
+        });
+    });
+});

src/config/devsphereConfigurationManager.test.ts

@@ -0,0 +1,188 @@
+import * as vscode from 'vscode';
+
+import {
+    DevsphereConfigurationManager,
+    executeVSCodeCommand,
+    getDefaultLifecycleFns,
+    LifecycleFns,
+    updateConfig,
+    View,
+} from './devsphere-config/devsphereConfigurationManager';
+
+// Mock vscode module
+jest.mock('vscode', () => ({
+    commands: {
+        executeCommand: jest.fn(),
+    },
+    workspace: {
+        getConfiguration: jest.fn(),
+    },
+}));
+
+describe('executeVSCodeCommand', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should execute command successfully', async () => {
+        const mockExecuteCommand = vscode.commands.executeCommand as jest.Mock;
+        mockExecuteCommand.mockResolvedValue(undefined);
+
+        await executeVSCodeCommand('test.command');
+
+        expect(mockExecuteCommand).toHaveBeenCalledWith('test.command');
+    });
+
+    it('should handle command execution error and log it', async () => {
+        const mockExecuteCommand = vscode.commands.executeCommand as jest.Mock;
+        const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+        const error = new Error('Command failed');
+        mockExecuteCommand.mockRejectedValue(error);
+
+        await executeVSCodeCommand('test.command');
+
+        expect(consoleErrorSpy).toHaveBeenCalledWith('Failed to execute VS Code command: test.command', error);
+
+        consoleErrorSpy.mockRestore();
+    });
+});
+
+describe('updateConfig', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should update config when value is different', async () => {
+        const mockGetConfiguration = vscode.workspace.getConfiguration as jest.Mock;
+        const mockGet = jest.fn().mockReturnValue('oldValue');
+        const mockUpdate = jest.fn().mockResolvedValue(undefined);
+
+        mockGetConfiguration.mockReturnValue({
+            get: mockGet,
+            update: mockUpdate,
+        });
+
+        await updateConfig('testSection', 'testKey', 'newValue');
+
+        expect(mockGetConfiguration).toHaveBeenCalledWith('testSection');
+        expect(mockGet).toHaveBeenCalledWith('testKey');
+        expect(mockUpdate).toHaveBeenCalledWith('testKey', 'newValue', true);
+    });
+
+    it('should not update config when value is the same', async () => {
+        const mockGetConfiguration = vscode.workspace.getConfiguration as jest.Mock;
+        const mockGet = jest.fn().mockReturnValue('sameValue');
+        const mockUpdate = jest.fn();
+
+        mockGetConfiguration.mockReturnValue({
+            get: mockGet,
+            update: mockUpdate,
+        });
+
+        await updateConfig('testSection', 'testKey', 'sameValue');
+
+        expect(mockGetConfiguration).toHaveBeenCalledWith('testSection');
+        expect(mockGet).toHaveBeenCalledWith('testKey');
+        expect(mockUpdate).not.toHaveBeenCalled();
+    });
+});
+
+describe('getDefaultLifecycleFns', () => {
+    it('should return default lifecycle functions', () => {
+        const lifecycle = getDefaultLifecycleFns();
+
+        expect(lifecycle).toHaveProperty('setup');
+        expect(lifecycle).toHaveProperty('shutdown');
+        expect(typeof lifecycle.setup).toBe('function');
+        expect(typeof lifecycle.shutdown).toBe('function');
+    });
+
+    it('should have setup function that resolves', async () => {
+        const lifecycle = getDefaultLifecycleFns();
+        await expect(lifecycle.setup()).resolves.toBeUndefined();
+    });
+
+    it('should have shutdown function that resolves', async () => {
+        const lifecycle = getDefaultLifecycleFns();
+        await expect(lifecycle.shutdown()).resolves.toBeUndefined();
+    });
+});
+
+describe('DevsphereConfigurationManager', () => {
+    let manager: DevsphereConfigurationManager;
+    let mockLifecycleFns: Record<View, LifecycleFns>;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+
+        mockLifecycleFns = {
+            [View.Noop]: {
+                setup: jest.fn().mockResolvedValue(undefined),
+                shutdown: jest.fn().mockResolvedValue(undefined),
+            },
+            [View.Review]: {
+                setup: jest.fn().mockResolvedValue(undefined),
+                shutdown: jest.fn().mockResolvedValue(undefined),
+            },
+        };
+
+        manager = new DevsphereConfigurationManager(mockLifecycleFns);
+    });
+
+    describe('constructor', () => {
+        it('should create instance successfully', () => {
+            expect(manager).toBeInstanceOf(DevsphereConfigurationManager);
+        });
+    });
+
+    describe('dispose', () => {
+        it('should dispose and reset lifecycle functions', () => {
+            manager.dispose();
+
+            // After dispose, the manager should work but with default lifecycle functions
+            expect(manager).toBeInstanceOf(DevsphereConfigurationManager);
+        });
+    });
+
+    describe('setupView', () => {
+        it('should setup new view and shutdown old one', async () => {
+            await manager.setupView(View.Review);
+
+            expect(mockLifecycleFns[View.Noop].shutdown).toHaveBeenCalled();
+            expect(mockLifecycleFns[View.Review].setup).toHaveBeenCalled();
+        });
+
+        it('should not change view if same view is requested', async () => {
+            await manager.setupView(View.Noop);
+
+            expect(mockLifecycleFns[View.Noop].shutdown).not.toHaveBeenCalled();
+            expect(mockLifecycleFns[View.Noop].setup).not.toHaveBeenCalled();
+        });
+
+        it('should handle shutdown error gracefully', async () => {
+            const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+            const shutdownError = new Error('Shutdown failed');
+            (mockLifecycleFns[View.Noop].shutdown as jest.Mock).mockRejectedValue(shutdownError);
+
+            await manager.setupView(View.Review);
+
+            expect(consoleErrorSpy).toHaveBeenCalledWith('Failed to shutdown view: noop', shutdownError);
+            expect(mockLifecycleFns[View.Review].setup).toHaveBeenCalled();
+
+            consoleErrorSpy.mockRestore();
+        });
+
+        it('should handle setup error gracefully', async () => {
+            const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+            const setupError = new Error('Setup failed');
+            (mockLifecycleFns[View.Review].setup as jest.Mock).mockRejectedValue(setupError);
+
+            await manager.setupView(View.Review);
+
+            expect(mockLifecycleFns[View.Noop].shutdown).toHaveBeenCalled();
+            expect(consoleErrorSpy).toHaveBeenCalledWith('Failed to setup view: review', setupError);
+
+            consoleErrorSpy.mockRestore();
+        });
+    });
+});