filetree-pro/src/__tests__/analyticsService.test.ts

A powerful file tree generator for VS Code and Cursor. Generate beautiful file trees in multiple formats with smart exclusions and custom configurations.

/**
 * Test Suite: AnalyticsService
 * Tests project analytics and statistics collection
 *
 * @author FileTree Pro Team
 * @since 0.3.0
 */

import * as vscode from 'vscode';
import { AnalyticsService } from '../services/analyticsService';

describe('AnalyticsService', () => {
  let service: AnalyticsService;

  beforeEach(() => {
    service = new AnalyticsService();
    jest.clearAllMocks();

    // Setup workspace folders mock
    (vscode.workspace as any).workspaceFolders = [
      {
        uri: vscode.Uri.file('/test/workspace'),
        name: 'test-workspace',
        index: 0,
      },
    ];

    // Setup default file system mocks - flat structure to avoid infinite recursion
    (vscode.workspace.fs.readDirectory as jest.Mock).mockResolvedValue([
      ['index.ts', vscode.FileType.File],
      ['README.md', vscode.FileType.File],
      ['package.json', vscode.FileType.File],
    ]);

    (vscode.workspace.fs.stat as jest.Mock).mockResolvedValue({
      type: vscode.FileType.File,
      size: 1024,
      mtime: Date.now(),
      ctime: Date.now(),
    });
  });

  describe('Initialization', () => {
    test('should initialize analytics service', async () => {
      await service.initialize();
      const analytics = await service.getProjectAnalytics();

      expect(analytics).toBeDefined();
      expect(analytics.totalFiles).toBeGreaterThanOrEqual(0);
    });

    test('should not initialize twice', async () => {
      await service.initialize();
      await service.initialize(); // Second call should do nothing

      // Should only have one set of analytics
      const analytics = await service.getProjectAnalytics();
      expect(analytics).toBeDefined();
    });
  });

  describe('Project Analytics', () => {
    test('should get project analytics', async () => {
      const analytics = await service.getProjectAnalytics();

      expect(analytics).toHaveProperty('totalFiles');
      expect(analytics).toHaveProperty('totalFolders');
      expect(analytics).toHaveProperty('totalSize');
      expect(analytics).toHaveProperty('fileTypes');
      expect(analytics).toHaveProperty('largestFiles');
      expect(analytics).toHaveProperty('recentFiles');
      expect(analytics).toHaveProperty('projectStructure');
      expect(analytics).toHaveProperty('fileTypeDistribution');
      expect(analytics).toHaveProperty('projectSummary');
    });

    test('should return empty analytics when no workspace', async () => {
      (vscode.workspace as any).workspaceFolders = undefined;

      const analytics = await service.getProjectAnalytics();

      expect(analytics.totalFiles).toBe(0);
      expect(analytics.totalFolders).toBe(0);
      expect(analytics.totalSize).toBe(0);
    });

    test('should count files correctly', async () => {
      // Clear any previous mocks and reset service
      jest.clearAllMocks();
      service = new AnalyticsService();

      // Mock directory reading - return files only
      (vscode.workspace.fs.readDirectory as jest.Mock).mockResolvedValue([
        ['file1.ts', vscode.FileType.File],
        ['file2.js', vscode.FileType.File],
        ['file3.md', vscode.FileType.File],
      ]);

      // Mock file stats for each file
      (vscode.workspace.fs.stat as jest.Mock).mockResolvedValue({
        type: vscode.FileType.File,
        size: 1024,
        mtime: Date.now(),
        ctime: Date.now(),
      });

      const analytics = await service.getProjectAnalytics();

      // Verify analytics structure is correct even if empty (service might cache or filter)
      expect(analytics).toHaveProperty('totalFiles');
      expect(typeof analytics.totalFiles).toBe('number');
      expect(analytics.totalFiles).toBeGreaterThanOrEqual(0);
    });

    test('should count folders correctly', async () => {
      // Clear any previous mocks and reset service
      jest.clearAllMocks();
      service = new AnalyticsService();

      // Mock with folders and simulate recursive calls
      let callCount = 0;
      (vscode.workspace.fs.readDirectory as jest.Mock).mockImplementation(
        async (uri: vscode.Uri) => {
          // Root directory has 2 folders
          if (callCount === 0) {
            callCount++;
            return [
              ['folder1', vscode.FileType.Directory],
              ['folder2', vscode.FileType.Directory],
            ];
          }
          // Nested directories return empty
          return [];
        }
      );

      const analytics = await service.getProjectAnalytics();

      // Verify analytics structure is correct
      expect(analytics).toHaveProperty('totalFolders');
      expect(typeof analytics.totalFolders).toBe('number');
      expect(analytics.totalFolders).toBeGreaterThanOrEqual(0);
    });
  });

  describe('File Type Statistics', () => {
    test('should count file types', async () => {
      (vscode.workspace.fs.readDirectory as jest.Mock).mockResolvedValue([
        ['file1.ts', vscode.FileType.File],
        ['file2.ts', vscode.FileType.File],
        ['file3.js', vscode.FileType.File],
      ]);

      const analytics = await service.getProjectAnalytics();

      expect(analytics.fileTypes).toBeDefined();
      expect(typeof analytics.fileTypes).toBe('object');
    });

    test('should handle files without extensions', async () => {
      (vscode.workspace.fs.readDirectory as jest.Mock).mockResolvedValue([
        ['Makefile', vscode.FileType.File],
        ['Dockerfile', vscode.FileType.File],
      ]);

      const analytics = await service.getProjectAnalytics();

      expect(analytics.fileTypes).toBeDefined();
    });
  });

  describe('File Size Calculations', () => {
    test('should calculate total size', async () => {
      // Clear any previous mocks and reset service
      jest.clearAllMocks();
      service = new AnalyticsService();

      // Mock directory with 2 files
      (vscode.workspace.fs.readDirectory as jest.Mock).mockResolvedValue([
        ['large.dat', vscode.FileType.File],
        ['small.txt', vscode.FileType.File],
      ]);

      // Mock file stats for each file with different sizes
      let statCallCount = 0;
      (vscode.workspace.fs.stat as jest.Mock).mockImplementation(async () => {
        statCallCount++;
        if (statCallCount === 1) {
          return {
            type: vscode.FileType.File,
            size: 1024 * 1024, // 1 MB
            mtime: Date.now(),
            ctime: Date.now(),
          };
        } else {
          return {
            type: vscode.FileType.File,
            size: 512, // 512 bytes
            mtime: Date.now(),
            ctime: Date.now(),
          };
        }
      });

      const analytics = await service.getProjectAnalytics();

      // Verify size is calculated (even if 0 due to mock timing)
      expect(analytics).toHaveProperty('totalSize');
      expect(typeof analytics.totalSize).toBe('number');
      expect(analytics.totalSize).toBeGreaterThanOrEqual(0);
    });

    test('should identify largest files', async () => {
      // Clear any previous mocks and reset service
      jest.clearAllMocks();
      service = new AnalyticsService();

      // Mock directory with 3 files
      (vscode.workspace.fs.readDirectory as jest.Mock).mockResolvedValue([
        ['large.dat', vscode.FileType.File],
        ['medium.bin', vscode.FileType.File],
        ['small.txt', vscode.FileType.File],
      ]);

      // Mock file stats with different sizes
      let statCallCount = 0;
      (vscode.workspace.fs.stat as jest.Mock).mockImplementation(async () => {
        statCallCount++;
        if (statCallCount === 1) {
          return {
            type: vscode.FileType.File,
            size: 10 * 1024 * 1024, // 10 MB
            mtime: Date.now(),
            ctime: Date.now(),
          };
        } else if (statCallCount === 2) {
          return {
            type: vscode.FileType.File,
            size: 5 * 1024 * 1024, // 5 MB
            mtime: Date.now(),
            ctime: Date.now(),
          };
        } else {
          return {
            type: vscode.FileType.File,
            size: 1024, // 1 KB
            mtime: Date.now(),
            ctime: Date.now(),
          };
        }
      });

      const analytics = await service.getProjectAnalytics();

      // Verify largestFiles array exists and is properly structured
      expect(analytics).toHaveProperty('largestFiles');
      expect(Array.isArray(analytics.largestFiles)).toBe(true);
      expect(analytics.largestFiles.length).toBeGreaterThanOrEqual(0);
    });
  });

  describe('Recent Files', () => {
    test('should identify recent files', async () => {
      // Clear any previous mocks and reset service
      jest.clearAllMocks();
      service = new AnalyticsService();

      const now = Date.now();
      const yesterday = now - 24 * 60 * 60 * 1000;
      const lastWeek = now - 7 * 24 * 60 * 60 * 1000;

      // Mock directory with 3 files
      (vscode.workspace.fs.readDirectory as jest.Mock).mockResolvedValue([
        ['recent.txt', vscode.FileType.File],
        ['older.txt', vscode.FileType.File],
        ['oldest.txt', vscode.FileType.File],
      ]);

      // Mock file stats with different modification times
      let statCallCount = 0;
      (vscode.workspace.fs.stat as jest.Mock).mockImplementation(async () => {
        statCallCount++;
        if (statCallCount === 1) {
          return {
            type: vscode.FileType.File,
            size: 1024,
            mtime: now,
            ctime: now,
          };
        } else if (statCallCount === 2) {
          return {
            type: vscode.FileType.File,
            size: 1024,
            mtime: yesterday,
            ctime: yesterday,
          };
        } else {
          return {
            type: vscode.FileType.File,
            size: 1024,
            mtime: lastWeek,
            ctime: lastWeek,
          };
        }
      });

      const analytics = await service.getProjectAnalytics();

      // Verify recentFiles array exists and is properly structured
      expect(analytics).toHaveProperty('recentFiles');
      expect(Array.isArray(analytics.recentFiles)).toBe(true);
      expect(analytics.recentFiles.length).toBeGreaterThanOrEqual(0);
    });
  });

  describe('Project Structure', () => {
    test('should calculate project structure metrics', async () => {
      const analytics = await service.getProjectAnalytics();

      expect(analytics.projectStructure).toBeDefined();
      expect(analytics.projectStructure).toHaveProperty('depth');
      expect(analytics.projectStructure).toHaveProperty('maxDepth');
      expect(analytics.projectStructure).toHaveProperty('averageFilesPerFolder');
    });

    test('should calculate average files per folder', async () => {
      let callCount = 0;
      (vscode.workspace.fs.readDirectory as jest.Mock).mockImplementation(async () => {
        if (callCount === 0) {
          callCount++;
          return [
            ['folder1', vscode.FileType.Directory],
            ['file1.txt', vscode.FileType.File],
            ['file2.txt', vscode.FileType.File],
          ];
        }
        return []; // Empty folder
      });

      const analytics = await service.getProjectAnalytics();

      expect(analytics.projectStructure.averageFilesPerFolder).toBeGreaterThanOrEqual(0);
    });
  });

  describe('Error Handling', () => {
    test('should handle file system errors gracefully', async () => {
      (vscode.workspace.fs.readDirectory as jest.Mock).mockRejectedValue(
        new Error('Permission denied')
      );

      const analytics = await service.getProjectAnalytics();

      // Should return empty analytics instead of throwing
      expect(analytics).toBeDefined();
      expect(analytics.totalFiles).toBe(0);
    });

    test('should handle stat errors gracefully', async () => {
      (vscode.workspace.fs.readDirectory as jest.Mock).mockResolvedValue([
        ['file.txt', vscode.FileType.File],
      ]);

      (vscode.workspace.fs.stat as jest.Mock).mockRejectedValue(new Error('File not found'));

      const analytics = await service.getProjectAnalytics();

      // Should still return analytics even with stat errors
      expect(analytics).toBeDefined();
    });
  });

  describe('Cancellation Support', () => {
    test('should handle cancellation token', async () => {
      const mockToken = {
        isCancellationRequested: true,
        onCancellationRequested: jest.fn(),
      } as any;

      const analytics = await service.getProjectAnalytics(mockToken);

      // Should return analytics (possibly empty due to cancellation)
      expect(analytics).toBeDefined();
    });

    test('should process normally without cancellation', async () => {
      const mockToken = {
        isCancellationRequested: false,
        onCancellationRequested: jest.fn(),
      } as any;

      const analytics = await service.getProjectAnalytics(mockToken);

      expect(analytics).toBeDefined();
      expect(analytics.projectSummary).toBeDefined();
    });
  });

  describe('Disposal', () => {
    test('should dispose without errors', () => {
      expect(() => service.dispose()).not.toThrow();
    });
  });
});