@afterxleep/doc-bot 1.9.1 → 1.13.0

package/src/services/docset/__tests__/DocsetDatabase.test.js

@@ -0,0 +1,337 @@
+import { DocsetDatabase, MultiDocsetDatabase } from '../database.js';
+import Database from 'better-sqlite3';
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+describe('DocsetDatabase', () => {
+  let tempDir;
+  let testDbPath;
+  let testDb;
+  let docsetInfo;
+
+  beforeEach(async () => {
+    // Create temporary directory and test database
+    tempDir = path.join(__dirname, 'temp-db-' + Date.now());
+    await fs.ensureDir(tempDir);
+    
+    // Create docset structure
+    const docsetPath = path.join(tempDir, 'Test.docset');
+    const resourcesPath = path.join(docsetPath, 'Contents', 'Resources');
+    await fs.ensureDir(resourcesPath);
+    
+    testDbPath = path.join(resourcesPath, 'docSet.dsidx');
+    
+    // Create test SQLite database with docset schema
+    testDb = new Database(testDbPath);
+    testDb.exec(`
+      CREATE TABLE searchIndex(
+        id INTEGER PRIMARY KEY,
+        name TEXT,
+        type TEXT,
+        path TEXT
+      );
+      CREATE UNIQUE INDEX anchor ON searchIndex (name, type, path);
+    `);
+    
+    // Insert test data
+    const insertStmt = testDb.prepare('INSERT INTO searchIndex (name, type, path) VALUES (?, ?, ?)');
+    insertStmt.run('UIViewController', 'Class', 'UIKit/UIViewController.html');
+    insertStmt.run('viewDidLoad', 'Method', 'UIKit/UIViewController.html#viewDidLoad');
+    insertStmt.run('NSString', 'Class', 'Foundation/NSString.html');
+    insertStmt.run('stringWithFormat:', 'Method', 'Foundation/NSString.html#stringWithFormat');
+    insertStmt.run('iOS App Lifecycle', 'Guide', 'Guides/AppLifecycle.html');
+    testDb.close();
+    
+    // Create docset info
+    docsetInfo = {
+      id: 'test-docset',
+      name: 'Test Docset',
+      path: docsetPath
+    };
+  });
+
+  afterEach(async () => {
+    // Clean up
+    await fs.remove(tempDir);
+  });
+
+  describe('constructor', () => {
+    it('should open database in readonly mode', () => {
+      const docsetDb = new DocsetDatabase(docsetInfo);
+      expect(docsetDb.docsetInfo).toEqual(docsetInfo);
+      expect(docsetDb.db.readonly).toBe(true);
+      docsetDb.close();
+    });
+  });
+
+  describe('search', () => {
+    it('should search by query with case-insensitive matching', () => {
+      const docsetDb = new DocsetDatabase(docsetInfo);
+      
+      const results = docsetDb.search('view');
+      expect(results).toHaveLength(2);
+      expect(results[0].name).toBe('viewDidLoad');
+      expect(results[1].name).toBe('UIViewController');
+      
+      docsetDb.close();
+    });
+
+    it('should filter by type when provided', () => {
+      const docsetDb = new DocsetDatabase(docsetInfo);
+      
+      const results = docsetDb.search('i', 'Class');
+      expect(results).toHaveLength(2); // UIViewController and NSString
+      expect(results.every(r => r.type === 'Class')).toBe(true);
+      
+      docsetDb.close();
+    });
+
+    it('should respect limit parameter', () => {
+      const docsetDb = new DocsetDatabase(docsetInfo);
+      
+      const results = docsetDb.search('i', null, 2);
+      expect(results).toHaveLength(2);
+      
+      docsetDb.close();
+    });
+
+    it('should include docset metadata in results', () => {
+      const docsetDb = new DocsetDatabase(docsetInfo);
+      
+      const results = docsetDb.search('UIViewController');
+      expect(results[0]).toMatchObject({
+        name: 'UIViewController',
+        type: 'Class',
+        url: 'UIKit/UIViewController.html',
+        docsetId: 'test-docset',
+        docsetName: 'Test Docset'
+      });
+      
+      docsetDb.close();
+    });
+  });
+
+  describe('searchExact', () => {
+    it('should find exact name match', () => {
+      const docsetDb = new DocsetDatabase(docsetInfo);
+      
+      const result = docsetDb.searchExact('UIViewController');
+      expect(result).toMatchObject({
+        name: 'UIViewController',
+        type: 'Class',
+        url: 'UIKit/UIViewController.html'
+      });
+      
+      docsetDb.close();
+    });
+
+    it('should return null when no exact match found', () => {
+      const docsetDb = new DocsetDatabase(docsetInfo);
+      
+      const result = docsetDb.searchExact('NonExistent');
+      expect(result).toBeNull();
+      
+      docsetDb.close();
+    });
+
+    it('should filter by type when provided', () => {
+      const docsetDb = new DocsetDatabase(docsetInfo);
+      
+      // Should not find UIViewController when searching for Method type
+      const result = docsetDb.searchExact('UIViewController', 'Method');
+      expect(result).toBeNull();
+      
+      docsetDb.close();
+    });
+  });
+
+  describe('statistics methods', () => {
+    it('should get all unique types', () => {
+      const docsetDb = new DocsetDatabase(docsetInfo);
+      
+      const types = docsetDb.getTypes();
+      expect(types).toEqual(['Class', 'Guide', 'Method']);
+      
+      docsetDb.close();
+    });
+
+    it('should count entries by type', () => {
+      const docsetDb = new DocsetDatabase(docsetInfo);
+      
+      expect(docsetDb.getTypeCount('Class')).toBe(2);
+      expect(docsetDb.getTypeCount('Method')).toBe(2);
+      expect(docsetDb.getTypeCount('Guide')).toBe(1);
+      
+      docsetDb.close();
+    });
+
+    it('should get total entry count', () => {
+      const docsetDb = new DocsetDatabase(docsetInfo);
+      
+      expect(docsetDb.getEntryCount()).toBe(5);
+      
+      docsetDb.close();
+    });
+  });
+});
+
+describe('MultiDocsetDatabase', () => {
+  let multiDb;
+  let tempDir;
+  let docset1Info;
+  let docset2Info;
+
+  beforeEach(async () => {
+    multiDb = new MultiDocsetDatabase();
+    tempDir = path.join(__dirname, 'temp-multi-' + Date.now());
+    await fs.ensureDir(tempDir);
+    
+    // Create two test docsets
+    const createDocset = async (name, entries) => {
+      const docsetPath = path.join(tempDir, `${name}.docset`);
+      const resourcesPath = path.join(docsetPath, 'Contents', 'Resources');
+      await fs.ensureDir(resourcesPath);
+      
+      const dbPath = path.join(resourcesPath, 'docSet.dsidx');
+      const db = new Database(dbPath);
+      db.exec(`
+        CREATE TABLE searchIndex(
+          id INTEGER PRIMARY KEY,
+          name TEXT,
+          type TEXT,
+          path TEXT
+        );
+      `);
+      
+      const insertStmt = db.prepare('INSERT INTO searchIndex (name, type, path) VALUES (?, ?, ?)');
+      entries.forEach(entry => insertStmt.run(entry.name, entry.type, entry.path));
+      db.close();
+      
+      return {
+        id: name.toLowerCase(),
+        name: name,
+        path: docsetPath
+      };
+    };
+    
+    docset1Info = await createDocset('iOS', [
+      { name: 'UIView', type: 'Class', path: 'UIKit/UIView.html' },
+      { name: 'UIViewController', type: 'Class', path: 'UIKit/UIViewController.html' }
+    ]);
+    
+    docset2Info = await createDocset('Swift', [
+      { name: 'Array', type: 'Structure', path: 'Swift/Array.html' },
+      { name: 'String', type: 'Structure', path: 'Swift/String.html' }
+    ]);
+  });
+
+  afterEach(async () => {
+    multiDb.closeAll();
+    await fs.remove(tempDir);
+  });
+
+  describe('docset management', () => {
+    it('should add and remove docsets', () => {
+      multiDb.addDocset(docset1Info);
+      expect(multiDb.databases.size).toBe(1);
+      
+      multiDb.addDocset(docset2Info);
+      expect(multiDb.databases.size).toBe(2);
+      
+      multiDb.removeDocset('ios');
+      expect(multiDb.databases.size).toBe(1);
+      expect(multiDb.databases.has('swift')).toBe(true);
+    });
+
+    it('should replace existing docset when adding with same ID', () => {
+      multiDb.addDocset(docset1Info);
+      const firstDb = multiDb.databases.get('ios');
+      
+      // Add again with same ID
+      multiDb.addDocset(docset1Info);
+      const secondDb = multiDb.databases.get('ios');
+      
+      expect(firstDb).not.toBe(secondDb);
+      expect(multiDb.databases.size).toBe(1);
+    });
+  });
+
+  describe('search across docsets', () => {
+    beforeEach(() => {
+      multiDb.addDocset(docset1Info);
+      multiDb.addDocset(docset2Info);
+    });
+
+    it('should search across all docsets', () => {
+      const results = multiDb.search('i');
+      expect(results).toHaveLength(3); // UIView, UIViewController, String contain 'i'
+      
+      // Check results come from both docsets
+      const docsetIds = [...new Set(results.map(r => r.docsetId))];
+      expect(docsetIds).toHaveLength(2);
+    });
+
+    it('should limit search to specific docset when ID provided', () => {
+      const results = multiDb.search('i', { docsetId: 'ios' });
+      expect(results).toHaveLength(2);
+      expect(results.every(r => r.docsetId === 'ios')).toBe(true);
+    });
+
+    it('should filter by type across all docsets', () => {
+      const results = multiDb.search('', { type: 'Structure' });
+      expect(results).toHaveLength(2);
+      expect(results.every(r => r.type === 'Structure')).toBe(true);
+    });
+
+    it('should respect global limit', () => {
+      const results = multiDb.search('', { limit: 3 });
+      expect(results).toHaveLength(3);
+    });
+  });
+
+  describe('exact search', () => {
+    beforeEach(() => {
+      multiDb.addDocset(docset1Info);
+      multiDb.addDocset(docset2Info);
+    });
+
+    it('should find exact match across all docsets', () => {
+      const result = multiDb.searchExact('Array');
+      expect(result).toMatchObject({
+        name: 'Array',
+        type: 'Structure',
+        docsetId: 'swift'
+      });
+    });
+
+    it('should limit to specific docset when ID provided', () => {
+      const result = multiDb.searchExact('Array', { docsetId: 'ios' });
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('statistics', () => {
+    beforeEach(() => {
+      multiDb.addDocset(docset1Info);
+      multiDb.addDocset(docset2Info);
+    });
+
+    it('should get stats for all docsets', () => {
+      const stats = multiDb.getStats();
+      expect(stats).toHaveLength(2);
+      
+      const iosStats = stats.find(s => s.docsetId === 'ios');
+      expect(iosStats.entryCount).toBe(2);
+      expect(iosStats.types).toEqual({ Class: 2 });
+      
+      const swiftStats = stats.find(s => s.docsetId === 'swift');
+      expect(swiftStats.entryCount).toBe(2);
+      expect(swiftStats.types).toEqual({ Structure: 2 });
+    });
+  });
+});

package/src/services/docset/__tests__/DocsetService.test.js

@@ -0,0 +1,195 @@
+import { DocsetService } from '../index.js';
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import os from 'os';
+
+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 = path.join(__dirname, 'temp-docsets-' + Date.now());
+    await fs.ensureDir(tempStoragePath);
+    
+    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);
+    });
+  });
+});