push-guardian 1.0.0

package/tests/unit/command-mirror.test.js

@@ -0,0 +1,179 @@
+jest.mock('../../src/core/configManager');
+jest.mock('../../src/core/mirroring/syncManager');
+jest.mock('../../src/core/mirroring/generate');
+jest.mock('../../src/core/errorCMD');
+jest.mock('../../src/core/module/env-loader');
+jest.mock('@octokit/rest', () => ({
+    Octokit: jest.fn()
+}));
+jest.mock('gitlab', () => ({
+    Gitlab: jest.fn()
+}));
+jest.mock('bitbucket', () => ({
+    Bitbucket: jest.fn()
+}));
+jest.mock('azure-devops-node-api', () => ({
+    WebApi: jest.fn()
+}));
+jest.mock('../../src/utils/chalk-wrapper', () => ({
+    getChalk: () => ({
+        red: (msg) => msg,
+        green: (msg) => msg,
+        blue: (msg) => msg,
+        cyan: (msg) => msg
+    })
+}));
+
+const mirrorCommand = require('../../src/cli/command/mirror');
+const { loadConfig } = require('../../src/core/configManager');
+const { SyncManager } = require('../../src/core/mirroring/syncManager');
+const { generateWorkflow } = require('../../src/core/mirroring/generate');
+const { getEnv, loadEnv } = require('../../src/core/module/env-loader');
+const errorCMD = require('../../src/core/errorCMD');
+
+describe('CLI Command - mirror', () => {
+    let mockSyncManager;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        console.log = jest.fn();
+        console.error = jest.fn();
+        jest.spyOn(process, 'exit').mockImplementation(() => {});
+
+        loadEnv.mockImplementation(() => {});
+        loadConfig.mockReturnValue({
+            mirroring: {
+                platforms: {
+                    github: { enabled: true },
+                    gitlab: { enabled: true }
+                }
+            }
+        });
+
+        mockSyncManager = {
+            mirror: jest.fn().mockResolvedValue()
+        };
+        SyncManager.mockImplementation(() => mockSyncManager);
+
+        getEnv.mockReturnValue('');
+        generateWorkflow.mockImplementation(() => {});
+        errorCMD.mockImplementation(() => {});
+    });
+
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+
+    test('doit avoir les bonnes métadonnées', () => {
+        expect(mirrorCommand.name).toBe('mirror');
+        expect(mirrorCommand.description).toContain('Référentiels miroirs');
+        expect(mirrorCommand.options).toHaveLength(10);
+    });
+
+    test('doit générer workflow avec --generate', async () => {
+        await mirrorCommand.action({ generate: true });
+
+        expect(generateWorkflow).toHaveBeenCalled();
+        expect(SyncManager).not.toHaveBeenCalled();
+    });
+
+    test('doit quitter si config mirroring manquante', async () => {
+        loadConfig.mockReturnValue({});
+
+        await mirrorCommand.action({ source: 'github' });
+
+        expect(console.log).toHaveBeenCalledWith(
+            expect.stringContaining('Configuration de mise en miroir manquante')
+        );
+        expect(process.exit).toHaveBeenCalledWith(1);
+    });
+
+    test('doit quitter si paramètres manquants', async () => {
+        await mirrorCommand.action({ source: 'github' });
+
+        expect(console.log).toHaveBeenCalledWith(
+            expect.stringContaining('Plateformes, repos et propriétaires source/cible requis')
+        );
+        expect(process.exit).toHaveBeenCalledWith(1);
+    });
+
+    test('doit exécuter mirror avec options complètes', async () => {
+        await mirrorCommand.action({
+            source: 'github',
+            target: 'gitlab',
+            sourceRepo: 'my-repo',
+            targetRepo: 'my-mirror',
+            sourceOwner: 'user1',
+            targetOwner: 'user2',
+            syncBranches: true,
+            publicRepo: true
+        });
+
+        expect(SyncManager).toHaveBeenCalledWith({
+            github: { enabled: true },
+            gitlab: { enabled: true }
+        });
+        expect(mockSyncManager.mirror).toHaveBeenCalledWith(
+            'github',
+            'gitlab',
+            'my-repo',
+            'my-mirror',
+            'user1',
+            'user2',
+            true,
+            true
+        );
+        expect(console.log).toHaveBeenCalledWith(
+            expect.stringContaining('Mise en miroir terminée avec succès')
+        );
+    });
+
+    test('doit charger valeurs depuis env si non spécifiées', async () => {
+        getEnv.mockImplementation((key) => {
+            const envVars = {
+                'SOURCE_PLATFORM': 'github',
+                'TARGET_PLATFORM': 'gitlab',
+                'SOURCE_REPO': 'env-repo',
+                'TARGET_REPO': 'env-mirror',
+                'SOURCE_OWNER': 'env-user1',
+                'TARGET_OWNER': 'env-user2'
+            };
+            return envVars[key] || '';
+        });
+
+        await mirrorCommand.action({});
+
+        expect(mockSyncManager.mirror).toHaveBeenCalledWith(
+            'github',
+            'gitlab',
+            'env-repo',
+            'env-mirror',
+            'env-user1',
+            'env-user2',
+            undefined,
+            undefined
+        );
+    });
+
+    test('doit appeler errorCMD en cas d\'erreur', async () => {
+        const testError = new Error('Mirror failed');
+        mockSyncManager.mirror.mockRejectedValue(testError);
+
+        await mirrorCommand.action({
+            source: 'github',
+            target: 'gitlab',
+            sourceRepo: 'repo',
+            targetRepo: 'mirror',
+            sourceOwner: 'user1',
+            targetOwner: 'user2'
+        });
+
+        expect(errorCMD).toHaveBeenCalledWith(testError);
+    });
+
+    test('doit appeler loadEnv au démarrage', async () => {
+        await mirrorCommand.action({ generate: true });
+
+        expect(loadEnv).toHaveBeenCalled();
+    });
+});

package/tests/unit/command-performance.test.js

@@ -0,0 +1,169 @@
+jest.mock('../../src/core/performance/performanceAnalyzer');
+jest.mock('../../src/core/performance/metricsCollector');
+
+const performanceCommand = require('../../src/cli/command/performance');
+const performanceAnalyzer = require('../../src/core/performance/performanceAnalyzer');
+const metricsCollector = require('../../src/core/performance/metricsCollector');
+
+describe('CLI Command - performance', () => {
+    let consoleLogSpy;
+    let processExitSpy;
+
+    beforeEach(() => {
+        consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+        processExitSpy = jest.spyOn(process, 'exit').mockImplementation(() => {});
+        jest.clearAllMocks();
+    });
+
+    afterEach(() => {
+        consoleLogSpy.mockRestore();
+        processExitSpy.mockRestore();
+    });
+
+    test('doit avoir les bonnes métadonnées', () => {
+        expect(performanceCommand.name).toBe('performance');
+        expect(performanceCommand.description).toBeDefined();
+        expect(performanceCommand.options).toBeDefined();
+        expect(performanceCommand.action).toBeInstanceOf(Function);
+    });
+
+    test('doit avoir les bonnes options', () => {
+        expect(performanceCommand.options).toHaveLength(3);
+        expect(performanceCommand.options[0].flags).toContain('--analyze');
+        expect(performanceCommand.options[1].flags).toContain('--compare');
+        expect(performanceCommand.options[2].flags).toContain('--reset');
+    });
+
+    describe('action reset', () => {
+        test('doit réinitialiser les métriques avec --reset', async () => {
+            await performanceCommand.action({ reset: true });
+
+            expect(metricsCollector.reset).toHaveBeenCalled();
+            expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('réinitialisées'));
+        });
+
+        test('ne doit pas appeler analyze ou compare avec --reset', async () => {
+            await performanceCommand.action({ reset: true });
+
+            expect(performanceAnalyzer.analyze).not.toHaveBeenCalled();
+            expect(performanceAnalyzer.compare).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('action compare', () => {
+        test('doit comparer avec rapport précédent avec --compare', async () => {
+            const reportPath = '/path/to/report.json';
+            await performanceCommand.action({ compare: reportPath });
+
+            expect(performanceAnalyzer.compare).toHaveBeenCalledWith(reportPath);
+        });
+
+        test('ne doit pas appeler analyze ou reset avec --compare', async () => {
+            await performanceCommand.action({ compare: '/path/to/report.json' });
+
+            expect(performanceAnalyzer.analyze).not.toHaveBeenCalled();
+            expect(metricsCollector.reset).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('action analyze', () => {
+        test('doit analyser les performances avec --analyze', async () => {
+            performanceAnalyzer.analyze.mockResolvedValue({});
+            await performanceCommand.action({ analyze: true });
+
+            expect(performanceAnalyzer.analyze).toHaveBeenCalled();
+        });
+
+        test('ne doit pas appeler compare ou reset avec --analyze', async () => {
+            performanceAnalyzer.analyze.mockResolvedValue({});
+            await performanceCommand.action({ analyze: true });
+
+            expect(performanceAnalyzer.compare).not.toHaveBeenCalled();
+            expect(metricsCollector.reset).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('sans options', () => {
+        test('doit afficher message d\'aide si aucune option', async () => {
+            await performanceCommand.action({});
+
+            expect(consoleLogSpy).toHaveBeenCalledWith(
+                expect.stringContaining('--help')
+            );
+        });
+
+        test('ne doit appeler aucune action si aucune option', async () => {
+            await performanceCommand.action({});
+
+            expect(performanceAnalyzer.analyze).not.toHaveBeenCalled();
+            expect(performanceAnalyzer.compare).not.toHaveBeenCalled();
+            expect(metricsCollector.reset).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('gestion des erreurs', () => {
+        test('doit gérer erreur lors de analyze', async () => {
+            performanceAnalyzer.analyze.mockRejectedValue(new Error('Analyze failed'));
+
+            await performanceCommand.action({ analyze: true });
+
+            expect(consoleLogSpy).toHaveBeenCalledWith(
+                expect.stringContaining('Erreur'),
+                expect.stringContaining('Analyze failed')
+            );
+            expect(processExitSpy).toHaveBeenCalledWith(1);
+        });
+
+        test('doit gérer erreur lors de compare', async () => {
+            performanceAnalyzer.compare.mockImplementation(() => {
+                throw new Error('Compare failed');
+            });
+
+            await performanceCommand.action({ compare: '/path/to/report.json' });
+
+            expect(consoleLogSpy).toHaveBeenCalledWith(
+                expect.stringContaining('Erreur'),
+                expect.stringContaining('Compare failed')
+            );
+            expect(processExitSpy).toHaveBeenCalledWith(1);
+        });
+
+        test('doit gérer erreur lors de reset', async () => {
+            metricsCollector.reset.mockImplementation(() => {
+                throw new Error('Reset failed');
+            });
+
+            await performanceCommand.action({ reset: true });
+
+            expect(consoleLogSpy).toHaveBeenCalledWith(
+                expect.stringContaining('Erreur'),
+                expect.stringContaining('Reset failed')
+            );
+            expect(processExitSpy).toHaveBeenCalledWith(1);
+        });
+    });
+
+    describe('priorité des options', () => {
+        test('reset doit avoir priorité sur compare', async () => {
+            await performanceCommand.action({ reset: true, compare: '/path/to/report.json' });
+
+            expect(metricsCollector.reset).toHaveBeenCalled();
+            expect(performanceAnalyzer.compare).not.toHaveBeenCalled();
+        });
+
+        test('reset doit avoir priorité sur analyze', async () => {
+            await performanceCommand.action({ reset: true, analyze: true });
+
+            expect(metricsCollector.reset).toHaveBeenCalled();
+            expect(performanceAnalyzer.analyze).not.toHaveBeenCalled();
+        });
+
+        test('compare doit avoir priorité sur analyze', async () => {
+            const reportPath = '/path/to/report.json';
+            await performanceCommand.action({ compare: reportPath, analyze: true });
+
+            expect(performanceAnalyzer.compare).toHaveBeenCalledWith(reportPath);
+            expect(performanceAnalyzer.analyze).not.toHaveBeenCalled();
+        });
+    });
+});

package/tests/unit/command-plugin.test.js

@@ -0,0 +1,288 @@
+jest.mock('../../src/core/plugins/pluginRegistry');
+jest.mock('../../src/core/plugins/pluginManager');
+
+const pluginCommand = require('../../src/cli/command/plugin');
+const pluginRegistry = require('../../src/core/plugins/pluginRegistry');
+const pluginManager = require('../../src/core/plugins/pluginManager');
+
+describe('CLI Command - plugin', () => {
+    let consoleLogSpy;
+
+    beforeEach(() => {
+        consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+        jest.clearAllMocks();
+        pluginRegistry.getPluginInfo.mockReturnValue(null);
+        pluginManager.listCommands.mockReturnValue([]);
+    });
+
+    afterEach(() => {
+        consoleLogSpy.mockRestore();
+    });
+
+    test('doit avoir les bonnes métadonnées', () => {
+        expect(pluginCommand.name).toBe('plugin');
+        expect(pluginCommand.description).toBeDefined();
+        expect(pluginCommand.arguments).toBeDefined();
+        expect(pluginCommand.action).toBeInstanceOf(Function);
+    });
+
+    test('doit avoir les bons arguments', () => {
+        expect(pluginCommand.arguments).toHaveLength(2);
+        expect(pluginCommand.arguments[0].name).toBe('<action>');
+        expect(pluginCommand.arguments[1].name).toBe('[args...]');
+    });
+
+    describe('action enable', () => {
+        test('doit activer un plugin avec nom valide', async () => {
+            await pluginCommand.action('enable', ['test-plugin'], {});
+
+            expect(pluginRegistry.enablePlugin).toHaveBeenCalledWith('test-plugin');
+        });
+
+        test('doit afficher erreur si nom de plugin manquant', async () => {
+            await pluginCommand.action('enable', [], {});
+
+            expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('requis'));
+            expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('Usage'));
+            expect(pluginRegistry.enablePlugin).not.toHaveBeenCalled();
+        });
+
+        test('doit afficher usage pour enable sans nom', async () => {
+            await pluginCommand.action('enable', [], {});
+
+            expect(consoleLogSpy).toHaveBeenCalledWith(
+                expect.stringContaining('push-guardian plugin enable <nom>')
+            );
+        });
+    });
+
+    describe('action disable', () => {
+        test('doit désactiver un plugin avec nom valide', async () => {
+            await pluginCommand.action('disable', ['test-plugin'], {});
+
+            expect(pluginRegistry.disablePlugin).toHaveBeenCalledWith('test-plugin');
+        });
+
+        test('doit afficher erreur si nom de plugin manquant', async () => {
+            await pluginCommand.action('disable', [], {});
+
+            expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('requis'));
+            expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('Usage'));
+            expect(pluginRegistry.disablePlugin).not.toHaveBeenCalled();
+        });
+
+        test('doit afficher usage pour disable sans nom', async () => {
+            await pluginCommand.action('disable', [], {});
+
+            expect(consoleLogSpy).toHaveBeenCalledWith(
+                expect.stringContaining('push-guardian plugin disable <nom>')
+            );
+        });
+    });
+
+    describe('action list', () => {
+        test('doit lister les plugins installés', async () => {
+            await pluginCommand.action('list', [], {});
+
+            expect(pluginManager.listPlugins).toHaveBeenCalled();
+        });
+
+        test('doit fonctionner sans arguments supplémentaires', async () => {
+            await pluginCommand.action('list', [], {});
+
+            expect(pluginManager.listPlugins).toHaveBeenCalledWith();
+        });
+    });
+
+    describe('action commands', () => {
+        test('doit lister les commandes disponibles', async () => {
+            await pluginCommand.action('commands', [], {});
+
+            expect(pluginManager.displayCommands).toHaveBeenCalled();
+        });
+
+        test('doit fonctionner sans arguments supplémentaires', async () => {
+            await pluginCommand.action('commands', [], {});
+
+            expect(pluginManager.displayCommands).toHaveBeenCalledWith();
+        });
+    });
+
+    describe('action run', () => {
+        test('doit exécuter une commande de plugin', async () => {
+            pluginManager.executeCommand.mockResolvedValue('result');
+            pluginRegistry.getPluginInfo.mockReturnValue({ enabled: true });
+
+            await pluginCommand.action('run', ['test-plugin', 'test-command'], {});
+
+            expect(pluginManager.executeCommand).toHaveBeenCalledWith(
+                'test-plugin',
+                'test-command',
+                [],
+                {}
+            );
+        });
+
+        test('doit passer les arguments à la commande', async () => {
+            pluginManager.executeCommand.mockResolvedValue(undefined);
+            pluginRegistry.getPluginInfo.mockReturnValue({ enabled: true });
+
+            await pluginCommand.action('run', ['test-plugin', 'test-command', 'arg1', 'arg2'], { opt: true });
+
+            expect(pluginManager.executeCommand).toHaveBeenCalledWith(
+                'test-plugin',
+                'test-command',
+                ['arg1', 'arg2'],
+                { opt: true }
+            );
+        });
+
+        test('doit afficher le résultat si défini', async () => {
+            pluginManager.executeCommand.mockResolvedValue('Success result');
+            pluginRegistry.getPluginInfo.mockReturnValue({ enabled: true });
+
+            await pluginCommand.action('run', ['test-plugin', 'test-command'], {});
+
+            expect(consoleLogSpy).toHaveBeenCalledWith('Success result');
+        });
+
+        test('ne doit pas afficher undefined', async () => {
+            pluginManager.executeCommand.mockResolvedValue(undefined);
+            pluginRegistry.getPluginInfo.mockReturnValue({ enabled: true });
+
+            await pluginCommand.action('run', ['test-plugin', 'test-command'], {});
+
+            expect(consoleLogSpy).not.toHaveBeenCalledWith(undefined);
+        });
+
+        test('doit afficher erreur si plugin manquant', async () => {
+            await pluginCommand.action('run', [], {});
+
+            expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('requis'));
+            expect(consoleLogSpy).toHaveBeenCalledWith(
+                expect.stringContaining('push-guardian plugin run <commande>')
+            );
+            expect(pluginManager.executeCommand).not.toHaveBeenCalled();
+        });
+
+        test('doit résoudre automatiquement une commande unique', async () => {
+            pluginManager.listCommands.mockReturnValue([
+                { plugin: 'example-plugin', command: 'hello', description: 'hello', args: [] }
+            ]);
+            pluginManager.executeCommand.mockResolvedValue(undefined);
+
+            await pluginCommand.action('run', ['hello'], {});
+
+            expect(pluginManager.executeCommand).toHaveBeenCalledWith('example-plugin', 'hello', [], {});
+        });
+
+        test('doit passer les args avec la syntaxe run <commande> [args...]', async () => {
+            pluginManager.listCommands.mockReturnValue([
+                { plugin: 'example-plugin', command: 'hello', description: 'hello', args: [] }
+            ]);
+            pluginManager.executeCommand.mockResolvedValue(undefined);
+
+            await pluginCommand.action('run', ['hello', 'a', 'b'], { flag: true });
+
+            expect(pluginManager.executeCommand).toHaveBeenCalledWith('example-plugin', 'hello', ['a', 'b'], {
+                flag: true
+            });
+        });
+
+        test('doit afficher erreur si commande introuvable en mode implicite', async () => {
+            pluginManager.listCommands.mockReturnValue([]);
+
+            await pluginCommand.action('run', ['unknown-cmd'], {});
+
+            expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('introuvable'));
+            expect(pluginManager.executeCommand).not.toHaveBeenCalled();
+        });
+
+        test('doit afficher erreur si commande ambiguë en mode implicite', async () => {
+            pluginManager.listCommands.mockReturnValue([
+                { plugin: 'plugin-a', command: 'hello', description: '', args: [] },
+                { plugin: 'plugin-b', command: 'hello', description: '', args: [] }
+            ]);
+
+            await pluginCommand.action('run', ['hello'], {});
+
+            expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('ambigu'));
+            expect(pluginManager.executeCommand).not.toHaveBeenCalled();
+        });
+
+        test('doit gérer erreur d\'exécution', async () => {
+            pluginManager.executeCommand.mockRejectedValue(new Error('Execution failed'));
+            pluginRegistry.getPluginInfo.mockReturnValue({ enabled: true });
+
+            await pluginCommand.action('run', ['test-plugin', 'test-command'], {});
+
+            expect(consoleLogSpy).toHaveBeenCalledWith(
+                expect.stringContaining('Erreur'),
+                expect.stringContaining('Execution failed')
+            );
+        });
+    });
+
+    describe('action inconnue', () => {
+        test('doit afficher erreur pour action inconnue', async () => {
+            await pluginCommand.action('unknown', [], {});
+
+            expect(consoleLogSpy).toHaveBeenCalledWith(
+                expect.stringContaining('Action inconnue: unknown')
+            );
+        });
+
+        test('doit afficher aide pour action inconnue', async () => {
+            await pluginCommand.action('invalid-action', [], {});
+
+            expect(consoleLogSpy).toHaveBeenCalledWith(
+                expect.stringContaining('Gestion des plugins')
+            );
+        });
+    });
+
+    describe('sans action', () => {
+        test('doit afficher aide si aucune action', async () => {
+            await pluginCommand.action(undefined, [], {});
+
+            expect(consoleLogSpy).toHaveBeenCalledWith(
+                expect.stringContaining('Gestion des plugins')
+            );
+            expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('enable'));
+            expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('disable'));
+            expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('list'));
+            expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('commands'));
+            expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('run'));
+        });
+    });
+
+    describe('intégration avec args array', () => {
+        test('doit gérer correctement args vide', async () => {
+            pluginManager.executeCommand.mockResolvedValue(undefined);
+            pluginRegistry.getPluginInfo.mockReturnValue({ enabled: true });
+
+            await pluginCommand.action('run', ['plugin', 'cmd'], {});
+
+            expect(pluginManager.executeCommand).toHaveBeenCalledWith(
+                'plugin',
+                'cmd',
+                [],
+                {}
+            );
+        });
+
+        test('doit gérer plusieurs args', async () => {
+            pluginManager.executeCommand.mockResolvedValue(undefined);
+            pluginRegistry.getPluginInfo.mockReturnValue({ enabled: true });
+
+            await pluginCommand.action('run', ['plugin', 'cmd', 'a', 'b', 'c'], {});
+
+            expect(pluginManager.executeCommand).toHaveBeenCalledWith(
+                'plugin',
+                'cmd',
+                ['a', 'b', 'c'],
+                {}
+            );
+        });
+    });
+});