@arela/uploader 1.0.3 → 1.0.5

package/tests/commands/ScanCommand.test.js

@@ -0,0 +1,382 @@
+/**
+ * Unit tests for ScanCommand
+ * Tests the arela scan command functionality
+ */
+import { jest, describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+
+// Mock dependencies before importing ScanCommand
+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(),
+  startTime: Date.now(),
+};
+
+const mockCliProgress = {
+  SingleBar: jest.fn(() => mockProgressBar),
+  Presets: {
+    shades_classic: {},
+    legacy: {},
+  },
+};
+
+const mockScanApiService = {
+  registerInstance: jest.fn(),
+  batchInsertStats: jest.fn(),
+  completeScan: jest.fn(),
+};
+
+const mockAppConfig = {
+  validateScanConfig: jest.fn(),
+  getScanConfig: jest.fn(),
+  getBasePath: jest.fn(),
+  getUploadSources: jest.fn(),
+};
+
+const mockPathNormalizer = {
+  toAbsolutePath: jest.fn((p) => `/absolute/${p}`),
+  normalizeSeparators: jest.fn((p) => p.replace(/\\/g, '/')),
+  getRelativePath: jest.fn((file, base) => file.replace(base, '')),
+  generateTableName: jest.fn(() => 'scan_test_table'),
+};
+
+const mockGlobbyStream = jest.fn();
+
+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,
+}));
+
+jest.unstable_mockModule('../../src/utils/PathNormalizer.js', () => ({
+  default: mockPathNormalizer,
+}));
+
+jest.unstable_mockModule('globby', () => ({
+  globbyStream: mockGlobbyStream,
+}));
+
+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 { ScanCommand } = await import('../../src/commands/ScanCommand.js');
+
+describe('ScanCommand', () => {
+  let scanCommand;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    
+    // Default mock implementations
+    mockAppConfig.getScanConfig.mockReturnValue({
+      companySlug: 'test-company',
+      serverId: 'test-server',
+      directoryLevel: 0,
+      excludePatterns: ['.DS_Store', 'Thumbs.db'],
+      batchSize: 2000,
+    });
+    mockAppConfig.getBasePath.mockReturnValue('./test-path');
+    mockAppConfig.getUploadSources.mockReturnValue(['.']);
+    mockAppConfig.validateScanConfig.mockReturnValue(undefined);
+    
+    mockScanApiService.registerInstance.mockResolvedValue({
+      tableName: 'scan_test_table',
+      existed: false,
+    });
+    mockScanApiService.batchInsertStats.mockResolvedValue({ inserted: 10 });
+    mockScanApiService.completeScan.mockResolvedValue({ success: true });
+    
+    scanCommand = new ScanCommand();
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should create a new ScanCommand instance', () => {
+      expect(scanCommand).toBeInstanceOf(ScanCommand);
+      expect(scanCommand.scanApiService).toBeNull();
+    });
+  });
+
+  describe('execute', () => {
+    it('should validate scan configuration', async () => {
+      // Setup mock for empty file stream
+      mockGlobbyStream.mockReturnValue({
+        async *[Symbol.asyncIterator]() {
+          // Empty stream
+        },
+      });
+
+      await scanCommand.execute({});
+
+      expect(mockAppConfig.validateScanConfig).toHaveBeenCalled();
+    });
+
+    it('should return success with stats when scan completes', async () => {
+      mockGlobbyStream.mockReturnValue({
+        async *[Symbol.asyncIterator]() {
+          // Empty stream for simplicity
+        },
+      });
+
+      const result = await scanCommand.execute({});
+
+      expect(result).toHaveProperty('success');
+      expect(result).toHaveProperty('stats');
+      expect(result.stats).toHaveProperty('filesScanned');
+      expect(result.stats).toHaveProperty('filesInserted');
+      expect(result.stats).toHaveProperty('filesSkipped');
+      expect(result.stats).toHaveProperty('totalSize');
+    });
+
+    it('should discover directories when directoryLevel is 0', async () => {
+      mockAppConfig.getScanConfig.mockReturnValue({
+        companySlug: 'test-company',
+        serverId: 'test-server',
+        directoryLevel: 0,
+        excludePatterns: [],
+        batchSize: 2000,
+      });
+
+      mockGlobbyStream.mockReturnValue({
+        async *[Symbol.asyncIterator]() {
+          // Empty stream
+        },
+      });
+
+      const result = await scanCommand.execute({});
+
+      expect(result.success).toBe(true);
+      expect(mockScanApiService.registerInstance).toHaveBeenCalled();
+    });
+
+    it('should handle configuration errors gracefully', async () => {
+      const { ConfigurationError } = await import('../../src/errors/ErrorTypes.js');
+      mockAppConfig.validateScanConfig.mockImplementation(() => {
+        throw new ConfigurationError('Missing required config');
+      });
+
+      const result = await scanCommand.execute({});
+
+      expect(result.success).toBe(false);
+      expect(result).toHaveProperty('error');
+    });
+
+    it('should register instances for each discovered directory', async () => {
+      mockAppConfig.getUploadSources.mockReturnValue(['.', 'subdir']);
+
+      mockGlobbyStream.mockReturnValue({
+        async *[Symbol.asyncIterator]() {
+          // Empty stream
+        },
+      });
+
+      await scanCommand.execute({});
+
+      expect(mockScanApiService.registerInstance).toHaveBeenCalled();
+    });
+
+    it('should complete scan after processing', async () => {
+      mockGlobbyStream.mockReturnValue({
+        async *[Symbol.asyncIterator]() {
+          // Empty stream
+        },
+      });
+
+      await scanCommand.execute({});
+
+      expect(mockScanApiService.completeScan).toHaveBeenCalled();
+    });
+
+    it('should return tables in result when successful', async () => {
+      mockScanApiService.registerInstance.mockResolvedValue({
+        tableName: 'scan_unique_table',
+        existed: false,
+      });
+
+      mockGlobbyStream.mockReturnValue({
+        async *[Symbol.asyncIterator]() {
+          // Empty stream
+        },
+      });
+
+      const result = await scanCommand.execute({});
+
+      expect(result.success).toBe(true);
+      expect(result.tables).toContain('scan_unique_table');
+    });
+
+    it('should handle countFirst option', async () => {
+      mockGlobbyStream.mockReturnValue({
+        async *[Symbol.asyncIterator]() {
+          // Empty stream
+        },
+      });
+
+      const result = await scanCommand.execute({ countFirst: true });
+
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('error handling', () => {
+    it('should handle API errors during registration', async () => {
+      mockScanApiService.registerInstance.mockRejectedValue(
+        new Error('API connection failed')
+      );
+
+      const result = await scanCommand.execute({});
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('API connection failed');
+    });
+
+    it('should handle batch insert failures', async () => {
+      mockScanApiService.batchInsertStats.mockRejectedValue(
+        new Error('Database error')
+      );
+
+      mockGlobbyStream.mockReturnValue({
+        async *[Symbol.asyncIterator]() {
+          yield { path: '/test/file.txt', stats: { size: 100, mtime: new Date() } };
+        },
+      });
+
+      const result = await scanCommand.execute({});
+
+      // Command should still complete but with errors
+      expect(result).toBeDefined();
+    });
+
+    it('should return zero stats on failure', async () => {
+      mockAppConfig.validateScanConfig.mockImplementation(() => {
+        throw new Error('Config validation failed');
+      });
+
+      const result = await scanCommand.execute({});
+
+      expect(result.success).toBe(false);
+      expect(result.stats.filesScanned).toBe(0);
+      expect(result.stats.filesInserted).toBe(0);
+      expect(result.stats.filesSkipped).toBe(0);
+      expect(result.stats.totalSize).toBe(0);
+    });
+  });
+
+  describe('file exclusion', () => {
+    it('should exclude files matching exclude patterns', async () => {
+      mockAppConfig.getScanConfig.mockReturnValue({
+        companySlug: 'test-company',
+        serverId: 'test-server',
+        directoryLevel: 0,
+        excludePatterns: ['.DS_Store', '*.tmp'],
+        batchSize: 2000,
+      });
+
+      mockGlobbyStream.mockReturnValue({
+        async *[Symbol.asyncIterator]() {
+          yield { path: '/test/.DS_Store', stats: { size: 100, mtime: new Date() } };
+          yield { path: '/test/valid.pdf', stats: { size: 200, mtime: new Date() } };
+        },
+      });
+
+      const result = await scanCommand.execute({});
+
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe('progress tracking', () => {
+    it('should create progress bar during scan', async () => {
+      mockGlobbyStream.mockReturnValue({
+        async *[Symbol.asyncIterator]() {
+          yield { path: '/test/file1.pdf', stats: { size: 100, mtime: new Date() } };
+        },
+      });
+
+      await scanCommand.execute({});
+
+      expect(mockCliProgress.SingleBar).toHaveBeenCalled();
+    });
+
+    it('should stop progress bar after scan completes', async () => {
+      mockGlobbyStream.mockReturnValue({
+        async *[Symbol.asyncIterator]() {
+          // Empty stream
+        },
+      });
+
+      await scanCommand.execute({});
+
+      expect(mockProgressBar.stop).toHaveBeenCalled();
+    });
+  });
+
+  describe('batch processing', () => {
+    it('should process files in batches', async () => {
+      const fileCount = 5;
+      const files = Array.from({ length: fileCount }, (_, i) => ({
+        path: `/test/file${i}.pdf`,
+        stats: { size: 100, mtime: new Date() },
+      }));
+
+      mockGlobbyStream.mockReturnValue({
+        async *[Symbol.asyncIterator]() {
+          for (const file of files) {
+            yield file;
+          }
+        },
+      });
+
+      mockAppConfig.getScanConfig.mockReturnValue({
+        companySlug: 'test-company',
+        serverId: 'test-server',
+        directoryLevel: 0,
+        excludePatterns: [],
+        batchSize: 2, // Small batch size to test batching
+      });
+
+      const result = await scanCommand.execute({});
+
+      expect(result.success).toBe(true);
+      // Should have called batchInsertStats multiple times due to small batch size
+      expect(mockScanApiService.batchInsertStats).toHaveBeenCalled();
+    });
+  });
+});