@arela/uploader 1.0.3 → 1.0.5

package/tests/commands/IdentifyCommand.test.js

@@ -0,0 +1,570 @@
+/**
+ * Unit tests for IdentifyCommand
+ * Tests the arela identify command functionality
+ */
+import { jest, describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+
+// Mock dependencies before importing IdentifyCommand
+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(),
+  getDetectionStats: jest.fn(),
+  fetchPdfsForDetection: jest.fn(),
+  batchUpdateDetection: jest.fn(),
+};
+
+const mockAppConfig = {
+  validateScanConfig: jest.fn(),
+  getScanConfig: jest.fn(),
+  getBasePath: jest.fn(),
+  setApiTarget: jest.fn(),
+};
+
+const mockFileDetectionService = {
+  detectFile: jest.fn(),
+};
+
+const mockFs = {
+  existsSync: jest.fn(),
+  statSync: jest.fn(),
+};
+
+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,
+}));
+
+jest.unstable_mockModule('p-limit', () => ({
+  default: jest.fn(() => (fn) => fn()),
+}));
+
+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,
+}));
+
+jest.unstable_mockModule('../../src/file-detection.js', () => ({
+  default: jest.fn(() => mockFileDetectionService),
+  FileDetectionService: jest.fn(() => mockFileDetectionService),
+}));
+
+jest.unstable_mockModule('../../src/errors/ErrorHandler.js', () => ({
+  default: jest.fn(() => ({
+    handleError: jest.fn(),
+  })),
+}));
+
+jest.unstable_mockModule('../../src/errors/ErrorTypes.js', () => ({
+  ConfigurationError: class ConfigurationError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = 'ConfigurationError';
+      this.errors = [];
+    }
+  },
+}));
+
+// Import the class after mocking
+const { IdentifyCommand } = await import('../../src/commands/IdentifyCommand.js');
+
+describe('IdentifyCommand', () => {
+  let identifyCommand;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    
+    // Default mock implementations
+    mockAppConfig.getScanConfig.mockReturnValue({
+      companySlug: 'test-company',
+      serverId: 'test-server',
+      basePathFull: '/test/path',
+    });
+    mockAppConfig.getBasePath.mockReturnValue('/test/path');
+    mockAppConfig.validateScanConfig.mockReturnValue(undefined);
+    
+    mockScanApiService.getInstanceTables.mockResolvedValue([
+      { tableName: 'scan_test_table' },
+    ]);
+    
+    mockScanApiService.getDetectionStats.mockResolvedValue({
+      totalPdfs: 100,
+      detected: 50,
+      pending: 50,
+      notPedimento: 0,
+      maxAttemptsReached: 0,
+      errors: 0,
+    });
+    
+    mockScanApiService.fetchPdfsForDetection.mockResolvedValue({
+      data: [],
+      hasMore: false,
+    });
+    
+    mockScanApiService.batchUpdateDetection.mockResolvedValue({
+      updated: 0,
+      errors: 0,
+    });
+    
+    mockFs.existsSync.mockReturnValue(true);
+    mockFs.statSync.mockReturnValue({ size: 1000, isFile: () => true });
+    
+    identifyCommand = new IdentifyCommand();
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should create a new IdentifyCommand instance', () => {
+      expect(identifyCommand).toBeInstanceOf(IdentifyCommand);
+      expect(identifyCommand.scanApiService).toBeNull();
+    });
+
+    it('should initialize detection service', () => {
+      expect(identifyCommand.detectionService).toBeDefined();
+    });
+  });
+
+  describe('execute', () => {
+    it('should validate scan configuration', async () => {
+      await identifyCommand.execute({});
+
+      expect(mockAppConfig.validateScanConfig).toHaveBeenCalled();
+    });
+
+    it('should fetch instance tables', async () => {
+      await identifyCommand.execute({});
+
+      expect(mockScanApiService.getInstanceTables).toHaveBeenCalledWith(
+        'test-company',
+        'test-server',
+        '/test/path'
+      );
+    });
+
+    it('should throw error when no tables found', async () => {
+      mockScanApiService.getInstanceTables.mockResolvedValue([]);
+
+      await expect(identifyCommand.execute({})).rejects.toThrow(
+        'No tables found for this instance'
+      );
+    });
+
+    it('should set API target when specified', async () => {
+      await identifyCommand.execute({ api: 'agencia' });
+
+      expect(mockAppConfig.setApiTarget).toHaveBeenCalledWith('agencia');
+    });
+
+    it('should use default batch size of 100', async () => {
+      await identifyCommand.execute({});
+
+      // Logger should show batch size
+      expect(mockLogger.info).toHaveBeenCalledWith(
+        expect.stringContaining('Batch Size: 100')
+      );
+    });
+
+    it('should use custom batch size when provided', async () => {
+      await identifyCommand.execute({ batchSize: 50 });
+
+      expect(mockLogger.info).toHaveBeenCalledWith(
+        expect.stringContaining('Batch Size: 50')
+      );
+    });
+
+    it('should skip table when all PDFs are processed', async () => {
+      mockScanApiService.getDetectionStats.mockResolvedValue({
+        totalPdfs: 100,
+        detected: 100,
+        pending: 0,
+        notPedimento: 0,
+        maxAttemptsReached: 0,
+        errors: 0,
+      });
+
+      await identifyCommand.execute({});
+
+      expect(mockLogger.info).toHaveBeenCalledWith(
+        expect.stringContaining('All PDFs processed')
+      );
+    });
+
+    it('should process pending PDFs', async () => {
+      mockScanApiService.getDetectionStats.mockResolvedValue({
+        totalPdfs: 10,
+        detected: 5,
+        pending: 5,
+        notPedimento: 0,
+        maxAttemptsReached: 0,
+        errors: 0,
+      });
+
+      mockScanApiService.fetchPdfsForDetection.mockResolvedValue({
+        data: [
+          { id: 1, absolute_path: '/test/file1.pdf', relative_path: 'file1.pdf' },
+          { id: 2, absolute_path: '/test/file2.pdf', relative_path: 'file2.pdf' },
+        ],
+        hasMore: false,
+      });
+
+      mockFileDetectionService.detectFile.mockResolvedValue({
+        detectedType: 'pedimento_simplificado',
+        detectedPedimento: '12345678',
+        detectedPedimentoYear: 2023,
+        rfc: 'RFC123456ABC',
+        arelaPath: 'RFC123456ABC/2023/3429/07/12345678/',
+      });
+
+      await identifyCommand.execute({});
+
+      expect(mockScanApiService.batchUpdateDetection).toHaveBeenCalled();
+    });
+  });
+
+  describe('file detection', () => {
+    beforeEach(() => {
+      mockScanApiService.getDetectionStats.mockResolvedValue({
+        totalPdfs: 1,
+        detected: 0,
+        pending: 1,
+        notPedimento: 0,
+        maxAttemptsReached: 0,
+        errors: 0,
+      });
+    });
+
+    it('should detect pedimento files', async () => {
+      mockScanApiService.fetchPdfsForDetection.mockResolvedValue({
+        data: [
+          { id: 1, absolute_path: '/test/pedimento.pdf', relative_path: 'pedimento.pdf' },
+        ],
+        hasMore: false,
+      });
+
+      mockFileDetectionService.detectFile.mockResolvedValue({
+        detectedType: 'pedimento_simplificado',
+        detectedPedimento: '12345678',
+        detectedPedimentoYear: 2023,
+        rfc: 'RFC123456ABC',
+        arelaPath: 'RFC123456ABC/2023/3429/07/12345678/',
+      });
+
+      await identifyCommand.execute({});
+
+      expect(mockFileDetectionService.detectFile).toHaveBeenCalledWith(
+        '/test/pedimento.pdf'
+      );
+    });
+
+    it('should handle file not found errors', async () => {
+      mockScanApiService.fetchPdfsForDetection.mockResolvedValue({
+        data: [
+          { id: 1, absolute_path: '/test/missing.pdf', relative_path: 'missing.pdf' },
+        ],
+        hasMore: false,
+      });
+
+      mockFs.existsSync.mockReturnValue(false);
+
+      await identifyCommand.execute({});
+
+      expect(mockScanApiService.batchUpdateDetection).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.arrayContaining([
+          expect.objectContaining({
+            id: 1,
+            detectionError: expect.stringContaining('FILE_NOT_FOUND'),
+          }),
+        ])
+      );
+    });
+
+    it('should skip files exceeding max size', async () => {
+      mockScanApiService.fetchPdfsForDetection.mockResolvedValue({
+        data: [
+          { id: 1, absolute_path: '/test/large.pdf', relative_path: 'large.pdf' },
+        ],
+        hasMore: false,
+      });
+
+      // 60MB file (exceeds 50MB limit)
+      mockFs.statSync.mockReturnValue({ size: 60 * 1024 * 1024 });
+
+      await identifyCommand.execute({});
+
+      expect(mockScanApiService.batchUpdateDetection).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.arrayContaining([
+          expect.objectContaining({
+            id: 1,
+            detectionError: expect.stringContaining('FILE_TOO_LARGE'),
+          }),
+        ])
+      );
+    });
+
+    it('should handle detection service errors', async () => {
+      mockScanApiService.fetchPdfsForDetection.mockResolvedValue({
+        data: [
+          { id: 1, absolute_path: '/test/corrupt.pdf', relative_path: 'corrupt.pdf' },
+        ],
+        hasMore: false,
+      });
+
+      mockFileDetectionService.detectFile.mockRejectedValue(
+        new Error('PDF parsing failed')
+      );
+
+      await identifyCommand.execute({});
+
+      expect(mockScanApiService.batchUpdateDetection).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.arrayContaining([
+          expect.objectContaining({
+            id: 1,
+            detectionError: expect.stringContaining('PDF parsing failed'),
+          }),
+        ])
+      );
+    });
+  });
+
+  describe('batch processing', () => {
+    it('should process multiple batches when hasMore is true', async () => {
+      mockScanApiService.getDetectionStats.mockResolvedValue({
+        totalPdfs: 200,
+        detected: 0,
+        pending: 200,
+        notPedimento: 0,
+        maxAttemptsReached: 0,
+        errors: 0,
+      });
+
+      // First call returns files with hasMore=true
+      mockScanApiService.fetchPdfsForDetection
+        .mockResolvedValueOnce({
+          data: [{ id: 1, absolute_path: '/test/file1.pdf', relative_path: 'file1.pdf' }],
+          hasMore: true,
+        })
+        .mockResolvedValueOnce({
+          data: [{ id: 2, absolute_path: '/test/file2.pdf', relative_path: 'file2.pdf' }],
+          hasMore: false,
+        });
+
+      mockFileDetectionService.detectFile.mockResolvedValue({
+        detectedType: null,
+        text: '',
+      });
+
+      await identifyCommand.execute({});
+
+      expect(mockScanApiService.fetchPdfsForDetection).toHaveBeenCalledTimes(2);
+    });
+
+    it('should stop processing when no more files', async () => {
+      mockScanApiService.getDetectionStats.mockResolvedValue({
+        totalPdfs: 10,
+        detected: 0,
+        pending: 10,
+        notPedimento: 0,
+        maxAttemptsReached: 0,
+        errors: 0,
+      });
+
+      mockScanApiService.fetchPdfsForDetection.mockResolvedValue({
+        data: [],
+        hasMore: false,
+      });
+
+      await identifyCommand.execute({});
+
+      expect(mockScanApiService.fetchPdfsForDetection).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('progress tracking', () => {
+    it('should create progress bar for pending PDFs', async () => {
+      mockScanApiService.getDetectionStats.mockResolvedValue({
+        totalPdfs: 10,
+        detected: 0,
+        pending: 10,
+        notPedimento: 0,
+        maxAttemptsReached: 0,
+        errors: 0,
+      });
+
+      mockScanApiService.fetchPdfsForDetection.mockResolvedValue({
+        data: [{ id: 1, absolute_path: '/test/file.pdf', relative_path: 'file.pdf' }],
+        hasMore: false,
+      });
+
+      mockFileDetectionService.detectFile.mockResolvedValue({
+        detectedType: null,
+        text: '',
+      });
+
+      await identifyCommand.execute({});
+
+      expect(mockCliProgress.SingleBar).toHaveBeenCalled();
+      expect(mockProgressBar.start).toHaveBeenCalled();
+      expect(mockProgressBar.stop).toHaveBeenCalled();
+    });
+  });
+
+  describe('statistics', () => {
+    it('should show detailed stats when showStats option is enabled', async () => {
+      mockScanApiService.getDetectionStats.mockResolvedValue({
+        totalPdfs: 10,
+        detected: 5,
+        pending: 0,
+        notPedimento: 5,
+        maxAttemptsReached: 0,
+        errors: 0,
+      });
+
+      await identifyCommand.execute({ showStats: true });
+
+      expect(mockLogger.info).toHaveBeenCalledWith(
+        expect.stringContaining('Detailed Statistics')
+      );
+    });
+
+    it('should log max attempts reached warning', async () => {
+      mockScanApiService.getDetectionStats.mockResolvedValue({
+        totalPdfs: 10,
+        detected: 5,
+        pending: 0,
+        notPedimento: 3,
+        maxAttemptsReached: 2,
+        errors: 0,
+      });
+
+      await identifyCommand.execute({});
+
+      expect(mockLogger.info).toHaveBeenCalledWith(
+        expect.stringContaining('2 PDFs reached max attempts')
+      );
+    });
+  });
+
+  describe('error handling', () => {
+    it('should handle configuration errors', async () => {
+      const { ConfigurationError } = await import('../../src/errors/ErrorTypes.js');
+      mockAppConfig.validateScanConfig.mockImplementation(() => {
+        const error = new ConfigurationError('Missing config');
+        error.errors = ['Missing company slug'];
+        throw error;
+      });
+
+      await expect(identifyCommand.execute({})).rejects.toThrow('Missing config');
+    });
+
+    it('should handle API errors', async () => {
+      mockScanApiService.getInstanceTables.mockRejectedValue(
+        new Error('API connection failed')
+      );
+
+      await expect(identifyCommand.execute({})).rejects.toThrow(
+        'API connection failed'
+      );
+    });
+  });
+
+  describe('pedimento detection logic', () => {
+    beforeEach(() => {
+      mockScanApiService.getDetectionStats.mockResolvedValue({
+        totalPdfs: 1,
+        detected: 0,
+        pending: 1,
+        notPedimento: 0,
+        maxAttemptsReached: 0,
+        errors: 0,
+      });
+
+      mockScanApiService.fetchPdfsForDetection.mockResolvedValue({
+        data: [{ id: 1, absolute_path: '/test/file.pdf', relative_path: 'file.pdf' }],
+        hasMore: false,
+      });
+    });
+
+    it('should mark file as not pedimento when marker not found', async () => {
+      mockFileDetectionService.detectFile.mockResolvedValue({
+        detectedType: null,
+        detectedPedimento: null,
+        detectedPedimentoYear: null,
+        rfc: null,
+        arelaPath: null,
+        text: 'Some random text without pedimento marker',
+      });
+
+      await identifyCommand.execute({});
+
+      expect(mockScanApiService.batchUpdateDetection).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.arrayContaining([
+          expect.objectContaining({
+            isNotPedimento: true,
+          }),
+        ])
+      );
+    });
+
+    it('should not mark as not pedimento when has required marker', async () => {
+      mockFileDetectionService.detectFile.mockResolvedValue({
+        detectedType: null,
+        detectedPedimento: null,
+        detectedPedimentoYear: null,
+        rfc: null,
+        arelaPath: null,
+        text: 'FORMA SIMPLIFICADA DE PEDIMENTO but missing fields',
+      });
+
+      await identifyCommand.execute({});
+
+      expect(mockScanApiService.batchUpdateDetection).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.arrayContaining([
+          expect.objectContaining({
+            isNotPedimento: false,
+          }),
+        ])
+      );
+    });
+  });
+});