@arela/uploader 1.0.3 → 1.0.5

package/tests/commands/PushCommand.test.js

@@ -0,0 +1,754 @@
+/**
+ * Unit tests for PushCommand
+ * Tests the arela push command functionality
+ */
+import { jest, describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+
+// Mock dependencies before importing PushCommand
+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(),
+  getPushStats: jest.fn(),
+  fetchFilesForPush: jest.fn(),
+  batchUpdateUpload: jest.fn(),
+};
+
+const mockAppConfig = {
+  validateScanConfig: jest.fn(),
+  getScanConfig: jest.fn(),
+  getPushConfig: jest.fn(),
+  getApiConfig: jest.fn(),
+  setApiTarget: jest.fn(),
+  packageVersion: '1.0.3',
+};
+
+const mockFs = {
+  existsSync: jest.fn(),
+  statSync: jest.fn(),
+  createReadStream: jest.fn(),
+};
+
+const mockFetch = jest.fn();
+
+const mockFormData = jest.fn(() => ({
+  append: jest.fn(),
+  getHeaders: 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('fs', () => ({
+  default: mockFs,
+  existsSync: mockFs.existsSync,
+  statSync: mockFs.statSync,
+  createReadStream: mockFs.createReadStream,
+}));
+
+jest.unstable_mockModule('node-fetch', () => ({
+  default: mockFetch,
+}));
+
+jest.unstable_mockModule('form-data', () => ({
+  default: mockFormData,
+}));
+
+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 { PushCommand } = await import('../../src/commands/PushCommand.js');
+
+describe('PushCommand', () => {
+  let pushCommand;
+  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',
+      tableName: 'scan_test_table',
+    });
+    
+    mockAppConfig.getPushConfig.mockReturnValue({
+      bucket: 'test-bucket',
+      rfcs: [],
+      years: [],
+    });
+    
+    mockAppConfig.getApiConfig.mockReturnValue({
+      baseUrl: 'https://api.test.com',
+      token: 'test-token',
+    });
+    
+    mockAppConfig.validateScanConfig.mockReturnValue(undefined);
+    
+    mockScanApiService.getInstanceTables.mockResolvedValue([
+      { tableName: 'scan_test_table' },
+    ]);
+    
+    mockScanApiService.getPushStats.mockResolvedValue({
+      totalWithArelaPath: 100,
+      uploaded: 50,
+      pending: 50,
+      errors: 0,
+      maxAttemptsReached: 0,
+      byRfc: [],
+    });
+    
+    mockScanApiService.fetchFilesForPush.mockResolvedValue([]);
+    mockScanApiService.batchUpdateUpload.mockResolvedValue({ updated: 0 });
+    
+    mockFs.existsSync.mockReturnValue(true);
+    mockFs.statSync.mockReturnValue({ isFile: () => true, size: 1000 });
+    mockFs.createReadStream.mockReturnValue({});
+    
+    mockFetch.mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({ uploaded: [{ id: 'file-id' }] }),
+    });
+    
+    pushCommand = new PushCommand();
+  });
+
+  afterEach(() => {
+    // Restore console methods
+    console.log = originalConsoleLog;
+    console.error = originalConsoleError;
+    process.exit = originalProcessExit;
+    jest.restoreAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should create a new PushCommand instance', () => {
+      expect(pushCommand).toBeInstanceOf(PushCommand);
+      expect(pushCommand.scanApiService).toBeDefined();
+    });
+  });
+
+  describe('execute', () => {
+    const defaultOptions = {
+      batchSize: '100',
+      uploadBatchSize: '10',
+    };
+
+    it('should validate configuration', async () => {
+      await pushCommand.execute(defaultOptions);
+
+      expect(mockAppConfig.validateScanConfig).toHaveBeenCalled();
+    });
+
+    it('should exit on configuration errors', async () => {
+      mockAppConfig.validateScanConfig.mockImplementation(() => {
+        throw new Error('Missing required config');
+      });
+
+      await pushCommand.execute(defaultOptions);
+
+      expect(mockProcessExit).toHaveBeenCalledWith(1);
+    });
+
+    it('should fetch instance tables', async () => {
+      await pushCommand.execute(defaultOptions);
+
+      expect(mockScanApiService.getInstanceTables).toHaveBeenCalledWith(
+        'test-company',
+        'test-server',
+        '/test/path'
+      );
+    });
+
+    it('should exit when no tables found', async () => {
+      mockScanApiService.getInstanceTables.mockResolvedValue([]);
+
+      await pushCommand.execute(defaultOptions);
+
+      expect(mockProcessExit).toHaveBeenCalledWith(1);
+      expect(mockConsoleError).toHaveBeenCalledWith(
+        expect.stringContaining('No tables found')
+      );
+    });
+
+    it('should set API target when specified', async () => {
+      await pushCommand.execute({ ...defaultOptions, api: 'agencia' });
+
+      expect(mockAppConfig.setApiTarget).toHaveBeenCalledWith('agencia');
+    });
+
+    it('should use different scan and push API targets', async () => {
+      await pushCommand.execute({
+        ...defaultOptions,
+        scanApi: 'agencia',
+        pushApi: 'cliente',
+      });
+
+      expect(mockAppConfig.setApiTarget).toHaveBeenCalledWith('agencia');
+      expect(mockAppConfig.getApiConfig).toHaveBeenCalledWith('cliente');
+    });
+
+    it('should apply RFC filters', async () => {
+      await pushCommand.execute({
+        ...defaultOptions,
+        rfcs: ['RFC123', 'RFC456'],
+      });
+
+      expect(mockConsoleLog).toHaveBeenCalledWith(
+        expect.stringContaining('RFC Filter: RFC123, RFC456')
+      );
+    });
+
+    it('should apply year filters', async () => {
+      await pushCommand.execute({
+        ...defaultOptions,
+        years: ['2023', '2024'],
+      });
+
+      expect(mockConsoleLog).toHaveBeenCalledWith(
+        expect.stringContaining('Year Filter: 2023, 2024')
+      );
+    });
+
+    it('should skip table when no pending files', async () => {
+      mockScanApiService.getPushStats.mockResolvedValue({
+        totalWithArelaPath: 100,
+        uploaded: 100,
+        pending: 0,
+        errors: 0,
+        maxAttemptsReached: 0,
+      });
+
+      await pushCommand.execute(defaultOptions);
+
+      expect(mockConsoleLog).toHaveBeenCalledWith(
+        expect.stringContaining('No files pending upload')
+      );
+    });
+  });
+
+  describe('file processing', () => {
+    const defaultOptions = {
+      batchSize: '100',
+      uploadBatchSize: '10',
+    };
+
+    it('should fetch files for push', async () => {
+      mockScanApiService.getPushStats.mockResolvedValue({
+        totalWithArelaPath: 10,
+        uploaded: 0,
+        pending: 10,
+        errors: 0,
+      });
+
+      mockScanApiService.fetchFilesForPush.mockResolvedValue([
+        {
+          id: 1,
+          absolute_path: '/test/file.pdf',
+          arela_path: 'RFC/2023/3429/07/12345/',
+          file_name: 'file.pdf',
+          rfc: 'RFC123',
+          detected_pedimento_year: 2023,
+        },
+      ]);
+
+      await pushCommand.execute(defaultOptions);
+
+      expect(mockScanApiService.fetchFilesForPush).toHaveBeenCalled();
+    });
+
+    it('should upload files and update database', async () => {
+      mockScanApiService.getPushStats.mockResolvedValue({
+        totalWithArelaPath: 1,
+        uploaded: 0,
+        pending: 1,
+        errors: 0,
+      });
+
+      mockScanApiService.fetchFilesForPush
+        .mockResolvedValueOnce([
+          {
+            id: 1,
+            absolute_path: '/test/file.pdf',
+            arela_path: 'RFC/2023/3429/07/12345/',
+            file_name: 'file.pdf',
+            rfc: 'RFC123',
+            detected_pedimento_year: 2023,
+            relative_path: 'file.pdf',
+          },
+        ])
+        .mockResolvedValueOnce([]);
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ uploaded: [{ id: 'storage-id' }] }),
+      });
+
+      await pushCommand.execute(defaultOptions);
+
+      expect(mockScanApiService.batchUpdateUpload).toHaveBeenCalled();
+    });
+
+    it('should handle file not found errors', async () => {
+      mockScanApiService.getPushStats.mockResolvedValue({
+        totalWithArelaPath: 1,
+        uploaded: 0,
+        pending: 1,
+        errors: 0,
+      });
+
+      mockScanApiService.fetchFilesForPush
+        .mockResolvedValueOnce([
+          {
+            id: 1,
+            absolute_path: '/test/missing.pdf',
+            arela_path: 'RFC/2023/3429/07/12345/',
+            file_name: 'missing.pdf',
+            rfc: 'RFC123',
+          },
+        ])
+        .mockResolvedValueOnce([]);
+
+      mockFs.existsSync.mockReturnValue(false);
+
+      // Should complete without throwing (errors are tracked internally)
+      await expect(pushCommand.execute(defaultOptions)).resolves.not.toThrow();
+    });
+
+    it('should handle non-file paths', async () => {
+      mockScanApiService.getPushStats.mockResolvedValue({
+        totalWithArelaPath: 1,
+        uploaded: 0,
+        pending: 1,
+        errors: 0,
+      });
+
+      mockScanApiService.fetchFilesForPush
+        .mockResolvedValueOnce([
+          {
+            id: 1,
+            absolute_path: '/test/directory',
+            arela_path: 'RFC/2023/3429/07/12345/',
+            file_name: 'directory',
+          },
+        ])
+        .mockResolvedValueOnce([]);
+
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.statSync.mockReturnValue({ isFile: () => false });
+
+      await pushCommand.execute(defaultOptions);
+
+      expect(mockScanApiService.batchUpdateUpload).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.arrayContaining([
+          expect.objectContaining({
+            id: 1,
+            uploaded: false,
+            uploadError: expect.stringContaining('NOT_A_FILE'),
+          }),
+        ])
+      );
+    });
+
+    it('should process multiple batches', async () => {
+      mockScanApiService.getPushStats.mockResolvedValue({
+        totalWithArelaPath: 200,
+        uploaded: 0,
+        pending: 200,
+        errors: 0,
+      });
+
+      mockScanApiService.fetchFilesForPush
+        .mockResolvedValueOnce([
+          {
+            id: 1,
+            absolute_path: '/test/file1.pdf',
+            arela_path: 'RFC/2023/3429/07/12345/',
+            file_name: 'file1.pdf',
+            rfc: 'RFC123',
+          },
+        ])
+        .mockResolvedValueOnce([]);
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ uploaded: [{ id: 'storage-id' }] }),
+      });
+
+      await pushCommand.execute(defaultOptions);
+
+      // Should have fetched files at least twice (once with data, once empty)
+      expect(mockScanApiService.fetchFilesForPush).toHaveBeenCalled();
+    });
+  });
+
+  describe('upload API', () => {
+    const defaultOptions = {
+      batchSize: '100',
+      uploadBatchSize: '10',
+    };
+
+    beforeEach(() => {
+      mockScanApiService.getPushStats.mockResolvedValue({
+        totalWithArelaPath: 1,
+        uploaded: 0,
+        pending: 1,
+        errors: 0,
+      });
+
+      mockScanApiService.fetchFilesForPush
+        .mockResolvedValueOnce([
+          {
+            id: 1,
+            absolute_path: '/test/file.pdf',
+            arela_path: 'RFC/2023/3429/07/12345/',
+            file_name: 'file.pdf',
+            rfc: 'RFC123',
+            detected_pedimento_year: 2023,
+            relative_path: 'file.pdf',
+          },
+        ])
+        .mockResolvedValueOnce([]);
+    });
+
+    it('should call storage API with correct endpoint', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ uploaded: [{ id: 'storage-id' }] }),
+      });
+
+      await pushCommand.execute(defaultOptions);
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        expect.stringContaining('/api/storage/batch-upload-and-process'),
+        expect.any(Object)
+      );
+    });
+
+    it('should handle API upload failure', async () => {
+      mockScanApiService.getPushStats.mockResolvedValue({
+        totalWithArelaPath: 1,
+        uploaded: 0,
+        pending: 1,
+        errors: 0,
+      });
+
+      mockScanApiService.fetchFilesForPush
+        .mockResolvedValueOnce([
+          {
+            id: 1,
+            absolute_path: '/test/file.pdf',
+            arela_path: 'RFC/2023/3429/07/12345/',
+            file_name: 'file.pdf',
+            rfc: 'RFC123',
+            detected_pedimento_year: 2023,
+            relative_path: 'file.pdf',
+          },
+        ])
+        .mockResolvedValueOnce([]);
+
+      mockFetch.mockResolvedValue({
+        ok: false,
+        status: 500,
+        text: () => Promise.resolve('Internal Server Error'),
+      });
+
+      // Should complete without throwing
+      await expect(pushCommand.execute(defaultOptions)).resolves.not.toThrow();
+    });
+
+    it('should handle network errors', async () => {
+      mockFetch.mockRejectedValue(new Error('Network error'));
+
+      await pushCommand.execute(defaultOptions);
+
+      expect(mockScanApiService.batchUpdateUpload).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.arrayContaining([
+          expect.objectContaining({
+            id: 1,
+            uploaded: false,
+            uploadError: expect.stringContaining('Network error'),
+          }),
+        ])
+      );
+    });
+
+    it('should handle empty upload response', async () => {
+      mockScanApiService.getPushStats.mockResolvedValue({
+        totalWithArelaPath: 1,
+        uploaded: 0,
+        pending: 1,
+        errors: 0,
+      });
+
+      mockScanApiService.fetchFilesForPush
+        .mockResolvedValueOnce([
+          {
+            id: 1,
+            absolute_path: '/test/file.pdf',
+            arela_path: 'RFC/2023/3429/07/12345/',
+            file_name: 'file.pdf',
+            rfc: 'RFC123',
+            detected_pedimento_year: 2023,
+            relative_path: 'file.pdf',
+          },
+        ])
+        .mockResolvedValueOnce([]);
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ uploaded: [], errors: ['No files processed'] }),
+      });
+
+      // Should complete without throwing
+      await expect(pushCommand.execute(defaultOptions)).resolves.not.toThrow();
+    });
+  });
+
+  describe('statistics display', () => {
+    const defaultOptions = {
+      batchSize: '100',
+      uploadBatchSize: '10',
+    };
+
+    it('should display table status', async () => {
+      await pushCommand.execute(defaultOptions);
+
+      expect(mockConsoleLog).toHaveBeenCalledWith(
+        expect.stringContaining('Table Status')
+      );
+    });
+
+    it('should display RFC breakdown when available', async () => {
+      mockScanApiService.getPushStats.mockResolvedValue({
+        totalWithArelaPath: 100,
+        uploaded: 50,
+        pending: 0,
+        errors: 0,
+        byRfc: [
+          { rfc: 'RFC123', uploaded: 25, total: 50 },
+          { rfc: 'RFC456', uploaded: 25, total: 50 },
+        ],
+      });
+
+      await pushCommand.execute(defaultOptions);
+
+      expect(mockConsoleLog).toHaveBeenCalledWith(
+        expect.stringContaining('Top RFCs')
+      );
+    });
+
+    it('should show errors count when present', async () => {
+      mockScanApiService.getPushStats.mockResolvedValue({
+        totalWithArelaPath: 100,
+        uploaded: 90,
+        pending: 0,
+        errors: 10,
+        maxAttemptsReached: 0,
+      });
+
+      await pushCommand.execute(defaultOptions);
+
+      expect(mockConsoleLog).toHaveBeenCalledWith(
+        expect.stringContaining('Errors: 10')
+      );
+    });
+
+    it('should show max attempts reached when present', async () => {
+      mockScanApiService.getPushStats.mockResolvedValue({
+        totalWithArelaPath: 100,
+        uploaded: 95,
+        pending: 0,
+        errors: 0,
+        maxAttemptsReached: 5,
+      });
+
+      await pushCommand.execute(defaultOptions);
+
+      expect(mockConsoleLog).toHaveBeenCalledWith(
+        expect.stringContaining('Max Attempts Reached: 5')
+      );
+    });
+
+    it('should display final results', async () => {
+      await pushCommand.execute(defaultOptions);
+
+      expect(mockConsoleLog).toHaveBeenCalledWith(
+        expect.stringContaining('Push Complete')
+      );
+      expect(mockConsoleLog).toHaveBeenCalledWith(
+        expect.stringContaining('Total Results')
+      );
+    });
+  });
+
+  describe('progress tracking', () => {
+    const defaultOptions = {
+      batchSize: '100',
+      uploadBatchSize: '10',
+    };
+
+    it('should create progress bar with correct total', async () => {
+      mockScanApiService.getPushStats.mockResolvedValue({
+        totalWithArelaPath: 100,
+        uploaded: 0,
+        pending: 100,
+        errors: 0,
+      });
+
+      mockScanApiService.fetchFilesForPush.mockResolvedValue([]);
+
+      await pushCommand.execute(defaultOptions);
+
+      expect(mockProgressBar.start).toHaveBeenCalledWith(
+        100,
+        0,
+        expect.any(Object)
+      );
+    });
+
+    it('should update progress during processing', async () => {
+      mockScanApiService.getPushStats.mockResolvedValue({
+        totalWithArelaPath: 2,
+        uploaded: 0,
+        pending: 2,
+        errors: 0,
+      });
+
+      mockScanApiService.fetchFilesForPush
+        .mockResolvedValueOnce([
+          {
+            id: 1,
+            absolute_path: '/test/file1.pdf',
+            arela_path: 'RFC/2023/3429/07/12345/',
+            file_name: 'file1.pdf',
+            rfc: 'RFC123',
+          },
+        ])
+        .mockResolvedValueOnce([]);
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ uploaded: [{ id: 'storage-id' }] }),
+      });
+
+      await pushCommand.execute(defaultOptions);
+
+      // Progress bar should have been started
+      expect(mockProgressBar.start).toHaveBeenCalled();
+    });
+  });
+
+  describe('error handling', () => {
+    const defaultOptions = {
+      batchSize: '100',
+      uploadBatchSize: '10',
+    };
+
+    it('should handle unexpected errors', async () => {
+      mockScanApiService.getInstanceTables.mockRejectedValue(
+        new Error('Unexpected error')
+      );
+
+      await pushCommand.execute(defaultOptions);
+
+      expect(mockProcessExit).toHaveBeenCalledWith(1);
+      expect(mockConsoleError).toHaveBeenCalledWith(
+        expect.stringContaining('Push failed'),
+        expect.stringContaining('Unexpected error')
+      );
+    });
+
+    it('should log detailed error information', async () => {
+      mockScanApiService.getPushStats.mockResolvedValue({
+        totalWithArelaPath: 10,
+        uploaded: 0,
+        pending: 10,
+        errors: 0,
+      });
+
+      mockScanApiService.fetchFilesForPush.mockRejectedValue(
+        new Error('Database connection failed')
+      );
+
+      await pushCommand.execute(defaultOptions);
+
+      // Fetch should have been attempted
+      expect(mockScanApiService.fetchFilesForPush).toHaveBeenCalled();
+    });
+  });
+
+  describe('configuration validation', () => {
+    const defaultOptions = {
+      batchSize: '100',
+      uploadBatchSize: '10',
+    };
+
+    it('should report missing table name', async () => {
+      mockAppConfig.getScanConfig.mockReturnValue({
+        companySlug: 'test-company',
+        serverId: 'test-server',
+        basePathFull: '/test/path',
+        tableName: null, // Missing table name
+      });
+
+      await pushCommand.execute(defaultOptions);
+
+      expect(mockConsoleError).toHaveBeenCalledWith(
+        expect.stringContaining('Configuration errors')
+      );
+      expect(mockProcessExit).toHaveBeenCalledWith(1);
+    });
+  });
+});