@afterxleep/doc-bot/src/services/docset/__tests__/DocsetService.test.js

Generic MCP server for intelligent documentation access in any project

import { DocsetService } from '../index.js';
import fs from 'fs-extra';
import os from 'os';
import path from 'path';
import { fileURLToPath } from 'url';
import { dirname } from 'path';

const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);

describe('DocsetService', () => {
  let docsetService;
  let tempStoragePath;

  beforeEach(async () => {
    // Create a temporary directory for test docsets
    tempStoragePath = await fs.mkdtemp(path.join(os.tmpdir(), 'doc-bot-docsets-'));
    
    docsetService = new DocsetService(tempStoragePath);
  });

  afterEach(async () => {
    // Clean up temporary directory
    await fs.remove(tempStoragePath);
  });

  describe('constructor', () => {
    it('should create instance with custom storage path', () => {
      expect(docsetService.storagePath).toBe(tempStoragePath);
      expect(docsetService.metadataPath).toBe(path.join(tempStoragePath, 'docsets.json'));
    });

    it('should create instance with default storage path when none provided', () => {
      const defaultService = new DocsetService();
      const expectedPath = path.join(os.homedir(), 'Developer', 'DocSets');
      expect(defaultService.storagePath).toBe(expectedPath);
    });
  });

  describe('initialize', () => {
    it('should create storage directory if it does not exist', async () => {
      // Remove the directory first
      await fs.remove(tempStoragePath);
      expect(await fs.pathExists(tempStoragePath)).toBe(false);
      
      // Initialize should create it
      await docsetService.initialize();
      expect(await fs.pathExists(tempStoragePath)).toBe(true);
    });

    it('should load existing metadata on initialization', async () => {
      // Create test metadata
      const testMetadata = [
        {
          id: 'test-docset-1',
          name: 'Test Docset',
          downloadedAt: new Date().toISOString()
        }
      ];
      await fs.writeJson(docsetService.metadataPath, testMetadata);
      
      // Create the docset directory
      await fs.ensureDir(path.join(tempStoragePath, 'test-docset-1'));
      
      // Initialize and check if metadata is loaded
      await docsetService.initialize();
      expect(docsetService.docsets.size).toBe(1);
      expect(docsetService.docsets.has('test-docset-1')).toBe(true);
    });

    it('should skip docsets that no longer exist on disk', async () => {
      // Create metadata for non-existent docset
      const testMetadata = [
        {
          id: 'missing-docset',
          name: 'Missing Docset',
          downloadedAt: new Date().toISOString()
        }
      ];
      await fs.writeJson(docsetService.metadataPath, testMetadata);
      
      // Initialize and check that missing docset is not loaded
      await docsetService.initialize();
      expect(docsetService.docsets.size).toBe(0);
    });
  });

  describe('listDocsets', () => {
    it('should return empty array when no docsets are installed', async () => {
      await docsetService.initialize();
      const docsets = await docsetService.listDocsets();
      expect(docsets).toEqual([]);
    });

    it('should return list of installed docsets', async () => {
      // Add test docsets to internal map
      docsetService.docsets.set('test-1', { 
        id: 'test-1', 
        name: 'Test Docset 1',
        downloadedAt: new Date()
      });
      docsetService.docsets.set('test-2', { 
        id: 'test-2', 
        name: 'Test Docset 2',
        downloadedAt: new Date()
      });
      
      const docsets = await docsetService.listDocsets();
      expect(docsets).toHaveLength(2);
      expect(docsets[0].name).toBe('Test Docset 1');
      expect(docsets[1].name).toBe('Test Docset 2');
    });
  });

  describe('getDocset', () => {
    it('should return docset by ID', () => {
      const testDocset = { 
        id: 'test-docset', 
        name: 'Test Docset',
        downloadedAt: new Date()
      };
      docsetService.docsets.set('test-docset', testDocset);
      
      const result = docsetService.getDocset('test-docset');
      expect(result).toEqual(testDocset);
    });

    it('should return undefined for non-existent docset', () => {
      const result = docsetService.getDocset('non-existent');
      expect(result).toBeUndefined();
    });
  });

  describe('removeDocset', () => {
    it('should throw error when docset does not exist', async () => {
      await expect(docsetService.removeDocset('non-existent'))
        .rejects.toThrow('Docset non-existent not found');
    });

    it('should remove docset directory and metadata', async () => {
      // Create a test docset
      const docsetId = 'test-remove';
      const docsetPath = path.join(tempStoragePath, docsetId, 'Test.docset');
      await fs.ensureDir(docsetPath);
      
      docsetService.docsets.set(docsetId, {
        id: docsetId,
        name: 'Test Docset',
        path: docsetPath,
        downloadedAt: new Date()
      });
      await docsetService.saveMetadata();
      
      // Remove the docset
      await docsetService.removeDocset(docsetId);
      
      // Check that directory is removed
      expect(await fs.pathExists(path.join(tempStoragePath, docsetId))).toBe(false);
      
      // Check that metadata is updated
      expect(docsetService.docsets.has(docsetId)).toBe(false);
      
      // Check that metadata file is updated
      const metadata = await fs.readJson(docsetService.metadataPath);
      expect(metadata).toHaveLength(0);
    });
  });

  describe('download progress tracking', () => {
    it('should track download progress for a docset', () => {
      const docsetId = 'test-download';
      const progress = {
        docsetId,
        url: 'https://example.com/test.docset',
        percentage: 50
      };
      
      docsetService.downloadProgress.set(docsetId, progress);
      
      const result = docsetService.getDownloadProgress(docsetId);
      expect(result).toEqual(progress);
    });

    it('should return all download progress', () => {
      docsetService.downloadProgress.set('download-1', { percentage: 25 });
      docsetService.downloadProgress.set('download-2', { percentage: 75 });
      
      const allProgress = docsetService.getAllDownloadProgress();
      expect(allProgress).toHaveLength(2);
      expect(allProgress[0].percentage).toBe(25);
      expect(allProgress[1].percentage).toBe(75);
    });
  });
});