@arela/uploader 1.0.3 → 1.0.5

package/tests/commands/PropagateCommand.test.js

@@ -0,0 +1,568 @@
+/**
+ * Unit tests for PropagateCommand
+ * Tests the arela propagate command functionality
+ */
+import { jest, describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+
+// Mock dependencies before importing PropagateCommand
+const mockLogger = {
+  info: jest.fn(),
+  success: jest.fn(),
+  error: jest.fn(),
+  warn: jest.fn(),
+  debug: jest.fn(),
+};
+
+const mockProgressBar = {
+  start: jest.fn(),
+  update: jest.fn(),
+  stop: jest.fn(),
+};
+
+const mockCliProgress = {
+  SingleBar: jest.fn(() => mockProgressBar),
+  Presets: {
+    shades_classic: {},
+  },
+};
+
+const mockScanApiService = {
+  getInstanceTables: jest.fn(),
+  getPropagationStats: jest.fn(),
+  markFilesNeedingPropagation: jest.fn(),
+  fetchPedimentoSources: jest.fn(),
+  fetchFilesNeedingPropagationByDirectory: jest.fn(),
+  batchUpdatePropagation: jest.fn(),
+};
+
+const mockAppConfig = {
+  validateScanConfig: jest.fn(),
+  getScanConfig: jest.fn(),
+  setApiTarget: jest.fn(),
+};
+
+// Store original console methods
+const originalConsoleLog = console.log;
+const originalConsoleError = console.error;
+const originalProcessExit = process.exit;
+
+jest.unstable_mockModule('cli-progress', () => ({
+  default: mockCliProgress,
+  SingleBar: mockCliProgress.SingleBar,
+  Presets: mockCliProgress.Presets,
+}));
+
+jest.unstable_mockModule('../../src/services/LoggingService.js', () => ({
+  default: mockLogger,
+}));
+
+jest.unstable_mockModule('../../src/services/ScanApiService.js', () => ({
+  default: jest.fn(() => mockScanApiService),
+}));
+
+jest.unstable_mockModule('../../src/config/config.js', () => ({
+  default: mockAppConfig,
+}));
+
+// Import the class after mocking
+const { PropagateCommand } = await import('../../src/commands/PropagateCommand.js');
+
+describe('PropagateCommand', () => {
+  let propagateCommand;
+  let mockConsoleLog;
+  let mockConsoleError;
+  let mockProcessExit;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    
+    // Mock console methods
+    mockConsoleLog = jest.fn();
+    mockConsoleError = jest.fn();
+    mockProcessExit = jest.fn();
+    console.log = mockConsoleLog;
+    console.error = mockConsoleError;
+    process.exit = mockProcessExit;
+    
+    // Default mock implementations
+    mockAppConfig.getScanConfig.mockReturnValue({
+      companySlug: 'test-company',
+      serverId: 'test-server',
+      basePathFull: '/test/path',
+    });
+    mockAppConfig.validateScanConfig.mockReturnValue(undefined);
+    
+    mockScanApiService.getInstanceTables.mockResolvedValue([
+      { tableName: 'scan_test_table' },
+    ]);
+    
+    mockScanApiService.getPropagationStats.mockResolvedValue({
+      totalFiles: 100,
+      withArelaPath: 50,
+      pedimentoSources: 10,
+      needsPropagation: 40,
+      pending: 40,
+      errors: 0,
+      maxAttemptsReached: 0,
+    });
+    
+    mockScanApiService.markFilesNeedingPropagation.mockResolvedValue({
+      markedCount: 40,
+    });
+    
+    mockScanApiService.fetchPedimentoSources.mockResolvedValue([]);
+    mockScanApiService.fetchFilesNeedingPropagationByDirectory.mockResolvedValue([]);
+    mockScanApiService.batchUpdatePropagation.mockResolvedValue({ updated: 0 });
+    
+    propagateCommand = new PropagateCommand();
+  });
+
+  afterEach(() => {
+    // Restore console methods
+    console.log = originalConsoleLog;
+    console.error = originalConsoleError;
+    process.exit = originalProcessExit;
+    jest.restoreAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should create a new PropagateCommand instance with default options', () => {
+      expect(propagateCommand).toBeInstanceOf(PropagateCommand);
+      expect(propagateCommand.options.batchSize).toBe(50);
+      expect(propagateCommand.options.showStats).toBe(false);
+      expect(propagateCommand.options.api).toBe('default');
+    });
+
+    it('should accept custom options', () => {
+      const customCommand = new PropagateCommand({
+        batchSize: 100,
+        showStats: true,
+        api: 'agencia',
+      });
+
+      expect(customCommand.options.batchSize).toBe(100);
+      expect(customCommand.options.showStats).toBe(true);
+      expect(customCommand.options.api).toBe('agencia');
+    });
+
+    it('should initialize stats object', () => {
+      expect(propagateCommand.stats).toBeDefined();
+      expect(propagateCommand.stats.pedimentosProcessed).toBe(0);
+      expect(propagateCommand.stats.filesUpdated).toBe(0);
+      expect(propagateCommand.stats.filesFailed).toBe(0);
+      expect(propagateCommand.stats.directoriesProcessed).toBe(0);
+    });
+  });
+
+  describe('execute', () => {
+    it('should validate configuration', async () => {
+      await propagateCommand.execute();
+
+      expect(mockAppConfig.validateScanConfig).toHaveBeenCalled();
+    });
+
+    it('should set API target', async () => {
+      const command = new PropagateCommand({ api: 'cliente' });
+      await command.execute();
+
+      expect(mockAppConfig.setApiTarget).toHaveBeenCalledWith('cliente');
+    });
+
+    it('should fetch instance tables', async () => {
+      await propagateCommand.execute();
+
+      expect(mockScanApiService.getInstanceTables).toHaveBeenCalledWith(
+        'test-company',
+        'test-server',
+        '/test/path'
+      );
+    });
+
+    it('should exit when no tables found', async () => {
+      mockScanApiService.getInstanceTables.mockResolvedValue([]);
+
+      await propagateCommand.execute();
+
+      expect(mockProcessExit).toHaveBeenCalledWith(1);
+      expect(mockConsoleError).toHaveBeenCalledWith(
+        expect.stringContaining('No tables found')
+      );
+    });
+
+    it('should log found tables', async () => {
+      mockScanApiService.getInstanceTables.mockResolvedValue([
+        { tableName: 'scan_table_1' },
+        { tableName: 'scan_table_2' },
+      ]);
+
+      await propagateCommand.execute();
+
+      expect(mockConsoleLog).toHaveBeenCalledWith(
+        expect.stringContaining('Found 2 tables')
+      );
+    });
+
+    it('should show initial status', async () => {
+      await propagateCommand.execute();
+
+      expect(mockConsoleLog).toHaveBeenCalledWith('📈 Initial Status:');
+    });
+  });
+
+  describe('table processing', () => {
+    it('should skip table when no pedimento sources', async () => {
+      mockScanApiService.getPropagationStats.mockResolvedValue({
+        totalFiles: 100,
+        withArelaPath: 0,
+        pedimentoSources: 0,
+        needsPropagation: 0,
+        pending: 0,
+        errors: 0,
+      });
+
+      await propagateCommand.execute();
+
+      expect(mockConsoleLog).toHaveBeenCalledWith(
+        expect.stringContaining('No pedimento sources found')
+      );
+    });
+
+    it('should skip table when all files have arela_path', async () => {
+      mockScanApiService.getPropagationStats
+        .mockResolvedValueOnce({
+          totalFiles: 100,
+          withArelaPath: 100,
+          pedimentoSources: 10,
+          needsPropagation: 0,
+          pending: 0,
+          errors: 0,
+        })
+        .mockResolvedValueOnce({
+          totalFiles: 100,
+          withArelaPath: 100,
+          pedimentoSources: 10,
+          needsPropagation: 0,
+          pending: 0,
+          errors: 0,
+        });
+
+      await propagateCommand.execute();
+
+      expect(mockConsoleLog).toHaveBeenCalledWith(
+        expect.stringContaining('All files already have arela_path')
+      );
+    });
+
+    it('should mark files needing propagation', async () => {
+      mockScanApiService.getPropagationStats
+        .mockResolvedValueOnce({
+          totalFiles: 100,
+          withArelaPath: 10,
+          pedimentoSources: 10,
+          needsPropagation: 0,
+          pending: 90,
+          errors: 0,
+        })
+        .mockResolvedValueOnce({
+          totalFiles: 100,
+          withArelaPath: 10,
+          pedimentoSources: 10,
+          needsPropagation: 90,
+          pending: 90,
+          errors: 0,
+        });
+
+      await propagateCommand.execute();
+
+      expect(mockScanApiService.markFilesNeedingPropagation).toHaveBeenCalledWith(
+        'scan_test_table'
+      );
+    });
+  });
+
+  describe('propagation processing', () => {
+    beforeEach(() => {
+      // Setup for active propagation
+      mockScanApiService.getPropagationStats
+        .mockResolvedValueOnce({
+          totalFiles: 100,
+          withArelaPath: 10,
+          pedimentoSources: 5,
+          needsPropagation: 90,
+          pending: 90,
+          errors: 0,
+        })
+        .mockResolvedValueOnce({
+          totalFiles: 100,
+          withArelaPath: 10,
+          pedimentoSources: 5,
+          needsPropagation: 90,
+          pending: 90,
+          errors: 0,
+        })
+        .mockResolvedValueOnce({
+          totalFiles: 100,
+          withArelaPath: 100,
+          pedimentoSources: 5,
+          needsPropagation: 0,
+          pending: 0,
+          errors: 0,
+        });
+    });
+
+    it('should fetch pedimento sources', async () => {
+      mockScanApiService.fetchPedimentoSources.mockResolvedValue([
+        {
+          id: 1,
+          directory_path: '/test/dir1',
+          arela_path: 'RFC/2023/3429/07/12345/',
+          rfc: 'RFC123',
+          detected_pedimento_year: 2023,
+        },
+      ]);
+
+      mockScanApiService.fetchFilesNeedingPropagationByDirectory.mockResolvedValue([]);
+
+      await propagateCommand.execute();
+
+      expect(mockScanApiService.fetchPedimentoSources).toHaveBeenCalled();
+    });
+
+    it('should process files in each directory', async () => {
+      mockScanApiService.fetchPedimentoSources.mockResolvedValue([
+        {
+          id: 1,
+          directory_path: '/test/dir1',
+          arela_path: 'RFC/2023/3429/07/12345/',
+          rfc: 'RFC123',
+          detected_pedimento_year: 2023,
+        },
+      ]);
+
+      mockScanApiService.fetchFilesNeedingPropagationByDirectory.mockResolvedValue([
+        { id: 2, file_name: 'file.xml' },
+        { id: 3, file_name: 'file.txt' },
+      ]);
+
+      mockScanApiService.batchUpdatePropagation.mockResolvedValue({ updated: 2 });
+
+      await propagateCommand.execute();
+
+      expect(mockScanApiService.fetchFilesNeedingPropagationByDirectory).toHaveBeenCalledWith(
+        'scan_test_table',
+        '/test/dir1'
+      );
+    });
+
+    it('should update progress bar during processing', async () => {
+      mockScanApiService.fetchPedimentoSources.mockResolvedValue([
+        {
+          id: 1,
+          directory_path: '/test/dir1',
+          arela_path: 'RFC/2023/3429/07/12345/',
+          rfc: 'RFC123',
+          detected_pedimento_year: 2023,
+        },
+      ]);
+
+      mockScanApiService.fetchFilesNeedingPropagationByDirectory.mockResolvedValue([]);
+
+      await propagateCommand.execute();
+
+      expect(mockProgressBar.start).toHaveBeenCalled();
+      expect(mockProgressBar.update).toHaveBeenCalled();
+      expect(mockProgressBar.stop).toHaveBeenCalled();
+    });
+
+    it('should process multiple batches of pedimentos', async () => {
+      mockScanApiService.fetchPedimentoSources
+        .mockResolvedValueOnce([
+          {
+            id: 1,
+            directory_path: '/test/dir1',
+            arela_path: 'RFC/2023/3429/07/12345/',
+            rfc: 'RFC123',
+            detected_pedimento_year: 2023,
+          },
+        ])
+        .mockResolvedValueOnce([]);
+
+      mockScanApiService.fetchFilesNeedingPropagationByDirectory.mockResolvedValue([]);
+
+      await propagateCommand.execute();
+
+      // The implementation may call once or twice depending on batch size logic
+      expect(mockScanApiService.fetchPedimentoSources).toHaveBeenCalled();
+    });
+  });
+
+  describe('error handling', () => {
+    it('should handle configuration validation errors', async () => {
+      mockAppConfig.validateScanConfig.mockImplementation(() => {
+        throw new Error('Missing required config');
+      });
+
+      await propagateCommand.execute();
+
+      expect(mockProcessExit).toHaveBeenCalledWith(1);
+    });
+
+    it('should handle API errors gracefully', async () => {
+      mockScanApiService.getInstanceTables.mockRejectedValue(
+        new Error('API connection failed')
+      );
+
+      await propagateCommand.execute();
+
+      expect(mockProcessExit).toHaveBeenCalledWith(1);
+      expect(mockConsoleError).toHaveBeenCalledWith(
+        expect.stringContaining('API connection failed')
+      );
+    });
+
+    it('should handle fetch pedimento sources errors', async () => {
+      mockScanApiService.getPropagationStats
+        .mockResolvedValueOnce({
+          totalFiles: 100,
+          withArelaPath: 10,
+          pedimentoSources: 5,
+          needsPropagation: 90,
+          pending: 90,
+          errors: 0,
+        })
+        .mockResolvedValueOnce({
+          totalFiles: 100,
+          withArelaPath: 10,
+          pedimentoSources: 5,
+          needsPropagation: 90,
+          pending: 90,
+          errors: 0,
+        });
+
+      mockScanApiService.fetchPedimentoSources.mockRejectedValue(
+        new Error('Database error')
+      );
+
+      // The command should handle the error (exit or log)
+      await propagateCommand.execute();
+
+      // Should have attempted to fetch pedimento sources
+      expect(mockScanApiService.fetchPedimentoSources).toHaveBeenCalled();
+    });
+
+    it('should handle invalid API response for files', async () => {
+      mockScanApiService.getPropagationStats
+        .mockResolvedValueOnce({
+          totalFiles: 100,
+          withArelaPath: 10,
+          pedimentoSources: 5,
+          needsPropagation: 90,
+          pending: 90,
+          errors: 0,
+        })
+        .mockResolvedValueOnce({
+          totalFiles: 100,
+          withArelaPath: 10,
+          pedimentoSources: 5,
+          needsPropagation: 90,
+          pending: 90,
+          errors: 0,
+        });
+
+      mockScanApiService.fetchPedimentoSources.mockResolvedValue([
+        {
+          id: 1,
+          directory_path: '/test/dir1',
+          arela_path: 'RFC/2023/3429/07/12345/',
+        },
+      ]);
+
+      // Return invalid response (not an array)
+      mockScanApiService.fetchFilesNeedingPropagationByDirectory.mockResolvedValue(null);
+
+      await propagateCommand.execute();
+
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        expect.stringMatching(/Invalid response/i),
+        null
+      );
+    });
+  });
+
+  describe('statistics display', () => {
+    it('should show final statistics', async () => {
+      mockScanApiService.getPropagationStats.mockResolvedValue({
+        totalFiles: 100,
+        withArelaPath: 100,
+        pedimentoSources: 10,
+        needsPropagation: 0,
+        pending: 0,
+        errors: 0,
+        maxAttemptsReached: 0,
+      });
+
+      await propagateCommand.execute();
+
+      // Final stats are shown after processing, check for any status output
+      expect(mockConsoleLog).toHaveBeenCalledWith(
+        expect.stringContaining('Initial Status')
+      );
+    });
+
+    it('should warn about max attempts reached', async () => {
+      // This test verifies the command handles maxAttemptsReached stats
+      mockScanApiService.getPropagationStats.mockResolvedValue({
+        totalFiles: 100,
+        withArelaPath: 90,
+        pedimentoSources: 10,
+        needsPropagation: 0,
+        pending: 0,
+        errors: 0,
+        maxAttemptsReached: 5,
+      });
+
+      // Should complete without error
+      await expect(propagateCommand.execute()).resolves.not.toThrow();
+    });
+
+    it('should show combined results for multiple tables', async () => {
+      mockScanApiService.getInstanceTables.mockResolvedValue([
+        { tableName: 'scan_table_1' },
+        { tableName: 'scan_table_2' },
+      ]);
+
+      mockScanApiService.getPropagationStats.mockResolvedValue({
+        totalFiles: 50,
+        withArelaPath: 50,
+        pedimentoSources: 0,
+        needsPropagation: 0,
+        pending: 0,
+        errors: 0,
+      });
+
+      await propagateCommand.execute();
+
+      expect(mockConsoleLog).toHaveBeenCalledWith(
+        expect.stringContaining('Tables Processed: 2')
+      );
+    });
+  });
+
+  describe('memory usage', () => {
+    it('should report memory usage when showStats is enabled', async () => {
+      const command = new PropagateCommand({ showStats: true });
+      
+      mockScanApiService.getPropagationStats.mockResolvedValue({
+        totalFiles: 100,
+        withArelaPath: 100,
+        pedimentoSources: 0,
+        needsPropagation: 0,
+        pending: 0,
+        errors: 0,
+      });
+
+      // The command should complete without error when showStats is enabled
+      await expect(command.execute()).resolves.not.toThrow();
+    });
+  });
+});